day11-实现Spring底层机制-01

实现Spring底层机制-01

主要实现：初始化IOC容器+依赖注入+BeanPostProcessor机制+AOP

前面我们实际上已经使用代码简单实现了：

  1. Spring XML 注入 bean （Spring基本介绍02）
  2. Spring 注解方式注入 bean （Spring管理Bean-IOC-04）
  3. Spring AOP 动态代理实现 （AOP-01）

1.引出问题

1.1原生Spring如何实现依赖注入、singleton和prototype

例子

1.创建新的Maven项目：

day11-实现Spring底层机制-01

2.在pom.xml文件中添加 spring 开发的基本包：

<dependencies>
    <!--加入 spring 开发的基本包-->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>5.3.8</version>
    </dependency>
    <!--加入spring开发切面编程需要的包-->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-aspects</artifactId>
        <version>5.3.8</version>
    </dependency>
</dependencies>

3.src/main/java/ 目录下创建包 com/li/component，在该包下分别创建UserDao.java、UserService.java、UserAction.java

day11-实现Spring底层机制-01

UserDao：

package com.li.component;
import org.springframework.stereotype.Component;
/**
 * @author 李
 * @version 1.0
 */
//也可以使用 @Repository
@Component
public class UserDao {
    public void hi() {
        System.out.println("UserDao-hi()---");
    }
}

UserService：

package com.li.component;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
/**
 * @author 李
 * @version 1.0
 */
//也可以使用 @Service
@Component
public class UserService {
    //定义属性
    //也可以使用 @Resource
    @Autowired
    private UserDao userDao;
    public void m1() {
        userDao.hi();
    }
}

UserAction：

package com.li.component;
import org.springframework.stereotype.Component;
/**
 * @author 李
 * @version 1.0
 * 一个 Controller
 */
//也可以使用 @Controller
@Component
public class UserAction {
}

4.在 src/main/resources 目录下创建 spring 的容器文件 beans.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/context
       https://www.springframework.org/schema/context/spring-context.xsd">
    <!--配置自动扫描的包，同时引入对应的名称空间-->
    <!--说明：
        1.如果是普通的java项目，beans.xml 放在src 目录下即可
        2.如果是maven项目，beans.xml文件就要放在 src/main/resources 目录下-->
    <context:component-scan base-package="com.li.component"/>
</beans>

5.测试类中获取配置的bean，并输出对象的地址值

package com.li;
import com.li.component.UserAction;
import com.li.component.UserDao;
import com.li.component.UserService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
/**
 * @author 李
 * @version 1.0
 */
public class AppMain {
    public static void main(String[] args) {
        //测试是否可以得到spring容器中的bean
        ApplicationContext ioc = new ClassPathXmlApplicationContext("beans.xml");
        UserAction userAction = (UserAction) ioc.getBean("userAction");
        UserAction userAction2 = (UserAction) ioc.getBean("userAction");
        System.out.println("userAction=" + userAction);
        System.out.println("userAction2=" + userAction2);
    }
}

可以看到通过“userAction”名称获取的对象的地址值相同，这说明它们实际上是同一个对象

day11-实现Spring底层机制-01

在默认情况下，我们配置的@Component，@Controller，@Service，@Repository 是单例的，即spring的ioc容器只会创建一个bean实例

6.如果我们希望将一个类配置为多例的，怎么办呢？

只需要在对应的类头部添加 @Scope(value = "prototype")，表示以多实例的形式返回该类的bean对象

package com.li.component;
import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Component;
@Component
@Scope(value = "prototype")
public class UserAction {
}

现在我们重新运行测试类，可以看到通过“userAction”名称获取的对象的地址值不相同，这说明它们是不同的对象。

day11-实现Spring底层机制-01

7.我们在测试类中获取userService对象，并调用m1方法

package com.li;
import com.li.component.UserAction;
import com.li.component.UserDao;
import com.li.component.UserService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
/**
 * @author 李
 * @version 1.0
 */
