Annotation di Spring

Tutorial
Spring

Spring Annotations ci permettono di configurare le dipendenze e implementare l’iniezione delle dipendenze attraverso programmi Java.

Spring Annotations

  • Il framework Spring implementa e promuove il principio dell’inversione di controllo (IoC) o l’iniezione delle dipendenze (DI) ed è, infatti, un contenitore IoC.
  • Tradizionalmente, Spring consente a uno sviluppatore di gestire le dipendenze dei bean utilizzando una configurazione basata su XML.
  • Esiste un modo alternativo per definire i bean e le loro dipendenze. Questo metodo è una configurazione basata su Java.
  • A differenza dell’approccio XML, la configurazione basata su Java consente di gestire i componenti dei bean programmatically. Ecco perché sono state introdotte le annotazioni di Spring.

In questo articolo esploreremo le annotazioni di Spring più comunemente utilizzate e daremo un’occhiata a un programma di esempio.

Elenco delle Spring Annotations

Alcune delle principali annotazioni del framework di base di Spring sono:

  1. @Configuration: Utilizzato per indicare che una classe dichiara uno o più metodi @Bean. Queste classi sono processate dal contenitore Spring per generare definizioni di bean e richieste di servizio per quei bean in fase di esecuzione.

  2. @Bean: Indica che un metodo produce un bean da gestire dal contenitore Spring. Questa è una delle annotazioni Spring più utilizzate e importanti. @Bean l’annotazione può anche essere utilizzata con parametri come nome, initMethod e destroyMethod.

    • nome – ti permette di dare un nome al bean
    • initMethod – ti permette di scegliere il metodo che verrà invocato durante la registrazione del contesto
    • destroyMethod – ti permette di scegliere il metodo che verrà invocato durante lo spegnimento del contesto

    Per esempio:

    @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("Carica sistema operativo");
    }
    public void turnOff(){
        System.out.println("Chiudi tutti i programmi");
    }
}

  3. @PreDestroy e @PostConstruct sono un modo alternativo per il metodo di inizializzazione (initMethod) e il metodo di distruzione (destroyMethod) del bean. Possono essere utilizzati quando la classe del bean è definita da noi. Ad esempio;

    public class Computer {

    @PostConstruct
    public void turnOn(){
        System.out.println("Carica il sistema operativo");
    }

    @PreDestroy
    public void turnOff(){
        System.out.println("Chiudi tutti i programmi");
    }
}

  4. @ComponentScan: Configura le direttive di scansione dei componenti da utilizzare con le classi @Configuration. Qui possiamo specificare i pacchetti di base da scansionare per i componenti di Spring.

  5. @Component: Indica che una classe annotata è un “componente”. Tali classi vengono considerate come candidati per la rilevazione automatica quando si utilizza la configurazione basata su annotazioni e la scansione del classpath.

  6. @PropertySource: fornisce un meccanismo dichiarativo semplice per aggiungere una sorgente di proprietà all’ambiente di Spring. C’è un’annotazione simile per aggiungere un array di file di origine delle proprietà, cioè @PropertySources.

  7. @Service: Indica che una classe annotata è un “Servizio”. Questa annotazione serve come specializzazione di @Component, consentendo alle classi di implementazione di essere rilevate automaticamente attraverso la scansione del classpath.

  8. @Repository: Indica che una classe annotata è un “Repository”. Questa annotazione serve come specializzazione di @Component ed è consigliabile utilizzarla con le classi DAO.

  9. @Autowired: L’annotazione Spring @Autowired viene utilizzata per l’iniezione automatica di bean. L’annotazione @Qualifier di Spring è utilizzata insieme a Autowired per evitare confusione quando abbiamo due o più bean configurati per lo stesso tipo.

Spring MVC Annotations

Alcune delle importanti annotazioni Spring MVC sono:

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

Puoi saperne di più su di loro a Tutorial di Spring MVC.

Spring Transaction Management Annotations

@Transactional è l’annotazione di gestione delle transazioni dichiarativa di Spring, leggi di più su Spring MVC Hibernate.

Spring Security Annotations

@EnableWebSecurity viene utilizzato con la classe @Configuration per definire la configurazione di Spring Security, leggi di più su Esempio di Spring Security.

Annotazioni di Spring Boot

  1. @SpringBootApplication
  2. @EnableAutoConfiguration

Leggi di più su Esempio di Spring Boot.

Esempio di Annotazioni Spring

Guardiamo un semplice esempio in cui useremo le annotazioni di Spring nella nostra applicazione. L’immagine sottostante illustra il mio progetto di esempio sulle Annotazioni di Spring.

Dependenze del 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>

Questo importerà tutti i file jar core di Spring per il nostro progetto.

Classi Componente

Il passo successivo è creare classi di componente. Qui sto imitando più componenti di database, uno per MySQL e un altro per Oracle. 

package com.journaldev.drivers;

public interface DataBaseDriver {
    public String getInfo();
}

DataBaseDriver è l’interfaccia di base che implementeremo. 

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

Nota l’uso dell’annotazione @Component per indicare al framework Spring di trattare questa classe come un componente. Stiamo anche usando le annotazioni @PropertySource e @Value, Spring le utilizzerà durante l’esecuzione per iniettare e impostare i valori di queste variabili dal file di proprietà specificato. Di seguito sono elencate le proprietà dichiarate nel file 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 è un semplice bean, utilizzeremo una classe di servizio per iniettare le proprietà in questo bean.

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

Qui stiamo utilizzando l’annotazione @Service per indicare al framework Spring di trattare questa classe come una classe di servizio. Quindi utilizziamo le annotazioni @Autowired e @Qualifier("oracleDriver") per dire al framework Spring di iniettare il bean denominato oracleDriver nella proprietà della classe dataBaseDriver. Notare che non abbiamo ancora creato questo bean Spring.

Bean Spring

L’ultimo passo è creare i nostri bean Spring e le classi di configurazione per collegare tutto insieme. 

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

Osservare la definizione del bean per oracleDriver. In questo metodo, leggiamo le proprietà dal file oracledatabase.properties che viene impostato sulla variabile environment dal framework Spring. Ecco le proprietà definite nel file oracledatabase.properties.

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

Il nostro esempio di progetto di annotazioni di primavera è pronto per essere testato. In sintesi, abbiamo eseguito i seguenti passaggi:

  1. Creato progetto maven e aggiunto le dipendenze di primavera necessarie.
  2. Creato classi di componente e iniettato le proprietà da un file di risorse nelle sue variabili.
  3. Se abbiamo un componente di terze parti, possiamo utilizzare la classe di servizio per iniettare le dipendenze in esso. Proprio come abbiamo fatto per OracleDriver attraverso la classe UserService.
  4. Infine, abbiamo creato la classe di configurazione per definire i bean di primavera e impostare il pacchetto di base per la scansione delle classi di componente di primavera e configurarle.

Esempio di test di annotazioni di primavera

Ecco la nostra classe principale per testare il nostro esempio di progetto di annotazioni di primavera. 

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’immagine sottostante mostra l’output prodotto. Notare che non abbiamo configurato alcun framework di logging, quindi tutto il logging del framework di primavera viene stampato sulla console in colore rosso. Questo è tutto per una breve introduzione alle annotazioni di primavera. Ho elencato qui la maggior parte delle annotazioni importanti, ma ce ne sono molte altre per compiti specifici. È possibile scaricare il mio progetto di esempio di annotazioni di primavera dal seguente link.

Scarica il progetto di esempio delle annotazioni Spring

Riferimento: Documentazione API

Source:
https://www.digitalocean.com/community/tutorials/spring-annotations