Bagaimana untuk melaksanakan konfigurasi automatik SpringBoot

Cara melaksanakan springboot

Dalam contoh helloworld sebelum ini, saya pada mulanya mengalami kemudahan springboot mengimport kebergantungan secara automatik dan melengkapkan konfigurasi.

Jadi, bagaimanakah springboot dilaksanakan?

1. Ciri pengurusan kebergantungan

Mula-mula lihat pom.xml dalam contoh kandungan sebelumnya:

<!--导入父工程-->
  <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>

Satu projek induk ditambahkan di sini dan hanya satu diimport. Bergantung pada spring-boot-starter-web, semua pakej berkaitan kami akhirnya masuk.

Semasa keseluruhan proses, anda tidak perlu risau tentang isu pakej panduan.

1. Projek induk

Setiap projek springboot mempunyai projek induk, yang biasanya digunakan untuk pengurusan pergantungan.

Projek induk mungkin mengisytiharkan banyak kebergantungan, jadi selagi sub-projek mewarisi projek induk, tidak perlu menambah nombor versi apabila menambah kebergantungan nanti.

Mengambil contoh di atas, projek induk menggunakan versi springboot 2.3.4.RELEASE, jadi tidak perlu menulis nombor versi untuk dependensi yang ditambahkan di bawah.

(1) Cara projek induk mengurus versi

Anda boleh tahan ctrl dan klik pada projek induk untuk mengetahuinya.

Selepas masuk, saya dapati dia juga mempunyai projek induk spring-boot-dependencies.

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

Teruskan masukkan spring-boot-dependencies, dan anda boleh melihat teg sifat di bawah:

Ini hampir mengisytiharkan semua kemungkinan yang kita ada dalam pembangunan Versi pakej balang yang akan digunakan.

Teruskan ke bawah untuk melihat dependency management management tertentu Versi yang dipetik di sini ialah versi yang diisytiharkan dalam sifat.

Contohnya:

Saya nampak pakej di sebelah kiri adalah log balik, jadi saya mencari di dalam dan mendapati versi yang ditakrifkan di sini ialah 1.2.3.

Jadi, fungsi utama projek induk ialah pengurusan kebergantungan, yang hampir mengisytiharkan nombor versi kebergantungan yang biasa digunakan dalam pembangunan.

(2) Gunakan versi yang ditentukan

Jika anda tidak mahu menggunakan versi timbang tara automatik, anda juga boleh menggunakan versi yang ditentukan.

Sebagai contoh, untuk versi mysql, keputusan timbang tara automatik ialah 8.0.21, tetapi saya hanya mahu menggunakan versi 5.1.43.

Tambahkan teg sifat dan isytiharkan versi di dalamnya.

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

Lihat pada kebergantungan yang diimport sekali lagi, ia telah menjadi versi yang ditentukan.

2. Pemula senario

Mari kita lihat spring-boot-starter-web pergantungan pertama yang diimport:

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

Kita akan lihat lebih banyak pemula dinamakan spring-boot-starter pada masa hadapan. Terdapat juga arahan terperinci dalam dokumen rasmi

Apakah itu permulaan?

pemula ialah satu set perihalan pergantungan, iaitu, biasanya kita hanya perlu memperkenalkan pemula, dan kemudian keseluruhan senario pembangunan yang sepadan akan diperkenalkan.

Sebagai contoh, jika anda ingin mula menggunakan Spring dan JPA untuk akses pangkalan data, kemudian perkenalkan kebergantungan spring-boot-starter-data-jpa ke dalam projek.

Selain itu, ambil perhatian bahawa spring-boot-starter-* di sini ialah kaedah penamaan starter rasmi.

Jadi masih ada yang tidak rasmi? Ya, jika anda merasakan bahawa senario pemula rasmi masih tidak dapat memenuhi keperluan anda, anda boleh menyesuaikan pemula.

Tetapi syor rasmi ialah menggunakan thirdpartyproject-spring-boot-starter untuk penamaan tersuai.

Mengenai sebab mengimport hanya satu pemula boleh mengimport kebergantungan keseluruhan adegan, ia sebenarnya adalah ciri kebergantungan maven yang sama seperti projek induk di atas.

Masukkan spring-boot-starter-web, tatal ke bawah dan anda boleh melihat kebergantungan yang digunakan dalam membangunkan senario web.

Jadi, untuk senario yang manakah anda perlu bangunkan pada masa hadapan, cuma rujuk dokumentasi rasmi dan import pelancar yang sepadan.

2. Konfigurasi automatik

Di sini sekali lagi, mari semak perkara yang dikonfigurasikan springboot secara automatik dalam projek helloworld sebelumnya:

• Konfigurasi tomcat secara automatik

• Konfigurasikan springMVC secara automatik

• Konfigurasikan fungsi web biasa secara automatik, seperti: isu pengekodan aksara

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

• 各种配置拥有默认值

• 按需加载所有自动配置项

• ......

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。

Atas ialah kandungan terperinci Bagaimana untuk melaksanakan konfigurasi automatik SpringBoot. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!