SpringIoc 实现原理

技术2022-08-01 83

什么是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的基本依赖即可，

<properties> <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>  <dependency> <groupId>cglib</groupId> <artifactId>cglib</artifactId> <version>3.2.10</version> </dependency>  <dependency> <groupId>com.mchange</groupId> <artifactId>c3p0</artifactId> <version>0.9.5.2</version> </dependency>  <dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifactId> <version>5.1.40</version> </dependency>  <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");

1 自定义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容器已经生效了

Processed: 0.017, SQL: 9