Spring Bean Learn to create and use < two >

transferred from: http://blessht.iteye.com/blog/1162131In the normal Java development, programmers in a class need to rely on other classes of methods, it is usually a new dependent class to invoke the class instance method, the problem is that the new class instance is not a unified management, spring put forward the idea of dependency injection, that is, the dependency class is not instantiated by the programmer, Instead, the spring container helps us to specify the instance and inject the instance into the class that needs the object. Another argument for dependency injection is "inversion of control", the popular understanding is that we are usually the new instance, the control of this instance is our programmer, and control inversion means that the new instance work is not done by our programmers but by the spring container. Spring has several forms of dependency injection, and the following is a description of how Spring uses XML for IOC configuration:

• Set injection

This is the simplest way to inject, assuming that there is a springaction, the class needs to instantiate a Springdao object, then you can define a private Springdao member variable, Then create the Springdao set method (which is the input entry for the IOC): Java code

2. Package com.bless.springdemo.action;
4. Public class Springaction {
6. //Inject object Springdao
8. private Springdao Springdao;
10. //Be sure to write the set method of the injected object
12. public void Setspringdao (Springdao springdao) {
14. This.springdao = Springdao;
16. }
20. public void ok () {
22. Springdao.ok ();
24. }
26. }

The name attribute in the XML file,<bean>, which is then written in spring, is an alias for the Class property, which refers to the full name of the classes, because there is a public property Springdao in Springaction, so the <bean > Create a <property> tag in the label to specify Springdao. The name in the <property> tag is the Springdao attribute name in the Springaction class, and ref refers to the following <bean name= "Springdao" ...; This is in fact the spring to instantiate the Springdaoimpl object and call Springaction's Setspringdao method to inject Springdao: Java code

1. <!--configuration Bean, which is configured with spring management
2. <bean name="springaction" class="com.bless.springdemo.action.SpringAction" >
3. <!--(1) Dependency injection, configuring the corresponding property in the current class --
4. <property name="Springdao" ref="Springdao" ></property>
5. </bean>
6. <bean name="Springdao" class="Com.bless.springdemo.dao.impl.SpringDaoImpl" ></bean>

• Constructor injection

This method of injection refers to the constructor injection with parameters, see the following example, I created two member variables Springdao and user, but did not set the object's set method, so it cannot support the first injection method, The injection method here is injected into the springaction constructor, meaning that the Springdao and user two parameter values are passed in when the Springaction object is created: Java code

2. Public class Springaction {
4. //Inject object Springdao
6. private Springdao Springdao;
8. Private User User;
12. Public springaction (Springdao springdao,user User) {
14. This.springdao = Springdao;
16. this.user = user;
18. System.out.println ("construct method calls Springdao and user");
20. }
24. public Void Save () {
26. User.setname ("Kaka");
28. Springdao.save (user);
30. }
32. }

In the XML file is also not in the form of <property>, but using the <constructor-arg> tag, the ref attribute also points to the name attribute of the other <bean> tag: XML code

2. <!--configuration Bean, which is configured with spring management
4. <Bean name= "springaction" class="Com.bless.springdemo.action.SpringAction">
6. <!--(2) to create a constructor injection, if the main class has a constructor that has parameters, you need to add this configuration --
8. <constructor-arg ref="Springdao"></constructor-arg>
10. <constructor-arg ref="user"></constructor-arg>
12. </Bean>
14. <Bean name= "Springdao" class="Com.bless.springdemo.dao.impl.SpringDaoImpl"> </Bean>
16. <Bean name="user" class="Com.bless.springdemo.vo.User"></ Bean>

To solve the uncertainty of the constructor method parameters, you may encounter the constructor method passed in the two parameters are the same type, in order to distinguish which to assign the corresponding value, you need to do some small processing: The following is set index, is the parameter location: XML code

2. <Bean name= "springaction" class="com.bless.springdemo.action.SpringAction">
4. <constructor-arg index="0" ref="Springdao"></constructor-arg >
6. <constructor-arg index="1" ref="user"></constructor-arg>
8. </Bean>

