Annotations Spring

Les annotations Spring nous permettent de configurer les dépendances et de mettre en œuvre l’injection de dépendances à travers des programmes Java.

Les annotations Spring

• Le framework Spring met en œuvre et promeut le principe d’inversion de contrôle (IoC) ou l’injection de dépendances (DI) et est en fait un conteneur IoC.
• Traditionnellement, Spring permet à un développeur de gérer les dépendances des beans en utilisant une configuration basée sur XML.
• Il existe une autre manière de définir les beans et leurs dépendances. Cette méthode est une configuration basée sur Java.
• Contrairement à l’approche XML, la configuration basée sur Java vous permet de gérer les composants de bean de manière programmatique. C’est pourquoi les annotations Spring ont été introduites.

Dans cet article, nous explorerons les annotations Spring les plus couramment utilisées et examinerons également un exemple de programme.

Liste des annotations Spring

Certaines des annotations principales du framework Spring sont :

1. @Configuration : Utilisé pour indiquer qu’une classe déclare une ou plusieurs méthodes @Bean. Ces classes sont traitées par le conteneur Spring pour générer des définitions de beans et des demandes de service pour ces beans à l’exécution.

2. @Bean: Indique qu’une méthode produit un bean à gérer par le conteneur Spring. Il s’agit de l’une des annotations Spring les plus utilisées et importantes. L’annotation @Bean peut également être utilisée avec des paramètres tels que le nom, initMethod et destroyMethod.

   • name – vous permet de donner un nom au bean
   • initMethod – vous permet de choisir la méthode qui sera invoquée lors de l’enregistrement du contexte
   • destroyMethod – vous permet de choisir la méthode qui sera invoquée lors de la fermeture du contexte

   Par exemple:

   @Configuration
   public class AppConfig {
   
       @Bean(name = "comp", initMethod = "turnOn", destroyMethod = "turnOff")
       Computer computer(){
           return new Computer();
       }
   }
   

   public class Computer {
   
       public void turnOn(){
           System.out.println("Chargement du système d'exploitation");
       }
       public void turnOff(){
           System.out.println("Fermeture de tous les programmes");
       }
   }
   

3. @PreDestroy et @PostConstruct sont des moyens alternatifs pour initMethod et destroyMethod de bean. Cela peut être utilisé lorsque la classe du bean est définie par nous. Par exemple;

    public class Computer {
   
       @PostConstruct
       public void turnOn(){
           System.out.println("Charger le système d'exploitation");
       }
   
       @PreDestroy
       public void turnOff(){
           System.out.println("Fermer tous les programmes");
       }
   }
   

4. @ComponentScan: Configure les directives de balayage des composants à utiliser avec @Configuration classes. Ici, nous pouvons spécifier les packages de base à analyser pour les composants spring.

5. @Component: Indique qu’une classe annotée est un « composant ». De telles classes sont considérées comme des candidats à la détection automatique lors de l’utilisation de la configuration basée sur des annotations et de l’analyse du classpath.

6. @PropertySource: fournit un mécanisme déclaratif simple pour ajouter une source de propriété à l’environnement de Spring. Il existe une annotation similaire pour ajouter un tableau de fichiers de source de propriété, c’est-à-dire @PropertySources.

7. @Service: Indique qu’une classe annotée est un « Service ». Cette annotation sert de spécialisation de @Component, permettant aux classes d’implémentation d’être détectées automatiquement grâce à l’analyse du classpath.

8. @Repository: Indique qu’une classe annotée est un « Repository ». Cette annotation sert de spécialisation de @Component et il est recommandé de l’utiliser avec les classes DAO.

9. @Autowired: L’annotation Spring @Autowired est utilisée pour l’injection automatique de beans. L’annotation @Qualifier de Spring est utilisée en conjonction avec Autowired pour éviter les confusions lorsque nous avons deux ou plusieurs beans configurés pour le même type.

Annotations Spring MVC

Quelques-unes des annotations Spring MVC importantes sont :

1. @Controller
2. @RequestMapping
3. @PathVariable
4. @RequestParam
5. @ModelAttribute
6. @RequestBody et @ResponseBody
7. @RequestHeader et @ResponseHeader

