依赖注入(DI)
DI(Dependency Injection),Spring IoC 不是一种技术,而是一种思想,通过这种思想,能够指导我们设计出松耦合的程序代码。而Spring IoC这个思想的作用体现在两个方面,一是如何将Bean装配到容器中去以及如何从容器中获取Bean,二是如何解决Bean之间的依赖关系,换句话说,就是如果由IoC容器来管理依赖关系,当一个Bean需要依赖另外一个Bean时,IoC容器如何实现这样的依赖关系。
解决Spring中Bean之间的依赖的实现方式,在Spring的概念中就被称之为依赖注入(Dependency Injection,DI)。普遍认为的Spring依赖注入的实现方式有三种:构造方法注入、setter方法注入、注解注入。但,就我而言,我认为应该划分为两种形式——基于XML注入和基于注解注入,然后再细分为下面的形式:
基于XML的注入方式是我们最先学习和使用的方式,也是最熟悉的方式,就简单的做个介绍,举个例子。
- 通过构造方法注入
public class UserServiceImpl implements UserService {
private UserDao userDao;
public UserServiceImpl(UserDao userDao) {
this.userDao = userDao;
}
/**继承自UserService的方法**/
}
首先定义一个服务层UserServiceImpl
,然后在其内部增加对dao层的引用userDao
。
接下来就是添加一个构造方法public UserServiceImpl(UserDao userDao)
以待Spring通过这个方法为userDao
注入实例。
<!--注册userDao-->
<bean id="userDao" class="com.klasdq.sb.c1.di.dao.impl.UserDaoImpl"></bean>
<!--注册userService 并注入userDao-->
<bean id="userService" class="com.klasdq.sb.c1.di.service.impl.UserServiceImpl">
<constructor-arg name="userDao" ref="userDao"></constructor-arg>
</bean>
最后在Spring XML配置文件中注入相应的bean实例。
通过构造方法的注入,必须要注入类中具有对应的构造方法,若没有对应的构造方法,会出现报错。
- 通过setter方法注入
修改UserServiceImpl.java
为:
public class UserServiceImpl implements UserService {
private UserDao userDao;
public void setUserDao(UserDao userDao) {
this.userDao = userDao;
}
/**继承自UserService的方法**/
}
再修改XML文件内容为:
<!--注册userDao-->
<bean id="userDao" class="com.klasdq.sb.c1.di.dao.impl.UserDaoImpl"></bean>
<!--注册userService 并注入userDao-->
<bean id="userService" class="com.klasdq.sb.c1.di.service.impl.UserServiceImpl">
<property name="userDao" ref="userDao"></property>
</bean>
这两种方式的区别在于,一、UserServiceImpl.java
可以不用添加构造方法,但是必须存在一个无参构造方法(如public UserServiceImpl()
,示例里面没写,是因为java默认会提供一个无参构造方法)以供Spring 容器注册生成Bean(如userService
)。二、XML文件中,采用构造方法注入时,需要使用<constructor-arg ></constructor-arg>
这对标签;而在setter方法注入时,使用<property ></property>
标签。
在XML注入过程中,除了使用ref=""
引用之外,还可以使用value=""
设定具体的值,其效果和使用注解@Value
差不多。
基于注解的依赖注入
@Autowired
- 源码
@Target({ElementType.CONSTRUCTOR,
ElementType.METHOD,
ElementType.PARAMETER,
ElementType.FIELD,
ElementType.ANNOTATION_TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Autowired {
boolean required() default true;
}
@Autowired
是基于注解的依赖注入的关键点,它的源码非常简单,只有一个参数request()
,这个参数的作用是标识注入Bean是否一定要注入,也就是说,在Spring容器没有找到相应Bean时,如果其值为true
,就会报出异常;如果其值为false
,就不会出现异常,但在使用过程中,如果容器一直不对Bean进行注入,那么有可能出现空指针异常。
另外一点就是,源码当中的@Target
所包含的参数正好就是基于注解的依赖注入的注入方式种类,@Target
决定了@Autowired
能够标注在哪些类型上面。
- 通过构造方法注入
@Service("userService")
public class UserServiceImpl implements UserService {
private UserDao userDao;
@Autowired
public UserServiceImpl(UserDao userDao) {
this.userDao = userDao;
}
/**继承自UserService的方法**/
}
根据开发文档的说法,这种只有一个构造方法的情况,自Spring4.3以后,就不再需要添加 @Autowired
标注,也可以。但是,如果有多个构造方法时,是必须要对其中一个方法标注 @Autowired
,不然Spring会报出异常。
- 通过setter方法注入
@Service("userService")
public class UserServiceImpl implements UserService {
private UserDao userDao;
@Autowired
public void setUserDao(UserDao userDao) {
this.userDao = userDao;
}
/**继承自UserService的方法**/
}
- 通过字段注入
@Service("userService")
public class UserServiceImpl implements UserService {
@Autowired
private UserDao userDao;
/**继承自UserService的方法**/
}
- 通过方法入参注入
上面三种注入方式,都是比较熟悉的就不再多做阐述了。重点说一下参数注入,其实方法入参注入方式感觉上是和构造方法、setter方法注入形式差不多,相当于将构造方法、setter方法上的注解@Autowired
放到入参的位置。说起来可能有些抽象,直接看例子:
@Component
public class UserDaoImpl implements UserDao {
//简单返回一个User,模拟数据库查找过程
@Override
public User getUser(Long id, String name){
User user = new User();
user.setId(id);
user.setName(name);
user.setAccount("12345678911");
user.setPassword("******");
user.setOtherInfo("this is a test account");
return user;
}
}
//UserService类
@Service("userService")
public class UserServiceImpl implements UserService {
private UserDao userDao;
public UserServiceImpl(@Autowired UserDao userDao,
@Autowired User user) {
System.out.println("UserServiceImpl: "+user);
this.userDao = userDao;
}
@Override
public User getUser(Long id, String name){
return userDao.getUser(id,name);
}
}
//简单的配置类
//作用就是为标有@Componet(@Service也算)注解的类 生成Bean
//同时 为@Autowired标识下的Bean(对象) 注入实例
@Configuration
@ComponentScan
public class DIConfig {
//用于Service类中入参user的注入
@Bean
public User getUser(){
User u = new User();
u.setName("user inject into service");
return u;
}
}
//测试类
//注意:使用JUnit4测试时,如果需要使用@Autowired注入那么必须添加
//@RunWith 标注使用Spring方式启动(或者SpringBootRunner)
//@ContextConfiguration 扫描配置类
@RunWith(SpringRunner.class)
@ContextConfiguration(classes = DIConfig.class)
public class DITest {
//如果不添加测试类上两个注解,会注入失败
@Autowired
private UserService userService;
@Test
public void testAutowired(){ System.out.println(userService.getUser(1L,"name"));
}
}
运行测试方法之后就得到以下结果:
public UserServiceImpl(@Autowired UserDao userDao,@Autowired User user)
中的输出结果:
public void testAutowired()
测试方法中的输出结果:
注意这里public UserServiceImpl(@Autowired UserDao userDao,@Autowired User user)
的入参:
userDao
是UserServiceImpl
的字段,但user
不是。也就是说,我们可以在构造方法中添加任意参数,只要是我们需要的,不一定要求该参数是类中属性字段。
此外还有需要注意的是,这里所说的方法,不是任意的方法,而是构造方法或setter方法,这种public void initService(@Autowired UserDao userDao)
自定义的方法是无法完成注入的。
@Primary 和 @Qualifier
在上面的例子中,我们注入使用到的bean,都只是容器中只有一个Bean实例的情况。那么当容器当中出现多个同类型的Bean
时,如何处理呢?
修改配置类代码如下:
@Configuration
@ComponentScan
public class DIConfig {
@Bean
public User getUser(){
User u = new User();
u.setName("this is user");
return u;
}
@Bean
public User getUser2(){
User u = new User();
u.setName("this is user2");
return u;
}
}
修改测试类:
@RunWith(SpringRunner.class)
@ContextConfiguration(classes = DIConfig.class)
public class DITest {
@Autowired
private User user;
@Test
public void testAutowiredPriamry(){
System.out.println(user);
}
}
当不做其他处理时,结果为:
因为有两个User Bean(getUser , getUser2
,@Bean未注明的情况下,默认方法名为Bean Name)的存在,所以Spring无法确定使用那个进行注入。
修改方式:
- 在
@Bean
中设置name,如@Bean(name="user")
,当名字能够匹配上private User user;
时,也能完成注入。 - 将
private User user
改写成getUser
或getUser2
任意一个,也能完成注入。道理和上面一样,Spring首先会按照type进行匹配,如果无法匹配,再按照名字匹配,都匹配不上时,自然抛出异常。
除此之外呢,Spring为我们提供了两个注解来消除依赖注入时的歧义问题。
@Primary
@Target({ElementType.TYPE, // 类、接口、枚举类型
ElementType.METHOD})// 方法
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Primary {
}
@Primary
是一个设定相同类型Bean优先级的注解,也就是说,一旦在某个类型上添加@Priamry
,当注入时,没有明确指定Bean时,就会注入被@Priamry
标识的Bean。
@Configuration
@ComponentScan
public class DIConfig {
@Primary
@Bean
public User getUser(){
User u = new User();
u.setName("this is user");
return u;
}
@Bean
public User getUser2(){
User u = new User();
u.setName("this is user2");
return u;
}
}
比如上面这样,在getUser()
上添加相应注解,测试方法也能正常运行。
但是这种方法的问题就在于@Priamry
可以用在很多类上,如果同一类型有多个Bean被标注了@Primary
,那么@Priamry
就失去了应有的效果。
@Qualifier
因此,Spring又提供了@Qualifier
这个注解,直接标注在@Autowired
注入的Bean上,为其明确指定注入某个Bean。
@Target({ElementType.FIELD,
ElementType.METHOD,
ElementType.PARAMETER,
ElementType.TYPE,
ElementType.ANNOTATION_TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Inherited
@Documented
public @interface Qualifier {
String value() default "";
}
@Qualifier
可以出现任何@Autowired
能够出现的地方,与之配套使用。比如下面这样:
@RunWith(SpringRunner.class)
@ContextConfiguration(classes = DIConfig.class)
public class DITest {
//直接指定使用getUser2进行注入
@Autowired
@Qualifier("getUser2")
private User user;
@Test
public void testAutowiredPriamry(){
System.out.println(user);
}
}
这两种注解都可以消除歧义,推荐使用@Bean(name="xxx")和@Qualifier(value="xxx")
组合使用的方式`。但是如果开发环境中没有歧义的存在,自然也就不需要使用这些了。
当然,上面只是对于@Autowired
一些常用介绍,如果想要了解更多,可以查看Annotation-based Container Configuration。这个参考文档当中有着更加详细、丰富的介绍。
总结
总得来说,Spring是如何实现IoC的呢?首先,Spring提供了一个获取和管理Bean的IoC容器。然后,再提供了一套依赖注入的机制去帮助IoC容器更好地管理各个Bean之间的依赖关系,从而更好地实现IoC的思想。一个Bean不可能完全脱离其他Bean的依赖关系而独立存在,当一个Bean需要其他Bean的引入才能初始化时,就需要依赖注入这个机制。
举例来说,假如存在一个A类想要去调用B接口的方法或者说需要B接口的一个实例。
传统的程序流程是,使用一个C类实现B接口,然后A类创建一个C类的实例,从而调用其方法。
在Spring的依赖注入过程中就变成了,A类只需要在自己的内部添加一个注入接口(广义上的接口,不是interface
这个接口),这个接口可以是构造方法,也可以是setter方法或者说其他形式;同时添加一个对B接口的引用(private B b;
)。
当真正需要生成A类的实例时,Spring IoC容器根据A类提供的接口,为其注入相应的Bean,而这个Bean可以是C类(class C implements B
{}),也可以D类(class D implements B
{})等等;具体是谁,根据Bean的装配策略和IoC容器中的Bean来确定,不再由开发人员管理。
最后,最近很多小伙伴找我要Linux学习路线图,于是我根据自己的经验,利用业余时间熬夜肝了一个月,整理了一份电子书。无论你是面试还是自我提升,相信都会对你有帮助!
免费送给大家,只求大家金指给我点个赞!
也希望有小伙伴能加入我,把这份电子书做得更完美!
有收获?希望老铁们来个三连击,给更多的人看到这篇文章
推荐阅读:
**粗体** _斜体_ [链接](http://example.com) `代码` - 列表 > 引用
。你还可以使用@
来通知其他用户。