手写Spring底层机制

手写Spring底层机制

IOC容器

1.     //定义 BeanDefinitionMap 存放 beanDefinition
2.     private ConcurrentHashMap<String,BeanDefinition> beanDefinitionMap =
3.             new ConcurrentHashMap<>();
5.     //定义 singletonObjects 存放 单例
6.     private ConcurrentHashMap<String,Object> singletonObjects =
7.             new ConcurrentHashMap<>();
10.     //定义beanPostProcessorList 存放 BeanPostProcessor
11.     private ArrayList<BeanPostProcessor> beanPostProcessorList=
12.             new ArrayList<>();

复制代码

构造器

1. //构造器
2. public ZyApplicationContext(Class configClass) {
3.     this.configClass = configClass;
5.     beanDefinitionsByScan();
7.     //初始化单例池
8.     initSingletonObjects();
9. }

复制代码

扫描包

1. private void beanDefinitionsByScan() {
2.         //获得扫描的包
3.         ComponentScan componentScan =
4.                 (ComponentScan)this.configClass.getDeclaredAnnotation(ComponentScan.class);
6.         //获取路径
7.         String path = componentScan.value();
9.         path = path.replace(".","/");
10.         //获取工作路径
11.         ClassLoader classLoader = ZyApplicationContext.class.getClassLoader();
13.         URL resource = classLoader.getResource(path);
15.         File file = new File(resource.getFile());
16.         if (file.isDirectory()){
17.             File[] files = file.listFiles();
18.             for (File f : files) {
19.                 //获取绝对路径
20.                 String fileAbsolutePath = f.getAbsolutePath();
21.                 if (fileAbsolutePath.endsWith(".class")) {
22.                     //获取className
23.                     String className = fileAbsolutePath.substring(fileAbsolutePath.lastIndexOf("\") + 1, fileAbsolutePath.indexOf(".class"));
25.                     String fullPath = path.replace("/", ".") + "." + className;
27.                     try {
28.                         Class<?> clazz = classLoader.loadClass(fullPath);
29.                         if (clazz.isAnnotationPresent(Component.class)) {
31.                             //初始化beanPostProcessorList
32.                             if (BeanPostProcessor.class.isAssignableFrom(clazz)){
33.                               BeanPostProcessor beanPostProcessor =
34.                                       (BeanPostProcessor)clazz.newInstance();
35.                                 beanPostProcessorList.add(beanPostProcessor);
36.                                 continue;
37.                             }
40.                             //处理className
41.                             String value = clazz.getDeclaredAnnotation(Component.class).value();
42.                             if ("".equals(value)){
43.                                 className = StringUtils.uncapitalize(className);
44.                             }else {
45.                                 className = value;
46.                             }
47.                             System.out.println("是一个bean 类名= " + className);
48.                             //设置 beanDefinition
49.                             BeanDefinition beanDefinition = new BeanDefinition();
50.                             //设置scope
51.                             if (clazz.isAnnotationPresent(Scope.class)){
52.                                 beanDefinition.setScope(clazz.getDeclaredAnnotation(Scope.class).value());
53.                             }else{
54.                                 beanDefinition.setScope("singleton");
55.                             }
56.                             beanDefinition.setClazz(clazz);
58.                             //放入 beanDefinitionMap
59.                             beanDefinitionMap.put(className,beanDefinition);
64.                         } else {
65.                             System.out.println("不是一个bean 类名= " + className);
66.                         }
67.                     } catch (Exception e) {
68.                         throw new RuntimeException(e);
69.                     }
70.                 }
71.             }
72.         }
73.     }

复制代码

初始化单例池

1. private void initSingletonObjects() {
2.         Enumeration<String> keys = beanDefinitionMap.keys();
3.         while (keys.hasMoreElements()){
4.             String beanName = keys.nextElement();
5.             BeanDefinition beanDefinition = beanDefinitionMap.get(beanName);
6.             String scope = beanDefinition.getScope();
7.             if ("singleton".equals(scope)){
8.                 Object bean = createBean(beanDefinition,beanName);
9.                 singletonObjects.put(beanName,bean);
10.             }
12.         }
13.     }

复制代码

getBean（）

1. public Object getBean(String name){
2.         if (beanDefinitionMap.containsKey(name)){
3.             BeanDefinition beanDefinition = beanDefinitionMap.get(name);
4.             String scope = beanDefinition.getScope();
5.             if ("singleton".equals(scope)){
6.                 return singletonObjects.get(name);
7.             }else{
8.                 return createBean(beanDefinition,name);
9.             }
10.         }
11.         return null;
12.     }

复制代码

createBean()

1. private Object createBean(BeanDefinition beanDefinition,String beanName){
2.         try {
3.             Class clazz = beanDefinition.getClazz();
4.             Object instance = clazz.getDeclaredConstructor().newInstance()；
5.             
6.             return instance;
7.         } catch (InstantiationException e) {
8.             throw new RuntimeException(e);
9.         } catch (IllegalAccessException e) {
10.             throw new RuntimeException(e);
11.         } catch (InvocationTargetException e) {
12.             throw new RuntimeException(e);
13.         } catch (NoSuchMethodException e) {
14.             throw new RuntimeException(e);
15.         }
16.     }

复制代码

依赖注入

• 加入到createBean()中
  

1.   private Object createBean(BeanDefinition beanDefinition,String beanName){
2.         try {
3.             Class clazz = beanDefinition.getClazz();
4.             Object instance = clazz.getDeclaredConstructor().newInstance();
6.             //依赖注入
7.             Field[] declaredFields = clazz.getDeclaredFields();
8.             for (Field declaredField : declaredFields) {
9.                 if (declaredField.isAnnotationPresent(Autowired.class)){
10.                     if (declaredField.getDeclaredAnnotation(Autowired.class).required()){
11.                         //获的字段名
12.                         String fieldName = declaredField.getName();
13.                         //获取实例
14.                         Object bean = getBean(fieldName);
15.                         declaredField.setAccessible(true);
16.                         declaredField.set(instance,bean);
17.                     }
18.                 }
19.             }
21.          
22.             return instance;
23.         } catch (InstantiationException e) {
24.             throw new RuntimeException(e);
25.         } catch (IllegalAccessException e) {
26.             throw new RuntimeException(e);
27.         } catch (InvocationTargetException e) {
28.             throw new RuntimeException(e);
29.         } catch (NoSuchMethodException e) {
30.             throw new RuntimeException(e);
31.         }
32.     }

复制代码

后置处理器

• 加入到createBean()中
  

1.   private Object createBean(BeanDefinition beanDefinition,String beanName){
2.         try {
3.             Class clazz = beanDefinition.getClazz();
4.             Object instance = clazz.getDeclaredConstructor().newInstance();
6.             //依赖注入
7.             Field[] declaredFields = clazz.getDeclaredFields();
8.             for (Field declaredField : declaredFields) {
9.                 if (declaredField.isAnnotationPresent(Autowired.class)){
10.                     if (declaredField.getDeclaredAnnotation(Autowired.class).required()){
11.                         //获的字段名
12.                         String fieldName = declaredField.getName();
13.                         //获取实例
14.                         Object bean = getBean(fieldName);
15.                         declaredField.setAccessible(true);
16.                         declaredField.set(instance,bean);
17.                     }
18.                 }
19.             }
21.             //后置处理器 before()
22.             //遍历 beanPostProcessorList
23.             for (BeanPostProcessor beanPostProcessor : beanPostProcessorList) {
24.                 Object current = beanPostProcessor.
25.                         postProcessBeforeInitialization(instance, beanName);
26.                 if (current!=null){
27.                     instance = current;
28.                 }
30.             }
33.             //初始化bean
34.             if (instance instanceof InitializingBean){
35.                 try {
36.                     ((InitializingBean)instance).afterPropertiesSet();
37.                 } catch (Exception e) {
38.                     throw new RuntimeException(e);
39.                 }
40.             }
44.             //后置处理器 after()
45.             //遍历 beanPostProcessorList
46.             for (BeanPostProcessor beanPostProcessor : beanPostProcessorList) {
47.                 Object current = beanPostProcessor.
48.                         postProcessAfterInitialization(instance, beanName);
49.                 if (current!=null){
50.                     instance = current;
51.                 }
53.             }
56.             System.out.println("");
57.             System.out.println("-------------------------------------");
58.             System.out.println("");
59.             return instance;
60.         } catch (InstantiationException e) {
61.             throw new RuntimeException(e);
62.         } catch (IllegalAccessException e) {
63.             throw new RuntimeException(e);
64.         } catch (InvocationTargetException e) {
65.             throw new RuntimeException(e);
66.         } catch (NoSuchMethodException e) {
67.             throw new RuntimeException(e);
68.         }
69.     }

复制代码

AOP

• AOP需要在后置处理器的before方法中实现
  

1. @Override
2.     public Object postProcessAfterInitialization(Object bean, String beanName) {
3.         System.out.println("ZyBeanPostProcessor后置处理器-After-beanName= "+beanName);
6.         //aop实现
8.         if("smartDog".equals(beanName)) {
9.             Object proxyInstance = Proxy.newProxyInstance(ZyBeanPostProcessor.class.getClassLoader(), bean.getClass().getInterfaces(), new InvocationHandler() {
12.                 @Override
13.                 public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
14.                     Object result = null;
16.                     if ("getSum".equals(method.getName())) {
17.                         SmartAnimalAspect.showBeginLog();
18.                         result = method.invoke(bean, args);
19.                         SmartAnimalAspect.showBeginLog();
20.                     }else {
21.                         result = method.invoke(bean, args);//执行目标方法
22.                     }
24.                     return result;
25.                 }
26.             });
27.             return proxyInstance;
28.         }
30.         return bean;
31.     }

复制代码

几个Spring的题目

1.单例/多例怎么实现的？@scope为什么可以实现？
回答：@scope 的value属性可以设置为singleton /prototype
通过getBean（）方法 如果bean中的属性scope为singleton 就从单例池直接拿，如果是prototype 就调用createBean（）创建一个实例
2.怎样实现依赖注入？@Autowired Spring容器怎样实现依赖注入？
回答： 遍历clazz的所有属性 通过@Autowired注解 如果有 先获取字段名 再通过getBean（）获取对应的bean 末了用filed.set()方法将实例的该属性设置为 获取到的bean 实现依赖注入
3.后置处理器 为什么在创建bean 时 调用bean 的 init方法初始化前/后 调用？

1. //后置处理器 before()
2.             //遍历 beanPostProcessorList
3.             for (BeanPostProcessor beanPostProcessor : beanPostProcessorList) {
4.                 Object current = beanPostProcessor.
5.                         postProcessBeforeInitialization(instance, beanName);
6.                 if (current!=null){
7.                     instance = current;
8.                 }
10.             }
13.             //初始化bean
14.             if (instance instanceof InitializingBean){
15.                 try {
16.                     ((InitializingBean)instance).afterPropertiesSet();
17.                 } catch (Exception e) {
18.                     throw new RuntimeException(e);
19.                 }
20.             }
24.             //后置处理器 after()
25.             //遍历 beanPostProcessorList
26.             for (BeanPostProcessor beanPostProcessor : beanPostProcessorList) {
27.                 Object current = beanPostProcessor.
28.                         postProcessAfterInitialization(instance, beanName);
29.                 if (current!=null){
30.                     instance = current;
31.                 }
33.             }

复制代码

4.后置处理器和AOP有什么关系，Spring Aop怎样实现?？
回答：aop的实现实在后置处理器的before中实现的，底层利用动态代理

1. //aop实现
3.         if("smartDog".equals(beanName)) {
4.             Object proxyInstance = Proxy.newProxyInstance(ZyBeanPostProcessor.class.getClassLoader(), bean.getClass().getInterfaces(), new InvocationHandler() {
7.                 @Override
8.                 public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
9.                     Object result = null;
11.                     if ("getSum".equals(method.getName())) {
12.                         SmartAnimalAspect.showBeginLog();
13.                         result = method.invoke(bean, args);
14.                         SmartAnimalAspect.showBeginLog();
15.                     }else {
16.                         result = method.invoke(bean, args);//执行目标方法
17.                     }
19.                     return result;
20.                 }
21.             });
22.             return proxyInstance;
23.         }
25.         return bean;

复制代码

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。