Spring用了挺久了，但是Spring源码一直不得其精髓，后来在B站上找视频，看到个手写一个简易的Spring，以此加深对Spring的理解。
Bean的生命周期
一个Spring容器的开始是从创建ApplicationContext开始的，然后通过ApplicationContext.getBean("beanName")创建一个实例Bean。
ApplicationContext applicationContext = new ApplicationContext(AppConfig.class);
System.out.println(applicationContext.getBean("testService"));
所以需要在ApplicationContext的构造方法里面实现以下几个点：
- 从AppConfig类中获取ComponentScan注解的参数，这个参数就是表示我要到哪些包下面找类；
- 根据1步骤找到的绝对路径，扫路径下的所有文件，包含Component注解的类全部捞出来解析；
- 如果Component有参数，就以参数为Bean名称，没有就小写类名首字母。解析类的特征存储进BeanDefinition对象封装起来，并且存放到BeanDefinitionMap中，方便后续处理和创建Bean；
- 把BeanDefinitionMap里的所有标注为单例的BeanDefinition捞出来先创建好单例Bean，创建好单例Bean后存储在单例池里面，这里的单例池用的还是ConcurrentHashMap
下面就是简易的ApplicationContext实现：
public ApplicationContext(Class className) {
this.className = className;
// 我们拿到配置类的名称之后，就要去配置类里面拿信息，第一个要拿的，就是配置类可以扫哪些包，即获取ComponentScan的信息
if (className.isAnnotationPresent(ComponentScan.class)) {
// 判断一下有没有ComponentScan的注解，有就拿出来
ComponentScan componentScan = (ComponentScan) className.getAnnotation(ComponentScan.class);
// 拿出配置的参数值，就是com.my.code.service这个值
String path = componentScan.value();
path = path.replace(".", "/");
// 根据相对路径找绝对路径
ClassLoader classLoader = ApplicationContext.class.getClassLoader();
URL resource = classLoader.getResource(path);
File file = new File(resource.getFile());
if (file.isDirectory()) {
// 判断一下是不是文件夹
File[] files = file.listFiles();
for (File f : files) {
String fileName = f.getAbsolutePath();
if (fileName.endsWith(".class")) {
// 判断这个类是不是有Component注解，用反射；先将绝对路径换成相对路径
String classPathName = fileName.substring(fileName.indexOf("com"), fileName.indexOf(".class"));
classPathName = classPathName.replace("\\", ".");
try {
Class<?> clazz = classLoader.loadClass(classPathName);
// 获取到类之后，判断是否有Component注解
if (clazz.isAnnotationPresent(Component.class)) {
Component component = clazz.getAnnotation(Component.class);
String beanName = component.value();
if (beanName.equals("")) {
// 如果不写Component的参数，默认是类名的首字母小写
beanName = Introspector.decapitalize(clazz.getSimpleName());
}
// 有这个注解，我们不直接创建Bean，而是先创建BeanDefinition
BeanDefinition beanDefinition = new BeanDefinition();
if (clazz.isAnnotationPresent(Scope.class)) {
Scope scopeAnnotation = clazz.getAnnotation(Scope.class);
beanDefinition.setScope(scopeAnnotation.value());
} else {
beanDefinition.setScope("singleton");
}
beanDefinition.setType(clazz);
beanDefinitionMap.put(beanName, beanDefinition);
}
} catch (ClassNotFoundException e) {
System.err.println("反射获取.class文件出错");
e.printStackTrace();
}
}
}
}
}
// 开始创建单例对象
for (String beanName : beanDefinitionMap.keySet()) {
BeanDefinition beanDefinition = beanDefinitionMap.get(beanName);
if (beanDefinition.getScope().equals("singleton")) {
Object bean = createBean(beanName, beanDefinition);
singletonObjectsMap.put(beanName, bean);
}
}
}
可以直接根据全限定类名从类加载器里面获取类，然后用isAnnotationPresent方法来判断是否有某个注解
以上就是完成了包扫描，加载好了Bean的相关信息，单例Bean也已经创建好了。只需要调用getBean就能够获取了。这里只考虑是否是单例Bean而讨论。实现思路还是很直接，拿BeanDefinitionMap里的信息，判断是单例还是多例，单例就从单例池里取，没有重新创建，有就拿出返回；多例就直接创建一个返回回去。这里的创建Bean有点复杂，所以单独拎出去写一个新方法。getBean实现如下：
public Object getBean(String beanName) {
BeanDefinition beanDefinition = beanDefinitionMap.get(beanName);
if (beanDefinition == null) {
throw new NullPointerException();
} else {
String scope = beanDefinition.getScope();
if (scope.equals("singleton")) {
Object bean = singletonObjectsMap.get(beanName);
if (bean == null) {
bean = createBean(beanName, beanDefinition);
assert bean != null;
singletonObjectsMap.put(beanName, bean);
}
return bean;
} else {
return createBean(beanName, beanDefinition);
}
}
}
private Object createBean(String beanName, BeanDefinition beanDefinition) {
Class<?> clazz = beanDefinition.getType();
try {
Object instance = clazz.getConstructor().newInstance();
// 对instance对象里面的属性自动配置，找有Autowired注解的属性
for (Field declaredField : clazz.getDeclaredFields()) {
if (declaredField.isAnnotationPresent(Autowired.class)) {
declaredField.setAccessible(true);
declaredField.set(instance, getBean(declaredField.getName()));
}
}
return instance;
} catch (InstantiationException | NoSuchMethodException | InvocationTargetException | IllegalAccessException e) {
e.printStackTrace();
}
return null;
}
这是创建Bean的实现，里面涉及到Autowired的自动注入注解，还有一个循环依赖的解决。
AOP的实现：先创建一个BeanPostProcessor，里面搞个后置处理器，在后置处理器里面创建一个代理类，替换原先的bean并且返回。这里JDK代理只能代理接口。
@Override
public Object postProcessAfterInitialization(String beanName, Object bean) {
// AOP的核心，就是在后置处理器里面创建了一个新的代理对象，这个代理对象不是原来的bean，而是在原有bean上加工过的对象
Object proxyInstance = Proxy.newProxyInstance(TestBeanPostProcessor.class.getClassLoader(), bean.getClass().getInterfaces(), new InvocationHandler() {
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("加入操作XXXX");
return method.invoke(bean, args);
}
});
return proxyInstance;
}
AOP的本质就是在创建这个Bean的时候，在后置处理器里面，创建一个同接口的实现类，这个实现类有自己加的新功能，也有原先的方法，所有的方法都被植入新操作，并以代理类代替了原先的实现类。
综上我们可以总结如下的Bean的生命周期：
ApplicationContext的构造方法里面，开始扫@Component注解的类。
Spring事务底层原理
事务开启会做两件事，一件是Spring自己建立一个JDBC连接，然后就是关闭自动提交。如果将提交和连接交给jdbcTemplate，那么就会出现jdbctemplate执行一个sql就提交一个，遇到异常抛出时，sql都已经提交了，回滚不回来了。所以需要spring自己管理一个连接。
spring事务失效的原理
@Transactional
public void test(){
jdbcTemplate.execute("insert into t1 values(1,1,1)");
a();
}
@Transactional
public void a(){
jdbcTemplate.execute("insert into t1 values(2,2,2)");
}
当调用Spring里的Bean（testService）的test()方法时，test()的@Transactional是会生效的，但是test()里面的a()方法的事务注解是不会生效的。
原因：在产生代理对象替代原普通对象时，普通对象里面的自动注入的属性在代理对象里面是没有用的，也就是自动注入注不到代理对象里面，CGlib的解决方法是在代理对象里面加一个同类型的target对象，这个target就是上面提到的普通对象，也可以认为是被代理的对象。这个时候再执行普通对象里面的test()方法和a()方法。于是问题就出现了：test()方法的事务注解是被解析过的并且在代理对象里是有事务的操作，所以不会失效，a()方法就不会了，他没有被事务解析过，调用的时候是调的target这个普通对象，你写的@Transactional他理都不理，等于没写。解决方法就是在这个类里面再自动注入自己，spring会帮忙解决循环依赖的问题。
三级缓存
一级缓存：单例池，存放已经完成初始化后的完整Bean；
二级缓存：因为出现循环依赖，而不得不提前进行AOP产生代理对象，存放在二级缓存中；二级缓存是为了保证这个代理对象单例唯一；
三级缓存：如果二级缓存中没有找到提前出现的代理对象，就会将执行反射创建代理对象的操作封装进函数式接口中，存放在三级缓存里面；
