什么是控制反转(IoC)?什么是依赖注入(DI)?以及实现原理
IoC不是一种技术,只是一种思想,一个重要的面向对象编程的法则,它能指导我们如何设计出松耦合、更优良的程序。传统应用程序都是由我们在类内部主动创建依赖对象,从而导致类与类之间高耦合,难于测试;有了IoC容器后,把创建和查找依赖对象的控制权交给了容器,由容器进行注入组合对象,所以对象与对象之间是松散耦合,这样也方便测试,利于功能复用,更重要的是使得程序的整个体系结构变得非常灵活
IoC很好的体现了面向对象设计法则之一—— 好莱坞法则:“别找我们,我们找你”;即由IoC容器帮对象找相应的依赖对象并注入,而不是由对象主动去找
DI—Dependency Injection,即“依赖注入”:是组件之间依赖关系由容器在运行期决定,形象的说,即由容器动态的将某个依赖关系注入到组件之中。依赖注入的目的并非为软件系统带来更多功能,而是为了提升组件重用的频率,并为系统搭建一个灵活、可扩展的平台。通过依赖注入机制,我们只需要通过简单的配置,而无需任何代码就可指定目标需要的资源,完成自身的业务逻辑,而不需要关心具体的资源来自何处,由谁实现。
理解DI的关键是:“谁依赖谁,为什么需要依赖,谁注入谁,注入了什么”,那我们来深入分析一下:
●谁依赖于谁:当然是应用程序依赖于IoC容器;
●为什么需要依赖:应用程序需要IoC容器来提供对象需要的外部资源;
●谁注入谁:很明显是IoC容器注入应用程序某个对象,应用程序依赖的对象;
●注入了什么:就是注入某个对象所需要的外部资源(包括对象、资源、常量数据)
本质上IoC和DI是同一思想下不同维度的表现 ,用通俗的话说就是,IoC是bean的注册,DI是bean的初始化
源码实现原理:
参考文章:
https://blog.csdn.net/lisongjia123/article/details/52129340
https://blog.csdn.net/lisongjia123/article/details/52134396
上面的文章根据源码进行分析,过程比较复杂,因此我进行了一个高度的抽象,希望来描述它们的实现原理:
简单的IoC控制反转代码实现,定义测试的Bean,Student和Teacher
public class Teacher {
private String tName;
// ....get set方法省略
}
public class Student {
private String name;
private String age;
private Teacher teacher;
// ....get set方法省略
}
BeanDefined类,对bean的描述类:
public class BeanDefined {
// bean的id
private String beanId;
// bean的文件路径
private String classPath;
public String getBeanId() {
return beanId;
}
public void setBeanId(String beanId) {
this.beanId = beanId;
}
public String getClassPath() {
return classPath;
}
public void setClassPath(String classPath) {
this.classPath = classPath;
}
}
BeanFactory --- 生成Bean的容器类:
public class BeanFactory {
// 存放bean的集合
private List<BeanDefined> beanDefinedList;
public List<BeanDefined> getBeanDefinedList() {
return beanDefinedList;
}
public void setBeanDefinedList(List<BeanDefined> beanDefinedList) {
this.beanDefinedList = beanDefinedList;
}
/**
* 获取bean实例
*
* @param beanId
* @return
* @throws Exception
*/
public Object getBean(String beanId) throws Exception {
Object instance;
for (BeanDefined bean : beanDefinedList) {
if (beanId.equals(bean.getBeanId())) {
String classPath = bean.getClassPath();
Class classFile = Class.forName(classPath);
// 在spring中调用默认的构造方法,这里我们也调用默认的构造方法
instance = classFile.newInstance();
return instance;
}
}
return null;
}
}
测试类:
public class Test {
public static void main(String[] args) throws Exception {
// 1、声明注册bean
BeanDefined beanObj = new BeanDefined();
beanObj.setBeanId("student");
beanObj.setClassPath("com.pojo.Student");
List<BeanDefined> beanList = new ArrayList<BeanDefined>();
beanList.add(beanObj);
// 2、声明一个BeanFactory,类似于Spring中的ApplicationContext
BeanFactory factory = new BeanFactory();
factory.setBeanDefinedList(beanList);
// 3、开发人员向BeanFactory索要实例对象
Student student = (Student) factory.getBean("student");
System.out.println(student);
}
}
测试结果截图:
从代码里面可以看出来,我们是没有直接new学生类的,主要的思想是,定义BeanDefined对象添加进集合中,通过BeanFactory为我们生产出需要的对象,其中用到的核心技术就是:反射
用代码实现简单的依赖注入:
BeanDefined类需要做一定的修改:
public class BeanDefined {
// bean的id
private String beanId;
// bean的文件路径
private String classPath;
// 存放属性的集合
private Map<String, String> propertyMap = new HashMap<>();
// ....省略set和get方法
}
BeanFactory类需要做如下的修改:
public class BeanFactory {
// 存放bean的集合
private List<BeanDefined> beanDefinedList;
public List<BeanDefined> getBeanDefinedList() {
return beanDefinedList;
}
public void setBeanDefinedList(List<BeanDefined> beanDefinedList) {
this.beanDefinedList = beanDefinedList;
}
/**
* 获取bean实例
*
* @param beanId
* @return
* @throws Exception
*/
public Object getBean(String beanId) throws Exception {
Object instance;
for (BeanDefined bean : beanDefinedList) {
if (beanId.equals(bean.getBeanId())) {
String classPath = bean.getClassPath();
Class classFile = Class.forName(classPath);
// 在spring中调用默认的构造方法,这里我们也调用默认的构造方法
instance = classFile.newInstance();
// 获取bean的属性配置
Map<String, String> propertyMap = bean.getPropertyMap();
if(propertyMap !=null) {
setValue(instance, classFile, propertyMap);
}
return instance;
}
}
return null;
}
/**
* 依赖注入的方法
*
* @param instance 当前的实例对象
* @param classFile 当前实例对象所关联的类文件
* @param propertyMap 属性
*/
public void setValue(Object instance, Class classFile, Map<String, String> propertyMap) throws Exception {
if(propertyMap !=null ) {
/***
* 获取map的所有属性配置
*/
Set<String> proper = propertyMap.keySet();
for(String string : proper) {
// 通过字符串拼接,拼出set方法名
char c = string.toUpperCase().charAt(0);
String s = "set" + c + string.substring(1);
// 获取当前属性的类型
Field field = classFile.getDeclaredField(string);
// 根据属性的类型进行调用
Method m = instance.getClass().getMethod(s, field.getType());
/**
* 直接try注入普通类型,或者catch注入bean工厂中的其他类型
*/
try {
m.invoke(instance, propertyMap.get(string));
} catch (Exception e) {
m.invoke(instance, getBean(propertyMap.get(string)));
}
}
}
}
}
测试类代码需要做如下修改:
public class Test {
public static void main(String[] args) throws Exception {
// 1、声明注册bean
BeanDefined beanObj = new BeanDefined();
beanObj.setBeanId("student");
beanObj.setClassPath("com.pojo.Student");
// 设置 property
Map<String, String> propertyMap = beanObj.getPropertyMap();
propertyMap.put("name", "kxm");
propertyMap.put("age", "22岁");
propertyMap.put("teacher", "teacher");
// 注册教师类
BeanDefined teacher = new BeanDefined();
teacher.setBeanId("teacher");
teacher.setClassPath("com.pojo.Teacher");
List<BeanDefined> beanList = new ArrayList<BeanDefined>();
beanList.add(beanObj);
beanList.add(teacher);
// 2、声明一个BeanFactory,类似于Spring中的ApplicationContext
BeanFactory factory = new BeanFactory();
factory.setBeanDefinedList(beanList);
// 3、开发人员向BeanFactory索要实例对象
Student student = (Student) factory.getBean("student");
System.out.println(student);
}
}
测试结果截图:
仔细分析代码,我们可以发现,没有显示的new对象,也没用用set方法去赋值,但是模拟出来了依赖注入的效果,这也是Spring中依赖注入的原理,当然这里是最简单的实现,剩下的路,还需要骚年你自己走哇~