Bagaimana untuk menyesuaikan pemula, adakah anda bosan mempelajarinya?

Dua hari lepas, seorang rakan ditanya tentang starter sekali lagi semasa temuduga. Semasa saya membuat temuduga olok-olok untuknya, saya sengaja menekankan bahawa saya mesti menulis pemula tersuai sendiri, dan pastinya, dia ditanya mengenainya semasa temuduga. . Rakan-rakan yang telah mempelajari Spring Boot harus tahu bahawa ada pepatah untuk menerangkan Spring Boot: Konvensyen lebih hebat daripada konfigurasi
.

Sebab Spring Boot dipanggil "konvensyen atas konfigurasi" adalah kerana ia mengamalkan konsep reka bentuk konvensyen atas konfigurasi. Pembangunan Java tradisional memerlukan sejumlah besar konfigurasi, seperti fail XML, anotasi, dsb., dan konfigurasi ini perlu ditentukan oleh pembangun sendiri. Spring Boot memudahkan proses pembangunan dengan menyediakan beberapa konfigurasi lalai dan konvensyen, mengurangkan jumlah kerja konfigurasi manual yang perlu dilakukan oleh pembangun.

Spring Boot secara automatik melengkapkan beberapa tugas konfigurasi biasa melalui beberapa sifat konfigurasi lalai dan konvensyen, seperti konfigurasi automatik sumber data, konfigurasi automatik pelayan web, konfigurasi automatik log, dsb. Pembangun hanya perlu menyusun kod dan fail konfigurasi mengikut cara yang dipersetujui untuk membina aplikasi yang berfungsi dengan cepat. Konsep reka bentuk konvensyen atas konfigurasi ini membolehkan pembangun tidak perlu lagi memberi perhatian kepada beberapa butiran konfigurasi konvensional dan lebih fokus pada pelaksanaan logik perniagaan. Pada masa yang sama, Spring Boot juga menyediakan beberapa pilihan konfigurasi yang boleh diperluaskan, membolehkan pembangun menyesuaikan dan mengembangkan mengikut keperluan mereka sendiri.

Secara umumnya, konsep reka bentuk Spring Boot bagi konvensyen atas konfigurasi membolehkan pembangun membangunkan aplikasi dengan lebih cepat dan cekap, serta mengurangkan kerumitan konfigurasi. Ini juga merupakan sebab mengapa Spring Boot boleh menjadi salah satu rangka kerja yang digunakan secara meluas dalam pembangunan Java. Dalam temu bual, saya meminta anda bercakap tentang prinsip pemasangan automatik Spring Boot Kami boleh menjawab ini:

fail.

@EnableAutoConfiguration anotasi digunakan untuk mendayakan automatik Untuk fungsi pemasangan, anotasi ini biasanya diletakkan pada kelas utama aplikasi. @EnableAutoConfiguration注解是用来开启自动装配的功能，该注解通常放在应用的主类上。

spring.factories文件是一个位于META-INF目录下的配置文件，其中定义了各个自动装配类的全限定名。

当Spring Boot启动时，会加载classpath下的所有spring.factories文件，并根据其中定义的自动装配类的全限定名，将其实例化并添加到Spring应用上下文中。

自动装配类通常会通过@Configuration注解来标注，同时会使用各种注解（如@ComponentScan、@Import等）来实现相应的自动装配逻辑。

通过@EnableAutoConfiguration注解和spring.factories

Apabila Spring Boot bermula, ia akan memuatkan semua spring. fail kilang dan nyatakan serta tambahkannya pada konteks aplikasi Spring berdasarkan nama layak sepenuhnya bagi kelas berwayar automatik yang ditakrifkan di dalamnya.

Mengikut@EnableAutoConfiguration anotasi dan spring.factoriesfail, Spring Boot boleh Ketergantungan dan konfigurasi; maklumat secara automatik memuatkan dan mengkonfigurasi komponen yang sepadan, memudahkan konfigurasi aplikasi dan proses pembangunan.

Malah, selagi kita tahu cara menyesuaikan pemula, ia akan menjadi lebih mudah untuk menjawab soalan di atas.

