【微服务专题】手写模拟SpringBoot

news2024/11/24 17:25:32

目录

  • 前言
  • 阅读对象
  • 阅读导航
  • 前置知识
  • 笔记正文
    • 一、工程项目准备
      • 1.1 新建项目
      • 1.1 pom.xml
      • 1.2 业务模拟
    • 二、模拟SpringBoot启动：好戏开场
      • 2.1 启动配置类
        • 2.1.1 shen-base-springboot新增
        • 2.1.2 shen-example客户端新增启动类
    • 三、run方法的实现
      • 3.1 步骤一：启动一个Spring容器
      • 3.2 步骤二：初始化SpringMVC
      • 3.3 完整步骤二：启动Tomcat容器，初始化SpringMVC
      • 3.4 试运行
    • 四、升级改造
      • 4.1 在shen-base-springboot中新增WebServer接口
      • 4.2 getWebServer实现
        • 4.2.1 实现一个@ShenConditionalOnClass及逻辑ShenOnClassConditional
        • 4.2.2 补充getWebServer逻辑
    • 五、模拟SpringBoot自动装配
      • 5.1 Java SPI
      • 5.2 Spring / SpringBoot的SPI实现
  • 学习总结
  • 感谢

前言

SpringBoot最大的特点是什么大家伙还记得吧？自动配置 + 约定大于配置原则。

阅读对象

阅读导航

在本文中，我自己手写的SpringBoot，我将其称为：ShenSpringBoot

前置知识

笔记正文

本次手写模拟SpringBoot总共会分为上下两部分。这里是第一部分，在本阶段，需要完成的目标如下：

  1. 简单模拟SpringBoot的启动
  2. 模拟实现SpringApplication.run方法，启动Spring容器，以及web容器
  3. 实现一个Web请求
  4. 模拟SpringBoot自动选择Tomcat/Jetty容器

另外还有一点，关于【手写边界】需要跟大家确认。
5. 这边只是模拟SpringBoot手写一个Web工程，而并非是手写Spring这块
6. 因为是模拟Web请求，所以也会用到SpringMVC的内容，但是SpringMVC的东西显然也不在我们的模拟范围内

一、工程项目准备

1.1 新建项目

新建一个工程，里面有两个Module
在这里插入图片描述

  • shenspringboot：我的父工程
  • shen-base-springboot：实现手写SpringBoot的模块。注意这个包名，它不能跟模拟使用示例的报名一样
  • shen-example：示例模块，用来测试我手写的SpringBoot是否能够工作。注意这个包名，它不能跟手写模拟框架的SpringBoot一样

1.1 pom.xml

因为是依赖Spring跟SpringMVC嘛，所以，我们肯定要在模拟SpringBoot的pom中加入前两者的依赖。另外我们也知道，SpringBoot它是内置容器的，比如Tomcat，所以，我们也需要在手写模块中添加这些依赖。如下：

注意：这里使用的Spring版本为：5.3.20

1）shen-base-springboot模块的pom.xml

    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context</artifactId>
      <version>${spring.version}</version>
    </dependency>

    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-webmvc</artifactId>
      <version>${spring.version}</version>
    </dependency>

    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-beans</artifactId>
      <version>${spring.version}</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>

2）shen-example的pom.xml

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

1.2 业务模拟

我们在shen-example里面简单新增了一个controler，用于接收一个web请求。
在这里插入图片描述
正常，会返回下面的结果给到客户端
在这里插入图片描述
显然，现在运行的化，不会，也不应该有任何效果。毕竟我们还没有完成启动类嘛

二、模拟SpringBoot启动：好戏开场

首先在模拟之前，我们来回忆下，你在项目中是如何启动一个SpringBoot的？应该是两步吧：

  1. 一个自定义的启动类
  2. 启动类上有@SpringBootApplication注解，然后在main方法中使用SpringApplication.run启动SpringBoot应用

大概就跟这个一样：
在这里插入图片描述
所以，我们也来照抄一个试试

2.1 启动配置类

当然啦，这个启动配置类在两端都要写点代码，但主要还是在shen-base-springboot这边。

2.1.1 shen-base-springboot新增

