前言

本文主要基于spring的注解的方式完成spring总体流程

1、配置文件配合容器实现
2、通过注解扫描所有的bean定义信息
3、完成CreatBean方法
4、实现getBean方法
5、实现postProcessor完成AOP（使用JDK动态代理）
6、实现aware回调

总体来说：
spring 模拟依赖
project 模拟我们的项目
在这里插入图片描述

一、总体步骤如下

总的来说
1、使用了spring文件夹模拟了我们平常的依赖。
2、project文件夹模拟我们平常的项目。

1、spring 文件夹

简介=》用于模拟我们导的spring依赖

1、编写一个容器
2、简单的完成一个构造方法，支持传入配置文件，通过注解方式进行下面的操作
——以上第一步完成存取——
3、定义一个@ComponentScan注解，目的是为了扫描
4、在context容器构造器中，扫描配置文件的注解，得到其中的路径值
5、扫描对应路径下的所有的类（我们扫描的是.class文件，而不是.java）；所以我们要拿到的是应用类加载器，然后获取对应的路径下的文件

——以上是类扫描——

6、获取所有文件的绝对路径，然后截取成可以读取到对应类的值
7、读取对应的类上的注解（如@Component，@Service…）判断是不是一个bean

——以上是判断是不是一个bean的逻辑——

8、定义@Scope注解（定义这是一个单例还是一个原型）
9、判断是不是有@Scope注解，取到其中的值
10、将类信息，单例or原型等信息封装成一个bean的定义信息，放到map中

——以上扫描包结束，封装bean定义信息放map中——

11、根据bean定义信息，创建bean，然后放到singletonObjects中

——以上创建bean到单例池中——

12、定义@Autowired依赖注入注解
13、判断bean类中是不是有对应的属性值有依赖注入注解
14、有点话就先getBean去单例缓存池中拿，拿不到就CreatBean（判断单例和原型）
——以上是依赖注入的过程——
15、定义后置处理器接口：里面主要分为前置和后置处理postProcessBeforeInitialization、postProcessAfterInitialization
16、在扫描的时候，就把所有的后置处理器干到缓存池中
17、判断这个bean是不是PostProcess（instanceof 父类就行）
18、在创建bean的时候我们要取出所有缓存中的处理器，然后看看他们要干嘛（循环每一个后置处理器）
——以上定义后置处理器接口——
19、定义@XXAware回调接口
20、和后置处理器差不多，我们也才creatBean判断bean是不是Aware
21、有的话就让spring回调干点事情

2、myProject 文件夹

简介=》用于我们项目中利用spring

1、编写配置文件
2、编写启动类
- 2.1 获取一个容器，然后在容器中getBean

——以上第一步完成存取——

3、和spring配置一样，我们要在配置文件中配置@ComponentScan注解

——以上是类扫描——

4、在对应的类中添加@Scope注解

——以上扫描包结束，封装bean定义信息放map中（区分原型还是单例）——

5、在对应类中添加@Autowired注解即可，其他交给容器去整
——以上是依赖注入的过程——
6、自定义一个BeanPostProcess,我们的Aop其实就是这里搞起来的，读取aop的注解缓存池，然后一通前置通知get
——以上定义后置处理器接口——

二、主要coding

1、配置文件

package com.xusj.myProject.config;import spring.annotation.ComponentScan;/*** @author xusj* 
CreateDate 2022/11/29 0:30*/
@ComponentScan("com.xusj.myProject")
public class AppConfig {}

2、容器

