So implementieren Sie die automatische SpringBoot-Konfiguration

So implementieren Sie Springboot

Im vorherigen Helloworld-Beispiel habe ich zunächst erlebt, wie einfach es ist, dass Springboot automatisch Abhängigkeiten importiert und die Konfiguration abschließt.

Wie wird Springboot implementiert?

1. Abhängigkeitsverwaltungsfunktionen

Schauen Sie sich zunächst die pom.xml im vorherigen Inhaltsbeispiel an:

<!--导入父工程-->
  <parent>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-parent</artifactId>
      <version>2.3.4.RELEASE</version>
  </parent>
  <dependencies>
      <dependency>
          <groupId>org.springframework.boot</groupId>
          <artifactId>spring-boot-starter-web</artifactId>
      </dependency>
  </dependencies>

Hier wird ein übergeordnetes Projekt hinzugefügt, und schließlich wird nur eine Abhängigkeit, spring-boot-starter-web, importiert. Wir haben die entsprechenden Pakete erhalten.

Sie müssen sich während des gesamten Prozesses keine Sorgen um das Reiseführerpaket machen.

1. Übergeordnetes Projekt

Jedes Springboot-Projekt verfügt über ein übergeordnetes Projekt, das im Allgemeinen für das Abhängigkeitsmanagement verwendet wird.

Das übergeordnete Projekt kann viele Abhängigkeiten deklarieren. Solange das Unterprojekt das übergeordnete Projekt erbt, ist es nicht erforderlich, beim späteren Hinzufügen von Abhängigkeiten eine Versionsnummer hinzuzufügen.

Nehmen wir das Obige als Beispiel: Das übergeordnete Projekt verwendet die Springboot-Version von 2.3.4.RELEASE, sodass die Versionsnummer für die unten hinzugefügten Abhängigkeiten nicht angegeben werden muss.

(1) Wie das übergeordnete Projekt Versionen verwaltet

Sie können die Strg-Taste gedrückt halten und auf das übergeordnete Projekt klicken, um dies herauszufinden.

Nachdem ich reinkam, stellte ich fest, dass er auch ein übergeordnetes Projekt mit Spring-Boot-Abhängigkeiten hat.

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-dependencies</artifactId>
    <version>2.3.4.RELEASE</version>
  </parent>

Fahren Sie mit der Eingabe von Spring-Boot-Abhängigkeiten fort, und Sie können unten ein Eigenschaften-Tag sehen:

Fast alle JAR-Paketversionen, die wir möglicherweise in der Entwicklung verwenden, werden hier deklariert.

Fahren Sie fort und Sie können die spezifische Abhängigkeitsverwaltung dependencyManagement sehen. Die hier angegebene Version ist die in den Eigenschaften deklarierte Version.

Zum Beispiel:

Ich habe links ein Paket namens logback gesehen, also habe ich es durchsucht und festgestellt, dass die hier definierte Version 1.2.3 ist.

Die Hauptfunktion des übergeordneten Projekts ist also das Abhängigkeitsmanagement, das nahezu die Versionsnummern von Abhängigkeiten angibt, die häufig in der Entwicklung verwendet werden.

(2) Verwenden Sie die angegebene Version

Wenn Sie nicht die automatisch geschlichtete Version verwenden möchten, können Sie auch die angegebene Version verwenden.

Für die MySQL-Version ist das Ergebnis der automatischen Schlichtung beispielsweise 8.0.21, ich möchte jedoch nur Version 5.1.43 verwenden.

Fügen Sie ein Eigenschaften-Tag hinzu und deklarieren Sie darin die Version.

<properties>
      <mysql.version>5.1.43</mysql.version>
  </properties>

Schauen Sie sich die importierten Abhängigkeiten noch einmal an, es ist die angegebene Version geworden.

2. Szenario-Starter

Werfen wir einen Blick auf die erste importierte Abhängigkeit Spring-Boot-Starter-Web:

<dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-web</artifactId>
  </dependency>

Wir werden in Zukunft weitere Starter mit dem Namen Spring-Boot-Starter sehen. Eine ausführliche Anleitung gibt es auch in den offiziellen Dokumenten

Was ist ein Starter?

Starter ist eine Reihe von Abhängigkeitsbeschreibungen. Das heißt, wir müssen normalerweise nur einen Starter einführen, und dann wird das entsprechende gesamte Entwicklungsszenario eingeführt.

Wenn Sie beispielsweise Spring und JPA für den Datenbankzugriff verwenden möchten, führen Sie die Abhängigkeit spring-boot-starter-data-jpa in das Projekt ein.

Beachten Sie außerdem, dass spring-boot-starter-* hier die offizielle Benennungsmethode für Starter ist.

