导航：
【Java笔记+踩坑汇总】Java基础+进阶+JavaWeb+SSM+SpringBoot+瑞吉外卖+SpringCloud+黑马旅游+谷粒商城+学成在线+MySQL高级篇+设计模式+牛客面试题
代码：https://wwmg.lanzouk.com/ictoK135ye2f
目录
扫描二维码关注公众号，回复：
16495902 查看本文章
1.1.9 Bean后置处理器接口：BeanPostProcessor
1.2.5 Bean后置处理器接口实现类：MyBeanPostProcessor
二、完善容器类：VinceApplicationContext
一、准备工作
1.0 项目目录
1.1 Spring包下的类
com.vince.spring包下的类：
1.1.1 容器类
对比一下创建Spring容器的方式，我们需要模拟的是AnnotationConfigApplicationContext类。
- ClassPathXmlApplicationContext：是需要传入一个xml配置文件，告诉Spring需要按照指定的配置创建一个Spring容器ApplicationContext，创建完之后就可以通过getBean从容器中拿到相应的bean对象
- AnnotationConfigApplicationContext ：也是一个容器，只是传入的是以Java配置类的形式传入。可以在类上加上@ComponentScan定义Spring等下需要扫描的路径。还可以通过@Bean的方法（等于bean标签），通过这种注解的方式，给容器加入一个Bean
public class Test { public static void main(String[] args) { ClassPathXmlApplicationContext classPathXmlApplicationContext = new ClassPathXmlApplicationContext("spring.xml"); classPathXmlApplicationContext.getBean("user"); AnnotationConfigApplicationContext annotationConfigApplicationContext = new AnnotationConfigApplicationContext(AppConfig.class); SpringCodeApplicationContext applicationContext = new SpringCodeApplicationContext(AppConfig.class); } }参考Spring框架可知，这个容器类需要有构造方法、传入参数、
getBean()方法
package com.vince.spring;
//模拟AnnotationConfigApplicationContext
public class VinceApplicationContext{
private Class configClass;
//构造方法，参数是配置类的字节码文件
public SpringCodeApplicationContext(Class configClass) {
//1.赋值配置类成员变量
this.configClass = configClass;
// 2.解析配置类
// 通过反射，判断配置类字节码有没有注解@ComponentScan
// 如果有，就根据@ComponentScan传入的扫描路径，扫描那个包下的Bean
// 3.实例化bean
}
//容器里拥有getBean()方法，获取Bean
public Object getBean(String beanName){
return null;
}
1.1.2 @ComponentScan注解
package com.vince.spring;
/**
* 用于扫描指定包路径的Bean
*/
@Retention(RetentionPolicy.RUNTIME)//注解生命周期，不仅被保存到class文件中，jvm加载class文件之后，仍然存在
//@Target用来表示注解作用范围，超过这个作用范围，编译的时候就会报错。
@Target(ElementType.TYPE)//注解范围是：接口、类、枚举、注解
public @interface ComponentScan {
String value() default "";
}1.1.3 @Component注解
package com.vince.spring;
/**
* 注解为Bean
*/
@Retention(RetentionPolicy.RUNTIME)//注解生命周期，不仅被保存到class文件中，jvm加载class文件之后，仍然存在
@Target(ElementType.TYPE)//注解范围是：接口、类、枚举、注解
public @interface Component {
String value() default "";
}1.1.4 @Autowired注解
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
public @interface Autowired {
}1.1.5 @Scope注解
@Retention(RetentionPolicy.RUNTIME)//注解生命周期，不仅被保存到class文件中，jvm加载class文件之后，仍然存在
@Target(ElementType.TYPE)//注解范围是：接口、类、枚举、注解
public @interface Scope {
String value() default "";
}1.1.6 Bean的声明类：BeanDefinition
BeanDefinition 定义 Bean 的配置元信息，包含：
- Bean 的类名
- 设置父 bean 名称、是否为 primary、
- Bean 行为配置信息，作用域、自动绑定模式、生命周期回调、延迟加载、初始方法、销毁方法等
- Bean 之间的依赖设置，dependencies
- 构造参数、属性设置
//Bean的声明类，用来描述Bean；里面定义的Bean的类型（Class格式）和作用域
public class BeanDefinition {
private Class type;
private String scope;
@Override
public String toString() {
return "BeanDefinition{" +
"type=" + type +
", scope='" + scope + '\'' +
'}';
}
public Class getType() {
return type;
}
public void setType(Class type) {
this.type = type;
}
public String getScope() {
return scope;
}
public void setScope(String scope) {
this.scope = scope;
}
}
1.1.7 Bean名回调接口：BeanNameAware
//回调接口，主要setter方法给Bean的beanName变量赋值。Aware译为明白的，意识到的。
public interface BeanNameAware {
public void setBeanName(String beanName);
}1.1.8 初始化接口：InitializingBean
//初始化Bean的接口，有个方法，
public interface InitializingBean {
//在属性填充后执行
public void afterPropertiesSet();
}1.1.9 Bean后置处理器接口：BeanPostProcessor
本接口的两个方法在初始化之前和之后执行，可以通过实现类使用JDK的Proxy
//Bean后置处理器接口
public interface BeanPostProcessor {
//在Bean 的初始化方法（如 @PostConstruct 注解的方法）被调用之前被自动调用
public Object postProcessBeforeInitialization(String beanName,Object bean);
//在 Bean 的初始化方法被调用之后被自动调用
public Object postProcessAfterInitialization(String beanName,Object bean);
}1.2 用户业务相关类
com.vince.service包下的类：
1.2.1 测试类创建容器
package com.vince.spring;
public class Test {
public static void main(String[] args){
//模拟AnnotationConfigApplicationContext容器，构造参数传入配置类
VinceApplicationContext applicationContext = new VinceApplicationContext(AppConfig.class);
UserInterface userService = (UserInterface)applicationContext.getBean("userService");
userService.test();
}
}
1.2.2 配置类AppConfig
package com.vince.spring;
// com/springCode/service/UserService.java
@ComponentScan("com.springCode.service")
public class AppConfig {
}
1.2.3 UserService
package com.vince.service;
public interface UserInterface {
public void test();
}@Component
//@Scope("prototype") //多例
public class UserService implements BeanNameAware , InitializingBean ,UserInterface{
@Autowired
private OrderService orderService;
private String beanName;
@Override
public void test(){
System.out.println(orderService);
}
@Override
public void setBeanName(String beanName) {
this.beanName = beanName;
}
@Override
public void afterPropertiesSet() {
System.out.println("初始化方法");
}
}1.2.4 OrderService，用于依赖注入
@Component
//@Scope("prototype") //多例
public class OrderService {
public void submitOrder(){
System.out.println("下单。。。");
}
}1.2.5 Bean后置处理器接口实现类：MyBeanPostProcessor
//Bean后置处理器实现类，两个方法在初始化之前和之后执行，可以通过实现类使用JDK的Proxy.newProxyInstance()；基于反射实现aop。
@Component
public class MyBeanPostProcessor implements BeanPostProcessor {
@Override
public Object postProcessBeforeInitialization(String beanName, Object bean) {
if ("userService".equals(beanName)) {
System.out.println("BeanPostProcessor实现类的postProcessBeforeInitialization()方法");
}
return bean;
}
@Override
public Object postProcessAfterInitialization(String beanName, Object bean) {
if ("userService".equals(beanName)) {
//代理对象，通过JDK的Proxy.newProxyInstance()；基于反射实现aop。
// 第一个参数类加载器，第二个参数接口的class对象，第三个参数重写invoke()的InvocationHandler实现类
Object proxyInstance = Proxy.newProxyInstance(MyBeanPostProcessor.class.getClassLoader(),
bean.getClass().getInterfaces(), new InvocationHandler() {
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("切面逻辑，BeanPostProcessor实现类的postProcessAfterInitialization()方法");
return method.invoke(bean,args);
}
});
return proxyInstance;
}
return bean;
}
}二、完善容器类：VinceApplicationContext
2.0 创建Bean流程
注解容器类构造方法创建Bean：
- 获取Bean扫描路径：获取配置类的Class对象，基于反射获取@ComponentScan注解里设置的扫描路径；
- 遍历扫描Bean：遍历扫描路径里每个类的字节码文件，用类加载器加载成class对象，基于反射判断@Component等注解，有的话这个类就是Bean类。
- BeanPostProcessor实例化后存列表：如果Bean类是BeanPostProcessor接口的实现类，那么就将这个Bean类实例化并存进成员变量List<BeanPostProcessor>里；
- 创建并赋值BeanDefinition对象：创建BeanDefinition对象并赋值，type变量赋值Bean类的class对象，scope变量赋值作用域（通过反射获取@Scope注解值）。BeanDefinition存储Bean的对象、作用域等元信息。
- beanDefinitionMap添加键值对：把Bean名和它对应的BeanDefinition对象，以键值对形式添加到容器类成员变量beanDefinitionMap里。beanDefinitionMap线程安全，是ConcurrentHashMap类型。
- 遍历beanDefinitionMap创建Bean：遍历beanDefinitionMap的键，调用createBean()方法创建Bean。createBean()方法具体逻辑：
- 实例化：基于反射，根据Bean类的Class对象推断构造方法、创建实例，如果是单例就存入单例池。实例化这个方法在getBean()时候也会用到，所以抽取成私有方法，这个方法获取Bean先判断作用域，单例的话就优先根据Bean名从单例池取，单例池没有就调用createBean()方法，根据Bean名和对应的BeanDefinition创建Object类型的Bean对象。
- 属性填充：基于反射，根据Bean类的Class对象获取它所有属性，将注解了@Autowired等的属性开启私有成员访问限制，通过getBean(名或类)方法给该属性填充它的Bean对象。getBean()方法：判断作用域，如果单例则调用createBean()再放入单例池再返回，如果原型则调用createBean()后直接返回。简化起见这里暂时只考虑一级缓存，二级三级缓存暂时不考虑。
- 处理Aware回调：如果Bean实例实现了BeanNameAware接口（通过instanceof判断），调用Bean重写的setBeanName()方法，给Bean实例的beanName变量赋值。
- 执行所有BeanPostProcessor的初始化前方法：遍历BeanPostProcessor列表，执行每个BeanPostProcessor对象里的postProcessBeforeInitialization()方法。本方法可以通过JDK的Proxy.newProxyInstance()实现动态代理返回目标对象的代理对象。
- 初始化：如果Bean实例实现了InitializingBean接口（通过instanceof判断），调用Bean重写的afterPropertiesSet()方法，处理初始化逻辑。afterPropertiesSet译为“在属性填充之后”
- 执行所有BeanPostProcessor的初始化后方法：遍历BeanPostProcessor列表，执行每个BeanPostProcessor对象里的postProcessAfterInitialization()方法。本方法可以通过JDK的Proxy.newProxyInstance()实现动态代理返回目标对象的代理对象。
- 放进单例池：如果是单例还要把Object类型Bean的代理对象放进单例池singletonObjects。
2.1 代码实现
spring包下的VinceApplicationContext类
2.1.1 成员变量
private Class configClass;//配置类的Class对象
//Bean名和它对应的BeanDefinition键值对；
private ConcurrentHashMap<String,BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<>();
//单例池；map存各Bean名所对应的Bean实例
private ConcurrentHashMap<String,Object> singletonObjects = new ConcurrentHashMap<>();
//存放扫描包路径下的所有BeanPostProcessor类
private ArrayList<BeanPostProcessor> beanPostProcessorList = new ArrayList<>();2.1.2 构造方法，参数是配置类
//构造方法，参数是配置类的Class对象
public VinceApplicationContext(Class configClass) {
//1.赋值配置类成员变量
this.configClass = configClass;
// 2.通过反射，判断配置类Class对象有没有注解@ComponentScan；如果有，就解析ComponentScan对象
// --->BeanDefinition -->beanDefinitionMap
if (configClass.isAnnotationPresent(ComponentScan.class)) {
//解析ComponentScan对象
ComponentScan componentScanAnnotation = (ComponentScan) configClass.getAnnotation(ComponentScan.class);
// 获取ComponentScan对象的value，也就是用户传入的扫描路径。例如@ComponentScan("com.vince.service")，扫描这个包下的Bean
String path = componentScanAnnotation.value();// com.vince.service
// 将包名中的点号替换为斜杠
path = path.replace(".","/");//com/vince/service
// 获取容器类的类加载器
ClassLoader classLoader = VinceApplicationContext.class.getClassLoader();
// 类加载器获取扫描包的绝对路径
URL resource = classLoader.getResource(path);//file:/D:/xxx/com/vince/service
// 把URL绝对路径对象封装成File对象
File file = new File(resource.getFile());
// 如果File对象是目录，则遍历判断扫描目录下的文件是不是bean；
if (file.isDirectory()) {
File[] files = file.listFiles();
//遍历“扫描路径”下所有文件中，找到Bean，创建对应BeanDefinition对象，并存到map里；
// 判断Bean方式：基于反射，判断该字节码文件对应的类有没有@Component注解
for (File f: files) {
String fileName = f.getAbsolutePath();
if (fileName.endsWith(".class")) {
//将文件名转为类名；D:\xxx\com\vince\service\AppConfig.class ----> AppConfig
//这里其实不应该写死成“com”，只是方便起见，其实应该用更复杂的逻辑截取全名为类名
String className = fileName.substring(fileName.indexOf("com"), fileName.indexOf(".class"));
className = className.replace("\\",".");
try {
//根据类的全限定名加载类
Class<?> clazz = classLoader.loadClass(className);
//如果该类有@Component注解
if (clazz.isAnnotationPresent(Component.class)) {
System.out.println("容器类构造方法里，扫描@ComponentScan('xx')，发现xx路径下这个类是Bean："+clazz.getName());
//a.如果@Component("类名")有设置类名，Bean名就是设置的这个类名
Component component = clazz.getAnnotation(Component.class);
String beanName = component.value();
//判断这个Bean类是不是BeanPostProcessor接口的实现类，如果是的话就通过反射创建实例，并放进处理器列表里。
//注意不能用instanceof，因为instanceof是实例与类的关系比较，isAssignableFrom是类和接口的关系比较
if (BeanPostProcessor.class.isAssignableFrom(clazz)) {
BeanPostProcessor instance = (BeanPostProcessor) clazz.newInstance();
beanPostProcessorList.add(instance);
System.out.println("这个Bean是BeanPostProcessor接口的实现类，需要加入list里，以供所有Bean初始化之前和之后增强");
}
//b.如果@Component没有设置类名，就将首字母小写后的Bean类名设为Bean名
if ("".equals(beanName)) {
beanName = Introspector.decapitalize(clazz.getSimpleName());//工具类将字符串校验后首字母小写
}
// 创建一个BeanDefinition对象，用来描述Bean，里面赋值这个Bean的类型和作用域
BeanDefinition beanDefinition = new BeanDefinition();
//反射获取@Scope注解指定的作用域，赋值给BeanDefinition对象的scope变量
if (clazz.isAnnotationPresent(Scope.class)) {
Scope scopeAnnotation = clazz.getAnnotation(Scope.class);
beanDefinition.setScope(scopeAnnotation.value());
}else{
beanDefinition.setScope("singleton");
}
//把这个Bean的Class对象赋值给BeanDefinition对象的type变量
beanDefinition.setType(clazz);
//把所有Bean名和它对应的BeanDefinition对象映射关系，存到map里统一管理
beanDefinitionMap.put(beanName,beanDefinition);
System.out.println("Bean名："+beanName+"，BeanDefinition对象："+beanDefinition);
}
} catch (ClassNotFoundException | InstantiationException | IllegalAccessException e) {
e.printStackTrace();
}
}
}
}
}
// 3.实例化bean，如果作用域是单例，则从单例池中取；取不到就创建新的Bean对象，并存入单例池
for (String beanName:beanDefinitionMap.keySet()) {
BeanDefinition beanDefinition = beanDefinitionMap.get(beanName);
if ("singleton".equals(beanDefinition.getScope())) {
//实例化Bean
Object bean = createBean(beanName,beanDefinition);
singletonObjects.put(beanName,bean);
}
}
}2.1.3 createBean()方法
//根据Bean名和BeanDefinition对象实例化Bean的方法；私有，只供本类内部调用
//BeanDefinition对象的成员变量type就是Bean的类型（Class格式）
private Object createBean(String beanName,BeanDefinition beanDefinition){
// 获取Bean的Class格式的类型
Class clazz = beanDefinition.getType();
try {
//1.基于反射创建Bean的实例；
Object instance = clazz.getConstructor().newInstance();
//2.依赖注入
//遍历Bean类Class对象的所有属性；
for (Field f : clazz.getDeclaredFields()) {
//找出有@Autowired注解的属性，给这些属性进行填充
if (f.isAnnotationPresent(Autowired.class)) {
//破除 private 修饰符访问限制；这样就可以访问注入的这个依赖里面的私有成员
f.setAccessible(true);
//给该属性填充属性名对应的Bean对象。
// 该属性通过getBean能获得Bean，因为上面构造方法里已经扫描了所有的Bean，并创建了BeanDefinition对象加入到“声明map”里了。
//void set(Object obj, Object value)
//obj 表示要设置属性值的对象；value 表示要为该成员变量设置的新值。
f.set(instance,getBean(f.getName()));
}
}
// 3.Aware回调。如果Bean实例实现了BeanNameAware接口，就调用重写的setter方法，给Bean实例的beanName变量赋值
if (instance instanceof BeanNameAware) {
((BeanNameAware) instance).setBeanName(beanName);
}
// 遍历后置处理器列表，执行后置处理器的before方法，在Bean 的初始化方法（如 @PostConstruct 注解的方法）被调用之前被自动调用
for (BeanPostProcessor beanPostProcessor : beanPostProcessorList) {
instance = beanPostProcessor.postProcessBeforeInitialization(beanName,instance);
}
// 初始化
if (instance instanceof InitializingBean) {
((InitializingBean) instance).afterPropertiesSet();
}
//Bean后置处理器接口的after方法，在 Bean 的初始化方法被调用之后被自动调用
for (BeanPostProcessor beanPostProcessor : beanPostProcessorList) {
instance = beanPostProcessor.postProcessAfterInitialization(beanName,instance);
}
return instance;
} catch (InstantiationException e) { //异常处理
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (InvocationTargetException e) {
e.printStackTrace();
} catch (NoSuchMethodException e) {
e.printStackTrace();
}
return null;
}2.1.4 getBean()方法
//容器类的getBean()方法，根据作用域获取Bean
public Object getBean(String beanName){
//从map里获取BeanDefinition对象
BeanDefinition beanDefinition = beanDefinitionMap.get(beanName);
if (beanDefinition == null) {
//如果BeanDefinition对象为空，说明这个bean没有创建成功，抛异常；
throw new NullPointerException();
}else{
//如果BeanDefinition对象不为空，则判断作用域后获取Bean
String scope = beanDefinition.getScope();
if ("singleton".equals(scope)) {
//如果是单例则从单例池根据Bean名取Bean；
Object bean= singletonObjects.get(beanName);
if (bean == null) {
//如果单例池查到的是null，则新创建Bean，再给单例池赋值
bean = createBean(beanName, beanDefinition);
singletonObjects.put(beanName,bean);
}
//返回Bean
return bean;
}else{
// 多例，每次直接创建新的
return createBean(beanName, beanDefinition);
}
}
}