Spring Boot est un framework permettant de créer des applications Java autonomes basées sur le framework Spring. Il fournit un certain nombre d'annotations pour configurer et personnaliser le comportement de l'application. Voici une analyse de certaines annotations de bas niveau Spring Boot courantes :
Analyse des annotations courantes du bas de la botte à ressort
@SpringBootApplication: Il s'agit d'une annotation composite utilisée pour marquer une classe d'application Spring Boot principale. Il comprend@Configuration,@EnableAutoConfigurationet@ComponentScantrois annotations pour activer la configuration automatique, l'analyse des composants et la définition des classes de configuration.
@SpringBootApplication
public class MyApp {
public static void main(String[] args) {
SpringApplication.run(MyApp.class, args);
}
}
@Configuration: Utilisé pour marquer une classe comme une classe de configuration, indiquant qu'elle contient une ou plusieurs@Beanméthodes d'annotation utilisées pour définir la configuration de l'application.
@Configuration
public class AppConfig {
@Bean
public MyService myService() {
return new MyServiceImpl();
}
}
@EnableAutoConfiguration: Utilisé pour activer le mécanisme de configuration automatique de Spring Boot. Il configure automatiquement diverses fonctionnalités de l'application en fonction des dépendances sur le chemin de classe et d'autres conditions.
@EnableAutoConfiguration
public class MyApp {
// ...
}
@ComponentScan: Il est utilisé pour spécifier le package à analyser par le conteneur Spring pour rechercher des classes avec des annotations telles que@Component,@Service,@Repositoryetc., et les enregistrer en tant que beans Spring.
@ComponentScan("com.example")
public class MyApp {
// ...
}
@RestController: Utilisé pour marquer une classe, indiquant qu'il s'agit d'un contrôleur de style RESTful. Il combine@Controlleret@ResponseBodyannotations, de sorte que les méthodes de la classe puissent renvoyer directement le contenu de la réponse.
@RestController
public class MyController {
@RequestMapping("/hello")
public String hello() {
return "Hello, World!";
}
}
@RequestMapping: utilisé pour mapper une méthode à un chemin d'URL spécifié. Il peut être utilisé au niveau de la classe et au niveau de la méthode pour définir la méthode de traitement des requêtes du contrôleur.
@RestController
@RequestMapping("/api")
public class MyController {
@GetMapping("/hello")
public String hello() {
return "Hello, World!";
}
}
Ce qui précède est l'analyse de certaines annotations de bas niveau Spring Boot courantes. Ces annotations peuvent aider les développeurs à configurer et à personnaliser plus facilement le comportement des applications Spring Boot.
L'annotation Spring Boot complète l'API RESTful
Voici un exemple simple qui montre comment utiliser les annotations Spring Boot pour compléter une API RESTful simple.
Commencez par créer un projet Spring Boot et ajoutez les dépendances suivantes au pom.xmlfichier :
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
</dependencies>
Ensuite, créez une UserControllerclasse de contrôleur appelée et marquez-la avec @RestControllerdes annotations :@RequestMapping
@RestController
@RequestMapping("/api/users")
public class UserController {
private List<User> users = new ArrayList<>();
@GetMapping
public List<User> getUsers() {
return users;
}
@PostMapping
public User createUser(@RequestBody User user) {
users.add(user);
return user;
}
}
Dans l'exemple ci-dessus, UserControllerla classe définit deux méthodes. getUsers()La méthode @GetMappingle mappe à /api/usersun chemin à l'aide d'annotations et renvoie une liste avec tous les utilisateurs. createUser()utilise @PostMappingdes annotations pour le mapper sur le même chemin, accepte un Userobjet comme corps de la requête et l'ajoute à la liste des utilisateurs.
Ensuite, créez une Userclasse Java simple appelée , qui représente l'objet utilisateur :
public class User {
private String name;
private int age;
// 省略构造函数、getter和setter方法
}
Enfin, dans la classe d'entrée de l'application, marquez-la avec @SpringBootApplicationl'annotation et ajoutez une main()méthode pour démarrer l'application :
@SpringBootApplication
public class MyApp {
public static void main(String[] args) {
SpringApplication.run(MyApp.class, args);
}
}
Maintenant, exécutez l'application et utilisez n'importe quel client HTTP tel que Postman pour tester l'API. Vous pouvez utiliser l'accès aux requêtes GET http://localhost:8080/api/userspour obtenir une liste de tous les utilisateurs, utiliser l'accès aux requêtes POST http://localhost:8080/api/userset ajouter un objet JSON dans le corps de la requête pour créer un nouvel utilisateur.
Cet exemple montre comment créer une API RESTful simple à l'aide des annotations Spring Boot. En utilisant des annotations, vous pouvez facilement définir des méthodes de traitement des demandes et des mappages de routage, ce qui simplifie le processus de développement.
Exemples complets d'autres annotations courantes
Voici un exemple complet démontrant l'utilisation des annotations couramment utilisées dans Spring Boot :
package com.example.demo;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;
import org.springframework.web.bind.annotation.*;
import java.util.ArrayList;
import java.util.List;
@SpringBootApplication
public class DemoApplication {
public static void main(String[] args) {
SpringApplication.run(DemoApplication.class, args);
}
@RestController
@RequestMapping("/api/users")
public class UserController {
private List<User> users = new ArrayList<>();
@GetMapping
public List<User> getUsers() {
return users;
}
@PostMapping
public User createUser(@RequestBody User user) {
users.add(user);
return user;
}
}
public class User {
private String name;
private int age;
public User() {
}
public User(String name, int age) {
this.name = name;
this.age = age;
}
// 省略getter和setter方法
}
@Configuration
public class AppConfig {
@Bean
public MyService myService() {
return new MyServiceImpl();
}
}
public interface MyService {
String getMessage();
}
public class MyServiceImpl implements MyService {
@Override
public String getMessage() {
return "Hello, World!";
}
}
}
Dans l'exemple ci-dessus, nous avons défini une DemoApplicationclasse et @SpringBootApplicationl'avons marquée avec une annotation comme point d'entrée de l'application Spring Boot.
Dans DemoApplicationles classes, nous définissons une UserControllerclasse et la marquons comme un contrôleur RESTful en utilisant @RestControlleret des annotations. La méthode de la classe prend l'annotation, la mappe à un chemin et renvoie une liste d'utilisateurs. La méthode utilise l'annotation, la mappe sur le même chemin, accepte un objet comme corps de la requête et l'ajoute à la liste des utilisateurs.@RequestMappingUserControllergetUsers()@GetMapping/api/userscreateUser()@PostMappingUser
Nous définissons également une Userclasse pour représenter l'objet utilisateur.
Dans DemoApplicationla classe, nous définissons également une AppConfigclasse et @Configurationla marquons comme une classe de configuration à l'aide d'une annotation. Dans AppConfigla classe, nous @Beandéfinissons une myService()méthode à l'aide de l'annotation, qui renvoie un MyServiceImplobjet. De cette manière, MyServiceImplla classe sera enregistrée en tant que Spring Bean.
Enfin, nous définissons une MyServiceinterface et une MyServiceImplclasse pour démontrer l'injection de dépendances et l'enregistrement de bean.
En exécutant l'exemple ci-dessus, nous pouvons accéder http://localhost:8080/api/userspour obtenir une liste d'utilisateurs et créer un nouvel utilisateur en utilisant une requête POST sur le même chemin.
Cet exemple illustre l'utilisation d'annotations courantes dans Spring Boot. En utilisant ces annotations, nous pouvons facilement créer une API RESTful, configurer des beans et implémenter l'injection de dépendances.