目录
1. 引言
此文目的是用通俗易懂的语言讲清楚什么是依赖注入与反转控制,在看了大量的博客文章后归纳总结,便于后续巩固!我相信,大多数人像我一样,刚开始学习Spring框架的时候仅仅是在学习技术,记住如何做而非为何如此做。因此,本文结合生活例子与项目实际问题入手,讲清楚Spring入门的两个概念。其中,第二篇章管中窥豹需要具备Spring基础知识,你不用非常理解但至少你知道怎么写依赖注入。
2. 管中窥豹
话说,有一天蟹老板想开个餐馆,可是开什么店好呢?他列出了几个选择,牛排店、蟹肉煲店、炸鸡店,火锅店,他非常纠结。于是海绵宝宝告诉他你可以春天卖牛排、夏天卖蟹肉堡、秋天换卖炸鸡,冬天卖火锅。于是,蟹老板接纳了海绵宝宝的意见。春天到了,蟹老板叫海绵宝宝开发了一套店内点餐系统,于是海绵宝宝定义了如下代码:
public interface Chef {
public void cook(); // 厨师长做菜
public void sing(); // 厨师长唱歌
}
并且从海底世界招聘到了张三厨师长,张三厨师长很擅长做牛排,尤其是黑椒牛排一绝,他也喜欢唱歌,因此海绵宝宝写下了如下代码:
public class ZhangChef implements Chef {
String name;
int age;
public ZhangChef(String name, int age) {
this.name = name;
this.age = age;
}
@Override
public void cook() {
System.out.println(name+"正在做黑椒牛排...");
}
@Override
public void sing() {
System.out.println(name+"唱着伤不起...");
}
}
最后,在我们的蟹老板的英明带领下,嘉年华顺利开店:
public class Restaurant {
private String name;
private String specialty;
Restaurant(String name, String specialty) {
this.name = name;
this.specialty = specialty;
}
public void kitchen(){
ZhangChef zhang = new ZhangChef("张三",26);
System.out.println("我们的厨师长是:"+zhang.name+",今年高龄:"+zhang.age);
zhang.cook(); //厨师做菜
}
}
运行结果>>> 我们的厨师长是:张三,今年高龄:26
张三正在做黑椒牛排...
这三个月过的很快,蟹老板也赚了很多钱,海绵宝宝更是成为了本店的CTO,大家其乐融融,一片安好。可是明天就到了夏天,餐厅更换业务,开始经营蟹肉煲,于是张三厨师长被毕业了,李四厨师长正好擅长蟹肉煲,我们的厨师长现在换成了李四。晚上十点钟,海绵宝宝正在加班加点改代码,他需要把整个系统的厨师长换成李四,这是他换好的第一个文件:
public class LiChef implements Chef {
String name;
int age;
public LiChef(String name, int age) {
this.name = name;
this.age = age;
}
@Override
public void cook() {
System.out.println(name+"正在做蟹肉煲...");
}
@Override
public void sing() {
System.out.println(name+"唱着撒浪嘿呦...");
}
}
然后,他需要把整个系统所有方法的zhangChef换成LisiChef,海绵宝宝工作了一夜,第二天依旧没有改完,直到改了半个月后才把整个系统的Chef换完,于是海绵宝宝丢了CTO的职位,成为了普通打工仔程序员。海绵宝宝很不甘心,他辞去了工作,专心研究这个问题如何解决。他发现,Chef 类需要在 Restaurant 类中被实例化,他认为 Restaurant 过于依赖 Chef 了,这不是废话吗?餐厅当然依赖与厨师了,一瞬间他灵机一动说:这种依赖关系是不可避免的,这样做是过度耦合的,我需要给他们解耦!Chef 的控制权并不应该由餐厅掌控,而应该是需要的时候由第三方空降,于是他把Chef 变成了 Restaurant 类的一个变量,Restaurant 不具备实例化他的能力,而是由第三方实例化好后直接赋值给Chef变量,于是他改写成如下代码:
public class Restaurant {
private String name;
private String specialty;
private Chef chef;
#=====================================
public void setChef(Chef chef) {
this.chef = chef;
}
#=====================================
Restaurant(String name, String specialty) {
this.name = name;
this.specialty = specialty;
}
public void kitchen(){
#======================
chef = 第三方力量直接空投 ;
#======================
System.out.println("我们的厨师长是:"+chef.name+",今年高龄:"+chef.age);
chef.cook(); //厨师做菜
}
}
如上面代码所示,第三方力量直接空投怎么实现呢?海绵宝宝思考了一夜,他想到了注射器,能不能像打针一样,把已经实例化好的Chef直接注射到 "chef = 第三方力量直接空投 ;"中的chef 呢?经过漫长的研究,海绵宝宝研发了一款框架,这种框架就是用来解决此问题,因为这是今年春天开始经历的困难,于是他把该框架命名成Spring。
3.1 Spring 依赖注入
他感悟道:如果一个类A 的功能实现需要借助于类B,那么就称类B是类A的依赖,如果在类A的内部去实例化类B, 那么两者之间会出现较高的耦合,一旦类B出现了问题,类A也需要进行改造,如果这样的情况较多,每个 类之间都有很多依赖,那么就会出现牵一发而动全身的情况,程序会极难维护,并且很容易出现问题。要解决这个问题,就要把A类对B类的控制权抽离出来,交给一个第三方去做,把控制权反转给第三方,就称 作控制反转(IOC Inversion Of Control)。控制反转是一种思想,是能够解决问题的一种可能的结果, 而依赖注入(Dependency Injection)就是其最典型的实现方法。由第三方(我们称作IOC容器)来控制依赖,把他通过构造函数 、属性或者工厂模式 等方法,注入到类A内,这样就极大程度的对类A和类B 进行了解耦。
上面 "chef = 第三方力量直接空投 ;" 写成:
ApplicationContext applicationContext = new
ClassPathXmlApplicationContext("applicationContext.xml");
Chef chef = (Chef) applicationContext.getBean("chef");
<bean id="chef" class="com.myjava.zhangChef"/>
这一步还不是依赖注入,只是使用Spring的API实例化对象。因为有setChef 方法,我们可以配置Spring容器调用set方法进行注入,如下才是依赖注入,Spring会自动调用setChef方法给chef设置实例对象,因此不需要上面那一句“chef = 第三方力量直接空投”。真正的空投看不见!
<bean id="chef" class="com.myjava.LiChef"/>
<bean id="restaurant" class="com.myjava.Restaurant">
<property name="chef" ref="chef"/>
</bean>
如果A类需要使用B类,那么我们称为B是A的依赖,我们需要Spring容器(第三方)将依赖B的示例注射给A。因此,需要在Spring核心配置文件中声明控制权,将指定全限定名称的类的控制权(创建权)交给Spring管理,意味着我们可以通过Spring的getBean()实例化。如果类 chef 后期需要升级维护,我们只需要更改其中的代码或者指定其他的类全限定名称(class名称)。
3.2 Bean 的依赖注入方式有两种
①构造方法
创建有参构造
public class UserServiceImpl implements Userservice{
private UserDao userDao;
public UserServiceImpl(UserDao userDao){
this.userDao = userDao;
}
}
配置Spring容器调用有参构造时进行注入
<bean id="userDao" class="com.myjava.dao.impl.UserDaoImpl"/>
<bean id="userService" class="com.myjava.service.impl.UserServiceImpl"> <constructor-arg name="userDao" ref="userDao"></constructor-arg>
</bean>
②set方法
在UserServiceImpl中添加setUserDao方法
public class UserServiceImpl implements UserService {
private UserDao userDao;
public void setUserDao(UserDao userDao) {
this.userDao = userDao;
}
@Override
public void save() {
userDao.save();
}
}
配置Spring容器调用set方法进行注入
<bean id="userDao" class="com.myjava.dao.impl.UserDaoImpl"/>
<bean id="userService" class="com.myjava.service.impl.UserServiceImpl">
<property name="userDao" ref="userDao"/>
</bean>
4. 总结
依赖注入是反转控制的一种实现方法,我个人认为依赖外置比依赖注入更好理解,当然我可能理解的不太深刻有错误。因为原来的程序是直接在A里面实例化B,如果B变了那将导致很多业务代码需要改,这种依赖关系又是无法消除的,只能减弱这种依赖。那么,可以考虑将依赖写到配置文件中,需要的时候注入即可,这里将依赖写到配置文件可以说是依赖外置,但是Spring在运行时是实例化对象然后通过Set或者构造方法将其注入到A类中,因此,这是一个相对的说法。从A类角度出发是外置,从Spring角度是注入。以上内容参考了知乎胡小国博主的文章,感谢!以上内容有错误希望指正!