首先新增一个@ShenSpringBootApplication注解类

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Configuration
@ComponentScan
public @interface ShenSpringBootApplication {
}

注意，相比于原生的，我这边缺少了一个很重要的注解，@EnableAutoConfiguration，这个后面的【5.3】会提到

至于为什么注解内容是这样子的，当然是因为原来的@SpringBootApplication就是这样子的呀
在这里插入图片描述

注意上图的一个注解：@EnableAutoConfiguration，后面【5.3】会提到

然后呢，还要新增一个单例，像这样的：
在这里插入图片描述
如下：
在这里插入图片描述
有了以上两者，我们就可以在客户端中使用了。

2.1.2 shen-example客户端新增启动类

启动类如下：

@ShenSpringBootApplication
public class MyApplication {
    public static void main(String[] args) {
        ShenSpringApplication.run(MyApplication.class);
    }
}

嘿，是不是有点感觉了。OK，理论上来说，客户端这边已经完成了所有了。按照我们正常使用SpringBoot，当我们点击运行之后，就可以开始我们的web请求了。显然，当我们点击这一步的时候，SpringBoot理应完成了以下两步，才能让整个程序正确的运作：（前面也讲过了）

  1. Spring容器已经被正确运行
  2. SpringMVC也被初始化完了
  3. 内置的Tomcat容器，也应该被启动了

这么一说，那 ShenSpringApplication.run(MyApplication.class);应该做什么，大家有点思路了吧。好戏开场了，xdm
在这里插入图片描述

三、run方法的实现

注意，该标题下代码都是写在shen-base-springboot模块下
注意，该标题下代码都是写在shen-base-springboot模块下
注意，该标题下代码都是写在shen-base-springboot模块下

OK，前面说过啊，这里要实现目的如下：

  1. Spring容器已经被正确运行
  2. SpringMVC也被初始化完了
  3. 内置的Tomcat容器，也应该被启动了

那行，我们就一步一步来呗

3.1 步骤一：启动一个Spring容器

启动一个Spring容器，这个不在我们本次的研究范围内，怎么启动一个Spring容器大家直接抄就好了。代码如下：

public class ShenSpringApplication {

    public static void run(Class clazz) {

        // 步骤一：创建并启动一个Spring容器
        AnnotationConfigWebApplicationContext context = new AnnotationConfigWebApplicationContext();
        context.register(clazz);
        context.refresh();
    }
}

为了美观，我通常喜欢把这种语义明确的代码写在一个独立的方法里面（偷偷告诉你们，这个是我看了Spring源码之后，学来的大神们的代码风格）。后面也基本会按照这种方式来写代码。美化后如下：

public class ShenSpringApplication {

    public static void run(Class clazz) {

        // 步骤一：创建并启动一个Spring容器
        ApplicationContext context = startSpring(clazz);
    }

    /**
     * 启动一个Spring容器
     *
     * @param clazz 配置类
     * @return 一个创建完成的Spring ApplicationContext
     */
    private static ApplicationContext startSpring(Class clazz) {
        AnnotationConfigWebApplicationContext context = new AnnotationConfigWebApplicationContext();
        context.register(clazz);
        context.refresh();
        return context;
    }
}

走到这里，大家多多少少知道，为什么run()方法要传入一个Class对象了吧，是的，充当配置类的。为了照顾Spring不太熟悉的朋友，简单说一下。
首先，我们传入的是客户端启动类MyApplication嘛，然后，我们的MyApplication不是被一个我们自定义的@ShenSpringBootApplication修饰吗？然后这个注解呢，他又是存在@ComponentScan注解的，所以自然，我们Spring容器想要知道怎么扫描，该扫描哪里，就需要程序员告知了。
所以，到此为止，之所以需要传入一个class，是为了告知Spring容器需要扫描的包路径是什么。SpringBoot默认扫描的路径大家还知道吧？启动类所在的包以及子包嘛。

3.2 步骤二：初始化SpringMVC

大家还知道SpringMVC是干什么的吗？O，我想处于SpringBoot时代的我们，对SpringMVC确实比较陌生一点。其实我自己也是，不过我呢，也只是很久没用过了，但是大致的内容跟原理还是懂的。这里给大家一篇文章，快速回忆学习下SpringMVC。

