Detailed explanation of several methods of dependency injection in Java Spring

This article mainly introduces several methods of Spring dependency injection in detail. The editor thinks it is quite good, so I will share it with you now and give it as a reference. Let’s follow the editor and take a look.

Introduction to IoC

In ordinary Java development, programmers need to rely on methods of other classes in a certain class.

Usually new is a method of relying on a class and then calling a class instance. The problem with this kind of development is that new class instances are not easy to manage uniformly.

Spring puts forward the idea of ​​dependency injection, that is, dependent classes are not instantiated by programmers, but the Spring container helps us specify new instances and inject the instances into classes that require the object.

Another term for dependency injection is "inversion of control". The popular understanding is: usually we create a new instance, and the control of this instance is our programmer.

Inversion of control means that the new instance work is not done by our programmers but is handed over to the Spring container.

Spring has multiple forms of dependency injection. This article only introduces how Spring performs IOC configuration through xml.

1.Set injection

This is the simplest injection method. Suppose there is a SpringAction and a SpringDao object needs to be instantiated in the class, then you can define a private SpringDao member variables, and then create the set method of SpringDao (this is the injection entry of ioc):

Then write the spring xml file, the name attribute in is an alias of the class attribute, and the class attribute Refers to the full name of the class. Because there is a public property Springdao in SpringAction, a tag must be created in the tag to specify SpringDao. The name in the tag is the SpringDao property name in the SpringAction class, and the ref refers to the following . In this way, spring actually instantiates the SpringDaoImpl object and calls the setSpringDao method of SpringAction to SpringDao injection:

<!--配置bean,配置后该类由spring管理--> 
<bean name="springAction" class="com.bless.springdemo.action.SpringAction"> 
<!--(1)依赖注入,配置当前类中相应的属性--> 
<property name="springDao" ref="springDao"></property> 
</bean> 
<bean name="springDao" class="com.bless.springdemo.dao.impl.SpringDaoImpl"></bean>

2. Constructor injection

This method of injection refers to injection with parameters Constructor injection, look at the example below. I created two member variables SpringDao and User, but did not set the set method of the object, so the first injection method cannot be supported. The injection method here is in the constructor of SpringAction. Injection, that is to say, when creating a SpringAction object, the two parameter values ​​​​of SpringDao and User must be passed in:

public class SpringAction { 
//注入对象springDao 
private SpringDao springDao; 
private User user; 

public SpringAction(SpringDao springDao,User user){ 
this.springDao = springDao; 
this.user = user; 
System.out.println("构造方法调用springDao和user"); 
} 

public void save(){ 
user.setName("卡卡"); 
springDao.save(user); 
} 
}

also does not use tag, and the ref attribute also points to the name attribute of other tags:

<!--配置bean,配置后该类由spring管理--> 
<bean name="springAction" class="com.bless.springdemo.action.SpringAction"> 
<!--(2)创建构造器注入,如果主类有带参的构造方法则需添加此配置--> 
<constructor-arg ref="springDao"></constructor-arg> 
<constructor-arg ref="user"></constructor-arg> 
</bean> 
<bean name="springDao" class="com.bless.springdemo.dao.impl.SpringDaoImpl"></bean> 
<bean name="user" class="com.bless.springdemo.vo.User"></bean>

Resolve the construction Uncertainty of method parameters. You may encounter that the two parameters passed in by the constructor are of the same type. In order to distinguish which one should be assigned the corresponding value, you need to do some small processing:

The following It is to set the index, which is the parameter position:

<bean name="springAction" class="com.bless.springdemo.action.SpringAction"> 
<constructor-arg index="0" ref="springDao"></constructor-arg> 
<constructor-arg index="1" ref="user"></constructor-arg> 
</bean>

The other is to set the parameter type:

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

3. Static factory method injection

As the name suggests, the static factory is to obtain the objects you need by calling the static factory method. In order for spring to manage all objects, we cannot Obtain the object directly through "Engineering Class. Static Method ()", but still obtain it through spring injection:

package com.bless.springdemo.factory; 

import com.bless.springdemo.dao.FactoryDao; 
import com.bless.springdemo.dao.impl.FactoryDaoImpl; 
import com.bless.springdemo.dao.impl.StaticFacotryDaoImpl; 

public class DaoFactory { 
//静态工厂 
public static final FactoryDao getStaticFactoryDaoImpl(){ 
return new StaticFacotryDaoImpl(); 
} 
}

Also look at the key class, here I need to inject a FactoryDao object. It looks exactly the same as the first injection, but if you look at the subsequent xml, you will find a big difference:

public class SpringAction { 
//注入对象 
private FactoryDao staticFactoryDao; 

public void staticFactoryOk(){ 
staticFactoryDao.saveFactory(); 
} 
//注入对象的set方法 
public void setStaticFactoryDao(FactoryDao staticFactoryDao) { 
this.staticFactoryDao = staticFactoryDao; 
} 
}

Spring IOC configuration file, please note that the class pointed by is not the implementation class of FactoryDao, but points to the static factory DaoFactory, and configure factory-method="getStaticFactoryDaoImpl" to specify which factory method to call:

<!--配置bean,配置后该类由spring管理--> 
<bean name="springAction" class="com.bless.springdemo.action.SpringAction" > 
<!--(3)使用静态工厂的方法注入对象,对应下面的配置文件(3)--> 
<property name="staticFactoryDao" ref="staticFactoryDao"></property> 
</property> 
</bean> 
<!--(3)此处获取对象的方式是从工厂类中获取静态方法--> 
<bean name="staticFactoryDao" class="com.bless.springdemo.factory.DaoFactory" factory-method="getStaticFactoryDaoImpl"></bean>

4. Instance factory method injection

The instance factory means that the method of obtaining the object instance is not static. So you need to first create a new factory class, and then call the ordinary instance method:

public class DaoFactory { 
//实例工厂 
public FactoryDao getFactoryDaoImpl(){ 
return new FactoryDaoImpl(); 
} 
}

The following class has nothing to say, it is very similar to the previous one, but we You need to create a FactoryDao object through the instance factory class:

public class SpringAction { 
//注入对象 
private FactoryDao factoryDao; 

public void factoryOk(){ 
factoryDao.saveFactory(); 
} 

public void setFactoryDao(FactoryDao factoryDao) { 
this.factoryDao = factoryDao; 
} 
}

Finally look at the spring configuration file:

<!--配置bean,配置后该类由spring管理--> 
<bean name="springAction" class="com.bless.springdemo.action.SpringAction"> 
<!--(4)使用实例工厂的方法注入对象,对应下面的配置文件(4)--> 
<property name="factoryDao" ref="factoryDao"></property> 
</bean> 

<!--(4)此处获取对象的方式是从工厂类中获取实例方法--> 
<bean name="daoFactory" class="com.bless.springdemo.factory.DaoFactory"></bean> 
<bean name="factoryDao" factory-bean="daoFactory" factory-method="getFactoryDaoImpl"></bean>

5. Summary

The most commonly used Spring IOC injection methods are (1) (2). The more you write and practice, the more you will become very proficient.

Also note: Objects created through Spring are singletons by default. If you need to create multiple instance objects, you can add an attribute after the tag:

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

The above is a detailed explanation of several methods of Java Spring dependency injection. For more related content, please pay attention to the PHP Chinese website (www.php.cn)!