Vous pouvez en apprendre davantage à leur sujet sur Tutoriel Spring MVC.

Annotations de gestion des transactions Spring

@Transactional est l’annotation de gestion des transactions déclarative de Spring, en savoir plus sur Spring MVC Hibernate.

Annotations de sécurité Spring

@EnableWebSecurity` est utilisé avec la classe @Configuration pour définir la configuration de Spring Security, consultez plus d’informations dans l’exemple de Spring Security.

Annotations de Spring Boot

1. @SpringBootApplication
2. @EnableAutoConfiguration

Consultez plus d’informations dans l’exemple de Spring Boot.

Exemple d’annotations Spring

Jetons un coup d’œil à un exemple simple où nous utiliserons des annotations Spring dans notre application. L’image ci-dessous illustre mon projet d’exemple d’annotations Spring.

Dépendances du framework Spring

I have created the maven project and added Spring Core Framework dependencies.

<project xmlns="https://maven.apache.org/POM/4.0.0" xmlns:xsi="https://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="https://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<groupId>com.journaldev.spring</groupId>
	<artifactId>spring-annotations</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<name>Spring Annotations</name>

	<properties>
		<spring.framework>4.3.0.RELEASE</spring.framework>
	</properties>

	<dependencies>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-context</artifactId>
			<version>${spring.framework}</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-core</artifactId>
			<version>${spring.framework}</version>
		</dependency>

	</dependencies>

</project>

Cela récupérera toutes les bibliothèques principales de Spring pour notre projet.

Classes de composants

La prochaine étape consiste à créer des classes de composants. Ici, je simule plusieurs composants de base de données, un pour MySQL et un autre pour Oracle.

package com.journaldev.drivers;

public interface DataBaseDriver {
    public String getInfo();
}

DataBaseDriver est l’interface de base que nous implémenterons.

package com.journaldev.drivers;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.PropertySource;
import org.springframework.stereotype.Component;

@Component
@PropertySource("classpath:mysqldatabase.properties")
public class MySqlDriver implements DataBaseDriver {

    @Value("${databaseName}")
    private String databaseName;
    @Value("${disableStatementPooling}")
    private String disableStatementPooling;

    public String getInfo() {
        return "[ Driver: mySql" +
                ", databaseName: " + databaseName +
                ", disableStatementPooling: " + disableStatementPooling +
                " ]";
    }
}

Notez l’utilisation de l’annotation @Component pour indiquer au framework Spring de traiter cette classe comme un composant. Nous utilisons également les annotations @PropertySource et @Value. Spring utilisera ces annotations lors de l’exécution pour injecter et définir les valeurs de ces variables à partir du fichier de propriétés spécifié. Voici les propriétés déclarées dans le fichier mysqldatabase.properties.

databaseName=school
disableStatementPooling=true

package com.journaldev.drivers;

public class OracleDriver implements DataBaseDriver {

    protected String url;
    protected String user;
    protected String password;
    protected String driver;
    protected Integer port;


    public String getUrl() {
        return url;
    }

    public String getUser() {
        return user;
    }

    public void setUser(String user) {
        this.user = user;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public String getDriver() {
        return driver;
    }

    public void setDriver(String driver) {
        this.driver = driver;
    }

    public Integer getPort() {
        return port;
    }

    public void setPort(Integer port) {
        this.port = port;
    }

    public void setUrl(String url) {
        this.url = url;
    }

    public String getInfo() {
        return "[ Driver: Oracle" +
                ", url: " + url +
                ", port; " + port +
                ", user: " + user +
                ", password: " + password  +
                ", driver: " + driver +
                " ] ";
    }
}

OracleDriver est un simple bean. Nous utiliserons une classe de service pour injecter des propriétés dans ce bean.

Classe de service Spring

package com.journaldev.service;

import com.journaldev.drivers.DataBaseDriver;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Service;

@Service
public class UserService {

    @Autowired
    @Qualifier("oracleDriver")
    private DataBaseDriver dataBaseDriver;

    public String getDriverInfo(){
        return dataBaseDriver.getInfo();
    }
}

Ici, nous utilisons l’annotation @Service pour indiquer au framework Spring de traiter cette classe comme une classe de service. Ensuite, nous utilisons les annotations @Autowired et @Qualifier("oracleDriver") pour indiquer au framework Spring d’injecter le bean nommé oracleDriver dans la propriété de classe dataBaseDriver. Notez que nous n’avons pas encore créé ce bean Spring.

Beans Spring

La dernière étape consiste à créer nos beans Spring et nos classes de configuration pour tout assembler.

package com.journaldev.config;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.PropertySource;
import org.springframework.core.env.Environment;

import com.journaldev.drivers.DataBaseDriver;
import com.journaldev.drivers.MySqlDriver;
import com.journaldev.drivers.OracleDriver;

@Configuration
@ComponentScan("com.journaldev")
@PropertySource("classpath:oracledatabase.properties")
public class AppConfig {

	@Autowired
        Environment environment;
	
	@Bean
	DataBaseDriver oracleDriver() {
        OracleDriver oracleDriver = new OracleDriver();
	oracleDriver.setDriver(environment.getProperty("db.driver"));
        oracleDriver.setUrl(environment.getProperty("db.url"));
        oracleDriver.setPort(Integer.parseInt(environment.getProperty("db.port")));
        oracleDriver.setUser(environment.getProperty("db.user"));
        oracleDriver.setPassword(environment.getProperty("db.password"));

        return oracleDriver;

	}

	@Bean
	DataBaseDriver mysqlDriver() {
		return new MySqlDriver();
	}
}

Notez la définition du bean pour oracleDriver. Dans cette méthode, nous lisons les propriétés du fichier oracledatabase.properties qui sont définies dans la variable environment par le framework Spring. Voici les propriétés définies dans le fichier oracledatabase.properties.

db.url=localhost
db.port=4444
db.user=vasiliy
db.password=yilisav
db.driver=driver_name

Notre exemple de projet d’annotations de printemps est prêt à être testé. En résumé, nous avons effectué les étapes suivantes :

1. Création du projet Maven et ajout des dépendances Spring requises.
2. Création des classes de composants et injection des propriétés à partir d’un fichier de ressources dans sa variable.
3. Si nous avons un composant tiers, nous pouvons utiliser la classe Service pour injecter les dépendances dedans. Tout comme nous l’avons fait pour OracleDriver à travers la classe UserService.
4. Enfin, nous avons créé une classe de configuration pour définir les beans Spring et définir le package de base à scanner pour les classes de composants Spring et les configurer.

Test d’exemple d’annotations Spring

Voici notre classe principale pour tester notre exemple de projet d’annotations Spring.

package com.journaldev;

import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.support.AbstractApplicationContext;

import com.journaldev.config.AppConfig;
import com.journaldev.drivers.DataBaseDriver;
import com.journaldev.service.UserService;

public class Main {
	public static void main(String[] args) {
	AbstractApplicationContext appContext = new AnnotationConfigApplicationContext(AppConfig.class);

	DataBaseDriver oracle = appContext.getBean("oracleDriver", DataBaseDriver.class);
	DataBaseDriver mysql = appContext.getBean("mysqlDriver", DataBaseDriver.class);
		
        System.out.println("Oracle driver info:");
        System.out.println(oracle.getInfo());
        
        System.out.println("MySQL driver info:");
        System.out.println(mysql.getInfo());

        System.out.println("UserService Information");
	UserService userService = appContext.getBean(UserService.class);
	System.out.println(userService.getDriverInfo());

	appContext.close();
	}
}

L’image ci-dessous montre la sortie produite. Remarquez que nous n’avons pas configuré de cadre de journalisation, donc toute la journalisation du framework Spring est imprimée dans la console en couleur rouge. C’est tout pour une brève introduction aux annotations Spring. J’ai répertorié ici la plupart des annotations importantes, mais il y en a beaucoup d’autres pour des tâches spécifiques. Vous pouvez télécharger mon exemple de projet d’annotations Spring depuis le lien ci-dessous.

Téléchargez le projet exemple d’annotations Spring

Référence: Documentation de l’API