通过手写模拟,了解Spring的底层源码启动过程
通过手写模拟,了解BeanDefinition、BeanPostProcessor的概念
通过手写模拟,了解Spring解析配置类等底层源码工作流程
通过手写模拟,了解依赖注入,Aware回调等底层源码工作流程
通过手写模拟,了解Spring AOP的底层源码工作流程
简易版本,重在理解spring底层思想大概做了什么。
package com.ljc;
import com.ljc.service.UserService;
import com.spring.LjcApplicationContext;
public class Test {
public static void main(String[] args) {
/**
* 1、扫描指定文件下的class文件,转换成class
* 2、如果带有Component,就生成Bean定义,设置作用域、以及是否延迟加载,放到BeanDefinitionMap里
* 3、遍历Bean定义生成Bean、属性填充(依赖注入),把单例的放进单例缓存池,原型对象则每次新建
* 4、执行aware回调、后置处理器、以及看是不是需要aop处理
*
*/
// 扫描生成Bean定义--->创建单例Bean BeanDefinition BeanPostPRocess
LjcApplicationContext applicationContext = new LjcApplicationContext(AppConfig.class);
UserInteface userService = (UserInteface) applicationContext.getBean("userService");
userService.test();
userService.testOrder();
}
}
做了几件事情
1、初始化配置类
2、扫描配置类下的文件类
3、遍历Bean定义Map,是单例就进行创建,添加到单例池
public class LjcApplicationContext {
private Class loadClass;
private Map<String, BeanDefinition> beanDefinitionMap = new HashMap<>();
private Map<String, Object> singletonObjects = new HashMap<>();
private List<BeanPostProcessor> beanPostProcessorList = new ArrayList<>();
public LjcApplicationContext(Class appConfigClass) {
loadClass = appConfigClass;
// 扫描
sacn(appConfigClass);
// 遍历Bean定义
for (Map.Entry<String, BeanDefinition> entry : beanDefinitionMap.entrySet()) {
String beanName = entry.getKey();
BeanDefinition beanDefinition = entry.getValue();
// 判断是不是单例
if("singleton".equals(entry.getValue().getScope())){
// 创建Bean
Object instance = createBean(beanDefinition,beanName);
// 添加到单例池
singletonObjects.put(beanName,instance);
}
}
}
做了几件事情
1、获取配置类的注解扫描路径,加载路径下的所有类文件
2、遍历文件类,判断是当前类是不是一个Bean
3、获取&初始化beanName,创建Bean定义,添加到Bean定义集合
/**
* 扫描配置类下的文件
* @param appConfigClass
*/
private void sacn(Class appConfigClass) {
// 配置类上面是否配置了@ComponentScan注解
if (appConfigClass.isAnnotationPresent(ComponentScan.class)) {
// 获取@ComponentScan注解的value,拿到扫描的路径
ComponentScan ComponentScan = (com.spring.ComponentScan) appConfigClass.getAnnotation(ComponentScan.class);
String path = ComponentScan.value();
path = path.replace(".", "/");
// 获取类加载器(appclassloader加载器,他是获取的target下面的文件,这是重点!!!)
ClassLoader classLoader = LjcApplicationContext.class.getClassLoader();
// 获取路径下的文件夹
URL resource = classLoader.getResource(path);
File file = new File(resource.getFile());
// 是文件夹则进行处理
if (file.isDirectory()) {
// 遍历文件夹下所有的文件
for (File f : file.listFiles()) {
try {
// 通过截取路径获取
String absolutePath = f.getAbsolutePath();
absolutePath = absolutePath.substring(absolutePath.indexOf("com"),absolutePath.indexOf(".class"));
absolutePath = absolutePath.replace("\\",".");
// 通过类加载器加载,获取类
Class<?> clazz = classLoader.loadClass(absolutePath);
// 判断有没有被@Component过,有的话进行增强
if (clazz.isAnnotationPresent(Component.class)) {
// 扫描后置处理器
if (BeanPostProcessor.class.isAssignableFrom(clazz)) {
// getConstructor获取类的构造方法
BeanPostProcessor instance = (BeanPostProcessor) clazz.getConstructor().newInstance();
beanPostProcessorList.add(instance);
}
// 获取注解的beanName
Component component = clazz.getAnnotation(Component.class);
String beanName = component.value();
// 如果没有写,则默认首字母小写
if ("".equals(beanName)) {
beanName = Introspector.decapitalize(clazz.getSimpleName());
}
// 创建Bean定义
BeanDefinition beanDefinition = new BeanDefinition();
// 设置是单例还是多例
if (clazz.isAnnotationPresent(Scope.class)) {
Scope scope = clazz.getAnnotation(Scope.class);
beanDefinition.setScope(scope.value());
}else{
beanDefinition.setScope("singleton");
}
// 设置Bean定义的类型
beanDefinition.setType(clazz);
// 添加到Bean定义Map
beanDefinitionMap.put(beanName,beanDefinition);
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
}
}
主要做了几件事情
1、遍历类属性,是否有依赖注入
2、有没有实现Aware接口、BeanPostPorcess接口、有没有实现初始化,有就处理
/**
* 创建bean
* @param beanDefinition
* @param beanName
* @return
*/
private Object createBean(BeanDefinition beanDefinition,String beanName) {
Class classz = beanDefinition.getType();
Object instance = null;
try {
// 反射出实体类
instance = classz.getConstructor().newInstance();
// 获取实体的所有属性
Field[] fields = classz.getDeclaredFields();
// 遍历、属性填充
for (Field field : fields) {
// 属性是否被@Autowired注解(依赖注入)
if (field.isAnnotationPresent(Autowired.class)) {
field.setAccessible(true);
// 注入
field.set(instance,getBean(field.getName()));
}
}
// 实现BeanNameAware
if (instance instanceof BeanNameAware) {
((BeanNameAware)instance).setBeanName(beanName);
}
// 遍历、初始化前
for (BeanPostProcessor beanPostProcessor : beanPostProcessorList) {
instance = beanPostProcessor.postProcessBeforeInitialization(instance, beanName);
}
// 实现了InitializingBean,则调用初始化
if (instance instanceof InitializingBean) {
((InitializingBean)instance).afterPropertiesSet();
}
// 遍历、初始化前
for (BeanPostProcessor beanPostProcessor : beanPostProcessorList) {
instance = beanPostProcessor.postProcessAfterInitialization(instance, beanName);
}
} catch (InstantiationException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (InvocationTargetException e) {
e.printStackTrace();
} catch (NoSuchMethodException e) {
e.printStackTrace();
}
return instance;
}
主要做了几件事情
1、判断Bean定义有没有这个beanName,没有就报错
2、有的话就去Bean定义集合里面拿
3、如果是单例就从单例池拿,没有就创建
4、不是单例就i直接创建Bean。
/**
* 获取Bean
* @param beanName
* @return
*/
public Object getBean(String beanName) {
// Bean定义如果不存在,则空指针
if (!beanDefinitionMap.containsKey(beanName)) {
throw new NullPointerException();
}
// 如果不存在,则需要创建,根据beanName从Bean定义Map里获取到Bean定义
BeanDefinition beanDefinition = beanDefinitionMap.get(beanName);
Object instance = null;
// 判断是否为单例
if (beanDefinition.getScope().equals("singleton")) {
// 从单例池获取
instance = singletonObjects.get(beanName);
// 单例池没有则去创建Bean
if(instance == null){
instance = createBean(beanDefinition,beanName);
}
}else{
// 不是单例则去创建Bean
instance = createBean(beanDefinition,beanName);
}
return instance;
}
@Component
public class AopBeanPostProcessor implements BeanPostProcessor {
@Override
public Object postProcessBeforeInitialization(Object bean, String beanName) {
System.out.println("BeforeInitialization——"+bean+"——"+beanName);
return BeanPostProcessor.super.postProcessBeforeInitialization(bean, beanName);
}
@Override
public Object postProcessAfterInitialization(Object bean, String beanName) {
if("userService".equals(beanName)){
Object proxyInstance = Proxy.newProxyInstance(LjcApplicationContext.class.getClassLoader(), bean.getClass().getInterfaces(), new InvocationHandler() {
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("切面逻辑");
return method.invoke(bean, args);
}
});
return proxyInstance;
}
return bean;
}
}