• spring-boot-starter-web: pemula untuk membina aplikasi web, termasuk Spring MVC dan pelayan Tomcat. Ia menyediakan fungsi untuk mengendalikan permintaan dan respons HTTP.
• spring-boot-starter-data-jpa: pemula untuk berinteraksi dengan pangkalan data hubungan, termasuk Spring Data JPA dan Hibernate. Ia memudahkan interaksi dengan pangkalan data dan menyediakan operasi CRUD biasa.
• spring-boot-starter-security: Pemula untuk menambah ciri keselamatan, termasuk Spring Security dan OAuth2. Ia menyediakan pengesahan, kebenaran dan keupayaan konfigurasi keselamatan.
• spring-boot-starter-test: pemula untuk menulis ujian unit dan ujian penyepaduan, termasuk Ujian JUnit dan Spring. Ia menyediakan rangka kerja dan alatan ujian untuk memudahkan ujian unit dan ujian integrasi.
• spring-boot-starter-actuator: Pemula untuk memantau dan mengurus aplikasi, termasuk pemeriksaan kesihatan, pengumpulan penunjuk dan fungsi pengurusan jauh. Ia menyediakan fungsi untuk memantau status berjalan aplikasi.
• spring-starter-cache: pemula untuk menambah sokongan cache, termasuk Spring Cache dan Ehcache. Ia menyediakan keupayaan untuk cache data dan meningkatkan prestasi aplikasi.
• spring-boot-starter-data-redis: Pemula untuk berinteraksi dengan pangkalan data Redis, termasuk Spring Data Redis. Ia memudahkan interaksi dengan Redis dan menyediakan kaedah operasi biasa.
• spring-boot-starter-mail: pemula untuk menghantar e-mel, termasuk JavaMail dan Spring Mail. Ia menyediakan fungsi untuk menghantar e-mel.
• spring-boot-starter-log4j2: pemula untuk log menggunakan Log4j2. Ia menyediakan fungsi pengelogan untuk memudahkan penyahpepijatan dan pengesanan ralat.
• spring-boot-starter-thymeleaf: pemula untuk menggunakan enjin templat Thymeleaf. Ia menyediakan fungsi untuk pemaparan halaman menggunakan Thymeleaf.
• ......

Pemula ini boleh dipilih dan digunakan mengikut keperluan aplikasi Mereka menyediakan pelbagai fungsi dan kemudahan, memudahkan proses pembangunan dan konfigurasi aplikasi.

Anda akan dapati daripada penamaan: spring- <code style="font-size: 14px; padding: 2px 4px;border-radius: 4px;margin-right: 2px;margin-left: 2px;background-color: rgba(27 , 31, 35, 0.05);font-family : " operator mono consolas monaco menlo monospace break-all rgb>spring-boot- starter-xxx. spring-boot-starter开头的spring-boot-starter-xxx。

但，我们在项目中也简单过这样的：mybatis-spring-boot-starter

Sebenarnya, kami biasanya memanggil spring-boot-starter-xxx dibuat oleh rasmi musim bunga untuk kami, xxx -spring-boot-starterFormat ini dibuat oleh saya sendiri, ia hanyalah penamaan. spring-boot-starter-xxx是spring官方给咱们搞的，xxx-spring-boot-starter这种格式就是自己搞的，只是个命名而已。

我们为何不能自己也来搞个starter过过瘾呗，哈哈哈，开搞。

自定义starter

我们来搞一个redisson的starter。

第一步创建一个Spring Boot项目，命名为：redisson-spring-boot-starter。

其中，pom依赖重点：

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter</artifactId>
        <version>2.3.1.RELEASE</version>
        <!-- 不让jar进行传递 避免jar包冲突-->
        <optional>true</optional>
    </dependency>
    <dependency>
        <groupId>org.redisson</groupId>
        <artifactId>redisson</artifactId>
        <version>3.13.1</version>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-configuration-processor</artifactId>
        <optional>true</optional>
    </dependency>
</dependencies>

创建配置解析类：RedissonProperties

/**
 * @author tianwc  公众号：java后端技术全栈、面试专栏
 * @version 1.0.0
 * @date 2023年07月20日 11:35
 * 在线刷题 1200+题和1000+篇干货文章：<a href="http://woaijava.cc/">博客地址</a>
 * 
 * 解析配置项
 */
@ConfigurationProperties(prefix = "tian.redisson")
public class RedissonProperties {

    private String host="localhost";
    private int port=6379;
    private int timeout;

    //get set 省略
}

自动装配类：RedissonAutoConfiguration

/**
 * @author tianwc  公众号：java后端技术全栈、面试专栏
 * @version 1.0.0
 * @date 2023年07月20日 11:27
 * 在线刷题 1200+题和1000+篇干货文章：<a href="http://woaijava.cc/">博客地址</a>
 */
//（条件装配）只有在我们的classpath目录下有Redisson.class 我们才自动装配RedissonClient bean
//@ConditionalOnClass(Redisson.class)
@EnableConfigurationProperties(RedissonProperties.class)
@Configuration
public class RedissonAutoConfiguration {
    private static final String PREFIX="redis://";
    @Bean
    public RedissonClient redissonClient(RedissonProperties redissonProperties){
        Config config=new Config();
        //redis单机模式
        config.useSingleServer().setAddress(PREFIX+redissonProperties.getHost()+":"+redissonProperties.getPort())
                .setConnectTimeout(redissonProperties.getTimeout());
        return Redisson.create(config);
    }
}