package spring.context;import spring.annotation.Autowired;
import spring.annotation.Component;
import spring.annotation.ComponentScan;
import spring.annotation.Scope;import java.beans.Introspector;
import java.io.File;
import java.lang.reflect.Field;
import java.net.URL;
import java.util.HashMap;
import java.util.Map;
import java.util.Objects;/*** @author xusj* 
CreateDate 2022/11/29 0:29*/
public class MyApplicationContext {private Class configClass;/*** bean定义信息的缓存池* k*/private final Map beanDefinitionMap = new HashMap<>();private final Map singletonObjects = new HashMap<>();/*** 构造方法，通过配置类完成** @param clazz*/public MyApplicationContext(Class clazz) {this.configClass = clazz;// 扫描对应下的所有子包// 1、判断有没有注解if (clazz.isAnnotationPresent(ComponentScan.class)) {// 2、先拿到注解和对应的值（路径）ComponentScan componentScanAnnotation = clazz.getAnnotation(ComponentScan.class);String path = componentScanAnnotation.value();// 转化成我们需要的pathpath = path.replace(".", "/");// 3、获取对应的类加载器，我们需要读取的应用类加载器中的文件而不是我们写的.java文件[返回类的类装载器。]ClassLoader classLoader = MyApplicationContext.class.getClassLoader();// 4、获取对应路径的资源URL resource = classLoader.getResource(path);// 5、获取对应位置的文件File file = new File(resource.getFile());// 判断文件if (file.isDirectory()) {getFile(file);}}}/**** 获取所有的文件** @param file 文件* @author xusj* 
CreateDate 2022/11/29 1:05*/private void getFile(File file) {// 遍历文件(一直遍历到最后)for (File f : Objects.requireNonNull(file.listFiles())) {if (f.isDirectory()) {// 递归getFile(f);} else {// 扫描所有类判断是不是个bean，是的话就创建一个bean定义信息，然后放到map中scanComponent(f);}}// 扫描bean定义信息map缓存，创建beanfor (Map.Entry entry : beanDefinitionMap.entrySet()) {String beanName = entry.getKey();BeanDefinition beanDefinition = entry.getValue();// 判断是单例还是原型if ("singleton".equals(beanDefinition.getScope())) {// 创建beanObject bean = createBean(beanName, beanDefinition);// TODO XUSJ 放到单例池中singletonObjects.put(beanName, bean);}}}/*** 创建bean** @param beanName* @param beanDefinition*/public Object createBean(String beanName, BeanDefinition beanDefinition) {// 获取类信息Class clazz = beanDefinition.getType();// 通过构造方法创建beanObject instance = null;try {instance = clazz.getConstructor().newInstance();// 判断依赖注入的问题for (Field field : clazz.getDeclaredFields()) {// 判断该类中有没有@Autowiredif (field.isAnnotationPresent(Autowired.class)) {field.setAccessible(true);field.set(instance, getBean(field.getName()));}}} catch (Exception e) {e.printStackTrace();}return instance;}private void scanComponent(File f) {// 1 获取所有的文件// 获取文件的绝对路径String absolutePath = f.getAbsolutePath();// 更换成可应用类加载器可以处理的结果absolutePath = absolutePath.substring(absolutePath.indexOf("com"), absolutePath.indexOf(".class"));absolutePath = absolutePath.replace("\\", ".");// 2 通过应用类加载器获取绝对路径中的类System.out.println("对应文件的绝对路径=》" + f.getName() + ":" + absolutePath);ClassLoader classLoader = MyApplicationContext.class.getClassLoader();try {Class clazz = classLoader.loadClass(absolutePath);// 3 判断这个类上面是不是有对应的bean相关的注解if (clazz.isAnnotationPresent(Component.class)) {// 4 获取我们定义的beanNameComponent componentScanAnnotation = clazz.getAnnotation(Component.class);String beanName = componentScanAnnotation.value();// 如果没有定义的话，直接就使用类目作为beanNameif (beanName.isEmpty()) {// 获取简单类目beanName = Introspector.decapitalize(clazz.getSimpleName());}// 5 构建bean的定义信息BeanDefinition beanDefinition = new BeanDefinition();beanDefinition.setType(clazz);beanDefinition.setBeanName(beanName);// 6、通过注解判断是单例还是原型if (clazz.isAnnotationPresent(Scope.class)) {Scope scopeAnnotation = clazz.getAnnotation(Scope.class);String value = scopeAnnotation.value();// 放到bean的定义信息中beanDefinition.setScope(value);} else {// 默认为singletonbeanDefinition.setBeanName("singleton");}// 将bean定义信息，放到beanDefinitionMap中beanDefinitionMap.put(beanName, beanDefinition);}} catch (ClassNotFoundException e) {e.printStackTrace();}}/**** 通过beanName去获取bean** @param name beanName* @return {@link Object}* @author xusj* 
CreateDate 2022/11/29 0:34*/public Object getBean(String name) {// 先判断bean定义信息是不是有值if (!beanDefinitionMap.containsKey(name)) {throw new RuntimeException();}// 获取bean定义信息BeanDefinition beanDefinition = beanDefinitionMap.get(name);// 判断是不是单例if ("singleton".equals(beanDefinition.getScope())) {// 先去单例池中去拿Object singletonObj = singletonObjects.get(name);if (singletonObj == null) {// 没有说明还没创建，那我就创建一个singletonObj = createBean(name, beanDefinition);// 放到单例池中singletonObjects.put(name, singletonObj);}return singletonObj;} else {// 原型模式[就是直接搞一个新的出来]Object prototypeBean = createBean(name, beanDefinition);return prototypeBean;}}
}

3、一些spring中的重要的注解

在这里插入图片描述

4、项目中的使用

package com.xusj.myProject.service;import spring.annotation.Autowired;
import spring.annotation.Component;
import spring.annotation.Scope;
import spring.aware.MyBeanAware;/*** @author xusj* 
CreateDate 2022/11/29 0:35*/
@Component(value = "oneService")
@Scope(value = "singleton")
public class OneService implements MyBeanAware {@Autowiredprivate TwoService twoService;public void test() {System.out.println("twoService" + "+++" + twoService);}@Overridepublic void setSth() {}
}

5.重要的bean定义信息

package spring.context;/*** @author xusj* 
CreateDate 2022/11/29 10:02*/
public class BeanDefinition {/*** beanName*/private String beanName;/*** 类信息*/private Class type;/*** bean类型*/private String scope;public BeanDefinition() {}@Overridepublic String toString() {return "BeanDefinition{" +"beanName='" + beanName + '\'' +", type=" + type +", scope='" + scope + '\'' +'}';}public String getScope() {return scope;}public void setScope(String scope) {this.scope = scope;}public String getBeanName() {return beanName;}public void setBeanName(String beanName) {this.beanName = beanName;}public Class getType() {return type;}public void setType(Class type) {this.type = type;}}

6、postProcessor重要，前置通知和后置

依赖倒置原则，先定义接口

package com.xusj.myProject.postProcessor;import spring.annotation.Component;
import spring.processor.BeanPostProcessor;import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;/*** 我的后置处理器** @author xusj* 
CreateDate 2022/11/29 16:31*/
@Component
public class MyBeanPostProcessor implements BeanPostProcessor {// 前置搞点事情（Aop，这里用的是JDK的动态代理，spring使用的CGLIB）@Overridepublic Object postProcessBeforeInitialization(Object bean, String beanName) {// 其实AOP也是在这里整的，就是读一些注解然后整if ("userService".equals(beanName)) {return Proxy.newProxyInstance(MyBeanPostProcessor.class.getClassLoader(), bean.getClass().getInterfaces(), new InvocationHandler() {@Overridepublic Object invoke(Object proxy, Method method, Object[] args) throws Throwable {// 切面System.out.println("切面逻辑");// 原来的对象去执行方法return method.invoke(bean, args);}});}// beanreturn bean;}// 后置搞点事情@Overridepublic Object postProcessAfterInitialization(Object bean, String beanName) {return BeanPostProcessor.super.postProcessAfterInitialization(bean, beanName);}
}

7、aware回调接口
总的来说和postProecssor一样，也是依赖倒置原则