public class AppMain {
    public static void main(String[] args) {   
        ApplicationContext ioc = new ClassPathXmlApplicationContext("beans.xml");
        UserService userService = (UserService) ioc.getBean("userService");
        System.out.println("userService=" + userService);
        //测试依赖注入
        System.out.print("userService对象调用m1()=");
        userService.m1();
    }
}

输出如下，成功获取到userService对象，并且调用m1方法成功。这说明UserService类中的userDao属性成功通过@AutoWired 注解装配。

day11-实现Spring底层机制-01

问题一：spring底层是如何通过注解来完成多例或者单例对象的创建的？

问题二：Spring容器如何实现依赖注入？

1.2原生Spring如何实现BeanPostProcessor

BeanPosecessor详见Spring管理Bean-IOC-03-2.16后置处理器

  1. 后置处理器会在 bean 初始化方法调用前 和 初始化方法调用后 被调用
  2. 后置处理器对象会作用在容器配置文件的所有bean对象中（即使bean对象没有初始化方法）

例子

1.创建一个后置处理器：

package com.li.process;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;
import org.springframework.stereotype.Component;
/**
 * @author 李
 * @version 1.0
 * 一个后置处理器
 */
@Component
public class MyBeanPostProcessor implements BeanPostProcessor {
    //在 Bean的 init初始化方法前被调用
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("postProcessBeforeInitialization 被调用 " + beanName + " bean= " + bean.getClass());
        return bean;
    }
    //在 Bean的 init初始化方法后被调用
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("postProcessAfterInitialization 被调用 " + beanName + " bean= " + bean.getClass());
        return bean;
    }
}

要使用后置处理器，需要进行配置，配置的方式有两种：（1）在xml容器文件中进行配置（2）添加注解

使用注解时，还要保证扫描的范围要覆盖到该类

2.在UserService类中添加初始化方法：

package com.li.component;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import javax.annotation.PostConstruct;
/**
 * @author 李
 * @version 1.0
 */
//也可以使用 @Service
@Component
public class UserService {
    //定义属性
    //也可以使用 @Resource
    @Autowired
    private UserDao userDao;
    public void m1() {
        userDao.hi();
    }
    //初始化方法-名称随意，需要@PostConstruct指定init为初始化方法
    @PostConstruct
    public void init(){
        System.out.println("UserService-init()");
    }
}

3.在测试类中进行测试：

package com.li;
import com.li.component.UserAction;
import com.li.component.UserDao;
import com.li.component.UserService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
/**
 * @author 李
 * @version 1.0
 */
public class AppMain {
    public static void main(String[] args) {
        ApplicationContext ioc = new ClassPathXmlApplicationContext("beans.xml");
        UserAction userAction = (UserAction) ioc.getBean("userAction");
        UserAction userAction2 = (UserAction) ioc.getBean("userAction");
        System.out.println("userAction=" + userAction);
        System.out.println("userAction2=" + userAction2);
        UserDao userDao = (UserDao) ioc.getBean("userDao");
        System.out.println("userDao=" + userDao);
        UserService userService = (UserService) ioc.getBean("userService");
        System.out.println("userService=" + userService);
        System.out.print("userService对象调用m1()=");
        userService.m1();
    }
}

如下，后置处理器对象会作用在容器配置文件的所有bean对象中（即使bean对象没有初始化方法），根据之前的配置，容器中一共有四个对象（UserAction为多例），因此一共调用了八次。

这里userAction对象因为是多例的，强制为懒加载，因此在被获取时（getBean()）才创建，因此排在最后。

day11-实现Spring底层机制-01

问题三：原生Spring如何实现BeanPostProcessor？

1.3原生spring如何实现AOP

例子-在上述代码的基础上添加如下内容

1.SmartAnimal 接口：

package com.li.aop;
/**
 * @author 李
 * @version 1.0
 */
public interface SmartAnimal {
    public float getSum(float i, float j);
    public float getSub(float i, float j);
}

2.SmartDog 实现类：

package com.li.aop;
import org.springframework.stereotype.Component;
/**
 * @author 李
 * @version 1.0
 */
