手写SpringBoot核心功能流程

        本文通过手写模拟实现一个简易版的Spring Boot 程序，让大家能以非常简单的方式知道Spring Boot大概的工作流程。

工程依赖

创建maven工程，并创建两个module

springboot模块：手写模拟springboot框架的源码实现

test模块：业务系统，用来写业务代码来测试我们所模拟出来的SpringBoot

springboot模块依赖：SpringBoot基于的Spring，依赖Spring同上也支持Spring MVC，所以也要依赖Spring MVC，包括Tomcat等，在SpringBoot模块中要添加以下依赖：

<dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.3.18</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-web</artifactId>
            <version>5.3.18</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>5.3.18</version>
        </dependency>

        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <version>4.0.1</version>
        </dependency>

        <dependency>
            <groupId>org.apache.tomcat.embed</groupId>
            <artifactId>tomcat-embed-core</artifactId>
            <version>9.0.60</version>
        </dependency>
    </dependencies>

test模块依赖：依赖springboot模块依赖即可：

<dependencies>
        <dependency>
            <groupId>org.example</groupId>
            <artifactId>springboot</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>
    </dependencies>

然后再test模块中创建相关的controller和service测试类：

/**
 * @author liupeng
 * @version 1.0
 * @description: TODO
 * @date 2024/5/7 17:05
 */
@RestController
public class TestController {
    @Autowired
    private TestService testService;

    @GetMapping("/test")
    public String test(@RequestParam("name") String name){
        return testService.sayHello(name);
    }
}

/**
 * @author liupeng
 * @version 1.0
 * @description: TODO
 * @date 2024/5/7 17:06
 */
@Component
public class TestService {

    public String sayHello(String name) {
        return "Hello " + name + "!";
    }
}

创建核心注解和核心执行类

在springboot中，最重要的是一个注解和一个启动类上的：

SpringApplication：该类有个run方法，主启动main中进行调用

@SpringBootApplication：该注解是添加在主启动类上的

因此我们可以在springboot模块中模拟实现以上核心注解和核心类。

@LPSpringBootApplication 注解：

/**
 * @author liupeng
 * @version 1.0
 * @description: TODO
 * @date 2024/5/7 17:10
 */
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Configuration
@ComponentScan
public @interface LPSpringBootApplication {
}

启动类：

/**
 * @author liupeng
 * @version 1.0
 * @description: TODO
 * @date 2024/5/7 17:11
 */
public class LPSpringApplication {
    public static void run(Class clazz) {

    }

   
}

然后在test模块中LPApplication类的进行使用

/**
 * @author liupeng
 * @version 1.0
 * @description: TODO
 * @date 2024/5/7 17:12
 */
@LPSpringBootApplication
public class LPApplication {
    public static void main(String[] args) {
        LPSpringApplication.run(LPApplication.class);
    }
}

填充完善run方法

        首先，我们希望run方法执行完后，能在浏览器中访问到UserController，那么run方法
中需要启动Tomcat，通过Tomcat接收到http请求。
        在SpringMVC中有一个Servlet非常核心，那就是DispatcherServlet，这个DispatcherServlet需要绑定一个Spring容器，因为DispatcherServlet接收到请求后，就会从所绑定的Spring容器中找到所匹配的Controller，并执行所匹配的方法。
因此，在run方法中，我们需要实现如下步骤：
        创建Spring容器
        创建Tomcat对象
        生成DispatcherServlet对象，并且创建出来的Spring容器进行绑定
        将DispatcherServlet添加到Tomcat中
        启动Tomcat

创建Spring容器

/**
 * @author liupeng
 * @version 1.0
 * @description: TODO
 * @date 2024/5/7 17:11
 */
public class LPSpringApplication {
    public static void run(Class clazz) {
        System.out.println("Hello World!");
        AnnotationConfigWebApplicationContext webApplicationContext = new AnnotationConfigWebApplicationContext();
        webApplicationContext.register(clazz);
        webApplicationContext.refresh();


    }

        我们创建AnnotationConfigWebApplicationContext 容器，并且将run方法传入的Class作为容器的配置类，比如上面的LPApplication.Class传入到了run方法中，于是LPApplication就变成容器的配置类，由于LPApplication 类上添加了@LPSpringBootApplication注解，同时该注解中存在@ComponentScan注解，于是该配置类会去扫描LPApplication所在的包路径，从而会将TestController 和TestService 类进行扫描并添加在容器内部，并在容器内部存在了这两个bean对象。

