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中依赖注入的原理，当然这里是最简单的实现，剩下的路，还需要骚年你自己走哇~