The other is to set the parameter type: XML code

1. <constructor-arg type="java.lang.String" ref= ""/>

• Method injection of static factory

Static factory as the name implies, is to call the static factory method to obtain their own objects, in order to let spring management of all objects, we can not directly through the "Engineering class. Static method ()" To get the object, but still through the form of spring injection to get: Java code

2. Package com.bless.springdemo.factory;
6. Import Com.bless.springdemo.dao.FactoryDao;
8. Import Com.bless.springdemo.dao.impl.FactoryDaoImpl;
10. Import Com.bless.springdemo.dao.impl.StaticFacotryDaoImpl;
14. Public class Daofactory {
16. //Static factory
18. public static final Factorydao Getstaticfactorydaoimpl () {
20. return new Staticfacotrydaoimpl ();
22. }
24. }

Also look at the key class, where I need to inject a Factorydao object, which looks exactly like the first injection, but looking at the subsequent XML will find a big difference: Java code

2. public class Springaction {
4. //Inject object
6. private Factorydao Staticfactorydao;
10. public void Staticfactoryok () {
12. Staticfactorydao.savefactory ();
14. }
16. the Set method of the//injected object
18. public void Setstaticfactorydao (Factorydao staticfactorydao) {
20. This.staticfactorydao = Staticfactorydao;
22. }
24. }

Spring's IOC configuration file, note that <bean name= "Staticfactorydao" > points to the class is not a Factorydao implementation class, but instead points to the static factory daofactory, and configures Factory-method= "Getstaticfactorydaoimpl" specifies which factory method to call: XML code

2. <!--configuration Bean, which is configured with spring management
4. <Bean name= "springaction" class="Com.bless.springdemo.action.SpringAction" >
6. <!--(3) Use the static factory method to inject the object, corresponding to the following configuration file (3) --
8. < name= "Staticfactorydao" ref="Staticfactorydao"></Property >
10. </Property>
12. </Bean>
14. <!--(3) The way to get objects here is to get the static method from the factory class--
16. <Bean name= "Staticfactorydao" class="Com.bless.springdemo.factory.DaoFactory " factory-method="Getstaticfactorydaoimpl"></beans>

• Method injection of the instance factory

The instance factory means that the method of getting an object instance is not static, so you need to first new factory class and then call the normal instance method: Java code

1. Public class Daofactory {
2. //Instance factory
3. Public Factorydao Getfactorydaoimpl () {
4. return new Factorydaoimpl ();
5. }
6. }

So the following class has nothing to say, similar to the previous one, but we need to create a Factorydao object from the instance factory class: Java code

2. Public class Springaction {
4. //Inject object
6. private Factorydao Factorydao;
10. public void Factoryok () {
12. Factorydao.savefactory ();
14. }
18. public void Setfactorydao (Factorydao factorydao) {
20. This.factorydao = Factorydao;
22. }
24. }

Last look at spring configuration file: XML code

2. <!--configuration Bean, which is configured with spring management
4. <Bean name= "springaction" class="Com.bless.springdemo.action.SpringAction">
6. <!--(4) Use the method of the instance factory to inject the object, corresponding to the following configuration file (4) --
8. < name= "Factorydao" ref="Factorydao"> </Property>
10. </Bean>
14. <!--(4) The way to get an object here is to get the instance method from the factory class--
16. <Bean name= "daofactory" class="Com.bless.springdemo.factory.DaoFactory"> </Bean>
18. <Bean name="Factorydao" factory-bean="daofactory" factory-method=" Getfactorydaoimpl "></bean>

• Summarize

The Spring IOC injection method uses the most of (1) (2) species, thanks to more skilled will be very proficient. Also note: Objects created by spring are singleton by default, and if you need to create a multi-instance object, you can add a property after the <bean> tag: Java code

1. <bean name="..." class= "..." scope="prototype" >

Spring Bean Learn to create and use < two >