Es gibt also inoffizielle? Ja, wenn Sie das Gefühl haben, dass das offizielle Starter-Szenario Ihren Anforderungen immer noch nicht entspricht, können Sie den Starter individuell anpassen.

Aber die offizielle Empfehlung lautet, für die individuelle Benennung den Thirdpartyproject-Spring-Boot-Starter zu verwenden.

Was den Grund betrifft, warum Sie die Abhängigkeiten der gesamten Szene importieren können, indem Sie nur einen Starter importieren, handelt es sich tatsächlich um die gleiche Abhängigkeitsfunktion von Maven wie beim übergeordneten Projekt oben.

Gehen Sie zu spring-boot-starter-web, scrollen Sie nach unten und Sie können die Abhängigkeiten sehen, die bei der Entwicklung von Webszenarien verwendet werden.

Welches Szenario Sie in Zukunft entwickeln müssen, lesen Sie einfach in der offiziellen Dokumentation nach und importieren Sie den entsprechenden Launcher. ?? Probleme

默认的包结构：主程序所在包以及下面所有子包里的组件都会被默认扫描

各种配置拥有默认值

按需加载所有自动配置项

......

1. 自动配置组件

不管自动配置好什么，步骤都是：先引入、再配置。

比如 tomcat，那么前提是先引入了 tomcat 依赖，这就由上面第一部分内容所讲的依赖管理完成，在引入了 web starter 后，自动引入场景。

自动引入了场景，也就引入了这个场景下所用到的各种 jar 包，接下来就是要配置这些内容，比如 tomcat、springMVC 等等。

拿 springMVC 举例，在之前要使用 springMVC，肯定要配置DispatcherServlet，帮我们拦截所有请求。

<servlet>
        <servlet-name>springMVC</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:springMVC.xml</param-value>
        </init-param>
        <load-on-startup>1</load-on-startup>
    </servlet>

现在看下之前的 helloworld 应用中，springboot 是在哪里帮我们做好配置的。

先看主程序类：

// 标记这是一个 springboot应用，这个类是主程序类，所有启动的入口
@SpringBootApplication
public class MainApplication {
    public static void main(String[] args) {
        SpringApplication.run(MainApplication.class, args);
    }
}

可以创建个本地变量(alt+enter)，可以看到这个是个ConfigurableApplicationContext类型。

@SpringBootApplication
public class MainApplication {
    public static void main(String[] args) {
        ConfigurableApplicationContext run = SpringApplication.run(MainApplication.class, args);
    }
}

可以使用getBeanDefinitionNames()方法，查看里面包含了哪些容器，遍历打印出来。

@SpringBootApplication
public class MainApplication {
    public static void main(String[] args) {
        // 返回IOC容器
        final ConfigurableApplicationContext run = SpringApplication.run(MainApplication.class, args);
        // 查看容器里的组件
        final String[] beanDefinitionNames = run.getBeanDefinitionNames();
        for (String name: beanDefinitionNames) {
            System.out.println(name);
        }
    }
}

接下来启动应用，看下控制台输出。

在控制台输出里ctrl+F搜索下DispatcherServlet：

发现 IOC 容器中已经有了对应的组件。

2. 默认的包结构

主程序所在包以及下面所有子包里的组件都会被默认扫描，所以我们不需要配置开启组件扫描，也可以正常使用。

但是要注意这里的范围：

示例中就是com.pingguo.boot包下以及所有子包都可以自动扫描。

如果你就是要放到外面，还希望被扫描到，怎么办？

那么可以使用主程序类中@SpringBootApplication注解中的一个属性scanBasePackages，扩大包的范围即可：

@SpringBootApplication(scanBasePackages = "com.pingguo")
public class MainApplication {
    public static void main(String[] args) {
... ...

3. 各种配置拥有默认值

比如 tomcat端口，在application.properties配置文件里使用 idea 输入的时候，就可以看到带有默认值8080:

点击进去可看到后面都是绑定了对应的 java 类。

配置文件的值最终会绑定在对应的类上，这个类会在容器中创建对象。

4. 按需加载所有自动配置项

比如应用中只引入了spring-boot-starter-web，那么就只有web场景的自动配置才会开启。

springboot 中的所有自动配置，都在这里：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-autoconfigure</artifactId>
    <version>2.3.4.RELEASE</version>
    <scope>compile</scope>
  </dependency>

点击spring-boot-starter-web可以找到spring-boot-starter，再进入其中就可以看到spring-boot-autoconfigure。

Das obige ist der detaillierte Inhalt vonSo implementieren Sie die automatische SpringBoot-Konfiguration. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!