E-cigarette ego-t, Electronic Cigarette Ego-t

Use of Spring 2.5 it Autowired comment IOC (annotation must see)

admin — Tue, 20 Mar 2012 23:17:39 +0000

January 15th, 2012
use the new features of Spring 2.5 – Autowired can achieve rapid automatic injection, but no need to add in the xml document inside the bean declaration, greatly reducing the maintenance of the xml document. (Even like this, because even the xml is not a cold). The following is an example:
@ Service annotation to define a bean, automatically according to the bean class name of instance of the first one to write letters to lowercase bean, such as Chinese instantiated as chinese, American instance into american If you need to change the name: @ the Service (“you change the bean name”).
in the spring configuration files which only need to add the , and can base-the package = “*” indicates all of the class.
Man interface in front of marked the @ Autowired and @ Qualifier annotation makes Man interface can be injected by the container when the Man interface there are two implementation class must specify which one to inject, use the first letter of the implementation class lowercase string to inject. Otherwise it can be omitted, just write the _AT_ Autowired
it can take advantage of Java reflection mechanism, the class structure information, this information can be effective in reducing the configuration. Attribute name, type, and other information such as the use of JPA annotations configuration ORM mapping, we do not need to specify the PO, if the field of relational tables and PO attribute name, type the same, you do not even need to write the task attribute mapping information – because the information can be obtained through the Java reflection mechanism.
annotations and Java code in a file, the XML configuration uses a separate configuration file, most of the configuration information is not adjusted, after the completion of the program development, if the configuration information and Java code together, help to strengthen the program cohesion. XML configuration file, the programmer to write a function, often in the program files and configuration files kept switching inconsistent on this way of thinking will reduce the efficiency of development.
In many cases, comments configuration than the XML configuration more popular, the comment with further popular trend. Spring 2.5 enhancements is the introduction of a lot of comment categories, Now you can use the comments configuration to complete most of the functionality of XML configuration. In this article, we l show you about using annotations to the bean definition and dependency injection.
use annotation configuration, the first to review the traditional on how to configure the bean and complete the establishment of dependencies between Bean. The following are the three classes, respectively, Office, Car, and Boss, the three classes in the Spring container configuration as bean:
of the Office and Car declaration in a Spring container bean, and injected into the Boss, bean: The following is the use of traditional XML to complete this configuration file beans.xml:
Spring container has been properly completed the work of creation and assembly of Bean.
Spring 2.5 introduces a the @ Autowired comment, it can be a class member variables, methods, and constructor label to complete the automatic assembly of the work. Look at @ Autowired member variables automatically injected code:
Spring through a BeanPostProcessor on @ Autowired, parse, so let work @ Autowired, must be Statement AutowiredAnnotationBeanPostProcessor bean in the Spring container.
In this way, when the start of the Spring container, AutowiredAnnotationBeanPostProcessor will scan all of the Spring container bean, When Bean with @ Autowired comment, find a match (the default type of match) bean, and injected go to the corresponding place.
accordance with the above configuration, the Spring will be directly using the Java reflection mechanism automatically injected into the Boss in the car and office, two private member variables. Member variable with @ Autowired, you could have to their setter methods (setCar () and setOffice ()) is removed from the Boss.
Of course, you also can be marked by @ Autowired method or constructor, look at the following code:
At this time, the @ Autowired will find the way to be marked into the parameter type of bean, and calls automatically injected bean. Use of the following annotation on the constructor:
Boss () constructor two into the parameter, namely, car and office, _AT_ Autowired will be looking for and they match the type of bean, them as Boss (Car car, the Office office) into the Senate to create the Boss, bean.
@ Autowired comment by default automatically injected into the Spring container that matches the number of candidate Bean must have one and only one. When you can not find a matching Bean, the Spring container will throw BeanCreationException exception, and that must have at least a matching bean. We can do an experiment:
due to the Office bean is commented out, so the Spring container will not type for the Office of the Bean, Boss office properties marked @ Autowired When you start the Spring container when the exception arises.
can not determine the Spring container must have a class beans, can be automatically injected class Bean can use the @ Autowired (required = false), which tells the Spring: looking for less than a matching Bean is not an error. Look at specific examples:
Of course, under normal circumstances, place @ Autowired are need to inject Bean use of auto-inject and allow injection only general in the development of or testing of encounter (eg, in order to quick start the Spring container, only the introduction of a number of modules at the Spring configuration file), so the @ Autowired (required = false) will be rarely used.
and can not find a type to match Bean opposite error is: If you have more than one candidate bean Spring container, the Spring container also throw BeanCreationException exception at startup. Consider the following example:
in the Spring container configured with two types of Office type of bean, the Spring container will not be able to determine when the member variables of the Boss office automatically injected in the end use Which one bean, an exception occurs.
Spring allows us to inject the name of the Bean specified by the @ Qualifier annotation, such ambiguity is eliminated by the following methods to resolve the exception:
@ Qualifier (“office”) in the office is the name of the Bean, so the @ Autowired and @ Qualifier when used in combination, auto-injection strategy from byType into byName the. @ Autowired can annotate the member variables, methods, and constructor, and the @ Qualifier annotation object is the member variables, methods, into the parameter, the constructor into the parameter. It is because of the different annotation object, so Spring does not the @ Autowired and the @ Qualifier unified into a single annotation class. Here is the annotated code into the member variables and constructor parameters:
@ Qualifier only and @ Autowired, in combination, @ Autowired useful supplement. In general, the @ Qualifier method signature into the parameter comment will reduce the readability of the code is relatively good, while the members of the variable comment.
Spring not only to support your own defined the @ Autowired comment also supports several annotations defined by JSR-250 specification, they are @ the Resource, @ PostConstruct and @ PreDestroy,,.
@ Resource role is equivalent to _AT_ Autowired, only the @ Autowired press byType automatically injected surface @ Resource default injected fills by byName automatically. @ Resource has two attributes is more important, namely the name and type, the Spring will be the name of the name attribute of the @ Resource annotation resolves to Bean, and the type attribute is parsed for the bean type. If you use the name attribute, use the auto-injection strategy byName, using the type attribute to use byType automatic injection strategy. If neither name nor specify the type attribute, then use reflection byName automatic injection strategy.
Resource annotation class in the Spring distribution lib/j2ee/common-annotations.jar class package before use must be added to the class library project. Look at an example using @ Resource:
Under normal circumstances, we do not need to use the comment similar to the @ Resource (type = Car.class), because the bean type of information available through the Java reflection from the code to obtain.
to make the JSR-250 annotations to take effect, in addition to label these comments in the Bean class, also need to be registered in the Spring container is responsible for dealing with these comments BeanPostProcessor:
CommonAnnotationBeanPostProcessor a BeanPostProcessor interface, which is responsible for scanning using the JSR-250 annotated beans, and the appropriate action.
Spring container Bean is a life-cycle, Spring allows to perform a particular operation in the bean initialization is complete and before Bean destruction, either through the early realization of the InitializingBean / DisposableBean which interface to customize after initialization / destruction of the previous methods of operation, can also elements init-method/destroy-method attributes specify the initialization / destruction is called before the operation. Spring life cycle, the author in Chapter 3 of “proficient in the Spring 2.x-business application development with Explanations are described in detail, interested readers can refer to.
the JSR-250 after initialization / destruction before the method specified the definition of two annotation classes are @ PostConstruct and @ PreDestroy, these two comments can only be applied. Marked @ PostConstruct annotated method will be invoked in the instance of the class after marked the @ PreDestroy method will be called before the class destruction.
You only need to be marked before the method @ PostConstruct or @ PreDestroy, these methods will be Bean is initialized or destroyed prior to the implementation of the Spring container.
we know, whether it is through the realization of the InitializingBean / DisposableBean which interface or configure through elements init-method/destroy-method property, only for Bean specify an initialization / destruction approach. Using the @ the PostConstruct, @ PreDestroy comment, but you can specify multiple initialization / destruction methods, those methods are marked @ PostConstruct or _AT_ PreDestroy comment will be executed in the initialization / destruction.
through the following test code, you will be able to see the bean initialization / destruction method is being executed:
At this time, you will see a marked @ PostConstruct postConstruct1 () method will be the start of the Spring container create Boss, Bean is triggered execution, while the marked the @ PreDestroy comments preDestroy1 () method will be destroyed before the Spring container is closed Boss, bean trigger execution.
Spring 2.1 adds a new context of the schema namespace, the namespace annotation-driven, the properties file into load time weaving and other functions to provide a convenient configuration. We know that the comment itself will not do anything, it provides only the metadata information. To make the metadata information real work must be allowed to handle these data processor to work.
we described earlier AutowiredAnnotationBeanPostProcessor and CommonAnnotationBeanPostProcessor is to deal with these annotation data processor. But directly in the Spring configuration file defines the beans seemed more clumsy. Spring provides us with a convenient register these BeanPostProcessor, This is . Consider the following configuration:
in the configuration file using the context namespace declaration element context namespace.
Although we can the @ Autowired or @ Resource in the bean class to use automatic injection capabilities, but Bean is defined in the XML file through – that is, in the XML configuration file definition of the bean, by the @ Autowired or @ Resource Bean member variables and methods into parametric or constructor function into the parameter automatically injected. Whether defined through annotations bean from an XML configuration file to completely remove the bean defined in the configuration it? The answer is yes, through the Spring 2.5 @ Component annotation can achieve this goal.
only in the class definition, use the @ Component annotation can be a class definition in a Spring container bean. The following code defines the Office for a bean:
In this way, we can in the Boss class by @ Autowired injection in front of the definition of Car and Office bean.
@ Component has an optional into the parameter used to specify the name of the Bean in the Boss, we will be Bean name is defined as “boss”. Under normal circumstances, the bean is a singleton, the need to inject Bean only through byType strategy can be automatically injected, so no need to specify the name of the Bean.
@ Component annotation, the Spring container must be enabled in class scanning mechanism to enable annotation-driven bean definitions and annotation-driven bean automatically injected into the strategy. Spring 2.5 context namespace extension to provide this feature, see the following configuration:
here, all defined by element Bean configuration content has been removed, requiring only add a line configuration to solve all problems – Spring XML configuration file to get the ultimate simplification (of course, the configuration metadata or only exist in a note Bale). of the base-package attribute specifies the need to scan the class package, class package recursively all sub package of the class will be processed.
also allows the custom filter certain types of base package included or excluded. Spring supports the following four types of filters, by the following table shows:
annotation the if com.baobaotao.SomeAnnotation a comment class, we can use the annotated class filtered out.
class name specified by the fully qualified class name filter, you can specify com.baobaotao.Boss into the scan will be excluded from the com.baobaotao.Car.
It is noteworthy that configuration not only enabled the annotation-driven class packages to be scanned in order to implement the annotation-driven bean defined function, but also enabled automatic injection functions ( that implicit in the internal registered AutowiredAnnotationBeanPostProcessor and the CommonAnnotationBeanPostProcessor is) When using removed.
default defined through the @ Component bean is a singleton, if you need to use the scope Bean @ Scope annotation to achieve our goals, such as shown in the following code:
In this way, when access to the boss bean from the Spring container, each time you return the new instance.
In addition to providing the @ Component annotation Spring 2.5 also defines several special semantic annotation, they are: the _AT_ Repository, @ Service and @ the Controller. 3 annotations and @ Component is equivalent to the current version of Spring, but the class names from the comment, it is easy to see that the 3 Notes and the persistence layer, service layer and control layer (Web Tier) counterparts. 3 Notes and @ Component is nothing new compared to Spring will add special features in a future version. So, if the Web application uses a classic three-tier hierarchy, then, the best in the persistence layer, service layer and control layer, @ Repository, @ Service and @ Controller annotated class stratification, and the @ Component more neutral class notes.
Notes configuration is not necessarily inherently superior to the XML configuration. Bean dependencies (such as Service uses which DAO classes), this configuration information does not occur in the deployment adjustment, then the annotation configuration is superior to the XML configuration; if this dependency will deploy adjustment, the XML configuration is clearly better than the annotation configuration, because the comment is the adjustment of the Java source code, you need to rewrite the source code and recompile it can be implemented to adjust.
if the bean is not written in class (such as the JdbcTemplate, SessionFactoryBean, etc.), the annotation configuration will not be able to implement the XML configuration is the only available way.
annotation configuration is often the class level, the XML configuration can be expressed in more flexible. Example, compared to the @ Transaction transaction annotation aop / tx namespace transaction configuration is more flexible and simple.
Spring annotation configuration in 2.1 after strong support for the annotation configuration features into Spring 2.5 one of the biggest bright spot. Rational use of Spring 2.5 annotation configuration can effectively reduce the workload of the configuration to improve the program cohesion. But this does not mean that traditional XML configuration toward extinction, the configuration of the third-party class Bean, as well as those such as the data source, cache pool configuration of persistence layer templates of operation, transaction management, XML configuration still has an irreplaceable status.

