TOC

Anotações do Spring Bean

Anotações do Spring Bean

1. Visão geral

Neste artigo, discutiremos a maioria doscommon Spring bean annotations usados ​​para definir diferentes tipos de feijão.

Existem várias maneiras de configurar beans em um contêiner Spring. Podemos declará-los usando a configuração XML. Podemos declarar beans usando a anotação@Bean em uma classe de configuração.

Ou podemos marcar a classe com uma das anotações do pacoteorg.springframework.stereotype e deixar o resto para a varredura de componentes.

2. Digitalização de componentes

O Spring pode verificar automaticamente um pacote em busca de beans se a verificação de componentes estiver ativada.

@ComponentScan configura qualpackages to scan for classes with annotation configuration. Podemos especificar os nomes dos pacotes básicos diretamente com um dos argumentosbasePackages ouvalue (value é um alias parabasePackages): 

@Configuration
@ComponentScan(basePackages = "com.example.annotations")
class VehicleFactoryConfig {}

Além disso, podemos apontar para classes nos pacotes básicos com o argumentobasePackageClasses: 

@Configuration
@ComponentScan(basePackageClasses = VehicleFactoryConfig.class)
class VehicleFactoryConfig {}

Ambos os argumentos são matrizes para que possamos fornecer vários pacotes para cada um.

Se nenhum argumento for especificado, a varredura ocorre a partir do mesmo pacote onde a classe anotada@ComponentScan está presente.

@ComponentScan aproveita o recurso de anotações repetidas do Java 8, o que significa que podemos marcar uma classe com ele várias vezes: 

@Configuration
@ComponentScan(basePackages = "com.example.annotations")
@ComponentScan(basePackageClasses = VehicleFactoryConfig.class)
class VehicleFactoryConfig {}

Como alternativa, podemos usar@ComponentScans para especificar várias configurações@ComponentScan: 

@Configuration
@ComponentScans({
  @ComponentScan(basePackages = "com.example.annotations"),
  @ComponentScan(basePackageClasses = VehicleFactoryConfig.class)
})
class VehicleFactoryConfig {}

Quandousing XML configuration, a configuração da verificação de componente é tão fácil:

3. @Component

@Component é uma anotação de nível de classe. Durante a varredura do componente,Spring Framework automatically detects classes annotated with @Component.

Por exemplo: 

@Component
class CarUtility {
    // ...
}

Por padrão, as instâncias de bean desta classe têm o mesmo nome que o nome da classe com uma inicial em minúscula. Além disso, podemos especificar um nome diferente usando o argumento opcionalvalue desta anotação.

Como@Repository,@Service,@Configuration e@Controller são todas metanotações de@Component, eles compartilham o mesmo comportamento de nomenclatura de bean. Além disso, o Spring os coleta automaticamente durante o processo de digitalização de componentes.

4. @Repository

As classes DAO ou Repositório geralmente representam a camada de acesso ao banco de dados em um aplicativo e devem ser anotadas com@Repository: 

@Repository
class VehicleRepository {
    // ...
}

Uma vantagem de usar essa anotação é queit has automatic persistence exception translation enabled. Ao usar uma estrutura de persistência como o Hibernate, as exceções nativas lançadas nas classes anotadas com@Repository serão automaticamente traduzidas em subclasses deDataAccessExeption do Spring.

To enable exception translation, precisamos declarar nosso próprio beanPersistenceExceptionTranslationPostProcessor: 

@Bean
public PersistenceExceptionTranslationPostProcessor exceptionTranslation() {
    return new PersistenceExceptionTranslationPostProcessor();
}

Observe que, na maioria dos casos, o Spring executa a etapa acima automaticamente.

Ou, via configuração XML:

5. @Service

Obusiness logic de um aplicativo geralmente reside dentro da camada de serviço - então, usaremos a anotação@Service para indicar que uma classe pertence a essa camada: 

@Service
public class VehicleService {
    // ...
}

6. @Controller

@Controller é uma anotação de nível de classe que informa ao Spring Framework que esta classe serve comocontroller in Spring MVC: 

@Controller
public class VehicleController {
    // ...
}

7. @Configuration

Configuration classes podemcontain bean definition methods anotadas com@Bean: 

@Configuration
class VehicleFactoryConfig {

    @Bean
    Engine engine() {
        return new Engine();
    }

}

8. Anotações de estereótipo e AOP

Quando usamos anotações de estereótipo Spring, é fácil criar um pointcut que visa todas as classes que têm um estereótipo particular.

Por exemplo, suponha que desejamos medir o tempo de execução dos métodos da camada DAO. Criaremos o seguinte aspecto (usando anotações AspectJ) aproveitando o estereótipo@Repository: 

@Aspect
@Component
public class PerformanceAspect {
    @Pointcut("within(@org.springframework.stereotype.Repository *)")
    public void repositoryClassMethods() {};

    @Around("repositoryClassMethods()")
    public Object measureMethodExecutionTime(ProceedingJoinPoint joinPoint)
      throws Throwable {
        long start = System.nanoTime();
        Object returnValue = joinPoint.proceed();
        long end = System.nanoTime();
        String methodName = joinPoint.getSignature().getName();
        System.out.println(
          "Execution of " + methodName + " took " +
          TimeUnit.NANOSECONDS.toMillis(end - start) + " ms");
        return returnValue;
    }
}

Neste exemplo, criamos um pointcut que corresponde a todos os métodos em classes anotadas com@Repository. Usamos o conselho@Around para, em seguida, direcionar esse pointcut e determinar o tempo de execução das chamadas de métodos interceptados.

Usando essa abordagem, podemos adicionar log, gerenciamento de desempenho, auditoria ou outros comportamentos a cada camada de aplicativo.

9. Conclusão

Neste artigo, examinamos as anotações do estereótipo Spring e aprendemos que tipo de semântica elas representam.

Também aprendemos como usar a varredura de componentes para informar ao contêiner onde encontrar classes anotadas.

Por fim - vimos como essas anotaçõeslead to a clean, layered designe separam as preocupações de um aplicativo. Eles também tornam a configuração menor, pois não precisamos mais definir explicitamente os beans manualmente.

Como de costume, os exemplos estão disponíveisover on GitHub.

Related