手写SpringBoot启动器主要步骤

这里写目录标题

• 背景
• 过程

• 2.1自启动实现原理
• 2.2手动实现SpringBoot自启动

• 2.2.1宏观
• 2.2.1微观

• 2.2.1.1三个服务之间调用
• 2.2.1.2自定义注解
• 2.2.1.1业务组装
• 2.2.1.3启动类

• 升华

• 自定义注解：
• 手动装配组件：
• 简化启动过程：
• 自动化注入依赖：
• 简化启动类：

背景

更好的理解框架：通过手写Spring Boot启动类，你将深入了解框架的内部机制和工作原理。你可以手动配置各种组件、定义Bean以及设置各种属性，从而更好地理解框架的运行方式。

过程

2.1自启动实现原理

1、Spring Boot是一个用于构建Java应用程序的开源框架，它简化了Spring应用程序的配置和部署。以下是一个模拟的Spring Boot启动过程的简要描述：

2、加载配置：当应用程序启动时，Spring Boot首先会加载应用程序的配置。这些配置可以包括应用程序的属性、数据库配置、日志配置等。

3、创建应用程序上下文：Spring Boot会创建一个应用程序上下文，该上下文包含了所有被管理的Bean以及它们之间的依赖关系。这个上下文可以让您访问和管理应用程序中的各个组件。

4、扫描和注册Bean：Spring Boot会扫描应用程序中的所有类，查找带有注解的Bean，并将它们注册到应用程序上下文中。常见的注解包括@Component、@Service、@Controller等。

6、自动配置：Spring Boot具有自动配置的特性，它根据应用程序的依赖和配置自动配置各种功能。例如，如果应用程序依赖于数据库，Spring Boot可以自动配置数据源和持久化框架。

7、启动应用程序：一旦所有的Bean都注册到应用程序上下文中，Spring Boot会启动应用程序，开始监听HTTP请求或其他入口点。

8、运行应用程序：应用程序开始运行，处理来自客户端的请求。根据应用程序的配置，Spring Boot可以处理路由、控制器、服务等，以满足客户端的需求。

2.2手动实现SpringBoot自启动

2.2.1宏观

2.2.1微观

2.2.1.1三个服务之间调用

@MyComponent("classService")
public class ClassService {
    @MyAutowired
    private TestService testService;

    public void test(){
        this.testService.test();
    }
}

@MyComponent("testService")
public class TestService {
    @MyAutowired
    private UserService userService;


    private String name;

    public void test(){
        userService.test();
    }
}

@MyComponent("userService")
public class UserService {


//    @MyAutowired
//    ClassService classService;
    public void test(){
//        classService.test();
        System.out.println("你好");
    }
}

2.2.1.2自定义注解

MyComponent ：装配注解

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

MyAutowired ：属性注入的注解

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
public @interface MyAutowired {
}

MyComponentScan ：扫包的注解

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

2.2.1.1业务组装

BeanDefinition：对对象的信息进行包装

public class BeanDefinition {
    private Class beanClass;

    public Class getBeanClass() {
        return beanClass;
    }

    public void setBeanClass(Class beanClass) {
        this.beanClass = beanClass;
    }
}

上下文类：

public class MyApplicationContext {
    private Map<String,BeanDefinition> beanDefinitionMap = new HashMap<>();

    private Map<String,Object> singletonObjects =new HashMap<>();

    //1、获取自动配置类相关信息
    public void run(Class configClass) throws ClassNotFoundException, InstantiationException, IllegalAccessException {
        //2、扫包
        this.scanPackage(configClass);

        //4、属性注入
        initAutowired();

    }
    private void scanPackage(Class configClass) throws ClassNotFoundException {
        MyComponentScan myComponentScan = (MyComponentScan) configClass.getAnnotation(MyComponentScan.class);
        String packagePath =  myComponentScan.value();
        packagePath = packagePath.replace(".","/");
        //拿到service包中所有的类的class对象
        List<Class> beanClass = getBeanClass(packagePath, configClass);

        for (Class aClass : beanClass) {
            //3、创建bean对象
            if (aClass.isAnnotationPresent(MyComponent.class)){
                BeanDefinition beanDefinition = new BeanDefinition();
                beanDefinition.setBeanClass(aClass);
                MyComponent myComponent = (MyComponent) aClass.getAnnotation(MyComponent.class);
                String beanName = myComponent.value();
                //将创建的bean对象放到map中
                beanDefinitionMap.put(beanName,beanDefinition);
            }

        }
    }