 Tomcat启动

使用Embed-Tomcat，模拟真正的springboot使用的内嵌Tomcat

public static void startTomcat(WebApplicationContext applicationContext){

        Tomcat tomcat = new Tomcat();

        Server server = tomcat.getServer();
        Service service = server.findService("Tomcat");

        Connector connector = new Connector();
        connector.setPort(8080);

        Engine engine = new StandardEngine();
        engine.setDefaultHost("localhost");

        Host host = new StandardHost();
        host.setName("localhost");

        String contextPath = "";
        Context context = new StandardContext();
        context.setPath(contextPath);
        context.addLifecycleListener(new Tomcat.FixContextListener());

        host.addChild(context);
        engine.addChild(host);

        service.setContainer(engine);
        service.addConnector(connector);

        tomcat.addServlet(contextPath, "dispatcher", new DispatcherServlet(applicationContext));
        context.addServletMappingDecoded("/*", "dispatcher");

        try {
            tomcat.start();
        } catch (LifecycleException e) {
            e.printStackTrace();
        }

    }

然后在run方法中执行startTomcat方法便可启动Tomcat容器

效果如下

然后访问controller中的测试方法

我们再test的业务模块中只需要用到@LPSpringBootApplication注解和LPSpringApplication类即可。

实现多http（servlet）服务器的切换

上面我们模拟实现了简单的sprinboot，但在真正的springboot中是可以进行使用多种http（servlet）服务器的比如Tomcat、undertow、jetty等。

那么我们就需要进行动态切换

        如果项目中有Tomcat的依赖，那就启动Tomcat
        如果项目中有Jetty的依赖就启动Jetty
        如果两者都没有或者都没有则进行报错

我们可以定义一个webserver接口，在接口进行定义抽象的start方法，不同的服务器进行各种的自定义实现

public interface WebServer {

   public void start();
}

public class TomcatWebServer implements WebServer{
    @Override
    public void start() {
        System.out.println("TomcatServer  is starting...");
    }

public class JettyWebServer implements WebServer {
    @Override
    public void start() {
        System.out.println("JettyWebServer is starting...");
    }

}

然后再run方法中我们需要进行获取对应的webserver实现，然后进行启动start方法

public class LPSpringApplication {
    public static void run(Class clazz) {
        System.out.println("Hello World!");
        AnnotationConfigWebApplicationContext webApplicationContext = new AnnotationConfigWebApplicationContext();
        webApplicationContext.register(clazz);
        webApplicationContext.refresh();

//        TomcatWebServer.startTomcat(webApplicationContext);
        getWebServer(webApplicationContext).start();
    }

    public static WebServer getWebServer(WebApplicationContext applicationContext){
        Map<String, WebServer> beansOfType = applicationContext.getBeansOfType(WebServer.class);

        if (beansOfType.isEmpty()) {
            throw new NullPointerException();
        }

        if (beansOfType.size() > 1) {
            throw new IllegalStateException();
        }
        return beansOfType.values().stream().findFirst().get();
    }

}

模拟使用条件注解

首先我们需要实现Contion接口和一个自定义的条件注解@LPConditionalOnClass

public class LPCondition implements Condition {
    @Override
    public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
        Map<String, Object> annotationAttributes = metadata.getAnnotationAttributes(LPConditionalOnClass.class.getName());
        String className = (String) annotationAttributes.get("value");

        try {
            context.getClassLoader().loadClass(className);
            return true;
        } catch (ClassNotFoundException e) {
            return false;
        }
    }
}

@Target({ ElementType.TYPE, ElementType.METHOD })
@Retention(RetentionPolicy.RUNTIME)
@Conditional(LPCondition.class)
public @interface LPConditionalOnClass {
    String value();
}

LPCondition 的逻辑是拿到LPConditionalOnClass 注解的value值然后进行类加载器加载，加载成功则符合条件，反之亦然。

模拟实现自动配置类

创建了条件注解我们应该咋样使用呢？

我们需要使用自动配置的概念，我们只需要将满足条件的类进行注入到spring容器中即可

public interface AutoConfiguration {
}

@Configuration
public class WebServerAutoConfiguration implements AutoConfiguration {

    @Bean
    @LPConditionalOnClass("org.apache.catalina.startup.Tomcat")
    public TomcatWebServer tomcatWebServer(){
        return new TomcatWebServer();
    }

    @Bean
    @LPConditionalOnClass("org.eclipse.jetty.server.Server")
    public JettyWebServer jettyWebServer(){
        return new JettyWebServer();
    }
}

然后再容器中进行根据WebServer类型进行加载便可获取到对应的bean对象：

