SpringIOC的实现原理

什么是SpringIOC

spring ioc指的是控制反转，IOC容器负责实例化、定位、配置应用程序中的对象及建立这些对象间的依赖。交由Spring容器统一进行管理，从而实现松耦合

“控制反转”，不是什么技术，而是一种设计思想。

在Java开发中，Ioc意味着将你设计好的对象交给容器控制，而不是传统的在你的对象内部直接控制。如何理解好Ioc呢？理解好Ioc的关键是要明确“谁控制谁，控制什么，为何是反转（有反转就应该有正转了），哪些方面反转了”，那我们来深入分析一下：

●谁控制谁，控制什么：传统Java SE程序设计，我们直接在对象内部通过new进行创建对象，是程序主动去创建依赖对象；而IoC是有专门一个容器来创建这些对象，即由Ioc容器来控制对 象的创建；谁控制谁？当然是IoC 容器控制了对象；控制什么？那就是主要控制了外部资源获取（不只是对象包括比如文件等）。

●为何是反转，哪些方面反转了：有反转就有正转，传统应用程序是由我们自己在对象中主动控制去直接获取依赖对象，也就是正转；而反转则是由容器来帮忙创建及注入依赖对象；为何是反转？因为由容器帮我们查找及注入依赖对象，对象只是被动的接受依赖对象，所以是反转；哪些方面反转了？依赖对象的获取被反转了。

IOC实现原理

使用反射机制+XML技术

理解了这些基本概念后，我们通过一个简单的示意图来简单描述一下整个流程，

从示意图可以看出，当web容器启动的时候，spring的全局bean的管理器会去xml配置文件中扫描的包下面获取到所有的类，并根据你使用的注解，进行对应的封装，封装到全局的bean容器中进行管理，一旦容器初始化完毕，beanID以及bean实例化的类对象信息就全部存在了，现在我们需要在某个service里面调用另一个bean的某个方法的时候，我们只需要依赖注入进来另一个bean的Id即可，调用的时候，spring会去初始化完成的bean容器中获取即可，如果存在就把依赖的bean的类的实例化对象返回给你，你就可以调用依赖的bean的相关方法或属性等；

下面通过实例代码来模拟一下整个IOC的原理和执行流程，
1、demo结构如下，

2、pom依赖文件，这里只需要spring的基本依赖即可，

	<spring.version>5.1.2.RELEASE</spring.version>
	<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
	<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
	<java.version>1.8</java.version>
</properties>

<dependencies>

	<dependency>
		<groupId>org.springframework</groupId>
		<artifactId>spring-core</artifactId>
		<version>${spring.version}</version>
	</dependency>

	<dependency>
		<groupId>org.springframework</groupId>
		<artifactId>spring-context</artifactId>
		<version>${spring.version}</version>
	</dependency>
	<dependency>
		<groupId>org.springframework</groupId>
		<artifactId>spring-aop</artifactId>
		<version>${spring.version}</version>
	</dependency>
	<dependency>
		<groupId>org.springframework</groupId>
		<artifactId>spring-orm</artifactId>
		<version>${spring.version}</version>
	</dependency>

	<dependency>
		<groupId>org.aspectj</groupId>
		<artifactId>aspectjrt</artifactId>
		<version>1.6.1</version>
	</dependency>

	<dependency>
		<groupId>org.aspectj</groupId>
		<artifactId>aspectjweaver</artifactId>
		<version>1.9.2</version>
	</dependency>


	<!-- https://mvnrepository.com/artifact/cglib/cglib -->
	<dependency>
		<groupId>cglib</groupId>
		<artifactId>cglib</artifactId>
		<version>3.2.10</version>
	</dependency>

	<!-- https://mvnrepository.com/artifact/com.mchange/c3p0 -->
	<dependency>
		<groupId>com.mchange</groupId>
		<artifactId>c3p0</artifactId>
		<version>0.9.5.2</version>
	</dependency>

	<!-- https://mvnrepository.com/artifact/mysql/mysql-connector-java -->
	<dependency>
		<groupId>mysql</groupId>
		<artifactId>mysql-connector-java</artifactId>
		<version>5.1.40</version>
	</dependency>

	<!-- https://mvnrepository.com/artifact/dom4j/dom4j -->
	<dependency>
		<groupId>dom4j</groupId>
		<artifactId>dom4j</artifactId>
		<version>1.6.1</version>
	</dependency>

