实现Spring底层机制-01¶
主要实现：初始化IOC容器+依赖注入+BeanPostProcessor机制+AOP
前面我们实际上已经使用代码简单实现了：
- Spring XML 注入 bean （Spring基本介绍02）
- Spring 注解方式注入 bean （Spring管理Bean-IOC-04）
- Spring AOP 动态代理实现 （AOP-01）
1.引出问题¶
1.1原生Spring如何实现依赖注入、singleton和prototype¶
例子
1.创建新的Maven项目：
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
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”名称获取的对象的地址值相同，这说明它们实际上是同一个对象
在默认情况下，我们配置的@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”名称获取的对象的地址值不相同，这说明它们是不同的对象。
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 注解装配。
问题一：spring底层是如何通过注解来完成多例或者单例对象的创建的？
问题二：Spring容器如何实现依赖注入？
1.2原生Spring如何实现BeanPostProcessor¶
BeanPosecessor详见Spring管理Bean-IOC-03-2.16后置处理器
- 后置处理器会在 bean 初始化方法调用前 和 初始化方法调用后 被调用
- 后置处理器对象会作用在容器配置文件的**所有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()）才创建，因此排在最后。
问题三：原生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);
}
}
测试结果：
前面的输出是因为之前配置了后置处理器，它在创建ioc容器时会被调用，对所有bean对象生效。
红框处，后置处理器的 postProcessBeforeInitialization() 方法调用时，bean对象的还是原生的类型，但是到了 postProcessAfterInitialization() 方法调用时，已经变成了代理对象 $Proxy。这说明后置处理器和aop切面编程有着密切的关系。
简单分析AOP和BeanPostProcessor的关系：
1.AOP实现Spring可以通过一个类加入注解@EnableAspectJAutoProxy来执行
2.我们来追一下@EnableAspectJAutoProxy
3.看一下 AnnotationAwareAspectJAutoProxyCreator 的类图
4.解读：
（1）AOP底层是基于BeanPostProcessor机制的
（2）即在Bean对象创建好后，根据是否需要AOP处理，决定返回代理对象还是原生的Bean对象
（3）在返回代理对象时，就可以根据要代理的类和方法来返回
（4）这个机制并不难，本质就是BeanPostProcessor 机制+动态代理技术
2.Spring整体架构分析¶