@Component
public class SmartDog implements SmartAnimal {
    @Override
    public float getSum(float i, float j) {
        float res = i + j;
        System.out.println("SmartDog-getSum()-res=" + res);
        return res;
    }
    @Override
    public float getSub(float i, float j) {
        float res = i - j;
        System.out.println("SmartDog-getSub()-res=" + res);
        return res;
    }
}

3.SmartAnimalAspect 切面类：

package com.li.aop;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.Signature;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;
import java.util.Arrays;
/**
 * @author 李
 * @version 1.0
 * 切面类
 */
@Component
@Aspect
public class SmartAnimalAspect {
    @Pointcut(value = "execution(public float com.li.aop.SmartAnimal.*(float,float))")
    public void myPointCut() {
    }
    //前置通知
    @Before(value = "myPointCut()")
    public void before(JoinPoint joinpoint) {
        Signature signature = joinpoint.getSignature();
        System.out.println("SmartAnimalAspect切面类-before()-" + signature.getName()
                + "-参数-" + Arrays.toString(joinpoint.getArgs()));
    }
    //返回通知
    @AfterReturning(value = "myPointCut()", returning = "res")
    public void afterReturning(JoinPoint joinpoint, Object res) {
        Signature signature = joinpoint.getSignature();
        System.out.println("SmartAnimalAspect切面类-afterReturning()-" + signature.getName() + "-res-" + res);
    }
    //异常通知
    @AfterThrowing(value = "myPointCut()", throwing = "res")
    public void afterThrowing(JoinPoint joinpoint, Throwable res) {
        Signature signature = joinpoint.getSignature();
        System.out.println("SmartAnimalAspect切面类-afterThrowing()-" + signature.getName() + "-res-" + res);
    }
    //最终通知
    @After(value = "myPointCut()")
    public void after(JoinPoint joinpoint) {
        Signature signature = joinpoint.getSignature();
        System.out.println("SmartAnimalAspect切面类-after()-" + signature.getName());
    }
}

4.在容器文件中开启基于注解的aop功能：

<!--配置自动扫描的包，同时引入对应的名称空间-->
<context:component-scan base-package="com.li.aop"/>
<!--开启基于注解的 aop 功能-->
<aop:aspectj-autoproxy/>

5.进行测试：

package com.li;
import com.li.aop.SmartAnimal;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
/**
 * @author 李
 * @version 1.0
 */
public class AppMain {
    public static void main(String[] args) {
        ApplicationContext ioc = new ClassPathXmlApplicationContext("beans.xml");
        SmartAnimal smartDogProxy = ioc.getBean(SmartAnimal.class);
        smartDogProxy.getSum(101, 99);
    }
}

测试结果：

day11-实现Spring底层机制-01

前面的输出是因为之前配置了后置处理器，它在创建ioc容器时会被调用，对所有bean对象生效。

红框处，后置处理器的 postProcessBeforeInitialization() 方法调用时，bean对象的还是原生的类型，但是到了 postProcessAfterInitialization() 方法调用时，已经变成了代理对象 $Proxy。这说明后置处理器和aop切面编程有着密切的关系。

简单分析AOP和BeanPostProcessor的关系：

1.AOP实现Spring可以通过一个类加入注解@EnableAspectJAutoProxy来执行

2.我们来追一下@EnableAspectJAutoProxy

day11-实现Spring底层机制-01
day11-实现Spring底层机制-01
day11-实现Spring底层机制-01
day11-实现Spring底层机制-01
day11-实现Spring底层机制-01
day11-实现Spring底层机制-01

3.看一下 AnnotationAwareAspectJAutoProxyCreator 的类图

day11-实现Spring底层机制-01

4.解读：

（1）AOP底层是基于BeanPostProcessor机制的

（2）即在Bean对象创建好后，根据是否需要AOP处理，决定返回代理对象还是原生的Bean对象

（3）在返回代理对象时，就可以根据要代理的类和方法来返回

（4）这个机制并不难，本质就是BeanPostProcessor 机制+动态代理技术

2.Spring整体架构分析

day11-实现Spring底层机制-01

标签 , , , ,

发表回复