言归正传。SpringMVC是Spring框架中的一个模块，用于实现Java Web应用程序的Model-View-Controller（MVC）设计模式。它的主要作用是将请求和响应分开处理，使应用程序的逻辑更加清晰，提高代码的可维护性和可重用性。
它的运行原理如下：

  1. 在SpringMVC运行原理中，Tomcat会先启动，然后加载SpringMVC的核心控制器DispatcherServlet
  2. 当用户向服务器发送请求时，DispatcherServlet将请求交给HandlerMapper做解析，HandlerMapper将要访问的Controller返回给DispatcherServlet
  3. DispatcherServlet将用户的请求发送给指定的Controller做业务处理，当业务处理完后，SpringMVC将需要传递的数据和跳转的视图名称封装为一个ModelAndView对象，将ModelAndView对象发送给DispatcherServlet
  4. DispatcherServlet从ModelAndView对象里取出视图名称，交给视图解析器做解析，视图解析器中配置页面路径中的后缀和前缀，解析之后将要跳转的页面反馈给DispatcherServlet
  5. 最终DispatcherServlet将数据发送给页面通过Response对象响应给用户

SpringMVC，主要把上面出现的几个英文名词（核心组件）搞清楚大概也差不多了

OK，我为什么要贴一段简单的SpringMVC运行原理呢，哈，主要是告诉大家一点：SpringMVC运行之前，Tomcat容器应该先被启动，再然后才会去加载SpringMVC核心组件DispatcherServlet。
所以，步骤二的代码其实跟Tomcat是融合在一起的，它们一起才是真正的步骤二。

3.3 完整步骤二：启动Tomcat容器，初始化SpringMVC

我们这里使用的是内嵌的Tomcat版本，模拟SpringBoot嘛，而对于启动内嵌的Tomcat，这并不是我们本篇笔记在意的内容，所以直接网上抄一个就好了。
代码如下：

public class ShenSpringApplication {

    public static void run(Class clazz) {

        // 步骤一：创建并启动一个Spring容器
        ApplicationContext context = startSpring(clazz);

        // 步骤二：启动tomcat容器，并且初始化SpingMVC的核心组件
        startTomcat(context);
    }

    /**
     * 启动一个Spring容器
     *
     * @param clazz 配置类
     * @return 一个创建完成的Spring ApplicationContext
     */
    private static ApplicationContext startSpring(Class clazz) {
        AnnotationConfigWebApplicationContext context = new AnnotationConfigWebApplicationContext();
        context.register(clazz);
        context.refresh();
        return context;
    }

    /**
     * 启动tomcat容器，并且初始化SpingMVC的核心组件
     *
     * @param applicationContext Spring应用上下文
     */
    private static void startTomcat(ApplicationContext applicationContext){

        Tomcat tomcat = new Tomcat();

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

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

        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);

        // 初始化SpringMVC组件
        tomcat.addServlet(contextPath, "dispatcher", new DispatcherServlet((AnnotationConfigWebApplicationContext) applicationContext));
        context.addServletMappingDecoded("/*", "dispatcher");

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

注意哦，我这边tomcat绑定的接口改为了8081，安全点嘛。至于其他代码为什么要这么写，啊，因为tomcat跟SpringMVC就是这么写的啊，我们也不关心啊。OK，到了这里，基本上一个简单的【模拟SpringBoot的Web工程】已经能提供简单的服务了。我们运行试试看效果。

3.4 试运行

在这里插入图片描述
点击运行后，首先出来的是tomcat的日志，没毛病。接着我们访问一下我们的接口看看，在浏览器输入http://localhost:8081/test试试看效果
在这里插入图片描述
输出结果如上，预期是：手写Springboot。哈，乱码了。不过无所谓，反正手写模拟SpringBoot成功了。

四、升级改造

到了这里，虽然基本的ShenSpringBoot跑起来了，但是，我们原生的SpringBoot的功能远不止如此。就比如，原生SpringBoot支持多种内置容器，有：Jetty、Undertown。然后默认是Tomcat这样子。在原有的SpringBoot中想要切换Jetty容器，只需要在pom.xml中的springboot-starter-web依赖中排除tomcat配置，然后添加jetty的依赖就可以了。如下：