Alert to manually load the spring configuration files causes the database session can not be released

admin — Tue, 20 Mar 2012 23:17:34 +0000

8 hours ago
Problem phenomenon: in Web applications will encounter this situation, some places can not be obtained through the web which ApplicationContext bean springIOC container, such as the WebService interface to the outside world This time you need to manually ClassPathXMLApplicationContext and other ways to get the ApplicationContext, the code is as follows:
the ApplicationContext context = new ClassPathXmlApplicationContext with (
“applicationContext-*. xml”);
IXXXService xxxservice = (IXXXService) context
. getBean (“xxxservice”);
This is a typical load.
However, it is this seemingly everywhere are loading behind the BUG foreshadowed.
xxxservice specific class of business it down and control transaction and DAO dependent, here on behalf of a classic and simple the service specific configuration omitted, it is worth mentioning that the scope, there is no specified, the default is a single case.
everything is so smooth, like this service code should be written at least a few hundred, may be more you write, the process is still very intoxicated, modify finished. Test, test. What? ORA-12519 error! Hell, I build this set is known as a quick and easy SSH2 framework has a number of projects received numerous tried and tested, wrote no less than several hundred times the service actually reported ORA-12519 error.
quickly open PLSQL, check the database for the session, the Select Count (1) the From v The $ the session the Where t.SCHEMANAME = of XX
With the service implementation, the session number is increasing , there is no reduction of meaning. Yes, when is.
Solution: This error occurs in the tried and tested framework which I was quite disturbed, there could be such a vulgar error. Organize your thoughts begin to analyze: this code is the only different is, in the web application is provided by the container load the bean, the only container to start will load the xml. The focus should be concerned about the loading of XML.
Here we use the ApplicationContext interface. Note the spring documentation 3.5.1.2.2 gracefully close the springioc container in a non-web applications. It is used here AbstractApplicationContext, made bean, and then perform a context.reGISterShutdownHook ();
experiment an ApplicationContext changed to AbstractApplicationContext to execution context.close (). The outcome of the session has been normal recovery, the truth is beginning to emerge.
Conclusion: each time you load the context of practice is equivalent to always generate a new spring container, in the case of default of a single case, if you do not turn off the context. dataSource created in which the service relies on the DAO had been in existence (including class) generated in all cases a single case, from the log of the session under the jurisdiction of the service transaction, it has been close, but the SessionFactory is still there. Closed container, and specify a dataSource instance configuration in the destroy-method = “close”, dataSource, which a single case will not be released.
spring the document life cycle, described very clearly. By DisposableBean or specified destroy-method can be a good release of a single case of an object. Prototype object of type requires the client to explicitly specify the release, the release of the object is completely client-side control, the spring is not responsible for the release.
Therefore, to improve the load of the context as much as possible to load several times, it is not the case, we must remember to close.
Lastly, write arbitrary code, the easy way, without thinking, is the root of the evil of this BUG.
http://dev.21tx.com/2009/04/16/14101.html

Life Cycle Detailed – page life cycle

admin — Tue, 20 Mar 2012 23:17:27 +0000

The first stage in the October 12, 2011
page life cycle is initialization. When the Init event occurs, all the controls have been instantiated. Aspx source files statically declared and whichever is the default value. It should be noted that when the view state information is not available.
each control can take advantage of this good time for the implementation of any need to be completed in the first minute to save the view state and rendering the output of the last update operation.
save the ViewState property to the string rewriting SaveViewState method can modify the ViewState property.
override the Render method to change the presentation of the various control mechanisms. The method to get an HTML writer object, and use that object to gather all the HTML text that will be generated for the control. The default implementation of the Page class Render method includes a recursive call on all members of the control. For each control the page calls the Render method and HTML output into the cache.
Unload event is the last surviving signs of a page, the event occurred before the page object to be lifted. In this event, you should release may be occupied by any key resources (eg, documents, graphics, objects, database connections). After this event browser receives the HTTP response packet and displays the page. When a page request is sent to the WEB server, whether the event is submitted by the page or page redirects to stimulate the page in its creation to the release process will run a series of events. An ASP.NET page is created to the release process consists of 10 events.
(1) the object is initialized Init event: the initialization of the page logo is the Init event. The page control (including the page itself) are in their initial Form initialized for the first time. Successfully created the page control tree, the application to stimulate this event. When the Init event occurs, all the controls of the static statement. Aspx source file to instantiate and whichever is the default value. It should be noted that this is also the view state information is available. Can override the OnInit method, but the system does not guarantee that these control instance is created according to what order.
(2) loading view: After initialization, page framework to immediately load the page view state (ViewState). The so-called view state is the name / value pairs, for example, you can save the ID of the TextBox control and the Text property value. It is generally used to persist in a round trip to the server, that is involved in the HTTP request and response.
page view state is stored in the
field, as the value of the _VIEWSTAE record. The view state by ASP.NE automatic maintenance. Rewrite LoadViewState method components, developers can control how to restore the view state, as well as how to insinuate to the internal state. LoadViewState method is to obtain the last state in the ViewState, the page control tree structure recursively traverse the entire tree to restore the state corresponding to each control.
(3) handling postback data: to restore the view state, control the state of the species of the page last time with the browser render the page the status of these controls are the same. Next you need to update the state of these controls to send to the client.
back to the data processing stage, individual controls have the opportunity to update their status, in order to accurately reflect the corresponding HTML element on the client status. For example, a server TextBox control to the corresponding HTML element
postback data stage, the TextBox control will retrieve the current value of the
tag and use it to refresh its internal state. Each control is responsible for extracting the corresponding value from the data sent to and update some of its properties. The TextBox control will update the Text property of the CheckBox control to refresh its Checked property. Matching relationship between the server controls and HTML elements is determined by the two ID.
page framework will submit data on the control achieve IpostBackDataHandler interface then stimulate LoadPostData event, interface controls IpostBackDataHandle by the page parsing, so you can return data to update the control state . Identify controls, ASP.NET the unique identifier by matching the controls to update the correct control of the identifier has a name value set and the name-value pairs. This is the specific page each control requires a unique identifier for one of the reasons. The other steps are the framework to complete, such as determining the basic attributes of each identifier is unique in the environment and control.