</dependencies>

3、首先我们自定义两个注解，我们知道在业务类中经常使用 @Service来标记这个类是bean管理的类，而@Autowired或者@Resource用于bean之间相互依赖使用，

// 自定义注解 service 注入bean容器

@Target({ ElementType.TYPE })
@Retention(RetentionPolicy.RUNTIME)
public @interface SelfService {

}

//模拟@Autowired注解

@Target({ TYPE, FIELD, METHOD })
@Retention(RUNTIME)
public @interface SelfAutowired {

}

4、模拟spring的bean容器类，想必使用过spring框架在进行整合测试的时候，都使用到下面这段代码，这段代码的作用其实就是模拟在spring启动加载的时候，通过这个类去初始化一个bean 的容器管理类，所有的bean的信息解析和保存都会在这个类里面进行，下面我们写一个这样的类来还原一下这个过程，

SelfPathXmlApplicationContext app = new SelfPathXmlApplicationContext("com.congge.service.impl");

自定义spring的bean容器类，
/**

自定义bean管理器
@author asus

*/
public class SelfPathXmlApplicationContext {

private String packageName;

// 封装所有的bean容器
private ConcurrentHashMap<String, Object> beans = null;

/**

• 该类被创建出来的时候加载
• @param packageName
• @throws Exception
  */
  public SelfPathXmlApplicationContext(String packageName) throws Exception {
  beans = new ConcurrentHashMap<String, Object>();
  this.packageName = packageName;
  initBeans();
  initEntryField();
  }

/**

• 初始化bean的实例对象的所有属性
• @throws Exception
  */
  private void initEntryField() throws Exception {
  // 1.遍历所有的bean容器对象
  for (Entry<String, Object> entry : beans.entrySet()) {
  // 2.判断属性上面是否有加注解
  Object bean = entry.getValue();
  attriAssign(bean);
  }
  }

/**

• 根据beanId获取bean名称
• @param beanId
• @return
• @throws Exception
  */
  public Object getBean(String beanId) throws Exception {
  if (StringUtils.isEmpty(beanId)) {
  throw new Exception("beanId参数不能为空");
  }
  // 1.从spring容器获取bean
  Object object = beans.get(beanId);
  // attriAssign(object);
  return object;
  }

/**

• 获取扫描包下面的所有bean
  */
  private void initBeans() throws Exception {
  // 1.使用java的反射机制扫包,[获取当前包下所有的类]
  List<Class<?>> classes = ClassParseUtil.getClasses(packageName);
  // 2、判断类上面是否存在注入的bean的注解
  ConcurrentHashMap<String, Object> classExisAnnotation = findClassExisAnnotation(classes);
  if (classExisAnnotation == null || classExisAnnotation.isEmpty()) {
  throw new Exception("该包下没有任何类加上注解");
  }

}

/**

• 判断类上是否存在注入自定义的bean的注解

• @param classes

• @return

• @throws Exception
  */
  public ConcurrentHashMap<String, Object> findClassExisAnnotation(List<Class<?>> classes) throws Exception {
  for (Class<?> classInfo : classes) {
  // 判断类上是否有注解 [获取自定义的service注解]
  SelfService annotation = classInfo.getAnnotation(SelfService.class);
  if (annotation != null) {
  // 获取当前类的类名
  String className = classInfo.getSimpleName();
  String beanId = toLowerCaseFirstOne(className);
  Object newInstance = newInstance(classInfo);
  beans.put(beanId, newInstance);
  }

  }
  return beans;
  }

// 首字母转小写
public static String toLowerCaseFirstOne(String s) {
if (Character.isLowerCase(s.charAt(0)))
return s;
else
return (new StringBuilder()).append(Character.toLowerCase(s.charAt(0))).append(s.substring(1)).toString();
}

/**

• 通过class名称获取类的实例化对象
• @param classInfo
• @return
• @throws ClassNotFoundException
• @throws InstantiationException
• @throws IllegalAccessException
  */
  public Object newInstance(Class<?> classInfo)
  throws ClassNotFoundException, InstantiationException, IllegalAccessException {
  return classInfo.newInstance();
  }

/**

• 依赖注入注解原理

• @param object

• @throws Exception
  */
  public void attriAssign(Object object) throws Exception {

  // 1.使用反射机制,获取当前类的所有属性
  Class<? extends Object> classInfo = object.getClass();
  Field[] declaredFields = classInfo.getDeclaredFields();

  // 2.判断当前类属性是否存在注解
  for (Field field : declaredFields) {
  SelfAutowired extResource = field.getAnnotation(SelfAutowired.class);
  if (extResource != null) {
  // 获取属性名称
  String beanId = field.getName();
  Object bean = getBean(beanId);
  if (bean != null) {
  // 3.默认使用属性名称，查找bean容器对象 1参数 当前对象 2参数给属性赋值
  field.setAccessible(true); // 允许访问私有属性
  field.set(object, bean);
  }
  }
  }

}
}