  <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-web</artifactId>
      <version>2.7.0</version>
      <exclusions>
        <exclusion>
          <groupId>org.springframework.boot</groupId>
          <artifactId>spring-boot-starter-tomcat</artifactId>
        </exclusion>
      </exclusions>
    </dependency>
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-jetty</artifactId>
      <version>2.7.0</version>
    </dependency>

那我现在我也想升级改造为支持自动切换的话，那也没啥问题，抄一下咯。整体来说思路是这样的：

  1. 如果项目中有tomcat的依赖，那就启动tomcat
  2. 如果项目中没有tomcat的依赖，但是有jetty的依赖，那就启动jetty

如何判断是否有对应的依赖？告诉大家一个方法，也是SpringBoot自动配置的思路。那就是使用类加载器load一下一个jar包比较有代表性的class。比如：classloader.loadClass("org.example.tomcat")，通常能load成功即可，出现异常则肯定是不存在依赖的。

  1. 如果两者都有，报错
  2. 两者都没有，也报错

注意啊，从这里开始其实会有点绕。
因为，这个逻辑是SpringBoot自动帮我们实现的，对于程序员而言，只要在pom中添加相关的依赖就可以了，想用什么容器都是用户自己的选择。
另外，我想大家通过上面的代码也发现了，所谓容器，不管是tomcat还是jetty，都是Servlet容器而已，所以我们可以定义一个接口去约束、表示他们，多态嘛。在设计模式中也叫做【策略模式】。这里就暂时叫做WebServer吧。

4.1 在shen-base-springboot中新增WebServer接口

public interface WebServer {

    /**
     * 启动一个容器
     */
    void start();
}

然后Tomcat实现：（注意，理论上这里需要实现Tomcat启动内容的，但是这里为了方便不写了，他也不是我们要关注的内容。我们随便看看效果）

public class TomcatWebServer implements WebServer{
    @Override
    public void start() {
        // 这巴拉巴拉的应该是Tomcat容器启动代码，我们前面也演示过了，这里不重复了
        System.out.println("启动一个Tomcat容器");
    }
}

Jetty实现：（注意，理论上这里需要实现Jetty启动内容的，但是这里为了方便不写了，他也不是我们要关注的内容。我们随便看看效果）

public class JettyWebServer implements WebServer{
    @Override
    public void start() {
    	// 这巴拉巴拉的应该是Jetty容器启动代码
        System.out.println("启动一个Jetty容器");
    }
}

当然，既然我们引入了Jetty容器的实现，我们也要在手写模拟的shen-base-springboot的pom中引入Jetty的依赖：（虽然我偷懒给了空实现，但是这一步是必要的）

    <dependency>
      <groupId>org.eclipse.jetty</groupId>
      <artifactId>jetty-server</artifactId>
      <version>9.4.46.v20220331</version>
    </dependency>

最后，咱也别忘了修改ShenSpringApplication的run方法：

    public static void run(Class clazz) {

        // 步骤一：创建并启动一个Spring容器
        ApplicationContext context = startSpring(clazz);

        // // 步骤二：启动tomcat容器，并且初始化SpingMVC的核心组件
        // startTomcat(context);

        // 改进步骤二：获取一个容器，并启动，接着初始化SpringMVC的核心组件
        final WebServer webServer = getWebServer();
        webServer.start();
    }
    
  	private static WebServer getWebServer() {
        return null;
    }

OK，这一步到这里就暂时收住了，剩下的代码就是考虑如何实现这个getWebServer。

4.2 getWebServer实现

getWebServer该如何实现呢？从实现思路来说，我觉得简单的可以分为2步：

  1. 从哪里拿
  2. 怎么拿

其实这些都不难理解，大哥们，咱们都是在Spring容器中开发了，当然是在Spring拿啊。所以嘛，我们能在客户端中，通过Spring容器去获取我们的容器，那肯定是因为，在SpringBoot那边，向Spring容器注册了Bean啊。有点拗口，直接上代码大家就懂了：（代码在shen-base-springboot）

@Configuration
public class WebServerAutoConfiguration{

    @Bean
    public TomcatWebServer tomcatWebServer() {
        return new TomcatWebServer();
    }