LostPostData method prototype is as follows:
Public virtual bool LoadPostData (string postDatakey, the NameValueCollection postCollection)
PostDataKey identifies the control keywords, you can understood as the control ID, postCollection include postback data collection, can be understood as the view state value. The method returns a bool, if true, indicates the control state to change the postback; otherwise false. Page framework will keep track of all the control and returns true control call RaisePostDataChangeEvent event.
the LoadPostData methods is defined by the System .. Web.WebControls.Control, and add a server control is inherited from the System .. Web.WebControls.Control, postback data processing does not require intervention.
(4) the page is loaded the Load: the end of the postback data processing phase, all the controls in the page are updated according to the input on the client to change state. At this point, the page stimulate the OnLoad event. For this event, I believe most of my friends will be more familiar with the Page_Load method in the generated pages using Visual Studio.Net is the response to the Load event, For each request, the Load event will trigger the Page_Load method is executed. Can use this method to perform the initialization of some pages, such as the preparation of a good database connection string. Reference of the event, in order to improve performance, typically use the IsPostBack property of Page class, the judge is not data postback.
(5) back hair change the notice RaisePostDataChanged: (3) above, IPostBackDataHandler interface control is the correct return data updates in all, each control has a Boolean value The logo, which identifies its data submitted since the last change control is to change or to maintain its value. And ASP.NET search page to find any display control data is to change the logo and stimulate RaisePostDataChanged. RaisePostDataChanged event until after the Load event, all the controls have been updated after the excitation. This ensures that in the control returns to the data update, the data of other controls RaisePostDataChanged event has not been manually changed. Although it could be the basis of Page own definition of the events of data changes, but usually this event by much use.
(6) to handle the postback event the RaisePostBackEvent: When the return updates cause data changes caused by the server-side events, causing the returned object will be processed in the RaisePostBackEvent event. This lead to the return of the object is often a button is clicked or the state change caused the postback controls. Such as Button trigger music Onclick events, the client has modified the text of a text box, the AutoPostBack is set to true, the TextChanged event is triggered.
a lot of code is executed in this event, because this is the ideal location to control the event-driven logic. In order to ensure the correctness of the data rendered to the browser, after the series of postback event, the RaisePostBackEvent event was eventually fired. Based on consistency, the change in returns control to be executed until the function is updated. Work to be done in the actual ASP.NET development work before this event handling code.
(7) pre-rendered The PreRender: postback event, the page is ready to render. The signs of this stage is the PreRender event. Each control can take advantage of this good time for the implementation of any need in the first minute to save the view state and rendering the output to complete the last update operation. The final processing of the request will change to play a response from the server, pre-rendered at this stage is the implementation of the change before the final presentation of the state, because more of its properties before showing a control to generate an HTML, such as the Style property. This is a typical example, before this pre-rendered, you can change the Style of a control, perform pre-rendering the Style saved display of HTML style information, as the render phase.
(8) to save the state of the SaveViewState: the next state of the SaveViewState in this state all the controls and the page itself can refresh own SaveState collection. The view state is then to be serialized, hashed, Base64 encoding and associated hidden since the end of VI-EMSTATE.
(9) presents the view of the Render: here, in fact pages processing the request basically came to an end, in the Render event, the calling object is to present them to HTML, and then collect the HTML sent to the customer. Restructuring after the customer receives the HTML tags, and ultimately displayed to the customer. When the Render event is overloaded, developers can create HTML value for the browser, any HTML page creation are not yet in force. Render method to use the HtmlTextWriter object parameters by generating HTML to the browser. This is mainly used for the development of custom controls.
(10) Disposal Disposed: final cleanup operations before the destruction of the control. At this stage must release expensive resources, such as the withdrawal of the memory, the database connection.
(11) uninstall Unload: a page of the last surviving symbol of the Unload event, which occurred before the page object is lifted. In this event, you can call the Dispose method to release the occupied resources (eg, file, graphic objects and database connections) as possible.
/ / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / /
Page handling process to explain
Page class is derived relations

Page is derived from the TemplateControl in the TemplateControl derived from Control. Their definitions are as follows:
/ / Control derive from object to achieve the four interfaces
public class the Control: System.ComponentModel.IComponent
 System.IDisposable,
System.Web.UI.IParserAccessor,
System.Web.UI.IDataBindingsAccessor
{}
/ / the TemplateControl derives from Control, to achieve the interface System.Web.UI.INamingContainer
public abstract class the TemplateControl: Control, System.Web.UI.INamingContainer
 {}
/ / Page from TemplateControl derived, the interface of the System.Web.UI. the IHttpHandler
public class Page: the TemplateControl, System.Web.IHttpHandler 
{}
Page you write, you _aspx.cs file prepared by the class that derives from Page, this inheritance relationship is when you add a WebForm page, Visual Studio. net you have built. Aspx page at runtime will be interpreted as a derived class from class _aspx.cs file. (Supplementary information).
question of

guess
When IIS receives a request to the aspnet_isapi.dll handle to the aspx page. aspnet_isapi and then do the following things:
the MyPage __ p;
__ p = new the MyPage ();
__ p.ProcessRequest (System.Web.HttpContext Current)
The above is my personal estimation, what the truth is not so, I will find the Microsoft engineers answer! I did not find in System.Web.dll il, to produce the Page instance, the Page class instance creation aspnet_isapi.dll made, but the aspnet_isapi.dll not use. NET written in its internal operation is how unable to get known.
following is not a guess!
the ProcessRequest (HttpContext) method
of the ProcessRequest Page (System.Web.HttpContext):
public virtual void the ProcessRequest ( Sunrise.Web.HttpContext context)
{
this.SetIntrinsics (context); / / basic initialization
this.ProcessRequest (); / / process the request
}

SetIntrinsics method.
you can see from the above code, the first call SetIntrinsics (HttpContext context) method, SetIntrinsics the role of the basic initialization of member variables of Page. SetIntrinsics are as follows:
/ / initialize the basic setup _context _request, _application the _cache initial value
private the void SetIntrinsics (HttpContext context)

{
this._context = context;
this._request = context.Request;
this._response = context. Response;
this._application = context.Application;
this._cache = context.Cache;
if (this._clientTarget! = null ) {
if (this._clientTarget.Length> 0) {
this._request.ClientTarget = this._clientTarget;
}
}
/ / to tune TempalateControl the HookUpAutomaticHandlers () method to initialize the basic event
/ /: Init, Load, the DataBinding The PreRender, Unload , Error,
/ / AbortTransaction, CommitTransaction
this.HookUpAutomaticHandlers ();
}
ProcessRequest method 
then began the implementation of ProcessRequest () method is as follows:
try
{
if (this.IsTransacted ) / / if the transaction state
{
this.ProcessRequestTransacted the ();
}
else / / non-transaction state
{
this.ProcessRequestMain ();
}
the
this.ProcessRequestEndTrace (); 
}
finally
{
/ / release resources _request, _response set to null, and perform UnloadRecursive (true)
this.ProcessRequestCleanup ();
}
ProcessRequestMain method
through the above code know when a Page non-transaction mode, to response ProcessRequestMain (). In fact, the transaction mode is also to call ProcessRequestMain (). The following pseudo-code on ProcessRequestMain () method:
/ / step1 the call Control.InitRecursive () recursive initialization Control the OnInit () method will be invoked at this time

this.InitRecursive (null);
/ / If it is back to pass state

if (this.IsPostBack in)
{ 
/ / step2 loading the ViewState
/ / / loading the ViewState of the Page Control the LoadViewState () method will be called
the this. LoadPageViewState ();
/ / step3 handle the return data Control realized System.Web.UI.IPostBackDataHandler, and
/ / LoadPostData () method at this time is called
this.ProcessPostData (this._requestValueCollection, true);
}
/ / step4 the call Control.LoadRecursive () method to load SubControls
/ / Control the Load () method is called at this time
this.LoadRecursive ();
/ / If the returned status
if (this.IsPostBack)
{
/ / step 5 again to deal with unhandled return data after
 / / Note the second call when the second argument is false, while the first is true
/ / return the data may be used to handle the OnLoad Control created the data? ?

this.ProcessPostData (this._leftoverPostData, false);
/ / step6 response data change event,
/ / Control to achieve the System . the interface Web.UI.IPostBackDataHandler
/ / Control RaisePostDataChangedEvent () method at this time call the /> this.RaiseChangedEvents of the

/ / step7 response return event __dopostback ()
/ / Control to achieve the System.Web.UI.IPostBackEventHandler interface, the RaisePostBackEvent Control () method is executed at this time
 this.RaisePostBackEvent (this._requestValueCollecti on);
/ / step8 calling Control PreRenderRecursiveInternal of ()
/ / Control the OnPreRender () method in this
this.PreRenderRecursiveInternal is called ();
}
/ / step9 BuiltTree build the ViewState
/ / ViewState ViewState is encoded by LosFormatter stored in the Trace in

this.BuildProfileTree (“ROOT”, this.EnableViewState);
/ / of step10 save Page ViewState
/ / Control the SaveViewState () method
this.SavePageViewState the ();
/ / step11 output
/ / Control the Render () method is called at this time
this.RenderControl (this.CreateHtmlTextWriter (this. Response.Output));

ProcessRequestMain method icon 
the Init
Load the ViewState
Load the PostData
Load
Load the PostData

RaiseChangeEvents

RaisePostBackEvents
BuildProfileTree (viewstate to coding)
SaveViewState
the Render
Dispose
Unload
the generated HTML code
the OnInit () method is called
the OnLoad () method is called
processing data
return again to return data
response data modification event, such as a TextBox TextChagned

response postback event
of the client __dopostback
ProcessRequestTransacted method
In fact, in the state of affairs, is also a call ProcessRequestMain (), we look at the look ProcessRequestTransacted code:
bool V_0;

System.Web.Util.TransactedCallback V_1;
V_0 = false;
 / / create a transaction callback delegate
V_1 = new System.Web.Util.TransactedCallback (this.ProcessReq uestMain);
/ / in the transactional environment to call ProcessRequestMain ()
System.Web.Util.Transactions.InvokeTransacted (
V_1,
the
(System.EnterpriseServices.TransactionOption,) (this _transactionMode),
ref V_0
);
if (V_0) {
this.OnAbortTransaction (System. EventArgs.Empty); / / terminate the transaction
}
Else {
the
this.OnCommitTransaction (System.EventArgs.Empty); / / submit
} of the transaction

