Configuration de l'application Spring à l'aide de XML et d'annotation Java

Dans cet article, nous apprendrons à en ajouter Code d'annotation Java avec XML Pour faire un mélange parfait des deux en minimisant le code XML. C'est une bonne approche si vous ne souhaitez pas utiliser plus XML dans votre code et pour la structure de printemps moderne. La plupart n'aiment pas utiliser XML. Ils préfèrent plutôt utiliser des annotations java. Voyons comment faire cela d'une manière étape par étape.

Qu'est-ce que l'annotation Java

Les annotations Java sont le balisage qui est utilisé pour fournir des métadonnées sur la classe. Par exemple, @Haricot L'annotation est utilisée pour spécifier que la classe est une classe de bean, pas une classe Java ordinaire.

Processus d'annotations Java à un moment de compilation, ou un temps d'exécution, pour un traitement spécial.

Vous connaissez peut-être une annotation commune, @Passer outre, Cela indique au compilateur que cette méthode est une méthode remplacée. Il est vérifié par le compilateur et le compilateur soulève le problème si cela ne correspond pas dans le cas.

Pourquoi les annotations pour les configurations de printemps

Imaginez que vous travaillez sur un grand projet qui a plus de 100 haricots. Pour les configurer, vous utilisez le XML complexe qui nécessite plus de code.

Alors que pour configurer un haricot, il vous suffit de mettre l'annotation @component à la classe, et tout est fait. Il n'est pas nécessaire d'utiliser XML.

Lorsque nous utilisons une annotation, le ressort de fond scanne les classes pour les annotations et enregistre automatiquement les haricots dans le conteneur à ressort. Ainsi, le printemps fait beaucoup de travail automatiquement et réduit le temps et les efforts du développeur.

Passons au processus de développement et commençons à créer une application de printemps en utilisant les annotations Java et le code XML.

Pour en savoir plus sur la configuration XML, vous pouvez vous référer à notre article détaillé ici Configuration de la configuration basée sur Spring XML

Processus de développement

Commençons par créer un projet maven. Ensuite, ajoutez les dépendances du noyau de ressort et du contexte au POM.fichier xml. Ici, nous expliquerons le concept.

Créer Java Bean

Après avoir créé un projet, créez d'abord une classe Java Bean Employé et placer cela dans com.linuxhint.paquet de haricots. Ajoutez deux variables ID et nom et créez ses méthodes Getters et Setters.

Marquez cette classe comme composant en ajoutant l'annotation @Component. Le code source de la classe des employés ressemble à ceci:

// Employé.Java
package com.linuxhint.haricots;
org d'importation.springframework.stéréotype.Composant;
@Component ("EMP")
Employé de classe publique
INT PRIVÉ ID;
nom de chaîne privé;
public String getName ()
nom de retour;

public void setName (nom de chaîne)
ce.name = name;

public int getID ()
Retour ID;

public void setid (int id)
ce.id = id;

Créer un contexte d'application

Maintenant, créez un applicationContext.Fichier XML pour configurer les grains. Ici, nous utiliserons le Tag pour spécifier le package de base à partir de l'endroit où le ressort scanne et trouvera la classe de bean.

Remarque, nous n'utiliserons pas le étiqueter plus pour configurer le haricot plutôt le Tag et le @Composant l'annotation fera notre tâche automatiquement.

Notre applicationContext.xml Le fichier ressemble à ceci:

xmlns: xsi = "http: // www.W3.org / 2001 / xmlschema-instance "
xmlns: context = "http: // www.springframework.org / schéma / contexte "
XSI: ScheMalation = "http: // www.springframework.org / schéma / beans http: // www.springframework.org / schéma / haricots / barines de printemps.xsd http: // www.springframework.org / schéma / contexte http: // www.springframework.org / schéma / contexte / printemps-contexte.xsd ">

Créer une classe principale

Ceci est la classe principale où nous obtenons l'objet bean en utilisant le getbean () méthode. Nous avons utilisé le Getter et le secteur du bean pour définir et obtenir une propriété.

package com.Linuxhint;
org d'importation.springframework.contexte.ApplicationContext;
org d'importation.springframework.contexte.soutien.ClassPathxMlApplicationContext;
Importer com.linuxhint.haricots.Employé;
classe publique SpringApp
public static void main (String [] args)
ApplicationContext ac = new ClassPathXMlApplicationContext ("ApplicationContext.xml ");
Employé EMP = (employé) AC.getbean ("EMP");
empiler.setName ("Rohan");
Nom de la chaîne = Emp.getName ();
Système.dehors.println ("name:" + name);

Dépendances du projet

Et enfin, assurez-vous que vous avez toutes ces dépendances dans le projet et mettez à jour le Maven pour obtenir les derniers pots.

// pom.xml

4.0.0
com.linuxhint
Springapp
0.0.1 snapshot
Springapp
Une application de printemps simple


org.springframework
printemps
$ printemps.version


org.springframework
contexte de printemps
$ printemps.version



5.2.8.LIBÉRER

Après avoir ajouté tous les fichiers. La structure du projet ressemble à ce qui suit:

Exécuter l'application

Maintenant, exécutez l'application, en faisant un clic droit sur le projet et sélectionnez: Exécuter comme -> Application Java

Cela produira la sortie suivante à la fenêtre de la console.

Conclusion

Dans cet article, nous avons appris à configurer une application Spring en utilisant des annotations et XML. Le XML est un moyen plus ancien de configurer une application Spring alors que de nos jours, les développeurs préfèrent utiliser des annotations. Par cet article, vous pouvez apprendre à configurer en mélangeant les deux (XML et annotations).