    @Bean
    public JettyWebServer jettyWebServer() {
        return new JettyWebServer();
    }
}

是这样没错吧？哈哈，其实有一点点错误。为什么， 因为正常过来说，这两个容器不会同时存在的，他们的存在都是有条件的，咱前面不是说了吗，需要某个包存在嘛，所以很明显，这里的@Bean还需要一个类似@ConditionalOnBean的条件注解。是的，这也正是我们要自定义实现的一个条件注解。怎么实现？抄。

4.2.1 实现一个@ShenConditionalOnClass及逻辑ShenOnClassConditional

注意，不懂得如何实现一个自定义条件注解的朋友可以自行百度先

主要实现类有：@ShenConditionalOnClass一个注解类，以及核心的条件实现类ShenOnClassConditional。后者ShenOnClassConditional才是真正做判断的地方。代码如下：（代码在shen-base-springboot）

@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Conditional(ShenOnClassConditional.class)
public @interface ShenConditionalOnClass {
    String value() default "";
}

ShenOnClassConditional 实现了Condition接口的类，它才是真正得条件逻辑处理类哦。

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

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

            // 找不到需要加载的类，会抛异常：ClassNotFoundException
            // 既然找不到，所以返回false
            return false;
        }
    }
}

具体逻辑为，拿到@ShenConditionalOnClass中的value属性，然后用类加载器进行加载，如果加载到了所指定的这个类，那就表示符合条件，如果加载不到，类加载会抛出异常ClassNotFoundException，则表示不符合条件。

那既然条件注解也实现了，接下来就是在WebServerConfig使用他们就好了，修改后的代码如下：

@Configuration
public class WebServerAutoConfiguration {

    /**
     * Tomcat容器典型加载类
     */
    private static final String TOMCAT_PATH = "org.apache.catalina.startup.Tomcat";

    /**
     * Jetty容器典型加载累
     */
    private static final String JETTY_PATH = "org.eclipse.jetty.server.Server";

    @Bean
    @ShenConditionalOnClass(TOMCAT_PATH)
    public TomcatWebServer tomcatWebServer() {
        return new TomcatWebServer();
    }

    @Bean
    @ShenConditionalOnClass(JETTY_PATH)
    public JettyWebServer jettyWebServer() {
        return new JettyWebServer();
    }
}

OK，到这里一个简单的容器自动配置类就完成了。上面这段代码的最终实现语意如下：

  1. 只有存在org.apache.catalina.startup.Tomcat类，那么我们手写模拟的ShenSpringBoot才会向Spring容器中注册TomcatWebServer这个Bean
  2. 只有存在2.org.eclipse.jetty.server.Server类，那么我们手写模拟的ShenSpringBoot才会向Spring容器中注册JettyWebServer这个Bean
4.2.2 补充getWebServer逻辑

那最后，就是在getWebServer填上这样的逻辑咯

    /**
     * 从当前Spring容器中获取一个Servlet容器
     *
     * @param applicationContext Spring应用上下文
     */
    private static WebServer getWebServer(ApplicationContext applicationContext) {

        // key为beanName, value为Bean对象
        Map<String, WebServer> webServers = applicationContext.getBeansOfType(WebServer.class);

        if (webServers.isEmpty()) {
            System.err.println("找不到可用的Web容器");
            throw new NullPointerException();
        }
        if (webServers.size() > 1) {
            System.err.println("找到了多个容器");
            throw new IllegalStateException();
        }

        // 返回唯一的一个
        return webServers.values().stream().findFirst().get();
    }

这样整体SpringBoot启动逻辑就是这样的：

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

那朋友们，这样就OK了吗？测试一下呗：
在这里插入图片描述
诶？空指针？找不到可用的Web容器？点解啊？在shen-base-springboot模块中不是依赖了Tomcat跟Jetty了吗？还做了自动配置。
对啊，你是在shen-base-springboot做了自动配置，可童鞋们，它的目录是啥：shen.springframework哦，而你现在的扫描路径是啥？com.shen.example，都扫描不到了，给你注册个锤锤哦。
是的，这也是在SpringBoot中一样会遇到的问题，他们是怎么解决的呢？当然原理肯定是把这些包也加入到扫描包里面，而SpringBoot则是通过自定义的，一个叫做SPI（Service Provider Interface）的服务发现机制，来扫描注册一些基础的服务Bean。

