依赖注入(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的注入方式是我们最先学习和使用的方式,也是最熟悉的方式,就简单的做个介绍,举个例子。
- 通过构造方法注入
1 2 3 4 5 6 7 8 9 10 | public class UserServiceImpl implements UserService { private UserDao userDao; public UserServiceImpl(UserDao userDao) { this.userDao = userDao; } /**继承自UserService的方法**/ } |
首先定义一个服务层
接下来就是添加一个构造方法
1 2 3 4 5 6 7 | <!--注册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方法注入
修改
1 2 3 4 5 6 7 8 9 10 | public class UserServiceImpl implements UserService { private UserDao userDao; public void setUserDao(UserDao userDao) { this.userDao = userDao; } /**继承自UserService的方法**/ } |
再修改XML文件内容为:
1 2 3 4 5 6 7 | <!--注册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> |
这两种方式的区别在于,一、
在XML注入过程中,除了使用
基于注解的依赖注入
@Autowired
- 源码
1 2 3 4 5 6 7 8 9 10 | @Target({ElementType.CONSTRUCTOR, ElementType.METHOD, ElementType.PARAMETER, ElementType.FIELD, ElementType.ANNOTATION_TYPE}) @Retention(RetentionPolicy.RUNTIME) @Documented public @interface Autowired { boolean required() default true; } |
另外一点就是,源码当中的
- 通过构造方法注入
1 2 3 4 5 6 7 8 9 10 11 | @Service("userService") public class UserServiceImpl implements UserService { private UserDao userDao; @Autowired public UserServiceImpl(UserDao userDao) { this.userDao = userDao; } /**继承自UserService的方法**/ } |
根据开发文档的说法,这种只有一个构造方法的情况,自Spring4.3以后,就不再需要添加
- 通过setter方法注入
1 2 3 4 5 6 7 8 9 10 11 | @Service("userService") public class UserServiceImpl implements UserService { private UserDao userDao; @Autowired public void setUserDao(UserDao userDao) { this.userDao = userDao; } /**继承自UserService的方法**/ } |
- 通过字段注入
1 2 3 4 5 6 7 8 | @Service("userService") public class UserServiceImpl implements UserService { @Autowired private UserDao userDao; /**继承自UserService的方法**/ } |
- 通过方法入参注入
上面三种注入方式,都是比较熟悉的就不再多做阐述了。重点说一下参数注入,其实方法入参注入方式感觉上是和构造方法、setter方法注入形式差不多,相当于将构造方法、setter方法上的注解
1 2 3 4 5 6 7 8 9 10 11 12 13 14 | @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; } } |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 | //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); } } |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 | //简单的配置类 //作用就是为标有@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; } } |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 | //测试类 //注意:使用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")); } } |
运行测试方法之后就得到以下结果:
注意这里
此外还有需要注意的是,这里所说的方法,不是任意的方法,而是构造方法或setter方法,这种
@Primary 和 @Qualifier
在上面的例子中,我们注入使用到的bean,都只是容器中只有一个Bean实例的情况。那么当容器当中出现多个同类型的
修改配置类代码如下:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 | @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; } } |
修改测试类:
1 2 3 4 5 6 7 8 9 10 11 12 | @RunWith(SpringRunner.class) @ContextConfiguration(classes = DIConfig.class) public class DITest { @Autowired private User user; @Test public void testAutowiredPriamry(){ System.out.println(user); } } |
当不做其他处理时,结果为:
因为有两个User Bean(
修改方式:
- 在
@Bean 中设置name,如@Bean(name="user") ,当名字能够匹配上private User user; 时,也能完成注入。 - 将
private User user 改写成getUser 或getUser2 任意一个,也能完成注入。道理和上面一样,Spring首先会按照type进行匹配,如果无法匹配,再按照名字匹配,都匹配不上时,自然抛出异常。
除此之外呢,Spring为我们提供了两个注解来消除依赖注入时的歧义问题。
@Primary
1 2 3 4 5 6 | @Target({ElementType.TYPE, // 类、接口、枚举类型 ElementType.METHOD})// 方法 @Retention(RetentionPolicy.RUNTIME) @Documented public @interface Primary { } |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 | @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; } } |
比如上面这样,在
但是这种方法的问题就在于
@Qualifier
因此,Spring又提供了
1 2 3 4 5 6 7 8 9 10 11 | @Target({ElementType.FIELD, ElementType.METHOD, ElementType.PARAMETER, ElementType.TYPE, ElementType.ANNOTATION_TYPE}) @Retention(RetentionPolicy.RUNTIME) @Inherited @Documented public @interface Qualifier { String value() default ""; } |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 | @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); } } |
这两种注解都可以消除歧义,推荐使用
当然,上面只是对于
总结
总得来说,Spring是如何实现IoC的呢?首先,Spring提供了一个获取和管理Bean的IoC容器。然后,再提供了一套依赖注入的机制去帮助IoC容器更好地管理各个Bean之间的依赖关系,从而更好地实现IoC的思想。一个Bean不可能完全脱离其他Bean的依赖关系而独立存在,当一个Bean需要其他Bean的引入才能初始化时,就需要依赖注入这个机制。
举例来说,假如存在一个A类想要去调用B接口的方法或者说需要B接口的一个实例。
传统的程序流程是,使用一个C类实现B接口,然后A类创建一个C类的实例,从而调用其方法。
在Spring的依赖注入过程中就变成了,A类只需要在自己的内部添加一个注入接口(广义上的接口,不是
当真正需要生成A类的实例时,Spring IoC容器根据A类提供的接口,为其注入相应的Bean,而这个Bean可以是C类(
最后,最近很多小伙伴找我要Linux学习路线图,于是我根据自己的经验,利用业余时间熬夜肝了一个月,整理了一份电子书。无论你是面试还是自我提升,相信都会对你有帮助!
免费送给大家,只求大家金指给我点个赞!
电子书 | Linux开发学习路线图
也希望有小伙伴能加入我,把这份电子书做得更完美!
有收获?希望老铁们来个三连击,给更多的人看到这篇文章
推荐阅读:
- 干货 | 程序员进阶架构师必备资源免费送
- 神器 | 支持搜索的资源网站