    private List<Class> getBeanClass(String packagePath,Class configClass) throws ClassNotFoundException {
        List<Class> beanClassList = new ArrayList<>();
        URL resource = configClass.getClassLoader().getResource(packagePath);
        File file = new File(resource.getFile());
        File[] files = file.listFiles();
        for (File f : files) {
            String fileName = f.getAbsolutePath();
            System.out.println(fileName);
            fileName = fileName.substring(fileName.indexOf("com"),fileName.indexOf(".class"));
            fileName = fileName.replace("\\",".");
            Class clazz = Class.forName(fileName);
            beanClassList.add(clazz);
        }
        return beanClassList;
    }


//将注入的属性进行初始化
    private void initAutowired() throws InstantiationException, IllegalAccessException {
        for (String beanName : beanDefinitionMap.keySet()) {
            BeanDefinition beanDefinition = beanDefinitionMap.get(beanName);
            Class beanClass = beanDefinition.getBeanClass();
            Object instance = beanClass.newInstance();
            //TestService
			//读取每个类中的属性
            Field[] declaredFields = beanClass.getDeclaredFields();
            for (Field field : declaredFields) {
                if (field.isAnnotationPresent(MyAutowired.class)){
                    field.setAccessible(true);
                    String fieldName = field.getName();
                    BeanDefinition definition = beanDefinitionMap.get(fieldName);
                    Object newInstance = definition.getBeanClass().newInstance();
                    field.set(instance,newInstance);
                }
            }
            //属性注入的对象放到另外一个容器里边
            singletonObjects.put(beanName,instance);
        }
    }

    public Object getBean(String beanName){
        return singletonObjects.get(beanName);
    }
}

2.2.1.3启动类

@MyComponentScan("com.example.demo.service")
public class DemoApplication {
    public static void main(String[] args) throws Exception {
        MyApplicationContext myApplicationContext = new MyApplicationContext();
        myApplicationContext.run(DemoApplication.class);

        Object testService = myApplicationContext.getBean("classService");
        Method method = testService.getClass().getMethod("test");
        method.invoke(testService);
    }
}

升华

自定义注解：

通过自定义注解（@MyComponent和@MyAutowired），你可以标识需要被Spring容器管理的组件，以及需要进行属性注入的依赖关系。这样可以实现基于注解的组件装配和依赖注入，简化了配置和编码工作。

手动装配组件：

在MyApplicationContext类中，你手动进行了组件的扫描、创建和属性注入过程。这样可以实现自定义的组件装配逻辑，灵活控制组件的创建和初始化过程。

简化启动过程：

通过MyApplicationContext类的run()方法，你可以一次性完成组件的扫描、创建和属性注入等启动过程。这样可以简化启动代码，减少了手动配置的工作量。

自动化注入依赖：

在MyApplicationContext类的initAutowired()方法中，你实现了自动注入属性依赖的逻辑。当一个组件需要依赖其他组件时，通过@MyAutowired注解，你可以自动将依赖的实例注入到目标组件中。这样可以减少手动编写属性注入的代码，提高开发效率。

简化启动类：

在启动类DemoApplication中，你只需实例化MyApplicationContext并调用run()方法即可完成启动过程。这样可以将启动类的逻辑简化为几行代码，提高了可读性和维护性。

这个示例是一个简化版的Spring Boot启动器，并没有涵盖完整的Spring Boot功能和特性。实际的Spring Boot启动器通常会涉及更复杂的配置和功能，例如自动配置、条件化装配等。手写Spring Boot启动器可以让你更深入地理解Spring Boot的原理和机制，并根据实际需求进行定制和扩展。

如果要解决各个Service之间互相依赖的问题又该如何进行解决呢，是不是就要引入三级缓存呢？请大家思考。