说SPI可能大家比较陌生，其实就是我们比较熟知的spring.factories

五、模拟SpringBoot自动装配

想要模拟的话，其实最好还是了解一下SPI机制比较合适，但说实在，想要真的深入去了解一下的话，单单是这个内容都可以写一篇文章出来了。所以我比较建议，大家直接去看这篇文章《SpringBoot（二）：springboot自动装配之SPI机制》。

不过对这个知识点不是很感兴趣的朋友，可以看看我这里的简单解释版本。

5.1 Java SPI

我们之所以聊到了SPI这个东西，是因为，我们在前面的推导中遇到了一个问题，那就是：

  • 已知我的业务项目中，Spring容器的扫描路径是com.shen.example，怎么去扫描位于手写模拟ShenSpringBoot下shen.springframework下的bean呢？

为什么要重申这个现象，主要是提醒大家，需要SPI的场景，一个简单的现象是：它们通常都发生在两个独立的jar包，或者说包路径上。它们彼此之间是第三方关系。理解这点非常非常重要！

那我再问大家一个问题？什么是API？它与SPI有什么区别？（对的，他们之间有联系的哦）
API即程序应用接口，它跟SPI一样，核心内容都包含接口。它和SPI最明显的区别是：API的接口与实现类存在于实现方；SPI是接口与实现类脱离，不在同一方。有点绕，由下图所示：
在这里插入图片描述所以情况就是这么个情况，想要弄明白这个情况的话，还是要好好思考一下这个情况。哈哈哈
由于是别人实现的，所以，Java提供了一个机制去发现别人的实现，这就是SPI。
在Spring里面，也需要解决类似的问题：由于是别人声明的Bean，所以我需要一种机制去让它们的Bean也注册到我们的Spring容器中。

5.2 Spring / SpringBoot的SPI实现

简单来说，它是这么实现的：

  1. Spring容器启动，注册类配置处理器
  2. spring刷新上下文，执行配置类处理器
  3. 扫描类路径下所有jar包里卖弄的spring.factories文件，将得到的BeanDefinition注册到容器
  4. spring实例化/初始化这些BeanDefinition

它们的实现，其实就是我在【2.1 启动配置类】少写的注解@EnableAutoConfiguration里面！而 @EnableAutoConfiguration集成了@Import注解，这个注解对于springboot非常重要！
在这里插入图片描述
具体的实现我就不再继续讲了，确实知识点挺深的。感兴趣的同学自己去继续研究下吧。

学习总结

  1. 简单学习了一下SpringBoot的启动流程
  2. 简单学习了一下SPI机制，及其在Java和Spring中的使用

感谢

感谢百度大佬【作者：一页一】的文章《SpringBoot（二）：springboot自动装配之SPI机制》

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1194719.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

Javaweb之javascript的BOM对象的详细解析

Javaweb之javascript的BOM对象的详细解析

1.5.2 BOM对象 接下来我们学习BOM对象&#xff0c;BOM的全称是Browser Object Model,翻译过来是浏览器对象模型。也就是JavaScript将浏览器的各个组成部分封装成了对象。我们要操作浏览器的部分功能&#xff0c;可以通过操作BOM对象的相关属性或者函数来完成。例如&#xff1a…
阅读更多...
asp.net core weapi 结合identity完成登录/注册/角色/权限分配

asp.net core weapi 结合identity完成登录/注册/角色/权限分配

1.安装所需要的nuget包 <PackageReference Include"Microsoft.AspNetCore.Identity.EntityFrameworkCore" Version"6.0.24" /><PackageReference Include"Microsoft.EntityFrameworkCore" Version"6.0.24" /><PackageR…
阅读更多...
Docker学习——⑥

Docker学习——⑥

文章目录 1、什么是存储卷?2、为什么需要存储卷?3、存储卷分类4、管理卷 Volume5、绑定卷 bind mount6、临时卷 tmpfs7、综合实战-MySQL 灾难恢复8、常见问题 1、什么是存储卷? 存储卷就是将宿主机的本地文件系统中存在的某个目录直接与容器内部的文件系统上的某一目录建立…
阅读更多...
实战leetcode(二)

