Recherche de site Web

Annotations Spring

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

Annotations de Spring

  • Le framework Spring met en œuvre et promeut le principe d'inversion de contrôle (IOC) ou d'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 manière alternative de définir des 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 beans de manière programmatique. C'est pourquoi les annotations Spring ont été introduites.

Dans cet article, nous allons explorer les annotations Spring les plus couramment utilisées et examiner également quelques programmes exemples.

Liste des annotations Spring

Certaines des annotations du framework Spring Core 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 qui sera géré 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 name, initMethod et destroyMethod.

    • nom - 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 l'arrêt 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("Load operating system");
    }
    public void turnOff(){
        System.out.println("Close all programs");
    }
}

  3. @PreDestroy et @PostConstruct sont des moyens alternatifs pour initMethod et destroyMethod d'un bean. Ils peuvent être utilisés lorsque la classe du bean est définie par nous. Par exemple ;

     public class Computer {

    @PostConstruct
    public void turnOn(){
        System.out.println("Load operating system");
    }

    @PreDestroy
    public void turnOff(){
        System.out.println("Close all programs");
    }
}

  4. @ComponentScan : Configure les directives de scan de composants pour une utilisation avec les classes @Configuration. Ici, nous pouvons spécifier les packages de base à scanner pour les composants Spring.

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

  6. @PropertySource : fournit un mécanisme déclaratif simple pour ajouter une source de propriétés à l'environnement de Spring. Il existe une annotation similaire pour ajouter un tableau de fichiers de sources de propriétés, 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 conseillé de l'utiliser avec les classes DAO.

  9. @Autowired : L'annotation Spring @Autowired est utilisée pour l'injection automatique de beans. L'annotation Spring @Qualifier est utilisée en conjonction avec @Autowired pour éviter toute confusion lorsqu'on a deux beans ou plus configurés pour le même type.

Annotations Spring MVC

Certaines des annotations importantes de Spring MVC sont :

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

Vous pouvez en apprendre davantage sur eux dans le tutoriel Spring MVC.

Annotations de gestion des transactions Spring

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

Annotations de sécurité Spring

@EnableWebSecurity est utilisé avec une classe @Configuration pour définir la configuration de Spring Security, en savoir plus sur Exemple Spring Security.

Annotations Spring Boot

  1. @SpringBootApplication
  2. @EnableAutoConfiguration

Lisez-en plus sur l'exemple Spring Boot.

Exemple d'annotations Spring

Examinons 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

J'ai créé le projet Maven et ajouté les dépendances du framework Spring Core.

<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 fera apparaître tous les fichiers JAR du noyau Spring pour notre projet.

Classes de composants

L'étape suivante consiste à créer des classes de composants. Ici, j'imite 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 allons implémenter.

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 +
                " ]";
    }
}

Remarquez 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 les utilisera lors de l'exécution pour injecter et définir les valeurs de ces variables à partir du fichier de propriétés spécifié. Ci-dessous se trouvent 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 ceci comme une classe de service. Ensuite, nous utilisons les annotations @Autowired et @Qualifier("oracleDriver") pour dire au framework Spring d'injecter le bean nommé oracleDriver dans la propriété de la classe dataBaseDriver. Notez que nous n'avons pas encore créé ce bean Spring.

Haricots de printemps

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

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();
	}
}

Remarquez la définition du bean pour oracleDriver. Dans cette méthode, nous lisons les propriétés du fichier oracledatabase.properties qui est défini 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 projet d'exemple d'annotations Spring est prêt à être testé. En résumé, nous avons effectué les étapes suivantes :

  1. Créé un projet Maven et ajouté les dépendances Spring requises.
  2. Créé des classes de composants et injecté des propriétés depuis un fichier de ressources dans ses variables.
  3. Si nous avons un composant tiers, nous pouvons utiliser la classe Service pour y injecter des dépendances. Tout comme nous l'avons fait pour OracleDriver via la classe UserService.
  4. Enfin, nous avons créé la classe Configuration pour définir les beans Spring et définir le package de base à scanner pour les classes composants Spring et les configurer.

Exemple de test des annotations Spring

Voici notre classe principale pour tester notre projet d'exemple 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 configuré aucun framework de journalisation, donc tous les journaux du framework Spring s'affichent dans la console en couleur rouge.

Télécharger Télécharger Exemple de Projet d'Annotations Spring

Référence : Doc API