Spring est un framework Java qui utilise un conteneur pour créer et gérer les différents composants d'une application. Le conteneur (souvent appelé contexte d'application Spring) connecte les différents composants d'une application à l'aide du modèle de conception d'injection de dépendance (DI). DI vous permet d'utiliser un objet dans une classe dépendante, sans en créer une nouvelle instance dans la classe dépendante.
Ainsi, plutôt que de permettre à chaque composant de créer de nouvelles instances de ceux sur lesquels il s'appuie, le conteneur de Spring crée et gère une instance de chacun des composants qu'il héberge. Ce conteneur injecte ensuite une instance d'un composant dans tous les autres composants qui en ont besoin.
Explorer les fonctionnalités principales de Spring
Le framework Spring compte environ 20 modules bien organisés qui jouent un rôle essentiel dans sa capacité à créer et à gérer des applications. En fonction des fonctionnalités principales de ces modules, vous pouvez les regrouper en cinq catégories :
- Conteneur principal
- Accès aux données/intégration
- la toile
- Programmation et instrumentation orientées aspect
- Test
Conteneur de printemps
Spring utilise un conteneur pour créer et gérer différents composants (appelés beans) d'une application. Le conteneur est accessible via l'interface ApplicationContext de Spring, qui vous permet d'instancier, de configurer et d'assembler des objets (ou beans). Le conteneur de Spring peut remplir sa fonction grâce à l'aide des métadonnées de configuration.
Ces métadonnées de configuration peuvent avoir plusieurs formes différentes, mais leur forme typique est XML. En plus des beans, le conteneur de Spring se compose également d'un noyau, d'un contexte et d'un module d'expression.
Accès/intégration des données Spring
L'aspect accès/intégration des données du framework Spring se compose de plusieurs sous-modules: JDBC, ORM, OXM, JMS et transaction. Ces modules fonctionnent ensemble pour gérer toutes les données utilisées par votre application.
Toile de printemps
La fonctionnalité Web de l'application Spring fournit une intégration orientée Web pour votre application. En plus de l'intégration orientée Web, Spring fournit un module de servlet Web. Le module de servlet Web est responsable de Spring Implémentation modèle-vue-contrôleur (MVC).
Programmation orientée aspect Spring (AOP)
Le cadre AOP de Spring est un autre de ses composants clés. Bien que le framework AOP ne soit pas crucial pour la fonction de conteneur de Spring, il complète le conteneur en étant une solution middleware performante. L'une des principales caractéristiques du framework AOP est qu'il fournit des services d'entreprise déclaratifs pour votre application, à savoir la gestion des transactions de déclaration.
La gestion déclarative des transactions est une approche souhaitable pour le développement de logiciels car elle a un impact minimal sur le code d'application.
Essai de printemps
Spring accorde une grande importance aux tests d'applications. Son module de test prend en charge les tests d'intégration et les tests unitaires à l'aide de JUnit ou de TestNG.
Création d'une application de printemps
Il existe plusieurs façons de créer le passe-partout pour une nouvelle application Spring. Les différentes approches comprennent :
- Depuis l'application Web (ou Spring Initializr) sur le site officiel de Spring.
- Création manuelle d'une structure de répertoires de projet et de spécifications de construction.
- Avec la suite d'outils Spring.
- À partir de la ligne de commande avec l'interface de ligne de commande Spring Boot.
- Avec l'IDE Eclipse.
- Avec l'IDE IntelliJ IDEA.
L'approche la plus populaire est Spring Initializr :
Comme vous pouvez le voir sur l'image ci-dessus, vous aurez plusieurs décisions à prendre. Le premier est le type de projet que vous souhaitez initialiser. Spring propose trois options: Gradle pour Groovy, Gradle pour Kotlin ou Maven. Cet exemple d'application utilisera un projet Maven.
Les autres options que vous devez sélectionner sont la langue (Java), la version de Spring Boot que vous souhaitez utiliser et les métadonnées du projet. Spring contient déjà des données factices dans ses cinq champs qui vous aideront à créer un exemple d'application. Cependant, vous devrez mettre à jour ces champs avec des données spécifiques au projet, car ces métadonnées décriront votre application Spring, y compris les beans Spring et leurs méthodes.
Ensuite, vous devrez sélectionner l'emballage dans lequel vous voulez vos fichiers (jar ou war). Ensuite, vous pouvez sélectionner la version de Java que vous avez sur votre appareil. La décision finale que vous devrez prendre est le type de dépendances que vous souhaitez pour votre application.
Spring fournit plusieurs dépendances que vous pouvez utiliser pour ajouter des propriétés à votre application. Pour ajouter une nouvelle dépendance à votre application, cliquez simplement sur le bouton Ajouter des dépendances à droite de Spring Initializr. Cette action générera la superposition suivante sur votre écran :
Pour cet exemple d'application, la seule dépendance dont vous aurez besoin est Spring Web. Cette dépendance vous permet de créer des applications Web à l'aide de l'architecture MVC. Après avoir sélectionné toutes les dépendances que vous souhaitez utiliser dans votre application, cliquez sur Générer. Cela téléchargera le passe-partout du projet pour vous.
Vous avez maintenant un projet Spring Boot (qui est l'une des bibliothèques de Spring). La dernière étape consiste à importer le projet dans votre IDE préféré. Votre projet Spring aura la structure de projet suivante :
Il s'agit d'une structure de projet Maven normale, et vous devez vous familiariser avec plusieurs fichiers importants.
- Pom.xml: contient les données de configuration de l'application Spring.
- OnlineShopaholicsApplication.java: Il s'agit de la classe principale Spring Boot, qui exécute l'application.
- OnlineShopaholicsApplicationTest.java: Il s'agit d'un Test JUnit classe qui garantit que le contexte d'application Spring (ou conteneur) se charge correctement.
Exécuter une application Spring
La classe bootstrap de Spring, qui dans ce cas est la classe OnlineShopaholicsApplication, a le code initial suivant :
emballer com.onlineshopaholics ;importerorg.springframework.botte.SpringApplication;
importerorg.springframework.botte.autoconfigure.SpringBootApplication;
@SpringBootApplication
publicclasseOnlineShopaholicsApplication{
publicstatiqueannulerprincipal(Chaîne [] arguments){
SpringApplication.run (application OnlineShopaholics.classe, arguments);
}
}
L'un des aspects les plus importants du code ci-dessus est le @SpringBootApplication annotation, qui est une annotation composite qui permet à votre application d'accéder aux fonctionnalités de trois autres annotations :
- @EnableAutoconfiguration: cette annotation active la configuration automatique de Spring Boot. Cela signifie qu'il indique à Spring boot de configurer tout composant dont il pense que votre application aura besoin pour fonctionner.
- @ComponentScan: cette annotation vous permet d'activer l'analyse des composants. Cette fonctionnalité est importante, elle permet à Spring de découvrir et d'enregistrer automatiquement d'autres composants annotés à utiliser par le contexte d'application Spring (ou conteneur).
- @SpringBootConfiguration: il s'agit d'une forme spécialisée de l'annotation @Configureation, qui vous permet d'enregistrer des beans (ou des objets) dans le contexte de l'application Spring.
L'autre aspect important du code ci-dessus est le principal() méthode, il exécute votre application. Lorsque l'application s'exécute maintenant, elle démarre simplement le serveur. Donc, si vous souhaitez ajouter plus de fonctionnalités à l'application, vous devrez mettre à jour le code :
emballer com.onlineshopaholics ;importerorg.springframework.botte.SpringApplication;
importerorg.springframework.botte.autoconfigure.SpringBootApplication;
importerorg.springframework.la toile.lier.annotation.GetMapping;
importerorg.springframework.la toile.lier.annotation.RequestParam;
importerorg.springframework.la toile.lier.annotation.RestController;@SpringBootApplication
@RestController
publicclasseOnlineShopaholicsApplication{
publicstatiqueannulerprincipal(Chaîne [] arguments){
SpringApplication.run (application OnlineShopaholics.classe, arguments);
}
@GetMapping("/client")
public Chaîne Bienvenue(@RequestParam (valeur = "nom", valeur par défaut = "Client") Chaîne nom) {
retourChaîne.format("Bienvenue %s !", nom);
}
}
L'application Spring Boot dispose désormais de trois nouvelles annotations :
- @RestController: cette annotation marque la classe en tant que contrôleur, de sorte que chaque méthode de la classe ci-dessus (à l'exception de main()) renverra un objet de domaine au lieu d'une vue.
- @GetMapping: cette annotation mappe les requêtes HTTP GET sur des méthodes d'en-tête spécifiques. Ainsi, chaque fois que vous créez une requête pour "/customer" dans le navigateur, la méthode Welcome() gère la requête en renvoyant une valeur de chaîne.
- @RequestParam: cette annotation indique qu'un paramètre de méthode doit être lié à un paramètre de requête Web.
Avec le code mis à jour, votre Spring OnlineShopaholicsApplication a maintenant une page client que vous pouvez afficher dans votre navigateur. L'exécution de l'application démarrera le serveur et produira une sortie dans la console.
Il y a beaucoup d'informations importantes dans la sortie. Il vous indique que le serveur est en cours d'exécution, il vous indique combien de temps le processus d'initialisation a pris et il vous indique sur quel port l'application s'exécute (8080, par défaut). Par conséquent, si vous naviguez vers http://localhost: 8080/client vous verrez la sortie suivante dans votre navigateur :
Vous pouvez maintenant concevoir votre vue d'application
Un autre fichier important dans la structure du projet que vous remarquerez peut-être est le fichier modèles dossier. Idéalement, le OnlineShopaholicsApplication La classe doit servir de contrôleur, qui gère les demandes de différentes vues. Par conséquent, dans une application complète, la classe contrôleur ne doit pas contenir le texte qui s'affichera dans la vue de sa requête.
Au lieu de cela, vous devrez créer des fichiers de modèle en utilisant HTML et les placer dans le dossier des modèles de votre application Spring.