然后，在resources目录下创建：META-INF目录，在这个目录下创建spring.factories文件，文件内容：

org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
  com.tian.RedissonAutoConfiguration

完事，这么就搞定了。是不是还没缓过神来？

使用自定义starter

再创建个spring Boot项目，把我们自定义的starter引入进来。

<dependency>
    <groupId>com.tian</groupId>
    <artifactId>charge-sms-spring-boot-starter</artifactId>
    <version>1.0-SNAPSHOT</version>
</dependency>

由于我们在RedissonProperties

Pemula tersuai

Antaranya, perkara utama pergantungan pom:

tian.redisson.host=localhost
tian.redisson.port=6379
tian.redisson.timeout=1000

Buat kelas parsing konfigurasi: RedissonProperties

{
  "properties": [
    {
      "name": "tian.redisson.host",
      "type": "java.lang.String",
      "description": "redis服务地址ip",
      "defaultValue": "localhost"
    },
    {
      "name": "tian.redisson.port",
      "type": "java.lang.Integer",
      "description": "redis服务端口号",
      "defaultValue": 6379
    },
    {
      "name": "tian.redisson.timeout",
      "type": "java.lang.Integer",
      "description": "redis连接超时时间",
      "defaultValue": 1000
    }
  ]
}

@Slf4j
@RestController
@RequestMapping("/test")
public class TestController {

    @Resource
    private RedissonClient redissonClient; 

    @GetMapping("/redisson")
    public String redisson() {
        RBucket bucket = redissonClient.getBucket("name");
        if(bucket.get()==null){
            bucket.set("公众号：java后端技术全栈");
        } 
        return bucket.get().toString();
    }
}

Gunakan pemula tersuai

要想有这个提示，还得在redisson-spring-boot-starter中搞点事情。

相关jar上面都已经引入了这里不再赘述。

同样是在META-INF下面创建一个文件(文件名需要注意不要写错)：additional-spring-configuration-metadata.json

内容如下：

{
  "properties": [
    {
      "name": "tian.redisson.host",
      "type": "java.lang.String",
      "description": "redis服务地址ip",
      "defaultValue": "localhost"
    },
    {
      "name": "tian.redisson.port",
      "type": "java.lang.Integer",
      "description": "redis服务端口号",
      "defaultValue": 6379
    },
    {
      "name": "tian.redisson.timeout",
      "type": "java.lang.Integer",
      "description": "redis连接超时时间",
      "defaultValue": 1000
    }
  ]
}

properties对应一个数组，每个配置项占一个。

• name：就是我们的配置项
• type：配置项类型
• description：配置项的描述
• defaultValue：默认值

重新打包，在使用的项目里执行Reload All Maven。

接着，再去properties文件里配置，就会有对应的提示了。

我们写一个controller来使用：

@Slf4j
@RestController
@RequestMapping("/test")
public class TestController {

    @Resource
    private RedissonClient redissonClient; 

    @GetMapping("/redisson")
    public String redisson() {
        RBucket bucket = redissonClient.getBucket("name");
        if(bucket.get()==null){
            bucket.set("公众号：java后端技术全栈");
        } 
        return bucket.get().toString();
    }
}

执行结果：

到这里，我们就搞定了一个自定义starter。

在实际项目中，在自定义starter时，可能还会用到下面这些注解，请注意收藏：

@Conditional: Mengikut syarat tertentu Buat pertimbangan dan daftarkan kacang ke dalam bekas jika syarat dipenuhi@Conditional：按照一定的条件进行判断，满足条件给容器注册bean

@ConditionalOnMissingBean：给定的在bean不存在时,则实例化当前Bean

@ConditionalOnProperty：配置文件中满足定义的属性则创建bean，否则不创建

@ConditionalOnBean：给定的在bean存在时,则实例化当前Bean

@ConditionalOnClass：当给定的类名在类路径上存在，则实例化当前Bean

@ConditionalOnMissingClass

@ConditionalOnMissingBean : Apabila kacang yang diberikan tidak wujud, nyatakan Bean semasa

@ConditionalOnProperty: Jika sifat yang ditentukan dalam fail konfigurasi dipenuhi, kacang akan dibuat, jika tidak, ia tidak akan dibuat@ConditionalOnBean: Apabila kacang yang diberikan wujud, nyatakan Bean semasa

@ConditionalOnClass: Apabila nama kelas yang diberikan wujud pada laluan kelas, nyatakan Bean semasa

@ConditionalOnMissingClass : Apabila diberi Nama kelas tidak wujud pada laluan kelas, kemudian nyatakan Bean semasa