简单实现以下spring流程
UserService.class > 无参构造方法 (推断构造方法)> 普通对象 > 依赖注入(属性赋值) > 初始化前@PostConstruct > 初始化InitializingBean > 初始化后(AOP)> 代理对象 > Bean
关于里面实现的代理对象,看起来像是栈逻辑
courseService执行after切面逻辑 com.lywtimer.service.MyBeanPostProcessor
courseService执行after切面逻辑 com.lywtimer.service.FilterBeanPostProcessor
courseService执行before切面逻辑
CourseService Testing
代码中 postProcessBeforeInitialization 和 postProcessAfterInitialization 的实现并不合理,感觉也没有必要
package com.spring;
import com.lywtimer.AppConfig;
import java.beans.Introspector;
import java.io.File;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.net.URL;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
public class MyApplicationContext {
private Class configClass;
private Map<String, BeanDefinition> beanDefinitionMap = new HashMap<>();
private Map<String, Object> singletonObjects = new HashMap<>();
private List<BeanPostProcessor> beanPostProcessorList = new ArrayList<>();
public MyApplicationContext(Class<AppConfig> configClass) {
this.configClass = configClass;
//扫描class文件,获取Bean
scan(configClass);
//遍历扫描好的map
for (Map.Entry<String, BeanDefinition> entry : beanDefinitionMap.entrySet()) {
String beanName = entry.getKey();
BeanDefinition beanDefinition = entry.getValue();
if (beanDefinition.getScope().equals("singleton")) {
//创建单例对象并存储
Object instance = createBean(beanName, beanDefinition);
singletonObjects.put(beanName, instance);
}
}
}
private Object createBean(String beanName, BeanDefinition beanDefinition) {
Object instance = null;
Class clazz = beanDefinition.getType();
try {
//选择构造方法
Constructor constructor = clazz.getDeclaredConstructor();
instance = constructor.newInstance();
//遍历属性
for (Field declaredField : clazz.getDeclaredFields()) {
if (declaredField.isAnnotationPresent(Autowired.class)) {
//简单化处理,存在循环依赖问题
declaredField.setAccessible(true);
declaredField.set(instance, getBean(declaredField.getName()));
}
}
//初始化前执行切面逻辑
for (BeanPostProcessor processor : beanPostProcessorList) {
instance = processor.postProcessBeforeInitialization(instance, beanName);
}
//初始化执行
if (instance instanceof InitializingBean) {
((InitializingBean) instance).afterPropertiesSet();
}
//初始化后执行切面逻辑
for (BeanPostProcessor processor : beanPostProcessorList) {
instance = processor.postProcessAfterInitialization(instance, beanName);
}
} catch (NoSuchMethodException | InstantiationException | IllegalAccessException |
InvocationTargetException e) {
throw new RuntimeException(e);
}
return instance;
}
public Object getBean(String beanName) {
if (!beanDefinitionMap.containsKey(beanName)) {
throw new NullPointerException("Bean " + beanName + " not found ");
}
var beanDefinition = beanDefinitionMap.get(beanName);
if (beanDefinition.getScope().equals("singleton")) {
Object bean = singletonObjects.get(beanName);
if (bean == null) {
bean = createBean(beanName, beanDefinition);
singletonObjects.put(beanName, bean);
}
return bean;
} else {
//重新新建bean对象
return createBean(beanName, beanDefinition);
}
}
private void scan(Class<AppConfig> configClass) {
if (configClass.isAnnotationPresent(ComponentScan.class)) {
var annotation = (ComponentScan) configClass.getAnnotation(ComponentScan.class);
String packageName = annotation.value();
var path = packageName.replace(".", "/");
//查找类加载器指定的目录
ClassLoader classLoader = MyApplicationContext.class.getClassLoader();
URL resource = classLoader.getResource(path);
//转换成目录文件读取
File file = new File(resource.getFile());
if (file.isDirectory()) {
for (File f : file.listFiles()) {
String p = packageName + "." + f.getName().replace(".class", "");
try {
var clazz = classLoader.loadClass(p);
//查找Bean
if (clazz.isAnnotationPresent(Component.class)) {
//查找实现类
boolean find = BeanPostProcessor.class.isAssignableFrom(clazz);
if (find) {
BeanPostProcessor instance = (BeanPostProcessor) clazz.getDeclaredConstructor().newInstance();
beanPostProcessorList.add(instance);
}
//获取 beanName
String beanName = clazz.getAnnotation(Component.class).value();
if ("".equals(beanName)) {
beanName = Introspector.decapitalize(clazz.getSimpleName());
}
String scope = "singleton";
if (clazz.isAnnotationPresent(Scope.class)) {
scope = clazz.getAnnotation(Scope.class).value();
}
//构建BeanDefinition
var beanDefinition = new BeanDefinition();
beanDefinition.setType(clazz);
beanDefinition.setScope(scope);
beanDefinitionMap.put(beanName, beanDefinition);
}
} catch (ClassNotFoundException e) {
throw new RuntimeException(e);
} catch (InvocationTargetException e) {
throw new RuntimeException(e);
} catch (InstantiationException e) {
throw new RuntimeException(e);
} catch (IllegalAccessException e) {
throw new RuntimeException(e);
} catch (NoSuchMethodException e) {
throw new RuntimeException(e);
}
}
}
}
}
}