实战leetcode(二)

Practice makes perfect&#xff01; 实战一&#xff1a; 这里我们运用快慢指针的思想&#xff0c;我们的slow和fast都指向第一个节点&#xff0c;我们的快指针一次走两步&#xff0c;慢指针一次走一步&#xff0c;当我们的fast指针走到尾的时候&#xff0c;我们的慢指针正好…
阅读更多...
FPGA UDP RGMII 千兆以太网（3）ODDR

FPGA UDP RGMII 千兆以太网（3）ODDR

1 xilinx原语 在 7 系列 FPGA 中实现 RGMII 接口需要借助 5 种原语，分别是：IDDR、ODDR、IDELAYE2、ODELAYE2(A7 中没有)、IDELAYCTRL。其中，IDDR和ODDR分别是输入和输出的双边沿寄存器，位于IOB中。IDELAYE2和ODELAYE2，分别用于控制 IO 口输入和输出延时。同时，IDELAYE2 …
阅读更多...
使用切面实现前端重复提交（防抖）

使用切面实现前端重复提交（防抖）

使用切面实现前端重复提交&#xff08;防抖&#xff09; 代码结构定义注解请求锁切面处理器入参对象使用注解 代码结构 原理&#xff1a; 1、前端提交保存操作&#xff1b; 2、后端通过注解指定重复提交的关键字段进行识别&#xff0c;可以有多个&#xff1b; 3、拼接关键字段&…
阅读更多...
科普测量开关电源输出波形的三种方法及电源波形自动化测试步骤

科普测量开关电源输出波形的三种方法及电源波形自动化测试步骤

开关电源波形测试就是对开关电源的输出波形进行检测和分析&#xff0c;观察开关电源参数变化&#xff0c;以此来判断开关电源的性能是否符合要求。好的开关电源对于设备以及整个电路的正常运行是非常重要的&#xff0c;因此开关电源输出波形测试是开关电源测试的重要环节&#…
阅读更多...
RK3399平台开发系列讲解（内存篇）free 命令查看内存占用情况介绍

RK3399平台开发系列讲解（内存篇）free 命令查看内存占用情况介绍

🚀返回专栏总目录 文章目录 一、free的使用二、free的内容📢free 指令会显示内存的使用情况，包括实体内存，虚拟的交换文件内存，共享内存区段，以及系统核心使用的缓冲区等。 一、free的使用 -b 　以 Byte 为单位显示内存使用情况。-k 　以 KB 为单位显示内存使用情况。…
阅读更多...
华为防火墙双机热备配置案例

华为防火墙双机热备配置案例

思路&#xff1a; IP和路由、ospf要两台防火墙单配&#xff0c;hrp不会同步 其它zone和策略会同步&#xff0c;只在master上配就行了 FW_A主要配置&#xff1a; hrp enable hrp interface GigabitEthernet1/0/2 remote 172.16.0.2 interface GigabitEthernet1/0/0 undo shut…
阅读更多...
海康Visionmaster-通讯管理：ModBus 通信发送非整型 数据的方法

海康Visionmaster-通讯管理：ModBus 通信发送非整型 数据的方法

Modbus 通信发送数据只能为 Int 类型&#xff0c;如下图所示&#xff1a; 可以发送 Int 和 Float 数据&#xff0c;如下图所示 通信设备配置如下&#xff1a; 发送事件配置如下&#xff1a; 通信管理界面显示有问题&#xff0c;显示为 Int 类型存在一定误导&#xff1b;可以…
阅读更多...
【性能测试】服务端中间件docker常用命令解析整理（详细）

【性能测试】服务端中间件docker常用命令解析整理（详细）

目录&#xff1a;导读 前言一、Python编程入门到精通二、接口自动化项目实战三、Web自动化项目实战四、App自动化项目实战五、一线大厂简历六、测试开发DevOps体系七、常用自动化测试工具八、JMeter性能测试九、总结&#xff08;尾部小惊喜&#xff09; 前言 1、搜索 docker …
阅读更多...
LeetCode（2）移除元素【数组/字符串】【简单】

LeetCode（2）移除元素【数组/字符串】【简单】

