绑定完请刷新页面
取消
刷新

分享好友

×
取消 复制
【Spring系列】- 手写模拟Spring框架
2022-11-18 10:37:08

1|1前言

上次已经学习了Java的设计模式,接下来就先来学习一下如何手写模拟简易的Spring,通过动手实践,才会更好的了解spring底层原理,今天就简单的模拟Spring容器是如何创建,bean又是如何注入的。
来看一下本次案例的spring类图

1|2Spring容器

模拟spring,首先就是需要一个容器,是Spring的核心,一切Spring bean都存储在Spring容器内,并由其通过IoC技术管理。Spring容器也就是一个bean工厂(BeanFactory)。应用中bean的实例化,获取,销毁等都是由这个bean工厂管理的。就像我们刚开始学习的时候接触的ApplicationContext,就是spring的容器,他就是为了完成容器的配置,初始化,管理bean的。因此笔者自己创建了一个LydApplicationContext来模拟简单的spring容器。

开始使用

首先通过new LydApplicationContext(AppConfig.class)实例化对象,在通过applicationContext.getBean("userService")去获得bean对象。然而在容器的初始化可是做了许多的事情,包括扫描、实例化bean等等操作。
初始容器创建:

public class LydApplicationContext { private Class configClass; public LydApplicationContext(Class configClass) { // 构造方法 this.configClass = configClass; } }

1|3Spring扫描底层实现

Spring容器建好之后我们就需要通过配置文件的注解获取扫描路径,我们需要获取所有的bean,并且需要实例对象。在此我们需要一个配置文件,就是使用new LydApplicationContext(AppConfig.class)实例携带的配置类,当然这里有好多的形式,也可以是通过xml文件来处理。

配置文件AppConfig.java

这个就是为了提供扫描的包路径的,不做任何操作,所以不需要其他代码。

@ComponentScan("com.lyd.service") // 扫描路径,扫描这个包下的 public class AppConfig { }

通过注解存放这个包路径,在后面可以通过这个注解来获取包路径,所以就需要我们创建一个ComponentScan注解。

编写ComponentScan注解

这个注解是用来spring容器扫描包为之提供包路径。

@Target(ElementType.TYPE) @Retention(RetentionPolicy.RUNTIME) public @interface ComponentScan { // 指定扫描路径 String value() default ""; }

编写Component注解

在Spring中,通过Component注解将bean注入Spring容器中,这里我们也采用高这个注解。

@Target(ElementType.TYPE) @Retention(RetentionPolicy.RUNTIME) public @interface Component { String value() default ""; }

获取包路径

既然已经通过注解将包路径存在配置类中,接下来就可以通过这个注解来得到。但是,在这里需要注意的是,我们扫描的并非是java源文件,而是编译后的class文件。我们需要在LydApplicationContext的构造方法中去实现。
首先,我们需要通过isAnnotationPresent方法先判断是否存在ComponentScan注解,在通过类的getAnnotation方法来得到注解。这样就可以直接得到注解上的值。这个值就是我们写入的包路径,注意,这里的路径是com.lyd.service,而我们需要用替换方法将'.'替换成'/',因为在后面获取资源路径的时候,用的是com/lyd/service这种形式,也就是相对路径。
接下来需要获取资源路径,这个时候就需要用到类加载器LydApplicationContext.class.getClassLoader(),类加载器中有一个getResource(path)方法,这个可以根据传入的路径获取相应的资源,后是能够拼出我们需要的路径。

if (configClass.isAnnotationPresent(ComponentScan.class)) { ComponentScan componentScanAnnotation = (ComponentScan) configClass.getAnnotation(ComponentScan.class); // 1.1 扫描路径:只是个包名,扫描的是java的class文件,而并非源文件,com.lyd.service String path = componentScanAnnotation.value(); // 1.2 将路径文件替换成/的形式 path = path.replace(".","/"); // 1.3 通过类加载器获取资源路径 ClassLoader classLoader = LydApplicationContext.class.getClassLoader(); URL resource = classLoader.getResource(path); // 1.4 转成文件形式,主要是为了获取他的地址 File file = new File(resource.getFile()); System.out.println(file); }

通过类加载器得到的资源有个获取File的方法,然后我们通过File file = new File(resource.getFile());将资源转成File类型,因为他可以表示一个地址或者是具体文件。扫描就是扫描文件路径,也就是文件夹。我们可以打印看一下这个地址:

判断是否为文件夹,如果是,那就获取里面的所有文件,在通过遍历这些文件,获取路径。

if (file.isDirectory()) { // 如果是文件夹 File[] files = file.listFiles(); for (File f : files) { String absolutePath = f.getAbsolutePath(); // 获取路径 System.out.println("路径:" + absolutePath); } }

我们可以打印出来看一下:

因为我们要的是编译的.class文件,因此需要在遍历文件的时候进行判断文件是否为.class文件。为了拿到这个类,需要通过全限定名使用类加载器获取类 ,也就是利用反射机制。我们都知道,spring是通过Component注解来将bean注入spring的,因此后就是通过判断是否有这个注解来得到一个bean。

for (File f : files) { String absolutePath = f.getAbsolutePath(); // 获取路径 System.out.println("路径:" + absolutePath); // 1.5 对编译文件进行处理 if (absolutePath.endsWith(".class")) { // 判断是否为编译文件 /** * 需要拿到的是编译文件,通过类加载器去获取 * 需要将com\lyd\service\UserService转成com.lyd.service.UserService */ String className = absolutePath.substring(absolutePath.indexOf("com"), absolutePath.indexOf(".class")); className = className.replace("\\", "."); System.out.println("类名:" + className); try { // 1.6 通过全限定名使用类加载器获取类 (利用反射机制) Class<?> clazz = classLoader.loadClass(className); // 1.7 在通过这个clazz(类)来判断是否有component注解,有则是bean if (clazz.isAnnotationPresent(Component.class)) { // 到这里就是一个bean } } catch (Exception e) { e.printStackTrace(); } } }

后我们需要的地址就是如下:

1|4Spring生成BeanDefinition

在我们Spring容器启动或者是扫描的时候,并不建议直接实例化bean对象,因为bean是区分单例和多例的,多例bean我们是需要用到的时候再去创建。这个时候就需要生成BeanDefinition,即bean的定义,这个类存储了类和作用域(单例还是多例)。

定义Scope注解

通过Scope这个注解来标明是单例bean还是多例bean。

@Target(ElementType.TYPE) @Retention(RetentionPolicy.RUNTIME) public @interface Scope { String value() default ""; }

定义BeanDefinition

在spring中,不会在获取bean的时候再去解析是否为单例,而是通过BeanDefinition类来操作。对bean的定义,记录了bean类和作用域。

public class BeanDefinition { private Class type; private String 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; } }

因为我们注入springbean对象是有Component注解,因此在扫描的时候,我们会通过这个获得到bean,在这时候去创建BeanDefinition对象。通过判断注解上的值来赋值其作用域,如果没有设置,就默认是单例模式。
创建好的bean对象,我们还需要将他进行保存起来,这个就需要定义ConcurrentHashMap<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<>();存储beanDefinition。key是component的值,如果component没有传入beanName的值,那就使用spring的命名规则,采用类名首字母小写。

// 1.7 在通过这个clazz(类)来判断是否有component注解,有则是bean if (clazz.isAnnotationPresent(Component.class)) { Component annotation = clazz.getAnnotation(Component.class); String beanName = annotation.value(); // * 默认生成bean,如果只使用Component注解,没有写上beanName的值,那么就需要自动生成 if (beanName.equals("")) { // 默认开头小字母 beanName = Introspector.decapitalize(clazz.getSimpleName()); } /** * 這就是一个bean了 * 然而在这里并不是直接就创建bean了,bean分为了单例bean和多例bean */ BeanDefinition beanDefinition = new BeanDefinition(); beanDefinition.setType(clazz); if (clazz.isAnnotationPresent(Scope.class)) { // 判断是单例还是多例 Scope scope = clazz.getAnnotation(Scope.class); beanDefinition.setScope(scope.value()); } else { beanDefinition.setScope("singleton"); } beanDefinitionMap.put(beanName, beanDefinition); }

1|5getBean底层

通过传来一个beanName,通过beanDefinitionMap中获取key为beanName的BeanDefinition对象,进行判空处理。这样我们可以通过这个BeanDefinition对象去获取作用域,判断是否为单例。

获取bean

在此,我们创建单例的时候,是需要将单例保存起来的,需要定义ConcurrentHashMap<String, Object> singletonObjects = new ConcurrentHashMap<>();单例池来保存单例bean。然后在getBean的时候,如果是单例bean,就可以先去单例池中寻找,如果没找到,再去创建对象。而多例模式就需要每次都去创建。

// 获取bean对象 public Object getBean(String beanName) { BeanDefinition beanDefinition = beanDefinitionMap.get(beanName); if (beanDefinition == null) { throw new NullPointerException("找不到bean名字为[" + beanName + "]的bean对象"); } else { // 找到就做相应的操作 String scope = beanDefinition.getScope(); if (scope.equals("singleton")) { // 通过单例池获取 Object bean = singletonObjects.get(beanName); if (bean == null) { // 单例池中如果没有bean,就需要去创建 bean = createBean(beanName, beanDefinition); singletonObjects.put(beanName, bean); } return bean; } else { // 多例的就不需要记录,每次都是通过创建 return createBean(beanName, beanDefinition); } } }

创建bean

利用反射机制,通过无参构造方法去获取实例,这里就是bean对象实例了。就可以直接返回。

// 创建bean private Object createBean(String beanName, BeanDefinition definition) { // 利用反射获取实例,采用无参构造方法 Class clazz = definition.getType(); // 通过无参构造方法获取实例 try { Object instance = clazz.getConstructor().newInstance(); // 到这里直接返回,bean的对象也就创建完成 return instance; } catch (InstantiationException e) { e.printStackTrace(); } return null; }

在构造方法扫描后要根据生成的beanDefinitionMap去创建单例bean对象。

// 2 创建单例bean对象 for (String beanName : beanDefinitionMap.keySet()) { BeanDefinition beanDefinition = beanDefinitionMap.get(beanName); if (beanDefinition.getScope().equals("singleton")) { // 那么,如何保证单例呢?就需要有个单例池,singletonObjects Object bean = createBean(beanName, beanDefinition); singletonObjects.put(beanName, bean); // 将单例bean存到单例池中 } }

运行

public class Test { public static void main(String[] args) { LydApplicationContext applicationContext = new LydApplicationContext(AppConfig.class); System.out.println(applicationContext.getBean("userService")); System.out.println(applicationContext.getBean("userService")); System.out.println(applicationContext.getBean("userService")); System.out.println(applicationContext.getBean("userService")); System.out.println(applicationContext.getBean("userService")); } }

我们可以先使用单例模式进行测试,我们不加scope注解,并且获取多个bean,可以看到得到的bean对象是同一个。


多例的时候在scope标上值,就可以看到每次获取的bean对象都是不一样的。

1|6Autowired自动依赖注入

当我们在UserService中使用RoleService,我们就需要通过Autowired注解进行依赖注入。就是需要在createBean方法中,在创建实例之后,获取类中的字段,进行依赖注入,要通过判断Autowried注解。通过字段的set方法,将bean对象注入,而这个对象如何获得呢?那就是用过getBean()方法。

// 3 依赖注入 for (Field field : clazz.getDeclaredFields()) { // 判断字段上是否存在Autowried注解 if (field.isAnnotationPresent(Autowired.class)) { /** * 值为 true 则指示反射的对象在使用时应该取消 Java 语言访问检查。 * 值为 false 则指示反射的对象应该实施 Java 语言访问检查; * 实际上setAccessible是启用和禁用访问安全检查的开关,并不是为true就能访问为false就不能访问 ; */ field.setAccessible(true); // 反射需要设置这个,不然无法赋值 // 用其属性名,这就意味着private RoleService roleService;roleService不能乱取 field.set(instance, getBean(field.getName())); } }

1|7Aware回调机制与初始化

Aware回调

那如果我们需要获取当前bean的名字呢?那就得通过Aware回调机制。我们需要创建一个BeanNameAware接口,里面提供一个setBeanName方法。

public interface BeanNameAware { public void setBeanName(String beanName); }

createBean方法中去编写回调机制,通过判断这个实例是否有BeanNameAware这个类,通过setName方法间接传递了beanName。

// 4 Aware回调机制 if (instance instanceof BeanNameAware) { ((BeanNameAware)instance).setBeanName(beanName); }

UserService方法中去实现这个BeanNameAware方法,这就能够在UserService里的beanName字段中得到这个bean对象的真实的beanName了。

@Component("userService") // 注入spring @Scope("property") public class UserService implements BeanNameAware, InitializingBean { @Autowired private RoleService roleService; // 依赖注入,加上@Autowired注解 private String beanName; @Override public void setBeanName(String beanName) { this.beanName = beanName; } public void test() { System.out.println("RoleService: " + roleService); } @Override public void afterPropertiesSet() { // ...... System.out.println("初始化"); } }

初始化

在spring容器中,不只是完成bean对象的创建,还需要能够对bean进行初始化。需要创建InitializingBean接口类。

public interface InitializingBean { public void afterPropertiesSet(); }

在需要进行初始化的bean对象去实现这个接口的方法,这里main可以进行一些操作。在createBean中,会根据判断是否有InitializingBean类,会在实例化之后调用这个方法进行初始化。

// 5 初始化 if (instance instanceof InitializingBean) { ((InitializingBean)instance).afterPropertiesSet(); }

结果

1|8BeanPostProcessor

BeanPostProcessor可以对spring中bean的创建去做一些操作。

BeanPostProcessor接口

在spring中定义一个BeanPostProcessor接口,里面会有初始化前后操作的方法,并且将beanNamebean对象带入进行自定义的操作。

public interface BeanPostProcessor { public Object postBeforeProcessor(String beanName, Object bean); // 初始化前 public Object postAfterProcessor(String beanName, Object bean); // 初始化后 }

自定义BeanPostProcessor

这里可以定义自己的类去实现spring中的BeanPostProcessor,对初始化进行一些相应操作。并且能够根据某个bean对象来做不同的操作。原理就是将MyBeanPostProcessor注入到容器中,在扫描的时候将这个对象保存起来,在创建bean的时候去遍历BeanPostProcessor集合,在去调用这个实例的方法。

@Component // 需要注入spring public class MyBeanPostProcessor implements BeanPostProcessor { @Override public Object postBeforeProcessor(String beanName, Object bean) { System.out.println("初始化前的bean:" + beanName + " -- " + bean); return bean; } @Override public Object postAfterProcessor(String beanName, Object bean) { System.out.println("初始化后的bean:" + beanName + " -- " + bean); return bean; } }

然而,在spring扫描的时候会进行操作,因为自己实现的BeanPostProcessor是通过Component注解注入spring容器的。因此可以通过判断有Component注解时候,进行判断是否含有BeanPostProcessor类,如果有生成BeanPostProcessor对象,并且将其实例添加到beanPostProcessorList容器中。在此就需要定义ArrayList<BeanPostProcessor> beanPostProcessorList = new ArrayList<>();来记录BeanPostProcessor。

// 6 判断是否是并加入beanPostProcessorList,这里不能使用instanceof if (BeanPostProcessor.class.isAssignableFrom(clazz)) { // 直接生成对象 BeanPostProcessor instance = (BeanPostProcessor) clazz.newInstance(); // 然后保存进去 beanPostProcessorList.add(instance); }

接着就可以在创建bean对象的时候,在初始化前后去遍历这个BeanPostProcessor链表,调用相应的方法,就能够调用自定义的MyBeanPostProcessor的方法。

// 6 BeanPostProcessor 初始化前 AOP 遍历beanPostProcessorList for (BeanPostProcessor beanPostProcessor : beanPostProcessorList) { instance = beanPostProcessor.postBeforeProcessor(beanName, instance); } // 5 初始化 if (instance instanceof InitializingBean) { ((InitializingBean)instance).afterPropertiesSet(); } // 6 BeanPostProcessor 初始化后 AOP for (BeanPostProcessor beanPostProcessor : beanPostProcessorList) { instance = beanPostProcessor.postAfterProcessor(beanName, instance); }

运行结果:.

1|9AOP机制

需要通过代理对象。这样如果不进行操作,返回的对象还是原来的,如果是通过操作了,那么返回的就是代理的对象。这里就简单的打印一句话。在扫描的时候,扫到userService这个bean的时候,返回的实例就是代理对象。

@Override public Object postAfterProcessor(String beanName, Object bean) { System.out.println("初始化后的bean:" + beanName + " -- " + bean); if (beanName.equals("userService")) { // 创建一个代理对象, 代理的是UserInterface这个 Object proxyInstance = Proxy.newProxyInstance(MyBeanPostProcessor.class.getClassLoader(), bean.getClass().getInterfaces(), new InvocationHandler() { @Override /** * proxy:代理对象 * method:代理对象当前正在执行的方法 */ public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { System.out.println("切面逻辑"); return method.invoke(bean, args); } }); return proxyInstance; } return bean; }

1|10源码备注

spring

LydApplicationContext

public class LydApplicationContext { private Class configClass; // 注入的配置类 private ConcurrentHashMap<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<>(); // key是component名字 private ConcurrentHashMap<String, Object> singletonObjects = new ConcurrentHashMap<>(); // 单例池 private ArrayList<BeanPostProcessor> beanPostProcessorList = new ArrayList<>(); // 记录BeanPostProcessor,在扫描的时候判断,使用 public LydApplicationContext(Class configClass) { // 构造方法 this.configClass = configClass; // spring容器创建之后 // 1 扫描 // 通过配置文件的注解获取扫描路径 if (configClass.isAnnotationPresent(ComponentScan.class)) { ComponentScan componentScanAnnotation = (ComponentScan) configClass.getAnnotation(ComponentScan.class); // 1.1 扫描路径:只是个包名,扫描的是java的class文件,而并非源文件,com.lyd.service String path = componentScanAnnotation.value(); // 1.2 将路径文件替换成/的形式 path = path.replace(".","/"); // 1.3 通过类加载器获取资源路径 ClassLoader classLoader = LydApplicationContext.class.getClassLoader(); URL resource = classLoader.getResource(path); // 1.4 转成文件形式,主要是为了获取他的地址 File file = new File(resource.getFile()); // System.out.println(file); if (file.isDirectory()) { // 如果是文件夹 File[] files = file.listFiles(); for (File f : files) { String absolutePath = f.getAbsolutePath(); // 获取路径 System.out.println("路径:" + absolutePath); // 1.5 对编译文件进行处理 if (absolutePath.endsWith(".class")) { // 判断是否为编译文件 /** * 需要拿到的是编译文件,通过类加载器去获取 * 需要将com\lyd\service\UserService转成com.lyd.service.UserService */ String className = absolutePath.substring(absolutePath.indexOf("com"), absolutePath.indexOf(".class")); className = className.replace("\\", "."); System.out.println("类名:" + className); try { // 1.6 通过全限定名使用类加载器获取类 (利用反射机制) Class<?> clazz = classLoader.loadClass(className); // 1.7 在通过这个clazz(类)来判断是否有component注解,有则是bean if (clazz.isAnnotationPresent(Component.class)) { // 6 判断是否是并加入beanPostProcessorList,这里不能使用instanceof if (BeanPostProcessor.class.isAssignableFrom(clazz)) { // 直接生成对象 BeanPostProcessor instance = (BeanPostProcessor) clazz.newInstance(); // 然后保存进去 beanPostProcessorList.add(instance); } Component annotation = clazz.getAnnotation(Component.class); String beanName = annotation.value(); // * 默认生成bean,如果只使用Component注解,没有写上beanName的值,那么就需要自动生成 if (beanName.equals("")) { // 默认开头小字母 beanName = Introspector.decapitalize(clazz.getSimpleName()); } /** * 這就是一个bean了 * 然而在这里并不是直接就创建bean了,bean分为了单例bean和多例bean */ BeanDefinition beanDefinition = new BeanDefinition(); beanDefinition.setType(clazz); if (clazz.isAnnotationPresent(Scope.class)) { // 判断是单例还是多例 Scope scope = clazz.getAnnotation(Scope.class); beanDefinition.setScope(scope.value()); } else { beanDefinition.setScope("singleton"); } beanDefinitionMap.put(beanName, beanDefinition); } } catch (Exception e) { e.printStackTrace(); } } } } } // 2 创建单例bean对象 for (String beanName : beanDefinitionMap.keySet()) { BeanDefinition beanDefinition = beanDefinitionMap.get(beanName); if (beanDefinition.getScope().equals("singleton")) { // 那么,如何保证单例呢?就需要有个单例池,singletonObjects Object bean = createBean(beanName, beanDefinition); singletonObjects.put(beanName, bean); // 将单例bean存到单例池中 } } } // 创建bean private Object createBean(String beanName, BeanDefinition definition) { // 利用反射获取实例,采用无参构造方法 Class clazz = definition.getType(); // 通过无参构造方法获取实例 try { Object instance = clazz.getConstructor().newInstance(); // 到这里直接返回,bean的对象也就创建完成 // 3 依赖注入 for (Field field : clazz.getDeclaredFields()) { // 判断字段上是否存在Autowried注解 if (field.isAnnotationPresent(Autowired.class)) { /** * 值为 true 则指示反射的对象在使用时应该取消 Java 语言访问检查。 * 值为 false 则指示反射的对象应该实施 Java 语言访问检查; * 实际上setAccessible是启用和禁用访问安全检查的开关,并不是为true就能访问为false就不能访问 ; */ field.setAccessible(true); // 反射需要设置这个,不然无法赋值 // 用其属性名,这就意味着private RoleService roleService;roleService不能乱取 field.set(instance, getBean(field.getName())); } } // * instanceof:是针对某个对象去判断是否实现某个类 // 4 Aware回调机制 if (instance instanceof BeanNameAware) { ((BeanNameAware)instance).setBeanName(beanName); } // 6 BeanPostProcessor 初始化前 AOP 遍历beanPostProcessorList for (BeanPostProcessor beanPostProcessor : beanPostProcessorList) { instance = beanPostProcessor.postBeforeProcessor(beanName, instance); } // 5 初始化 if (instance instanceof InitializingBean) { ((InitializingBean)instance).afterPropertiesSet(); } // 6 BeanPostProcessor 初始化后 AOP for (BeanPostProcessor beanPostProcessor : beanPostProcessorList) { instance = beanPostProcessor.postAfterProcessor(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; } // 获取bean对象 public Object getBean(String beanName) { BeanDefinition beanDefinition = beanDefinitionMap.get(beanName); if (beanDefinition == null) { throw new NullPointerException("找不到bean名字为[" + beanName + "]的bean对象"); } else { // 找到就做相应的操作 String scope = beanDefinition.getScope(); if (scope.equals("singleton")) { // 通过单例池获取 Object bean = singletonObjects.get(beanName); if (bean == null) { // 单例池中如果没有bean,就需要去创建 bean = createBean(beanName, beanDefinition); singletonObjects.put(beanName, bean); } return bean; } else { // 多例的就不需要记录,每次都是通过创建 return createBean(beanName, beanDefinition); } } } }

service

test

public class Test { public static void main(String[] args) { LydApplicationContext applicationContext = new LydApplicationContext(AppConfig.class); // UserService userService = (UserService) applicationContext.getBean("userService"); UserInterface userService = (UserInterface) applicationContext.getBean("userService"); // System.out.println(applicationContext.getBean("userService")); // System.out.println(applicationContext.getBean("roleService")); userService.test(); } }
分享好友

分享这个小栈给你的朋友们,一起进步吧。

Spring
创建时间:2021-08-11 15:53:20
Spring中国教育管理中心助力Spring认证学员发展
展开
订阅须知

• 所有用户可根据关注领域订阅专区或所有专区

• 付费订阅:虚拟交易,一经交易不退款;若特殊情况,可3日内客服咨询

• 专区发布评论属默认订阅所评论专区(除付费小栈外)

栈主、嘉宾

查看更多
  • Talent skills
    栈主

小栈成员

查看更多
  • 你见吾家
  • LCR_
戳我,来吐槽~