InitRecursive method
ProcessRequestMain method, the first implementation of Control InitRecursive method. InitRecursive in the OnInit method is executed. As follows:
internal void InitRecursive (System.Web.UI.Control namingContainer) / / ok
{
string V_0;

int V_1;
int V_2;
System.Web.UI.Control V_3;
if (this._controls! = null)
{
/ / flag [128] realized System.Web.UI.INamingContainer interface
if (this. flags [128]) {
namingContainer = this;
}
/ / set _controls read-only and return to the original _readOnlyErrorMsg , the saved in V_0
V_0 = this._controls.SetCollectionReadOnly (“Parent_colle ctions_readonly);
V_1 = this._controls.Count;
for (V_2 = 0; V_2 {
V_3 = this._controls [V_2];
V_3._namingContainer = namingContainer;
if (namingContainer! = null)
{
if ((V_3._id == null)

Spring-based Annotation dependence into

admin — Tue, 20 Mar 2012 23:17:18 +0000

March 9, 2012 Spring Annotation dependence into

@ Repository, @ Service, @ the Controller and @ Component class identified as bean
Spring since the beginning of 2.0 version, started incorporating some of the annotations to simplify the development of the Spring. @ Repository annotation will belong to a group of first introduction of, it is used for the Data Access Layer (DAO Layer), identified as the Spring bean. Specific just the label of the annotation can be in the DAO class. Meanwhile, in order to let Spring be able to scan the class path of the class and identify the @ Repository annotation Bean automatic scanning function is enabled in the XML configuration file, which by . As follows: / / First use the @ Repository, the DAO class declaration for the bean the package bookstore.dao; @ Repository, public class the implements UserDaoImpl UserDao {…} / / Second, the automatic scan function to start the Spring XML configuration file …… …
so, we no longer need to explicitly in the XML to use bean configuration. Spring in the container during initialization will automatically scan all class files specified by the base-package package and its subpackages, all marked with the @ Repository classes will be registered for the Spring bean.
Why the @ Repository, can only be marked in the DAO class? This is because the role of the annotation is not only the class identified as bean, at the same time, data access exception thrown in the class it can be marked package for Spring data access exception type. Spring itself provides a rich and has nothing to do with the specific data access technology data access exception structure for the exception thrown by the package different persistence layer framework, making the exception independent of the underlying framework.
Spring 2.5 @ Repository on the basis of an increase of the function is similar to the three additional annotation: @ the Component the _AT_ Service, _AT_ Constroller, were used for the different levels of software systems: @ Component is a pan- the concept, only represents one component (bean), can act at any level.
@ Service is usually applied in the business layer, but the function is the same as @ Component.
the
@ Constroller, usually acting on the control layer, but the function is the same as the @ Component.
by the class using the @ Repository, @ the Component, @ Service and annotation @ Constroller, Spring will automatically create a corresponding BeanDefinition objects and registered in the ApplicationContext. These classes became the Spring managed components. These three annotations in addition to the role of different software levels, and its use with the @ Repository is identical.
In addition, in addition to the above four notes, the user can create custom annotations, and then in the annotation @ Component annotation on the custom annotation it will have the same functionality with the @ Component . However, this feature is not commonly used.
When a Bean is automatically detected, it will generate the bean name that scanner BeanNameGenerator strategy. By default, contains the name attribute of @ the Component, @ Repository, @ the Service @ the Controller, will name value as the bean name. If this annotation does not contain a name value, or the custom filter component found, the default bean name is lowercase at the beginning of the non-qualified class name. If you do not want to use the default bean naming strategy, can provide a custom naming strategy. First to achieve BeanNameGenerator interface, be sure to include a default no-argument constructor. And then configure the scanner to provide a fully qualified class name, as follows:
Spring bean XML configuration The Notes are identified bean, the default scope is the “singleton” in order to meet these four annotations, marked Bean at the same time be able to specify the Bean The scope of the Spring 2.5 introduces the @ Scope annotation. Simply provide the name of the scope when using the annotation, as follows: @ Scope (“the prototype”) @ Repository, public class Demo {…}
If you would like to provide a custom role domain parsing strategy without using annotation-based approach, simply achieve ScopeMetadataResolver interfaces, be sure to include a default constructor with no parameters. Fully qualified class name when configuring the scanner:
@ PostConstruct and @ PreDestroy, specified life cycle callback method
Spring bean after it by the Spring IoC container management, initialization and destruction (the prototype type initialized by the container from the container without container management), we usually do not need to concern container Bean initialization and destruction operations, after a constructor or factory method to create by Spring Bean is the initialization has been completed and immediately available. In some cases, however, may need our hand to do some additional initialization or destruction operation, which is usually for some resources to acquire and release operations. The Spring 1.x provides two ways for the user to specify the life cycle callback method.
a way that Spring provides two interfaces: the InitializingBean and DisposableBean. If you want to perform some custom action after the completion of the Bean initialization, you can to bean to achieve InitializingBean interface, the interface contains an afterPropertiesSet () method, the container after the Bean set the property will automatically call the method; Bean the interface DisposableBean, before the destruction of the bean, the container will call this interface the destroy () method. The disadvantage of this approach is that the bean class implements Spring interface, an increase of the degree of coupling of the code with the Spring Framework, and therefore not recommended.
The second way is used in the XML file the init-method and destroy-method attribute specified initialization and destruction callback methods before, the code does not need to implement any interface. The values ??of these two properties is the initialization and destruction of the corresponding bean class, method name any, but the method must have no parameters. Examples are as follows: …
Spring 2.5 in retain the above two ways, based on JSR-250 support. JSR-250 specification defines two annotations to specify the method of statement cycle: _AT_ PostConstruct and @ PreDestroy,. These two annotations to use very simple, just were marked executed after the initialization callback method or destroyed prior to the implementation of callback methods. The use of annotations, so you need to configure beans post-processor, that is, add the following line in the XML:
comparison of the three specified life cycle callback method way, is not recommended, not only of their usage as good as two flexible, and virtually increase the degree of coupling of the code framework. Behind are two ways developers can choose one according to usage, but it is best not to mix so as not to increase the difficulty of maintenance. @ Required bean dependence check
to rely on examining the role, judgment to the corresponding set Bean Setter method are instantiated when called. Not judge whether the field has a value exists. Spring dependency checking, it will only determine if the property is used Setter Injection. If a property does not use Setter Injection, even if the constructor has been injected for the property value, Spring still think it does not perform the injection, which throws an exception. In addition, the Spring just whether performed by Setter injection, injected values, there is no requirement, even if the the injected , Spring also considered the implementation of dependency injection.
the label dependency-check attribute for dependency checking. The values ??of the property include the following: none – the default does not perform a dependency check. The default-dependency-check attribute in on the label to change the default value.
simple – check the original basic types and collection types.
objects – complex type of check (in addition to other types of simple examined by type).
an all – for all types of checks.
old version of the dependency-check in the configuration file to set the disadvantage is that the coarse grain size. Provided by the Spring2.0 the @ Required annotation to provide a more fine-grained control. @ Required annotation can only be marked above Setter method. Because the nature of dependency injection is to check Setter method is called, not really to check whether the attribute assignment and assigned a value of. If the label of the annotation in the type of the non setXxxx () method are ignored.
to let Spring handle the annotations, you need to activate the Bean post processor. To activate the post-processor, simply add the following line in the XML to.
is called when a is marked @ Required Setter did not, then Spring will throw an exception when resolved to remind developers that the corresponding attribute settings. Use @ Resource, _AT_ Autowired and the the @ Qualifier to the specified Bean automated assembly strategy
automatic assembly refers to the Spring when assembly Bean, according to the specified automatic assembly rules, a Bean need to reference type the Bean injected in. element provides a specified automatic assembly type autowire property, which have the following options: no – explicitly specify the use of automatic assembly.
byName the the – if there is a consistent attribute name beans, use the bean to be injected. If the name matches the type mismatch, an exception is thrown. If you do not match the type, then do nothing.
byType – if there is a current property type Bean (the same type or subtype), then use the bean to be injected. byType able to identify a factory method, that is able to identify the return type of the factory-method. If you have more than one type of bean, an exception is thrown. If you do not match the type, then do nothing.
the constructor – and byType similar to, but it is in terms of the constructor injection. If no constructor parameter types that match the bean throws an exception. Use of the assembly mode, priority matching parameter constructor.
autodetect – decided to adopt byType or the constructor for automatic assembly according to Bean introspection mechanism. Bean provides a default constructor, uses byType; otherwise using the constructor for automatic assembly.
to use byType or constructor autowiring by type when automatic assembly also supports the array of reference types, or use a generic collection, so that the Spring will inspect the container matches the type of bean, composed of a collection or array to perform the injection. The use of a generic type Map, if the key is of type String, Spring will automatically perform the assembly, all types that match the bean as the value, the bean name as the key.
We can to increase in the default-the autowire properties, set the default automatic packaging strategy. The default value is “no”. If the use of automatic assembly, but also specifies the property or constructor-arg tag explicitly specified value will override the value of the automatic assembly. Automatic package does not support the simple types, such as basic types, the String, Class, and their array type.
match by type (which may byType, the constructor, autodetect), the same type may be more than one bean, if property is to be injected arrays, collections, or Map, this might not be But if simply a reference type, an exception is thrown. Solution are summarized as follows: the abolition of the automatic assembly properties of the Bean, the use of explicit injection. We may not want a Bean is as the candidates of other bean to perform automatic package, we can increase the the autowire-candidate = “false”. (The autowire-candidate attributes and the autowire attribute is independent and unrelated. A Bean can be the autowire-candidate is set to false, use autowire features.) In addition, we can set default-the autowire-candidates attribute, you can specified in this attribute can be used to match the mode of the automatic assembly candidate Bean, such as the default-the autowire-candidates = “* serv, * the dao”, which means that all the names as candidates for serv or dao end of Bean, while others ignore , which is equivalent to other beans are designated as the autowire-candidate = “false”, then you can explicitly specify the autowire-candidate = “true”. The set specified in , you want to overwrite the settings specified on the .
If multiple types of beans preferred bean, then the primary attribute is set to “true”, so that the automatic assembly will give priority to use the bean to be assembled. Can not be the autowire-candidate set to false.
If you are using Java 5 or later, you can use annotations to more fine-grained control.
@ Autowired and the @ Qualifier annotation implementation of the automatic assembly
use the @ Autowired annotation assembly can only be based on the type of match. _AT_ Autowired comment Setter method, constructor, field can be used, and even the ordinary method, provided that the method must have at least one parameter. The @ Autowired for the array and the use of generic collection types. Then injected into the Spring container will be all types of matching bean come. The The @ Autowired marked role in the type Map, the Map key of type String, Spring will be the Map the value corresponding to the type of all types of container the bean into consideration, as the Map key to use id or name of the Bean.
@ Autowired, marked role in the ordinary way, it will produce a side effect, is to initialize the bean instance when the container calls the method. Of course, the implementation of the automatic assembly does not meet the conditions of the assembly, the method will not be executed.
marked @ Autowired,, automatic injection can not meet an exception is thrown. We to @ Autowired, marked increase to a required = false attribute to change this behavior. In addition, each class can have only one constructor @ Autowired.required () property is true. Otherwise the problem. If use @ Autowired at the same time marked more than one constructor, then Spring will use the greedy algorithm to match the constructor (constructor maximum).
@ Autowired,-there is one role is to be marked in the type BeanFactory, ApplicationContext type, a ResourceLoader type, ApplicationEventPublisher type, the MessageSource types, then Spring will automatically inject the implementation class instance, does not require additional action.
When there are multiple Bean container types and injection at the same time, the injection can not be executed, we can to @ Autowired increase the value of a candidate, the practice to add a @ Qualifier the @ Autowired behind label a String value as the name of the candidate bean. The following are examples: the @ Autowired (required = false) @ Qualifier (“ppp”) public void setPerson (person Show-p) {}
@ Qualifier can even act on the method parameter (for only one parameter , we can @ Qualifer label is placed above the method declaration, but recommended to be placed in front of the parameter), for example, as follows: @ Autowired (required = false) public void the sayHello (@ Qualifier (“ppp”) the Person p, String name) { }
qualifier name, we can specify a bean in the configuration file as follows: the
annotation @ Autowired, the corresponding processing registration and similar to the front, only in the configuration file to increase the following line to:
If injected @ Autowired, the system type of the BeanFactory, the ApplicationContext, a ResourceLoader, then you do not need the @ Qualifier at this time even the @ Qualifier annotation. bean will be ignored; for the automatic assembly of the custom type, use the @ Qualifier annotation and no name matching, automatic assembly fails to match.
If you want automatic assembly performed by name, use the JSR-250 @ Resource and @ Qualifier annotation
, you should use the JSR-250 @ Resource annotation, rather than should use a combination of the @ Autowired with @ Qualifier.
@ Resource use byName way to perform automated package. @ Resource annotation can Setter method with a parameter, the field, as well as the ordinary method with a parameter. @ Resource annotation has a name attribute that specifies the name of the corresponding bean in the configuration file. If you do not specify a name attribute, then the default value of the field or property name. With @ Resource and @ Qualifier is still valid, but the @ Qualifier @ Resource, almost equivalent to the name attribute.
@ Resource does not specify a name attribute, then use byName after the match fails, fall back to use byType continue to match, if we fail, then throw exception. Not the @ Resource annotation to explicitly specify the name attribute of the premise, if the label in type BeanFactory and the ApplicationContext type, a ResourceLoader type, ApplicationEventPublisher types, the MessageSource types, then Spring will automatically inject the implementation class instance, no additional operation. The name attribute does not need to specify (or designated as “”), or injected into the failure; If you use the @ Qualifier, the annotation will be ignored. For the injection of user-defined type, the @ Qualifier and name equivalent, and will not be neglected.
the the primary and the autowire-candidate attribute the _AT_ Resource, @ Autowired still valid. @ Configuration and @ Bean Bean statement
since the release of version 2.0, Spring continue to provide 10 more comments, but these comments just to simplify in some cases the XML configuration. is not intended to replace the XML configuration. This can be seen from the Spring IoC container initialization class: the most commonly used implementation class of the ApplicationContext interface is ClassPathXmlApplicationContext and FileSystemXmlApplicationContext,, as well as for Portlet XmlPortletApplicationContext and web-oriented XmlWebApplicationContext, they are oriented XML. Spring 3.0 added the other two implementation classes: AnnotationConfigApplicationContext and AnnotationConfigWebApplicationContext. We can see from the name, they are born as a comment, directly dependent on the annotation to initialize the class as a container configuration information sources IoC container. AnnotationConfigWebApplicationContext is the web version of AnnotationConfigApplicationContext its use compared with the latter there is little difference, so this article will be AnnotationConfigApplicationContext example to explain.
AnnotationConfigApplicationContext match on @ Configuration and @ Bean annotation, since the XML configuration is no longer the only configuration of the Spring IoC container. In a competitive relationship between a certain range of memory, but in most cases or collaborative relationship, the combination makes the configuration of the Spring IoC container is easier, more powerful.
before configuration information to focus on writing in XML, now use annotations, the configuration information of the carrier by the XML file transferred to a Java class. We usually will be used to store configuration information in the class of the class to the “Config” at the end, such as AppDaoConfig.java, AppServiceConfig.java and so on. We need a class that is used to specify configuration information with the @ Configuration annotation, clear that the class is the source of the bean configuration information. Spring marked the Configuration class, the following requirements: Configuration class can not be final;
configuration class can not be localized, that is not the definition of the configuration class inside a method in other classes;
configuration class must have a no-argument constructor.
AnnotationConfigApplicationContext configuration class annotated with @ Bean method return value is recognized as a Spring bean, and register to the container by the IoC container management. @ Bean role is equivalent to the tag in the XML configuration. The following example: @ Configuration public class BookStoreDaoConfig {@ bean the public UserDao userDao () {return new UserDaoImpl ();} @ the Bean bookDao () {return new BookDaoImpl of the public BookDao ();}}
Spring resolved to the above documents will identify all the methods marked @ bean, perform, and method return values ??(UserDaoImpl, and BookDaoImpl objects) registered to the IoC container. By default, the bean name is the name of the method. Therefore, the above configuration equivalent XML configuration is as follows:
@ Bean has the following four attributes: name – Specifies the name of one or more Bean. This is equivalent to the XML configuration name attribute.
the initMethod – After initializing Bean container will call the method specified in the property. This is equivalent to the XML configuration init-method attribute.
and destroyMethod makes – The properties and initMethod function similar to the attribute specifies the method is called before the container destroyed Bean. This is equivalent to the XML configuration destroy-method attribute.
the autowire automatic assembly strategies – the specified Bean property value is a static property of the Autowire type three. Autowire.BY_NAME, Autowire.BY_TYPE, Autowire.NO. Autowire attribute values ??in the XML configuration, where the less the constructor, this is because the constructor has no meaning here.
@ Bean did not directly specify the scope attribute to achieve the @ Scope and @ Scope usage listed above.
The following explain the initialization of the container based on annotations. AnnotationConfigApplicationContext three constructor used to initialize the container. AnnotationConfigApplicationContext (): The constructor initializes an empty container, the container does not contain any bean information later by calling the the register () method to register the configuration class, and call refresh () method to refresh the container.
AnnotationConfigApplicationContext (Class … annotatedClasses): This is the most commonly used constructor, will involve the configuration of classes passed to the constructor to the corresponding configuration class of the Bean automatically registered into the container.
AnnotationConfigApplicationContext (String. .. basePackages): The constructor will automatically scan a given package and its subpackages under class, and automatically identify all the Spring beans to be registered to the container in. Not only does it identify the annotation @ Configuration class configuration and resolved correctly, but also to identify the use of @ Repository, @ the Service @ the Controller, the _AT_ Component marked class.
In addition to the above third type of constructor for the container automatically scans the bean configuration information, AnnotationConfigApplicationContext also provides scan () method, its function is also similar to the above, this method is mainly used in container initialize the dynamic increase in the Bean to the container. Call the method usually requires immediate manually call refresh () Refresh the container to let the changes take effect immediately.
should be noted that, when AnnotationConfigApplicationContext in parsing the configuration class, the configuration of the class itself is registered as a bean, because the @ Configuration annotation itself defined by the @ Component annotations. Therefore we can say a @ Configuration @ the Component. In most cases, the developer less than the bean, and in the ideal case, the beans should be transparent to the developer. @ Configuration defined as follows: @ Target ({ElementType.TYPE}) @ Retention is (RetentionPolicy.RUNTIME) @ the Documented @ Component public @ the interface the Configuration {String of value () default “”;}
in the general project, in order to clear structure, usually based on software modules or structure is defined multiple XML configuration file, and then define an entrance of the configuration file, the file configuration file organization. Finally just the file passed to ClassPathXmlApplicationContext constructor can. Annotation-based configuration, Spring also provides a similar function, simply define an entrance configuration class and @ Import annotation to the introduction of other configuration class can be used in such, the last class to pass the entrance to AnnotationConfigApplicationContext. Specific examples are as follows: @ the Configuration @ Import ({BookStoreServiceConfig.class, BookStoreDao Config.class}) public class BookStoreConfig {…}
mix of XML and annotations to the bean configuration

The reason for the coexistence of the two, mainly attributed to three reasons: First, the present, most of the Spring development projects, almost all based on XML configuration Spring introduction of annotations at the same time, must ensure that the annotations and XML harmonious coexistence, which is the prerequisite; Second, comment to the introduction of late, so the function is also no development for many years the power of XML for complex configuration, annotations also difficult to work independently. still need a period of time with the XML can solve the problem. In addition, the configuration of Spring beans with Spring core modules are decoupled and, therefore, change the configuration of the Spring framework itself is transparent. Spring can be very convenient for the annotation support through the use of the Bean processor (the BeanPostProcessor) This is a very easy thing in technology.
want to use a mixed configuration, you first need to determine what kind of configuration-based. Different answers on this issue will directly affect the manner of implementation. However, no need for this headache, whether by way of XML-based, or to annotation-based configuration is simple and easy to understand. There is not a wrong decision, because the only expression is not the same. We first assume that based on XML configuration.
large-scale projects already exist, may be early is an XML Bean configuration, follow-up gradually adding annotation support, then we need only in the XML configuration file will be marked by the @ Configuration classes defined as common the , and to register the processing annotated bean post processor. The following example: / / assume the existence of the following @ Configuration class: package bookstore.config; import bookstore.dao. *; @ The Configuration public the class MyConfig {@ bean the public UserDao userDao () {return new UserDaoImpl ();}} At this point, simply make the following declaration in XML can be: … The
Bean after processor for the annotation is enabled, it resolves to the ApplicationContext MyConfig class, the class marked with the @ Configuration annotation, then it will deal with the class label @ Bean method, these methods return the value of registered total container bean.
For more than one way, if there are multiple annotation @ Configuration class, you need to list them in an XML file. Another way is using the aforementioned auto-scan function, the following configuration:
so Spring will scan all of the demo. class in the config package and its subpackages, to identify all marked with @ Component, @ the Controller, @ Service, @ Repository annotation class, the @ Configuration annotation itself is marked using @ Component, Spring will be able to identify the @ Configuration annotation class and correct parsing of the.
annotated configuration, simply use the @ ImportResource annotation introduction of the XML can exist, the @ Configuration @ ImportResource is as follows: (the “the classpath :/ the bookstore / config / spring-beans xml “) public class MyConfig {…} / / initialization process of the container and pure configuration for the center in a manner consistent the: AnnotationConfigApplicationContext ctx =
the new AnnotationConfigApplicationContext (MyConfig.class); this article from: http://www.ibm.com/developerworks/cn/opensource/os -cn-spring-iocannt/index.html? ca = drs-cn-0506

The company recruitment

admin — Fri, 03 Feb 2012 12:28:09 +0000

June 3, 2011
my colleagues
Below. Are the vacancies in our company recently, please kindly the find detailed-info as you need ~ if you have any enquires / recommendation, please feel of free to at contact me!
The following are the current vacancies jobs, if you have any suitable candidates to recommend, welcome to communicate information to me ~ If you have any doubts, please consult me! My contact information listed below, welcome the recommendation! the
the

#
the Position post
Number The , the number of
 Location
Location
the Requirements requirements 
1
the Product Development the Sample Coordinator furniture sample development Coordinator
2
Chengdu
1 At least 2-3 years work experience in furniture company, working at production line / R

SRGAVC0301 encoder-ALPS encoder suppliers -18,923,485,199 Zhang

admin — Fri, 03 Feb 2012 12:27:50 +0000

July 2, 2010
industry Pradesh Industrial Co., Ltd. – sales agent a full range of ALPS switch, ALPS encoder, ALPS potentiometer, the ALPS deck, ALPS sensors. The products are widely used in automotive electronics (Car DVD, GPS, vehicle anti-theft device, etc.), audio-visual products (such as audio, amplifier, mixer), digital products, mobile phones and other communications products, medical equipment and various types of instrumentation.
industry Bang Industrial Co., Ltd.
Contact: Mr. Zhang 18,923,485,199
Tel :0755-26567300 Fax :0755-26576355
E-mail: Sales09@yepong.com Other:

-ALPS encoders supplier -18,923,485,199 Zhang
-the ALPS encoder supplier -18,923,485,199 the
SPVQ340400 switch button-ALPS encoder supplier -18,923,485,199,

-ALPS encoder suppliers -18923485199 -18923485199 Zhang

EC11J0920601 encoder-the ALPS encoder supplier
, SRGAVC0301, encoder
Address: 1111 Blue Lake County, northern New Area Kim open road – Blues Day Street SA-1
Chongqing A Shilai Furniture Co., Ltd. Tel: 67,888,889

Ashley Furniture Company in southwest China business agency:
Ashley furniture from around the world carefully buy expensive, high-quality native wood, so that product quality has always been a world leader; in the production process: world-class high-tech production line and the old hand-carved art, to keep the way of native wood and natural form, products, fine workmanship, exquisite workmanship; development, the use of high-tech biological wax products finish, corrosion, decay, extend product the useful life of many ways to produce a magical effect; artistic style: long European and American culture and the arts; royal grandeur; beautiful idyllic … blend. Ashley Furniture will never penetrate: simple, natural, peaceful European and American pastoral charm, beautiful, warm breath of life; show: luxury, elegance, classic, luxury style.

www.ashleyfurniture.com
by Ashley Furniture U.S. Headquarters: Wisconsin 阿卡狄亚阿 Shilai Avenue
by Ashley Furniture Company for each patrons: freedom of choice, combined; products directly from the company headquarters, EC11B2024304 encoders; responsible for the delivery; provide furniture installation, design and decoration advice and after-sales quality service and a wide range of services such as content. Never performed the “Total Customer Satisfaction” promise.
Ashley Furniture Company global headquarters in Arcadia, Wisconsin, USA. Founded in 1945, initially unknown company, one only has 3500 ft2 site SPVS410100 switch button. 60 years, the company firmly adheres to the implementation of a “complete customer satisfaction; to produce the world best products, SPVQ311500, switch button; become the world best companies,” the belief, hard work, now has six production bases. factory area of ??more than 300 million square feet, has become the world furniture production, sales center, SPVQ371000 switch button; is the world third largest furniture manufacturing company.

Dewaxedshellac plastic wax shellac

admin — Fri, 03 Feb 2012 12:27:45 +0000

October 15, 2011
(a) household types
Adjustablebed adjustable bed
the Airbed Qichuang
Anti-slipstripforstairs (crib) non-slip stairs against the handrails

Antiquefurniture ancient furniture
Antiquereproductionfurniture antique furniture
of Armchair Armchair
 B
Babycrib crib
Backlesswall-unit is not to set the backplane closet
Bamboofurniture bamboo furniture

Banquetingchair banquet chairs
Barstool chairs
the the
Bathroomaccessories bathrooms supporting device

Bathroomcombination bathroom cabinet
Bathroomconsoles bathroom multi-purpose frame.
Bathroomfurniture bathroom furniture
Bathroomvanity bathroom vanity

Battendoor lath door

Bedbase bedstead, bed sets
Bedbaseset complete sets of bed frame

Bedroomsuite bedroom family furniture
the Bedstead bedstead
Bentwoodfurniture bentwood furniture
Besidetable bedside cabinet
Birchdoor birch doors
Board-roomandconferencetable conference table
Bookcase Bookcase
the Bookshelf bookshelves
Built-inkitchen matching kitchen furniture
Bunk bunk beds
Bunkbed Bunk beds
C
Cabinbed children with multi-functional bed
Cabinfurnitureforships marine furniture
Canopybed with canopy beds, four poster beds
CD- side videostoragecabinet audio cabinet
the
Chairwithcastors foot wheelchair
Changingtable adjustable tables
Chestofdrawers multi-drawer cabinets
Childcot Tong Bed
the
Children bed children bed

Children bedroomsuite children bedroom furniture series

Children chair children chair
CKD (completeknockdown) overall removable furniture
Clothesrail clothes rail
Cocktailcabinet bar cabinet, wine cabinet

Cocktailtable cocktail table
Coffeetable coffee table, coffee table
the Combine-unit cabinet
composite Compositefurniture furniture
Console table near
Consoletable (mounted on the wall) volute legs table
Contractfurniture made the furniture, buy furniture online, the construction of furniture
Contractprogrammes made furniture
Cornersofasuite corner handrail
Cot crib (cot)
Couch, couch,
Cupboard cabinets
 Cupboardwallunitforflat suite wardrobe
Curtain, curtains, curtain
Customizedfurniture made furniture
D
Decorativelighting decorative lamps
Diningroomfurniture restaurant furniture
supporting Diningroomset living room furniture
Diningtable table
Divan couch, sofa bed 
Dividingwallandfittedwallunit wall panels and a series of
DIYfurniture mounted furniture
Double-bed double bed
Doublefunctionsofa-bed double sofa bed
Doublesidedmirror two-way mirror

Draughtsmanchair bar chair
Drawer drawer
Dressingtable dresser
E
Easychair lightweight chair
Endtable coffee table
the
Entrancehallfurniture hall furniture
Exteriordoor outdoor door 
F
Filingcabinet file cabinet
Fireplace fireplace
the Fitment fixed furniture
of Fitting Home Supplies
Flap turned to the door

Flowerstand flower

Flushdoor plane door and for the entire board door

Foldingchair folding chair
Foldingfurniture folding furniture
Folkfurniture folk furniture
Foot-stool step footstool
Framedmirror with box mirror
French-typefurniture mode The furniture
Frenchcabinet French furniture curved feet
the
Frenchdoor glass door
Functionsofa multifunctional sofa

Furnitureforbedrooms bedroom furniture
Furnitureforpublicpremises public places furniture
G
Gametable toy table
Gate- legtable folding table

Glasscabinet glass display cabinet

Glasscase glass furnishings cabinet
Glassunitandcontainer glass container products
the
Glazeddoor glass door
H-

Hallfurniture rooms. furniture
Hatandcoatstand coat rack
Headboard bed

Heirloomqualityfurniture ancestral furniture
foot bed Highbed children (without drawer cabinets)
the Highchair high chairs
Highbackexecutivechair high back office chair
the
Homefurniture family furniture, furniture

Homeofficefurniture home office furniture

Hotelfurniture hotel furniture
Householdfurniture home furniture
, Hutch in a bowl of

Institutionalfurniture custom furniture, public furniture
J
Juniordeskchair students desks chair
K
Kitchenblock / kitchenrock kitchen floor tiles
Kitchencabinet sideboard
Kitchenchair, stoolandbench kitchen chairs, stools and chair
Kitchenfitment fixed kitchen furniture

Kitchentable kitchen table
Kitchenunit kitchen sets, furniture
L
Lamptable lamp tables
Lathgrid lath grid
Ledgeddoor the candybar door
Linkchair the WordPad chair
Livingroomfurniture
, living room furniture Locker, locker
Loungefurniture living room furniture
Louvereddoor shutters doors
Lowbackexecutivechair low back office chair
back the
Lowbackguestchair low-back guest chair
Lowbackvisitorchair low back visitor chair
M
Managerialmediumbackchair manager chair
the
Marginedflushdoor trim flat-panel door
Mattress in the mattress, Simmons
Mediumbackexecutivechair back office chair
Metalfurniture metal furniture

Mirrordoor glass doors

Mirrorforchestofdrawers multi-drawer cabinets vanity mirror
Multi-purposesofa multi-sofa
Multi- purposetable multi-purpose table
N
Nest coffee table
O
Occasionalfurniture matching furniture, leisure furniture
 Occasionaltable leisure table
Officefurniture office furniture
Officeseating office seat.
Officetable desk
P 
Partitionwall, cut off
Pembroketable fold topped table
Planterschair gardener chair
Plasticfurniture plastic furniture
 Playfurniture entertainment furniture
Presidentialhighbackchair high back office chair
Pull-outtable telescopic tableware
R
Rattanfurniture
, rattan furniture, Recliner recliner
Refectorytable long table
Rockingchair rocking chair
Rotarychair swivel
Rusticstylefurniture the country style furniture

rectangulartable long table
red-lacqueredchest red wood box
the
roundbed round bed

roundstool stool
roundtable roundtable
round the-backedarmchair armchair
S
Schooltable desk
screen screen
Seat, seat
secretaire desk (especially the drawers and classification grid)

Secretarialchair Secretary Chair 
sectionalsofa put together the sofa
semi-of CKD dismantling furniture

separatewinecabinet independent cabinet
servingtable send the table
settee; chaiselongue settee
shelvingcombination combination frame
the
shoerack Xiejia
sidetable small table
 sideboard sideboard
simmousbed the Simmons
singlebed single beds
slatstool board bench
sleepersofa to sleep on the sofa
sofa sofa
sofabed sofa bed
sofatable sofa table

softchair ottoman
springbed; steelcot spring bed; spring bed
spring-seatchair spring seat
the
squarestool Fangdeng
squaretable square table
steelchair armchair
steeldesk steel desk
steelsafe safe
stepstool ladder stool
stool stool; put footstool

storageforumbrellas umbrella frame

straightbackchair straight back chairs
strongbox;
studiocouch the the safe safe single sofa bed
suitcase; the trunk the trunk; small suitcase
swivelarmchair canvas deck chairs
swivel-topstool The rotating stool
(b) furniture style
A —-

agenerationofchairs office chair Improved
aprovenprogram an implementation. The project
arelaxedpostureineveryseatingposition adapt to various posture, furniture, people feel more comfortable
aestheticdesign aesthetic design
allowanambiencetobeharmoniouslycreated the create a harmonious and warm atmosphere beautiful

appealingdesign shape
artisancraftsmanship craftsmanship
B —-
Barocostyle Baroque style
C —-
Colonialplantationfurniture colonial plantation furniture
Contemporarydesign modern style.
Copy to copy, imitation, counterfeit 
D —-
the
Designstudio design firm
Designtrend design trends
Designer designer
Distinctgrainpattern clear wood grain pattern
—-
Economical, versatileandefficient affordable, multi-purpose, high efficiency
Emphasizethemagnificentfeaturesoftherange express a more convenient and comfortable luxurious atmosphere
Energyandcomfort
Essential functionaldesign basic functions
EthnicAfricanstyle African ethnic style

Focusontheessential focus on the nature of
of Freelance freelance
Functional, ergonomic, long-lasting full-featured, ergonomic, durable
Functionality, qualityandappealingdesign function, excellent quality, fabric sofa,,
Graphicdesign picture, good shape
G —-
(binding) design
H —-
Highquality quality
—-
Idealcombinationbetween both perfect The combination of
Imitate imitate
InaItalianwalnutfinish Italian walnut effect
of Innovative innovative
Intelligentdesign rational design
Interiordecorator indoor artist
Interiordesign
Interiordesigner indoor decorator, interior design

Italianstyle Italian style
L —-

Lightcolor light-colored, pale
M —
Marbledeffect marble effect

Meetthestandardsofallareasofthemodernworldofwork meet modern office requirements
MingDynasty Ming Dynasty
N —-
Naturalfeelingofwarmthandtexture texture of warm natural
neo-classical style
in Neoclassicstyle
P —-
Perfectinshapeandfunction shape of a beautiful, fully functional

Productimagedevelopment product image promotion
Productindustrialization the products of industrialization (design)
Q —-
QingDynasty Qing Dynasty
R —-
the Rectangular Rectangular
Rococostyle Rococo style
T —-
Terra the-cottagranulatedpaintfinish Tao gravel paint effects
 Thestrengthofthecompany focus
Traditionaldesign traditional style
W —-
Withaclassictrend with classical style
 Withtheexperienceofspecialist expert design
Withoutcompromise exhaustive
(c) paint coating vocabulary
A —-
 Accelerate Accelerator hardener promoting agent

in contact with agents Aceticacid acetate
Acetone Acetone
Achromaticcolor no color
Acidstain acrylic resin
Acrylic, acrylic
Acrylicsacidresin acrylic resin (class)
AcrylonitrilebutadienestyreneresinABS resin, Acrylonitrile – butadiene – styrene resin

Activeagent active agent
additive additive
Additivemixture additive color mixing

Adhesivesolvent rubber (material) solvent
Adjacentcolor similar color
Advancingcolor into the excellent
Aerosolspraying simple spray
Afterimage afterimage

Airdrying dry at room temperature
Airlessspraying airless spray

Alcoholstain alcohol colorants the
Alertcolor warning color
Alkydresin alkyd
Alligatoring film cracking.
Amountofspread the amount of adhesive

anti-rust paint Anticorrosivepaint
Antifoulingpaint antifouling paint
Antiquefinish antique paint
Automaticspraying automatic spraying
B – -

Bakingfinish paint spray
Baseboat primer
Blistering vesicles
Blushing albino
Bodyvarnish polished the paint
Brilliant, bright
Brushing Brush
Brushingmark / streak brush marks

bubbling the bubble
Buttonlac refined shellac
C —-
the Caf □ brown
Carbamideresinadhesive, urea resin plastic
Catalyst catalyst, catalyst contact agent
Chalking Chalking
Cherry Cherry
word Chipping peeling.
Chromaticcolor, a color
Chromaticity Chromaticity
Chromaticitycoordinates chromaticity coordinates
Chromaticitydiagram chroma circle
the Clssing up painting
Clearcoating transparent coating
Clearlacquer transparent paint
Clearpaint transparent coating
Coarseparticle coarse
Coating. paint
Cobwebbing cracks
Cocos cocoa color
Coldwaterpaint waterborne coatings
The Colorblindness color blindness

Colorconditioning color adjustment

Colorharmony color to reconcile

Colorinoil tablets kinds of special (color)
Colormatching color
Colornumber color (color number or code)
Colorpaint colored, paint

Colorreaction significant color reaction

Colorreproduction color reproducibility allow poor
Compatibility Compatibility
Complimentarycolor complementary color
Consistency thick thickness

Colortolerance color
Contractivecolor contraction color
the
Colcolor cold color, cool

Coolingagent coolant
Coveringpower covering the force
 Cracking cracking Cresolresinadhesive cresol resin
Crimping wrinkles, cracks

Cure is hardening
Curingagent, hardener
the
Curingtemperature curing temperature
D —-
Dark dark
Deep deep
the Degumming unglued

Dewaxedshellac plastic wax shellac
the Diluent thinner, diluting agent

Dilutionratio dilution ratio of
Dingy muddy color
Dipping impregnated coating
Dippingtreatment color
Discoloring color
Discord incongruous color the Drier desiccant

Dryrubbing dry grinding
Dryingtime drying time
Dulling loss of light

E —-
Egg-shell Zhi Kong Yaguang Hin Kong Yaguang
electrostaticspraying electrostatic painting
 emulsionadhesive the emulsification plastic
emulsionpaint emulsion paint
enamel paint, enamel
end-coating seal coating

epoxyfinish Epoxy effect
epoxyresinglue epoxy glue

ethylcelluloselacquer ethyl cellulose paint
F —-
Fading fading
Filler Putty, Zhi materials, fillers
Finishcode paint number
Flatness Finshing finishing

Flaking peeling
Flatpaint extinction coating
extinction
Floorpaint floor coating

Foamglue bubble gum
G —-
gelatin gelatin, furniture online store, gel
glare Glare
Glue, adhesive, glue, rubber

of Glueandfillerbond animal glue and filler cement
Gluemixer tune glue
Gluespreader Gum, gum, gum
H —-
Hardener hardener
the Hide leather, gluing machine

Highsolidlacquer high solids paint, glue

Honeycolor honey color
—-

Illuminantcolor light color 
J —-
the
Jellystrength glial strength

Jointstrength plastic bonding strength
L, —- 
Lac shellac
Lacvarnish varnish
Lacquer paint
of Latex latex
Latexpaint The synthetic resin emulsion paint
Levelingagent of the agents
Light bright

Liquidglue liquid glue
Longoilvarnish long sexual the varnishes
Loveformaldehyde low formaldehyde
M —-
Makeuppaint mixed paint
Mediumoilvarnish Petroleum degrees varnish 
Melamineresinadhesive trimeric chloramine resin, melamine resin plastic

Melamineresinsheet trimer the chloramine resin (tablets)
Methylalcohol formaldehyde
the Multi-color colorful paint
N —-

Naturalclearlacquer varnish
N.Clacquer nitrocellulose paint
N.Clacquerenamel, nitrate color cotton paint

N.Clacquersealer nitrocotton-primer

N.Clacquersurfacer tip of cotton coated the entire surface of the coating
Nitro-celluloselacquer nitrocellulose lacquer, nitro-beech
the Nitro-lacquer Nitrocellulose Liquor
Nitrocelluloselacquer nitrocellulose (spray) paint

Nontoxixfinishes non-toxic paint
Novolac (linear) novolac
O —-
off-color discoloration, fading, Non-standard colors

Oilpaint oil paint
oil Oilputty the putty
Oilsolvent oil solvent
Oilstain oil colorant 
Oilstaining oil coloring
Oilstone Whetstone
Oilvarnish oil-based varnish, varnish
Opacity opacity
 Opaquepaint opaque paint
P —-
the Paint paint paint
Paintfilm coating
paint nozzle
Paintnozzle
Penetrant penetrants
Phenolaldehyderesin phenolic resin
Polishingvarish rub the light (light) varnish
PolyUrethaneResin polyurethane (PU)
Polyester polyester
Polyesterresinlacquer polyester resin coating
Polypropylene Polypropylene
Polystyrene polystyrene Polyurethane polyurethane, ethylene

Polyvinylacetateadhesive polyvinyl acetate glue (resin)

Polyvinyladhesive polyethylene resin
Polyvinylchlorideresin poly vinyl coating
Pre-coating pre-coated

Procuring Precuring
Preservative preservatives
Primer is primer (the coated paint)
Putty putty
Pyroxylinlacquer nitrolacquer
Q —-
Quickdryingpaint speed The Dry Lacquer
R —-
Readymixedpaint reconcile paint

Refinedshellac refined shellac

Resinadhesive resin glue 
Reversecoater, reverse coating device
the
Rollerbrush roller
S —-

Sampleboard model
Sandblast Sandblasting
(d) wood furniture vocabulary
A —-
Abele Populus
 Abnormalwood abnormal sound board (wood) material
Acousticacidboard sound-absorbing fiberboard
Acousticalboard suck (repeat)
Adjustabletemplate adjustable model
Adultwood adult material
Africanblackwood African Blackwood Dalbergia
Africanebony African ebony
Africanmabogany senegalensis
Africa
Africanpadauk sandalwood
Aging. aging, the aging
Airdrying atmosphere dry
Airseasoning natural drying

Alaskafir Alaska fir
Alaskayellowcedar Alaska cedar
Alder, Alnus class
Americanash ash
Americanbeech U.S. the beech
Americaneim U.S., elm, Ulmus pumila
Americanplane U.S., sycamore
Americantulipwood U.S. Liriodendron
Annualring ring
the Apron Wangban
Armor-plywood metal panels
Arris, edge
Artificialslabs wood-based panels

Artificialtimber artificial wood
Ash ash
Aspen Poplar class
B —-
Babool acacia trees
Back backplane
the Backboard backplane
Backveneer liner
Baldcypress Taxodium
the Bamboo bamboo
Basswood Basswood, American basswood
Battenboard board heart Blockboard
the Beech Beech
Beechparquet, beech parquet
Bentwood (curved) bentwood
Birch, White Birch,

Birdseyemaple bird eye maple panels
Block plug angle
Blockfloor parquet
Blockboard fretwork wood
Board plates
Bottom backplane
Bowing along curved
the the Branchwood branches material
Brazilianmahogany Brazilian mahogany
Brightsap net surface sapwood, the skinless sapwood
Broadleafwood hardwood
Brownash U.S. dark ash
of hardwood the Burl tree scars, burl
C —-
Caul plate, lining
Cedar cedar, Friends of furniture sofa, fir

Ceylonebony ebony
Cherry Cherry
Chilepine Chi Lisson
Chinesechi (China) sumac
Chip sawdust
# 1common,-Pu a
# 2common general two

compreg glue. compression wood
compressedwood compression conifers, wood
coniferousspecies

continuouslayerboard multilayer
cork cork
cottonwood cottonwood, poplar ( Populus tomentosa class) crotch Ah right
crook bent wood
the crossrail pull files

cupping Alice bend
curlybirch wrinkles birch board
curvedlaminatedwood bending, laminated timber
curvedplywood curved plywood
cypress conifer
 D —-
Dado dado, dado
Damproompanel moisture paneling
Decay early rot
 Deciduousspecies broadleaf
D □ corpanel paneling, decorative plate

Deltawood multi-layer wood
Densifiedwood strengthen wood
 Densityofwood wood density
Dent, bite the head
Depthofcut cutting the amount (depth)
Diffuseporouswood scattered the porous wood,

Dimensionstock specification material
Dimpledjohar corrugated
the Doorframe wings wood
Doorlining doorframe
 Dovetail door liner
Dowel dovetail
Drawerfront round tenon
Drawerside drawer next to the board
Dressedtimber net material
E —-
Easterncottonwood (U.S.) Eastern Poplar
Easternhemlock (Canada) hemlock
Easternlarch larch
Easternwhitepine (United States) white pine
the Ebony ebony
Edgecutting Edge
the Elm Elm
Elmburl thin elm burl wood
Endcutting truncated
Englishplane the English Platanaceae
of Eucalyptus eucalyptus, eucalyptus (class)
Eucalyptuspom lemon the metal eucalyptus wood
Europecherry European cherry board
Eropeanash European ash
European birch
Europeanbeech
Europeanbirch European birch
Europeanchestnut European chestnut
Europeanhop-hornbeam European ears elm

Europeanhorse-chestnut European Buckeyes
Europeanlarch European larch
Europeanlime European basswood
Europeanspruce European spruce
Europeanyew Europe yew
Excelsior-board wood wool board
the Exotics foreign wood
Exteriorplywood outdoor plywood
F – -
Faceveneer surface veneer
of FAS one and two
FAX1F sided one
Fibreboard the fiberboard
the Fiddleback violin back (board)

Fiddlebutt instrument material
Figured Shadow Wood
Figuredsycomore Indus shadow wood 
Finewoodboard fiberboard
Flakeboard particle board
Flakes flake shavings
Flame, retardantfibrebuildingboard refractory fiberboard
 flat-grainlumber Ping cutting pattern sheet
Flooring floor
Flushpanel (light) paneling
Formedplywood molded, (molding) plywood 
Framecoreflushpanel hollow plywood
Fromsustainableforests from sustainable forests
Furnituredimensionstock Furniture Lumber
Furnitureplywood furniture plywood the
Furnitureveneer production furniture flakes
G —-
Gap

Giantcedar (USA), side away from the seam the Bo
Gloss gloss
Grade Level
Gradeoflumber lumber grades
raded graded

Grain, texture
H —-

the
Bandselected manual selection
Hardboard rigid fiberboard
the
Hardmaple hard maple, mechanical tree
Hardycatapa (United States) catalpa

Heatboard heart board
Hickory, Mountain The walnut
High-densityplywood, compressed plywood, high-density plywood
Highgloss super gloss
Highmoistureresistant (HMR) high strength anti-wet

Hipboard Blockboard
Holedrilling drill
heart Honey the-combcoreplywood cellular, plywood
Huanghauliwood yellow rosewood
I —-
Identificationoftimbers timber identification
Imitationwood imitation wood
Importedtimber imported materials
Impregnatedwood ( synthetic resin) impregnated wood
Indiancamphor India camphor
Indianchestnut India chestnut
Indiancinnamon India cinnamon
Indianebony India, ebony
Indian laurel “India” laurel “
Insectattack insect eyes
Insertingpanel Pallet
Installwoodstripflooring install strip flooring 
J —-
Japanesebeech Japanese beech
Japaneselarch Japanese larch
Japanese (red) pine Japan Akamatsu
Japanesethuja Luo Hanbo
Japanesewhitepine Japan to be loose
Jointflooring tongue and groove floor
Jointlessflooring seamless flooring
K —-
the
Karelianbirch g if Lee birch board
Kerfwidth saws road width
Khaya senegalensis

Kilndriedpine kiln dried pine wood
Kilndrying artificial kiln drying
Kindoftimber timber species
Kirl purple Paulownia
the Knob Setsuko
Knock-downcarcass may at any time the framework of the demolition
Knot, knot, knots
L —-
Laminate laminate
Laminatedwood laminated wood, multi-layer laminated wood

Leg leg, foot

Liquidcuttingofwood timber hydraulic cutting
Log logs
Loggrade log grades

outdoor furniture – Artie, baby basket

admin — Fri, 03 Feb 2012 12:27:35 +0000

Name: baby basket BABY SWING
belongs to the: Product: Asian emperor

Noble and charming ASHLEY furniture

admin — Fri, 03 Feb 2012 12:27:31 +0000

June 27, 2011
ASHLEY famous furniture brand from Arcadia, has over 50 years of development history, the nation largest furniture manufacturer, and year-round to maintain sales The ASHLEY company always adhere to the class design and products for the consumer home into a fine and elegant living environment. Features: affordable, fine workmanship, sophisticated materials, the United States and flavor!

[Reserved] C # keywords – using

admin — Tue, 03 Jan 2012 14:24:22 +0000

November 18, 2011
using keyword has two main purposes:
(a ) as instructions for creating an alias for a namespace or import other types defined in a namespace.
(b) As a statement, used to define a range, in this range will be released at the end of the object.
using directive
① allow the use of types in a namespace, so you do not have space in the name of a limited a type of use:
using System.Text;
using PC.Company;
 ② To create an alias for a namespace or type.
using MyCompany = PC.Company; / / namespace alias.
using Project = PC.Company.Project; / / type of alias
using namespace introduced, does not mean that the compiler compiled with the set the namespace where the assembly, assembly process of the load depends on the existence of an assembly operation is invoked , if there is no code, the compiler will call the action does not load using the namespace where the introduction of the assembly. Therefore, beginning in the source file, the introduction of multiple namespaces, not loading multiple assemblies, will not cause “excessive reference” of the state.
create an alias for another important reason is that the same file into a different namespace includes the type of the same name, such as SharpMap.Geometries.Point with System.Drawing.Point. To avoid name conflicts can be resolved by setting an alias:
using SGPoint = SharpMap.Geometries.Point;
using SDPoint = System.Drawing.Point;
Although we can type the whole name to be distinguished, but this is clearly not the best solution. Create an alias with the using directive, effective solution to this potential naming conflicts, is the best solution.
using statement
using statement allows the programmer to specify the use of resources when the object should release resources. objects used in a using statement must implement the IDisposable interface. This interface provides the Dispose method, which will release resources for this object.
① being declared in the using statement object.
Font font2 = new Font (“Arial”, 10.0f);
using (font2)
{

/ / use font2
}
② in the using statement before the statement object.
using (Font font2 = new Font (“Arial”, 10.0f))
{
/ / use font2 
}
③ Multiple objects can be used together with the using statement, but must be declared inside the using statement in these objects.
using (Font font3 = new Font (“Arial”, 10.0f), font4 = new Font (“Arial”, 10.0f))
{
/ / Use font3 and font4.
}
use rules
① using can only be used to implement the IDisposable interface type, to prohibit the type does not support the IDisposable interface using statement, otherwise it will appear compile error ;
② using statement for clean-up individual unmanaged resources, and more to clean up the unmanaged object is best to try-finnaly to achieve, because there may be nested using statement to hide the Bug. inner using block throws an exception, will not block the release of the outer layer of the object using resources;
③ using multiple variable initialization statement to support, but only the type of these variables must be the same For example:
using (Pen p1 = new Pen (Brushes.Black), p2 = new Pen (Brushes.Blue))
{

/ /
}
④ for the initialization of the different types of variables can be declared as IDisposable type are, for example:
using (IDisposable font = new Font (“Verdana”, 12), pen = new Pen (Brushes.Black))
{
float size = (font as Font) . Size;
Brush brush = (pen as Pen). Brush;
}
using real
at the assembly stage, the compiler will automatically be using try-finally statement is generated as a statement in the finally block and call the object Dispose method to clean up resources. Therefore, using try-finally statement is equivalent to the statement, for example:
Font f2 = new Font (“Arial”, 10, FontStyle.Bold);
try
{
/ / perform text drawing operations
}
finally
{
if (f2! = null) ((IDisposable) f2). Dispose ();
}