Comment personnaliser une entrée, vous en avez marre de l'apprendre ?
- Java后端技术全栈avant
- 2023-08-15 16:02:061219parcourir
Il y a deux jours, un ami a de nouveau été interrogé sur le starter lors d'un entretien. Lorsque je faisais une simulation d'interview pour lui, j'ai délibérément souligné que devais écrire moi-même une entrée personnalisée, et bien sûr, on lui a posé des questions à ce sujet pendant l'interview.
Peut-être que certaines personnes n'ont pas fait l'expérience de Servlet à Spring MVC. Si vous l'avez expérimenté, vous saurez que la configuration est assez lourde, donc Spring Boot n'est pas inclus.
Les amis qui ont étudié Spring Boot devraient savoir qu'il existe un dicton pour décrire Spring Boot : La convention est supérieure à la configuration.
Pourquoi Spring Boot est-il appelé convention plutôt que configuration ?
La raison pour laquelle Spring Boot est appelé « convention sur configuration » est qu'il adopte le concept de conception de convention sur configuration. Le développement Java traditionnel nécessite une grande quantité de configuration, telle que des fichiers XML, des annotations, etc., et ces configurations doivent être spécifiées par les développeurs eux-mêmes. Spring Boot simplifie le processus de développement en fournissant certaines configurations et conventions par défaut, réduisant ainsi la quantité de travail de configuration manuelle que les développeurs doivent effectuer.
Spring Boot effectue automatiquement certaines tâches de configuration courantes via certaines propriétés et conventions de configuration par défaut, telles que la configuration automatique des sources de données, la configuration automatique des serveurs Web, la configuration automatique des journaux, etc. Les développeurs n'ont qu'à organiser le code et les fichiers de configuration d'une manière convenue pour créer rapidement une application fonctionnelle.
Ce concept de conception de convention sur la configuration permet aux développeurs de ne plus avoir besoin de prêter attention à certains détails de configuration conventionnels et de se concentrer davantage sur la mise en œuvre de la logique métier. Dans le même temps, Spring Boot fournit également des options de configuration extensibles, permettant aux développeurs de personnaliser et de développer en fonction de leurs propres besoins.
En général, le concept de conception de Spring Boot en matière de convention sur la configuration permet aux développeurs de développer des applications plus rapidement et plus efficacement, et réduit la complexité de la configuration. C'est également la raison pour laquelle Spring Boot peut devenir l'un des frameworks les plus utilisés dans le développement Java.
Dans l'interview, je vous ai demandé de parler du principe d'assemblage automatique de Spring Boot. Nous pouvons simplement répondre à ceci :
Le principe d'assemblage automatique de Spring Boot est implémenté via
@EnableAutoConfiguration注解和spring.factoriesfichiers.
@EnableAutoConfigurationl'annotation est utilisée pour activer l'automatisation Pour les fonctions d'assemblage, cette annotation est généralement placée sur la classe principale de l'application.@EnableAutoConfiguration注解是用来开启自动装配的功能，该注解通常放在应用的主类上。
spring.factories文件是一个位于META-INF目录下的配置文件，其中定义了各个自动装配类的全限定名。当Spring Boot启动时，会加载classpath下的所有
spring.factories文件，并根据其中定义的自动装配类的全限定名，将其实例化并添加到Spring应用上下文中。自动装配类通常会通过
@Configuration注解来标注，同时会使用各种注解（如@ComponentScan、@Import等）来实现相应的自动装配逻辑。通过
@EnableAutoConfiguration注解和spring.factoriesspring.factoriesle fichier se trouve dans Le fichier de configuration dans le répertoire META-INF définit le nom complet de chaque classe d'assembly automatique.
Lorsque Spring Boot démarre, il chargera tous les @ConfigurationAnnotations sont utilisés pour marquer, et diverses annotations (telles que @ComponentScan , @Import etc. ) pour implémenter la logique d'assemblage automatique correspondante.
Par@EnableAutoConfiguration annotation et spring.factories fichier, Spring Boot peut Dépendances et configuration Les informations chargent et configurent automatiquement les composants correspondants, simplifiant ainsi le processus de configuration et de développement de l'application.
En fait, tant que nous saurons personnaliser une entrée, il sera beaucoup plus facile de répondre aux questions ci-dessus.
🎜🎜Lorsque nous utilisons Spring Boot pour développer, les plus courants sont divers starters. 🎜🎜Démarreurs courants🎜🎜Il existe de nombreux démarreurs couramment utilisés dans Spring Boot. Voici quelques démarreurs courants : 🎜spring-boot-starter-web : démarreur pour créer des applications Web, notamment Spring MVC et le serveur Tomcat. Il fournit des fonctionnalités pour gérer les requêtes et les réponses HTTP. spring-boot-starter-data-jpa : starter pour interagir avec les bases de données relationnelles, notamment Spring Data JPA et Hibernate. Il simplifie l'interaction avec la base de données et fournit des opérations CRUD courantes. spring-boot-starter-security : un démarreur pour ajouter des fonctionnalités de sécurité, notamment Spring Security et OAuth2. Il fournit des fonctionnalités d’authentification, d’autorisation et de configuration de sécurité. spring-boot-starter-test : starter pour l'écriture de tests unitaires et de tests d'intégration, notamment JUnit et Spring Test. Il fournit un cadre de test et des outils pour faciliter les tests unitaires et les tests d'intégration. spring-boot-starter-actuator : un démarreur pour la surveillance et la gestion des applications, y compris les fonctions de vérification de l'état, de collecte d'indicateurs et de gestion à distance. Il fournit des fonctionnalités pour surveiller l’état d’exécution des applications. spring-starter-cache : starter pour ajouter la prise en charge du cache, notamment Spring Cache et Ehcache. Il offre la possibilité de mettre en cache les données et d'améliorer les performances des applications. spring-boot-starter-data-redis : Un démarreur pour interagir avec les bases de données Redis, y compris Spring Data Redis. Il simplifie l'interaction avec Redis et fournit des méthodes de fonctionnement courantes. spring-boot-starter-mail : starter pour l'envoi d'emails, notamment JavaMail et Spring Mail. Il fournit des fonctionnalités pour l'envoi d'e-mails. spring-boot-starter-log4j2 : démarreur pour la journalisation à l'aide de Log4j2. Il fournit une fonctionnalité de journalisation pour faciliter le débogage et le suivi des erreurs. spring-boot-starter-thymeleaf : starter pour utiliser le moteur de template Thymeleaf. Il fournit des fonctionnalités pour le rendu des pages à l'aide de Thymeleaf. ......
Ces démarreurs peuvent être sélectionnés et utilisés en fonction des besoins de l'application. Ils offrent diverses fonctions et commodités, simplifiant le processus de développement et de configuration de l'application.
Vous trouverez dans le nom : 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
mybatis-spring-boot-starter n'est pas la méthode de dénomination ci-dessus. 🎜En fait, nous appelons généralement spring-boot-starter-xxx est créé par Spring Official pour nous, xxx -spring-boot-starterCe format est créé par moi-même, c'est juste un nom. 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
Démarreur personnalisé
us Commençons une entrée de rédisson. La première étape consiste à créer un projet Spring Boot, nommé :redisson-spring-boot-starter. 
Parmi eux, les points clés de la dépendance pom :
tian.redisson.host=localhost tian.redisson.port=6379 tian.redisson.timeout=1000
Créer une classe d'analyse de configuration : 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
}
]
}🎜Classe de câblage automatique : RedissonAutoConfiguration🎜@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();
}
}🎜Ensuite, créez : le répertoire META-INF dans le répertoire des ressources, créez spring.factories fichier, contenu du fichier : 🎜rrreee🎜C'est fait, c'est tout. Vous n'avez pas encore récupéré ? 🎜Utiliser un démarreur personnalisé
🎜 Créez-en un autre projet Spring Boot et présentez notre démarreur personnalisé. 🎜rrreee🎜Puisque nous utilisons 35, 0,05);famille de polices : "Operator Mono", Consolas, Monaco, Menlo, monospace;saut de mot : break-all;couleur : rgb(239, 112, 96);"> Classe RedissonProperties Les valeurs par défaut sont attribuées à l'hôte et au port, donc lorsque nous ne configurons aucun paramètre dans le fichier application.properties, nous utilisons les valeurs par défaut. 🎜🎜S'il est configuré, c'est comme suit :🎜rrreee🎜Cependant, lorsque vous jouez vraiment comme ça, vous constaterez que lorsque nous configurons habituellement quelque chose, nous le demanderons essentiellement, comme : 🎜🎜🎜🎜🎜N'est-ce pas assez rapide ? 🎜要想有这个提示，还得在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: Selon certaines conditions Faites un jugement et enregistrez le bean dans le conteneur si les conditions sont remplies@Conditional：按照一定的条件进行判断，满足条件给容器注册bean
@ConditionalOnMissingBean：给定的在bean不存在时,则实例化当前Bean
@ConditionalOnProperty：配置文件中满足定义的属性则创建bean，否则不创建
@ConditionalOnBean：给定的在bean存在时,则实例化当前Bean
@ConditionalOnClass：当给定的类名在类路径上存在，则实例化当前Bean
@ConditionalOnMissingClass@ConditionalOnMissingBean: Lorsque le bean donné n'existe pas, instanciez le Bean actuel
@ConditionalOnProperty : Si les propriétés définies dans le fichier de configuration sont remplies, le bean sera créé, sinon il ne sera pas créé@ConditionalOnBean : Lorsque le bean donné existe, instanciez le Bean actuel
@ConditionalOnClass : lorsque le nom de classe donné existe sur le chemin de classe, instanciez le Bean actuel
@ConditionalOnMissingClass : Une fois donné, le nom de la classe n'existe pas sur le chemin de la classe, alors instanciez le Bean actuel
Nous venons de créer une version autonome ci-dessus. En fait, nous pouvons également créer différentes versions de maître-esclave, sentinelle, cluster, etc., ou nous pouvons créer un accès SSL. Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!