    public static WebServer getWebServer(WebApplicationContext applicationContext){
        Map<String, WebServer> beansOfType = applicationContext.getBeansOfType(WebServer.class);

        if (beansOfType.isEmpty()) {
            throw new NullPointerException();
        }

        if (beansOfType.size() > 1) {
            throw new IllegalStateException();
        }
        return beansOfType.values().stream().findFirst().get();
    }

        整体SpringBoot大概启动逻辑：

        创建一个AnnotationConfigWebApplicationContext容器
        解析LPApplication类，然后进行扫描
        通过getWebServer方法从Spring容器中获取WebServer类型的Bean
        调用WebServer对象的start方法

        有了以上步骤，但是还差了一个关键步骤，就是Spring要能解析到WebServiceAutoConfiguration这个自动配置类，此时我们需要SpringBoot在run方法中，能找到WebServiceAutoConfiguration这个配置类并添加到Spring容器中。
        为了让Spring解析到WebServiceAutoConfiguration这个自动配置类并将其添加到Spring容器中，Spring Boot在run方法中需要找到这个自动配置类。虽然LPApplication是Spring的配置类，并且我们可以将其传递给Spring Boot以添加到Spring容器中，但WebServiceAutoConfiguration的自动发现需要借助Spring Boot的机制，而不是通过手动配置。

        由于LPApplication是我们显式提供给Spring Boot的配置类，Spring Boot会将其添加到Spring容器中。然而，WebServiceAutoConfiguration需要Spring Boot自动发现，并且不能依赖常规的组件扫描，因为它的包路径不同于应用程序的扫描路径。LPApplication所在的扫描路径是"com.lp.test"，而WebServiceAutoConfiguration在"com.lp.springboot"中。

        Spring Boot是如何实现自动发现并将自动配置类添加到Spring容器中的呢？关键在于Spring Boot的SPI机制。Spring Boot实现了自己的Service Provider Interface (SPI)机制，通过spring.factories文件来自动配置应用程序所需的类。通过这个机制，Spring Boot能够自动发现WebServiceAutoConfiguration这样的自动配置类，而无需显式配置。

        因此，如果我们希望Spring Boot自动发现自定义的自动配置类，可以通过在spring.factories文件中列出相应的配置类来实现。该文件通常位于META-INF目录中，Spring Boot在启动时会读取它，并将指定的自动配置类添加到Spring容器中。

        这个过程使得Spring Boot能够灵活地扩展和自动配置，而无需开发人员显式指定所有配置类。这种自动化机制大大简化了配置过程，并提供了高度可扩展性。

        那么我们模拟就可以直接用JDK自带的SPI机制。

解析自动配置类

我们只需要在springboot模块的resource文件下创建如下文件

也就是上面的AutoConfiguration接口，然后通过SPI机制和Import机制将WebServerAutoConfiguration配置类型进行导入到spring容器中

public class LPDeferredImportSelector implements DeferredImportSelector {
    @Override
    public String[] selectImports(AnnotationMetadata importingClassMetadata) {
        ServiceLoader<AutoConfiguration> load = ServiceLoader.load(AutoConfiguration.class);
        List<String> list = new ArrayList<>();
        for (AutoConfiguration autoConfiguration : load) {
            list.add(autoConfiguration.getClass().getName());
        }
        return list.toArray(new String[0]);
    }
}

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Configuration
@ComponentScan
@Import(LPDeferredImportSelector.class)
public @interface LPSpringBootApplication {
}

这样就完成了在从com.lp.springboot.AutoConfiguration文件中获取自动配置类的名称并且进行导入到spring容器中，然后spring容器就可以获取到对应的配置类信息。

然后在test模块中添加jetty的依赖同时保留Tomcat依赖

        <dependency>
            <groupId>org.eclipse.jetty</groupId>
            <artifactId>jetty-server</artifactId>
            <version>9.4.43.v20210629</version>
        </dependency>

然后启动test的启动类

便会进行异常处理。

这样我们就可以在test业务工程进行自定义使用http（servlet）服务器的切换。

结语

我们通过模拟了springboot的主要启动流程：核心注解、核心启动类、创建spring容器、对内嵌Tomcat的启动和注入spring的DispatcherServlet容器、使用多servlet服务器的切换、条件注解、自动配置类的解析等关键功能节点完成了一个简单版本的Springboot，使用这样的方式让我们对Springboot项目能有个更加深刻的理解。