Anotações da Primavera

As Anotações do Spring permitem-nos configurar dependências e implementar injeção de dependência através de programas Java.

Anotações do Spring

• O framework Spring implementa e promove o princípio da inversão de controle (IoC) ou injeção de dependência (DI) e é, de fato, um contêiner IoC.
• Tradicionalmente, o Spring permite que um desenvolvedor gerencie as dependências do bean usando configuração baseada em XML.
• Existe uma maneira alternativa de definir beans e suas dependências. Este método é uma configuração baseada em Java.
• Ao contrário da abordagem XML, a configuração baseada em Java permite que você gerencie componentes de bean programaticamente. É por isso que as anotações do Spring foram introduzidas.

Neste artigo, exploraremos as Anotações do Spring mais comumente usadas e também veremos alguns exemplos de programas.

Lista de Anotações do Spring

Algumas das anotações principais do framework Spring são:

1. @Configuration: Usado para indicar que uma classe declara um ou mais métodos @Bean. Essas classes são processadas pelo contêiner Spring para gerar definições de bean e solicitações de serviço para esses beans em tempo de execução.

2. @Bean: Indica que um método produz um bean a ser gerenciado pelo contêiner Spring. Esta é uma das anotações Spring mais usadas e importantes. A anotação @Bean também pode ser usada com parâmetros como nome, initMethod e destroyMethod.

   • nome – permite que você dê um nome ao bean
   • initMethod – permite que você escolha o método que será invocado no registro do contexto
   • destroyMethod – permite que você escolha o método que será invocado no encerramento do contexto

   Por exemplo:

   @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("Carregar sistema operacional");
       }
       public void turnOff(){
           System.out.println("Fechar todos os programas");
       }
   }
   

3. @PreDestroy e @PostConstruct são formas alternativas para o initMethod e destroyMethod do bean. Pode ser usado quando a classe do bean é definida por nós. Por exemplo;

    public class Computador {
   
       @PostConstruct
       public void ligar(){
           System.out.println("Carregando sistema operacional");
       }
   
       @PreDestroy
       public void desligar(){
           System.out.println("Fechando todos os programas");
       }
   }
   

4. @ComponentScan: Configura diretivas de varredura de componentes para uso com @Configuration classes. Aqui podemos especificar os pacotes base para varredura de componentes Spring.

5. @Component: Indica que uma classe anotada é um “componente”. Tais classes são consideradas candidatas para detecção automática ao usar configuração baseada em anotações e varredura de classpath.

6. @PropertySource: fornece um mecanismo declarativo simples para adicionar uma fonte de propriedades ao Ambiente do Spring. Existe uma anotação semelhante para adicionar uma matriz de arquivos de origem de propriedades, ou seja, @PropertySources.

7. @Service: Indica que uma classe anotada é um “Serviço”. Esta anotação serve como uma especialização de @Componente, permitindo que as classes de implementação sejam detectadas automaticamente por meio da varredura no classpath.

8. @Repository: Indica que uma classe anotada é um “Repositório”. Esta anotação serve como uma especialização de @Componente e é aconselhável usá-la com classes DAO.

9. @Autowired: A anotação Spring @Autowired é usada para injeção automática de beans. A anotação @Qualifier do Spring é usada em conjunto com Autowired para evitar confusão quando temos dois ou mais beans configurados para o mesmo tipo.

Anotações do Spring MVC

Algumas das anotações importantes do Spring MVC são:

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

Você pode aprender mais sobre eles em Spring MVC Tutorial.

Spring Transaction Management Annotations

@Transactional é a anotação de gerenciamento de transações declarativa do Spring, leia mais em Spring MVC Hibernate.

Spring Security Annotations

@EnableWebSecurity é usado com a classe @Configuration para ter a configuração de segurança do Spring definida, leia mais em Exemplo de Segurança do Spring.

Anotações do Spring Boot

1. @SpringBootApplication
2. @EnableAutoConfiguration

Leia mais em Exemplo do Spring Boot.

Exemplo de Anotações do Spring

Vamos dar uma olhada em um exemplo simples onde usaremos anotações do Spring em nossa aplicação. A imagem abaixo ilustra meu projeto de Exemplo de Anotações do Spring.

Dependências do 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>

Isso irá incluir todos os jars principais do Spring para nosso projeto.

Classes de Componentes

O próximo passo é criar classes de componente. Aqui estou imitando múltiplos componentes de banco de dados, um para MySQL e outro para Oracle. `

package com.journaldev.drivers;

public interface DataBaseDriver {
    public String getInfo();
}

DataBaseDriver` é a interface base que vamos implementar. `

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

Observe o uso da anotação @Component para indicar ao framework Spring que trate esta classe como um Componente. Também estamos usando as anotações @PropertySource e @Value, o Spring usará essas anotações em tempo de execução para injetar e definir os valores dessas variáveis a partir do arquivo de propriedades especificado. Abaixo estão as propriedades declaradas no arquivo 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` é um bean simples, vamos usar uma classe de serviço para injetar propriedades neste bean. `

Classe de Serviço do 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();
    }
}

Aqui estamos usando a anotação @Service para indicar ao framework Spring que trate isso como uma classe de Serviço. Em seguida, estamos usando as anotações @Autowired e @Qualifier("oracleDriver") para dizer ao framework Spring para injetar o bean chamado oracleDriver na propriedade da classe dataBaseDriver. Observe que ainda não criamos este bean do Spring. `

Beans do Spring

O último passo é criar nossos beans do Spring e classes de configuração para juntar tudo. `

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

Observe a definição do bean para oracleDriver. Neste método, estamos lendo as propriedades do arquivo oracledatabase.properties que estão sendo definidas como variável environment pelo framework Spring. Aqui estão as propriedades definidas no arquivo oracledatabase.properties.

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

Nosso exemplo de projeto de anotações de primavera está pronto para teste. Como resumo, realizamos os seguintes passos:

1. Criamos um projeto Maven e adicionamos as dependências de primavera necessárias.
2. Criamos classes de componente e injetamos propriedades de um arquivo de recurso em sua variável.
3. Se tivermos um componente de terceiros, podemos usar a classe de Serviço para injetar dependências nele. Assim como fizemos para o OracleDriver através da classe UserService.
4. Finalmente, criamos uma classe de Configuração para definir beans de primavera e configurar o pacote base para escanear classes de componentes de primavera e configurá-las.

Teste de Exemplo de Anotações de Primavera

Aqui está nossa classe principal para testar nosso projeto de exemplo de anotações de 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();
	}
}

A imagem abaixo mostra a saída produzida. Observe que não configuramos nenhum framework de registro, então todo o registro do framework de primavera está sendo impresso no console em cor vermelha. Isso é tudo para uma breve introdução às anotações de primavera. Eu listei aqui a maioria das anotações importantes, mas há muitas outras para tarefas específicas. Você pode baixar meu projeto de exemplo de anotações de primavera no link abaixo.

Baixar Projeto Exemplo de Anotações Spring

Referência: Documentação da API