当这个类被初始化的时候，通过构造函数里面的两个方法，通过外部传入指定的包名，解析该包下面的所有类和相关注解，其实现原理主要是使用了反射，

通过一个工具类获取到了所有的类的实例化集合后，我们对这个集合进行遍历，具体的执行方法可以看findClassExisAnnotation 这个方法，

在findClassExisAnnotation这个方法里面，可以看到，我们使用自定义的注解去到这个实例类对象去匹配，如果匹配到了相应的注解，就把这个bean封装到全局的集合中，这里使用了concurrentHashMap进行封装，

这一步完成之后，包含了自定义注解[@Service]的相关类对象就存在了内存集合中了，如果在web容器启动完毕之后，使用自己的bean的时候就可以直接通过getBean这个方法去容器里面直接获取就可以了，通过这个方法就可以拿到当前beanId对应的类的实例化对象，可以使用里面的相关方法，

但是到这里并没有完事啊，假如在我们某个标注了@Service的类里面有下面这样的注解，即依赖了其他的某个bean,比如，在我们的userService类里面依赖了orderService，就形成了所谓的依赖注入，

同样，依赖注入也是通过上面相同的方式，在initBean()方法结束之后立即执行，我们来看看这个方法，

在initEntryField（）这个方法里，要做的事情就是遍历上述初始化好的所有bean，然后再去每个bean的实例对象中解析并封装属性相关的对应信息，下面看一下initEntryField（）这个方法，

通过这个方法，就可以将某个bean中依赖的其他bean信息进行封装，

/**
* 依赖注入注解实现原理
* @param object
* @throws Exception
*/
public void attriAssign(Object object) throws Exception {

	// 1.使用反射机制,获取当前类的所有属性
	Class<? extends Object> classInfo = object.getClass();
	Field[] declaredFields = classInfo.getDeclaredFields();

	// 2.判断当前类属性是否存在注解
	for (Field field : declaredFields) {
		SelfAutowired extResource = field.getAnnotation(SelfAutowired.class);
		if (extResource != null) {
			// 获取属性名称
			String beanId = field.getName();
			Object bean = getBean(beanId);
			if (bean != null) {
				// 3.默认使用属性名称，查找bean容器对象 1参数 当前对象 2参数给属性赋值
				field.setAccessible(true); // 允许访问私有属性
				field.set(object, bean);
			}
		}
	}

}

最后我们写一个测试类来验证一下，直接运行下面的main函数，

public class Test1 {

public static void main(String[] args) throws Exception {
	
	SelfPathXmlApplicationContext app = new SelfPathXmlApplicationContext("com.congge.service.impl");
	UserServiceImpl userServiceImpl = (UserServiceImpl) app.getBean("userServiceImpl");
	String result = userServiceImpl.add();
	System.out.println("获取到了orderService的执行结果是 : " + result);
	System.out.println("当前的bean的实例对象是: " + userServiceImpl);
}

}

可以看到我们自定义的bean容器已经生效了，

---

原文链接：https://blog.csdn.net/zhangcongyi420/article/details/89419715