实现Spring Framework底层机制
大家好呀!我是小笙,本节主要是想和大家简单讲讲ioc的实现以及aop的部分实现原理
实现Spring Framework底层机制
思考三个问题:
- Spring容器 如何实现依赖注入singleton,prototype(单例,多例)
- Spring 如何实现BeanPostProcesser (后置处理器)
- Spring 如何实现AOP切面编程机制
注意:以下实现只是为了便于理解真正的 spring 底层机制,并非完全一致
整体架构
思路分析以及实现过程
1.创建Spring容器
扫描包下所有的文件,将标有特定注解的类通过反射创建bean对象,存入到ioc容器中
- 使用lnsSpringConfig.java代替bean.xml文件
- 扫描包下文件是否被标记注解
- 将单例bean对象实例化放入singleton 单例池中
知识点
类加载器 详细说明
Bootstrap 类加载器 <=> 对应路径 jre/lib
Ext 类加载器 <=> 对应路径 jre/lib/ext
App 类加载器 <=> 对应路径 classpath
1.指定需要扫描包的全路径
使用 lnsSpringConfig.java 代替 bean.xml 文件(指定需要扫描包的全路径)
/**
* @author Al_tair
* @date 2022/7/14-22:14
* 作用类似于bean.xml文件配置扫描包的全路径
*/
@ComponentScan(value = "com.Al_tair.spring.myComponent")
public class ClassPathConfig {
}
@ComponentScan注解是自己实现的,就是用 value 来存储指定扫描包的全路径
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface ComponentScan {
// 通过 value 指定扫描包的全路径
String value() default "";
}
主方法就是将配置类的信息传给 ioc 容器,进行扫描包进行初始化
public class AppMain {
public static void main(String[] args) {
// ClassPathConfig.class 配置类信息,可以通过获取该类上的注解信息来进行 bean 对象的注入
SpringIocApplicationContext ioc = new SpringIocApplicationContext(ClassPathConfig.class);
}
}
2.扫描包并进行分类(单例、多例)
首先,我们需要选择存储的数据结构,我采用 Map 键值对的形式来定义 BeanDefinition 对象和 singletonObject 单例池对象
- BeanDefinition 对象是用来存储 scope(单例或者多例) 和 bean 对象的 class 信息,方便反射初始化对象
- singletonObject 单例池对象是提前创建来懒加载单例对象,方便获取,多例对象都是通过创建 bean 对象的时候创建
/**
* 定义属性 BeanDefinitionMap id <-> BeanDefinition 对象
* ConcurrentHashMap 线程安全
*/
private final ConcurrentHashMap<String,BeanDefinition> ioc = new ConcurrentHashMap<>();
/**
* 单例池:存放单例对象
*/
private ConcurrentHashMap<String,Object> singletonObject = new ConcurrentHashMap<>();
BeanDefinition 类信息
/**
* 用于封装/记录Bean的信息
* 1. scope
* 2. bean 对应的 Class 对象
*/
public class BeanDefinition {
private String scope;
private Class clazz;
// ...省略
}
然后,我们需要找到需要扫描的类(找出.class的文件,并存储类路径)
// 1.获取注解信息:@com.Al_tair.spring.annotation.ComponentScan(value=com.Al_tair.spring.myComponent)
ComponentScan componentScan = (ComponentScan)this.springConfig.getDeclaredAnnotation(ComponentScan.class);
// 2.取出注解里的 value 值并转换成相对文件路径 com/Al_tair/spring/myComponent
String ScanPackage = componentScan.value().replace('.','/');
// 3.得到类加载器:找到资源运行的真实路径
ClassLoader classLoader = SpringIocApplicationContext.class.getClassLoader();
URL resource = classLoader.getResource(ScanPackage);
// 4.获取到资源路径上的文件夹
File file = new File(resource.getFile());
// 通过文件夹所在位置进行遍历
scanFiles(file);
扫描指定文件夹下的 .class 文件,我将这个类路径放在 list 列表下,方便以后获取
/**
* 存储包下的全部.class文件路径
*/
private List<String> list = new ArrayList<>();
scanFiles 方法:采用递归的方式进行遍历搜索
/**
* 扫描所有包以及子包下的类,返回全路径
* @param files 传入需要扫描的文件
*/
private void scanFiles(File files){
File[] f = files.listFiles();
for (File file : f) {
if(file.isDirectory()){
scanFiles(file);
}else{
String absolutePath = file.getAbsolutePath();
if(absolutePath.endsWith("class")) {
// 例如:com.Al_tair.spring.myComponent.myService.PrototypeServiceImpl
list.add(absolutePath.substring(absolutePath.lastIndexOf("\\com") + 1, absolutePath.lastIndexOf(".class")).
replace("\\","."));
}
}
}
}
最后,我们要对指定注入的 bean 对象带上 MyComponent 注解以及 区分单例还是多例的 MyScope 注解
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface MyComponent {
// 通过 value 可以给组件注入对象的id名,默认id名为类名首字母小写
String value() default "";
}
/**
* 指定一个 bean 的作用范围 【singleton,prototype】
*/
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface MyScope {
/**
* 使用value来指定 singleton,prototype
* @return
*/
String value() default "";
}
然后我们需要遍历列表中每个类路径,并进行类加载,判断该类是否被 MyComponent 注解标注,如果有则将 id 和 Class 信息存储在 BeanDefinition 中
for (String s : list) {
try {
Class<?> aClass = classLoader.loadClass(s);
// 判断该类是否被 MyComponent 注解标注
if(aClass.isAnnotationPresent(MyComponent.class)){
MyComponent declaredAnnotation = aClass.getDeclaredAnnotation(MyComponent.class);
// beanName
String id = declaredAnnotation.value();
if("".equals(id)){
// 将类名首字母小写作为 id
id = s.substring(s.lastIndexOf(".") + 1,s.lastIndexOf(".") + 2).toLowerCase()
+ s.substring(s.lastIndexOf(".")+2);
}
// 将 id 和 Class 信息存储在 BeanDefinition 中
BeanDefinition beanDefinition = new BeanDefinition();
beanDefinition.setClazz(aClass);
// 判断是单例还是多例
if(aClass.isAnnotationPresent(MyScope.class)){
// 标注注解则从注解的 value 取出值判断是多例还是单例
MyScope ScopeValue = aClass.getDeclaredAnnotation(MyScope.class);
beanDefinition.setScope(ScopeValue.value());
}else{
// 没有标注注解默认为单例对象
beanDefinition.setScope("singleton");
}
ioc.put(id,beanDefinition);
// 如果是单例对象,放入单例池
if("singleton".equals(beanDefinition.getScope())){
Object bean = createBean(beanDefinition,id);
singletonObject.put(id,bean);
}
}
} catch (Exception e) {
e.printStackTrace();
}
}
3.创建 Bean 对象
分三种情况:
- 依赖注入 MyAutowired 方法:在其他类 创建的时候需要注入其他 bean 对象(控制反转,动态依赖注入)
- 单例对象直接获取该 Bean 对象(而且只能创建一次)
- 多例对象每次获取都需要创建 Bean 对象(每个对象都是不同的)
/**
* 创建 bean 对象
*/
private Object createBean(BeanDefinition beanDefinition,String beanName){
// 得到 bean 的 Class 对象
Class clazz = beanDefinition.getClazz();
try {
// 通过反射得到 bean 实例
Object instanse = clazz.getDeclaredConstructor().newInstance();
// 依赖注入
// 1.遍历当前的所有对象的字段
Field[] declaredFields = clazz.getDeclaredFields();
for (Field declaredField : declaredFields) {
// 2. 判断字段是否被特定注解注释
if(declaredField.isAnnotationPresent(MyAutowired.class)){
MyAutowired annotation = declaredField.getAnnotation(MyAutowired.class);
// 3.是否必须依赖注入
boolean required = annotation.required();
if(required){
// 4.获取字段名字
String name = declaredField.getName();
// 5.通过 getBean 来组装对象
Object bean = getBean(name);
// 6.进行组装(因为属性是私有的,所以需要进行暴破)
declaredField.setAccessible(true);
declaredField.set(instanse,bean);
}else{
// 假设都需要依赖注入
}
}
}
return instanse;
} catch (Exception e) {
e.printStackTrace();
}
// 如果创建对象失败
return null;
}
4.获取 Bean 对象
通过 id 来获取 bean 对象
public Object getBean(String id){
BeanDefinition beanDefinition = ioc.get(id);
if(beanDefinition != null && ioc.containsKey(id)){
String scope = beanDefinition.getScope();
// 如果是单例对象,直接获取
if("singleton".equals(scope)){
return singletonObject.get(id);
}else{
// 反之多例对象,需要创建 Bean
return createBean(beanDefinition,id);
}
}else{
throw new RuntimeException("没有该 bean 对象");
}
}
讲到这里 IOC 容器就算简单的创建出来了,接下来我们需要讲一下 AOP机制
2.实现 AOP 机制
1.首先需要实现添加对象初始化接口
/**
* 初始化 Bean 对象的接口:用来初始化 Bean 的时候调用
*/
public interface MyInitializingBean {
// 初始化方法:在 setter 方法执行后调用
void afterPropertiesSet() throws Exception;
}
实现了该初始化接口的类:当创建 MyServiceImpl 对象的时候将会初始化
@MyComponent
public class MyServiceImpl implements MyInitializingBean {
@MyAutowired
private MyDaoImpl myDaoImpl;
@Override
public void afterPropertiesSet() throws Exception {
System.out.println("MyServiceImpl 初始化方法被调用");
}
}
将初始化操作放在创建 Bean 对象方法的后面
private Object createBean(BeanDefinition beanDefinition,String beanName){
// 得到 bean 的 Class 对象
Class clazz = beanDefinition.getClazz();
// 通过反射得到 bean 实例
try {
Object instanse = clazz.getDeclaredConstructor().newInstance();
// 依赖注入
// ...省略
// 创建好实例之后进行初始化
// instanceof: 判断当前某个对象的运行类型是否为该类型实现的接口或者父类
if(instanse instanceof MyInitializingBean){
((MyInitializingBean)instanse).afterPropertiesSet();
}
return instanse;
} catch (Exception e) {
e.printStackTrace();
}
// 如果创建对象失败
return null;
}
2.后置处理器的实现
MyBeanPostProcessor 接口实现:主要是在所有 bean 对象初始化前后调用(切面编程)
/**
* 后置处理器:会对 Spring 容器中的所有 Bean实例生效(切面编程)
*/
public interface MyBeanPostProcessor {
/**
* 在 bean 对象初始化方法之前调用
*
* @param bean
* @param beanName
* @return
* @throws BeansException
*/
@Nullable
default Object postProcessBeforeInitialization(Object bean, String beanName) {
return bean;
}
/**
* 在 bean 对象初始化方法之后调用
*
* @param bean
* @param beanName
* @return
*/
@Nullable
default Object postProcessAfterInitialization(Object bean, String beanName) {
return bean;
}
}
实现自制的后置处理器接口: AOP 动态代理机制的实现核心就是后置处理器实现类中实现
/**
* 实现自制化的后置处理器
*/
@MyComponent
public class LnsBeanPostProcessor implements MyBeanPostProcessor {
@Override
public Object postProcessBeforeInitialization(Object bean, String beanName) {
// 后置处理器会在容器初始化 bean 对象之前生效
// 通过 instanceof 关键字判断,可以用于多个对象的编程
// 可以用来处理日志、权限、身份、事务等
System.out.println("Before=" + beanName);
return bean;
}
@Override
public Object postProcessAfterInitialization(Object bean, String beanName) {
System.out.println("After=" + beanName);
return bean;
}
}
为了简化操作,我将后置处理器对象单独放一个容器中,方便调用对象初始化方法前后调用
/**
* 存放实现了 MyBeanPostProcessor 接口的后置处理器的对象
* 实际是存放在单例池中,这里为了方便取出后置处理器的对象单独写个集合
*/
private List<MyBeanPostProcessor> beanPostProcessorList = new ArrayList<>();
为了添加后置处理器对象,需要使用 isAssignableFrom() 方法判断某个类是否实现了某个接口(注意区别 instanceof 关键字)
// beanDefinitionByScan 方法
for (String s : list) {
try {
Class<?> aClass = classLoader.loadClass(s);
if(aClass.isAnnotationPresent(MyComponent.class)){
// 判断是否实现了MyBeanPostProcessor 接口
// 这里不能使用instanceof来判断,因为instanceof是用来判断实例对象,但是判断某个类是否实现了某个接口就要用底下这个方法
if(MyBeanPostProcessor.class.isAssignableFrom(aClass)){
MyBeanPostProcessor myBeanPostProcessor = (MyBeanPostProcessor)aClass.newInstance();
beanPostProcessorList.add(myBeanPostProcessor);
continue;
}
MyComponent declaredAnnotation = aClass.getDeclaredAnnotation(MyComponent.class);
// beanName
String id = declaredAnnotation.value();
if("".equals(id)){
// 将类名首字母小写作为 id
id = s.substring(s.lastIndexOf(".") + 1,s.lastIndexOf(".") + 2).toLowerCase()
+ s.substring(s.lastIndexOf(".")+2);
}
BeanDefinition beanDefinition = new BeanDefinition();
beanDefinition.setClazz(aClass);
// 判断是单例还是多例
if(aClass.isAnnotationPresent(MyScope.class)){
MyScope ScopeValue = aClass.getDeclaredAnnotation(MyScope.class);
beanDefinition.setScope(ScopeValue.value());
}else{
beanDefinition.setScope("singleton");
}
ioc.put(id,beanDefinition);
// 如果是单例对象,放入单例池
if("singleton".equals(beanDefinition.getScope())){
Object bean = createBean(beanDefinition,id);
singletonObject.put(id,bean);
}
}
} catch (Exception e) {
e.printStackTrace();
}
}
最后需要在初始化方法前后添加后置处理器对象的调用
// createBean 方法
// 后置处理器
for (MyBeanPostProcessor myBeanPostProcessor : beanPostProcessorList) {
Object o = myBeanPostProcessor.postProcessBeforeInitialization(instanse,beanName);
if(o != null){
instanse = o;
}
}
// 创建好实例之后进行初始化
// instanceof: 判断当前某个对象的运行类型是否为该类型实现的接口或者父类
if(instanse instanceof MyInitializingBean){
((MyInitializingBean)instanse).afterPropertiesSet();
}
// 后置处理器
for (MyBeanPostProcessor myBeanPostProcessor : beanPostProcessorList) {
Object o = myBeanPostProcessor.postProcessAfterInitialization(instanse,beanName);
if(o != null){
instanse = o;
}
}
实现效果
3.最后实现 AOP 机制,需要在后置处理器里进行操作
/**
* 1. 在Spring容器中,仍然把HspBeanPostProcessor当做一个Bean对象, 要在注入到容器
* 2. 还要考虑多个后置处理器对象注入到容器问题
*/
@Component
public class LnsBeanPostProcessor implements BeanPostProcessor {
@Override
public Object postProcessBeforeInitialization(Object bean, String beanName) {
// 可以用于日志,权限,身份, 事务等
if (bean instanceof Car) {
System.out.println("Car对象");
}
return bean;
}
@Override
public Object postProcessAfterInitialization(Object bean, String beanName) {
// 实现AOP, 返回代理对象, 即对 Bean 对象进行包装
if ("smartDog".equals(beanName)) {
//使用Jdk的动态代理,返回返回bean的代理对象
Object proxyInstance = Proxy.newProxyInstance(HspBeanPostProcessor.class.getClassLoader(),
bean.getClass().getInterfaces(), new InvocationHandler() {
@Override
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
System.out.println("method=" + method.getName());
Object result = null;
// 假如我们进行前置通知+返回通知 处理的方法是getSum
// 后面可以通过注解来做的更加灵活
if ("getSum".equals(method.getName())) {
SmartAnimalAspect.showBeginLog();
// 执行目标方法
result = method.invoke(bean, args);
// 进行返回通知的处理
SmartAnimalAspect.showSuccessLog();
} else {
// 执行目标方法
result = method.invoke(bean, args);
}
return result;
}
});
// 如果bean是需要返回代理对象的, 这里就直接return proxyInstance
return proxyInstance;
}
// 如果不需要AOP, 返回 bean
return bean;
}
}