目录 1.题目2.答案3.提交结果截图 链接&#xff1a; 27. 移除元素 1.题目 给你一个数组 nums 和一个值 val&#xff0c;你需要 原地 移除所有数值等于 val 的元素&#xff0c;并返回移除后数组的新长度。 不要使用额外的数组空间&#xff0c;你必须仅使用 O(1) 额外空间并 原…
阅读更多...
【机试题】LazyIterator迭代器懒加载问题

【机试题】LazyIterator迭代器懒加载问题

将下面这个未完成的Java工具类补充完成&#xff0c;实现懒加载的功能&#xff0c;该类需要实现Iterable接口&#xff0c;能够遍历所有数据。具体要求如下&#xff1a; 工具类提供了一个ValueLoader接口&#xff0c;用于获取数据&#xff0c;其中ValueLoader的接口定义为&#x…
阅读更多...
Guitar Pro8.2中文版简谱制作工具

Guitar Pro8.2中文版简谱制作工具

在音乐的大舞台上&#xff0c;谁不想成为一位吉他弹奏大师呢&#xff1f;但在现实中&#xff0c;学吉他并非一蹴而就&#xff0c;许多小伙伴都因为吉他的上手难度而被浇灭学习的热情。然而&#xff0c;这里有一款神奇的软件&#xff0c;叫做Guitar Pro&#xff0c;它就像是一把…
阅读更多...
SDN和NFV笔记

SDN和NFV笔记

目录 SDN SDN的引入 SDN的概念 SDN网络部署的方式 SDN架构 OpenFlow SDN与传统网络的区别 SDN的应用 SDN的优点 NFV NFV的概念&#xff1a; NFV的架构&#xff1a; NFV相比于传统物理网元&#xff1a; NFV与SDN的关系 NFV与SDN的相似点 NFV与SDN的不同 SDN SD…
阅读更多...
EXPLAIN详解（MySQL）

EXPLAIN详解（MySQL）

EXPLAIN概述 EXPLAIN语句提供MySQL如何执行语句的信息。EXPLAIN与SELECT, DELETE, INSERT, REPLACE和UPDATE语句一起工作。 EXPLAIN返回SELECT语句中使用的每个表的一行信息。它按照MySQL在处理语句时读取表的顺序列出了输出中的表。MySQL使用嵌套循环连接方法解析所有连接。…
阅读更多...
2022年12月 Python（四级）真题解析#中国电子学会#全国青少年软件编程等级考试

2022年12月 Python（四级）真题解析#中国电子学会#全国青少年软件编程等级考试

Python等级考试（1~6级）全部真题・点这里 一、单选题（共25题，每题2分，共50分） 第1题 有n个按名称排序的商品，使用对分查找法搜索任何一商品，最多查找次数为5次，则n的值可能为？（）（2分） A.5 B.15 C.30 D.35 答案：C 答案解析：对分查找最多查找次数m与个数之间n的…
阅读更多...
高斯过程回归 | GPR高斯过程回归

高斯过程回归 | GPR高斯过程回归

高斯过程回归（Gaussian Process Regression, GPR）是一种强大的非参数回归方法，它通过假设数据是从一个高斯过程中生成的来预测新的数据点。 高斯过程是一种定义在连续输入空间上的随机过程，其中任何有限集合的观测值都呈多变量高斯分布。 实现GPR的Python代码import numpy …
阅读更多...
Coding面试题之手写线程池

Coding面试题之手写线程池

原理图 JDK线程池原理 实现代码 1.线程类&#xff08;PoolThread&#xff09; 这个类用于执行任务队列中的任务。 public class PoolThread extends Thread {private final Queue<Runnable> taskQueue;private boolean isStopped false;public PoolThread(Queue<…
阅读更多...
Python---练习：求幸运数字6

Python---练习：求幸运数字6

案例&#xff1a; 幸运数字6&#xff08;只要是6的倍数&#xff09;&#xff1a;输入任意数字&#xff0c;如数字8&#xff0c;生成nums列表&#xff0c;元素值为1~8&#xff0c;从中选取幸运数字移动到新列表lucky&#xff0c;打印nums与lucky。 思考&#xff1a; 要求是6的…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023