Como praticamente todos os frameworks modernos, o Spring 3 permite a declaração de componentes (Spring Beans) via anotação, tornando o uso de XML desnecessário. Porém, é comum haver confusão sobre as diferentes anotações que parecem fazer a mesma coisa.

Definindo quais classes o Spring deve considerar

Quando adicionamos uma anotação em uma classe, estamos colocando ali uma meta-informação, isto é, uma informação arbitrária que vai além do código executado e das características da classe como nome, modificador de acesso, etc.

Entretanto, o Spring (ou qualquer outro framework) precisa encontrar e ler a classe com a anotação para que ela possa efetivamente ser usada.

Isso é feito através de configuração XML:

<context:component-scan 
    base-package="br.com.pacote.projeto.service,
                  br.com.pacote.projeto.controller"/>

Ou ainda através da anotação de configuração @ComponentScan:

@Configuration
@ComponentScan({
    "br.com.pacote.projeto.service",
    "br.com.pacote.projeto.controller"})
public class ConfiguracaoSpring { ... }

Nos exemplos acima, especificamos os pacotes onde o Spring irá procurar por classes. Ele irá vasculhar qualquer classe com as anotações de componentes que estão nesses pacotes ou em subpacotes.

Agrupando componentes com estereótipos

Primeiro, existe uma anotação genérica @Component. Com essa anotação, uma classe passa a ser um bean disponível para injeção de dependências nos demais componentes do sistema.

Por outro lado, há também anotações mais específicas que possibilitam marcar as classes com estereótipos, assim como na UML. Dessa forma, os componentes podem ser agrupados por seu “tipo” ou comportamento.

Se uma classe é anotada com @Service pode-se facilmente pressupor que ela contém regras de negócio, transações ou lógica relacionada ao modelo da aplicação.

Se a anotação é @Repository, fica óbvio que a classe implementa o padrão de projeto Repository (que não o mesmo que DAO, mas é de alguma forma análogo).

Por fim, se a anotação é @Controller podemos associar a classe diretamente a um controlador do padrão MVC.

Alguns benefícios

Embora tudo isso a princípio pareça apenas um mero enfeite, é possível listar algumas vantagens:

Ajuda na separação lógica de camadas da aplicação.
Possibilita a utilização de Programação Orientada a Aspecto (AOP – Aspect Oriented Programming), como usado módulo Spring Data JPA, o qual “gera” dinamicamente a implementação de interfaces anotadas com @Repository.
Permite o tratamento pontual de exceções lançadas por camadas específicas, novamente com o exemplo da camada de acesso a dados (@Repository), onde o Spring irá traduzir as exceções de cada driver de banco de dados para classes padronizadas.
Você também pode criar qualquer funcionalidade que se aplique por camada, basta usar um pouco a imaginação. 😉

Considerações

Minha única ressalva com relação ao uso das anotações como novo padrão em detrimento dos tradicionais e “verbosos” XML’s é com relação ao desempenho da configuração component-scan. Se definirmos um pacote muito abrangente, isto é, que contém muitas classes, o Spring irá levar um tempo considerável listando as classes a procura das anotações. Mapear os beans em XML ajuda se o tempo de inicialização da aplicação for um requisito importante.

Este artigo foi baseado na minha resposta no StackOverflow em Português!

Defining where Spring should look for annotations

When we add an annotation to some class, we are putting a meta-information, that is, an arbitrary information that has nothing to do the code or the properties of the class, like its name, modifiers, etc.

However, Spring (as any other framework) needs to find and read annotated classes in order they can effectively be used.

<context:component-scan base-package="com.package.project.service, com.package.project.controller"/>

Also through the annotation @ComponentScan:

@Configuration @ComponentScan({ "com.package.project.service", "com.package.project.controller"}) public class SpringConfiguration { ... }

In the above example, we defined in which packages Spring should search for classes. It’ll look for classes with component annotations in these packages and in their subpackages.

Grouping components with stereotypes

Firstly, there is the generic @Component. This annotation makes one class a bean available for dependency injection to the remaining components of the system.

On the other hand, there are more specific annotations that allow us to mark beans with stereotypes, as in UML. This way, the components can be grouped by their “type” or behavior.

If one class is annotated with @Service you can just suppose it contains business methods, high level transactions or some logic related to the application model.

The annotation @Repository makes it obvious that the component implements Repository design patter (which is not the same of DAO, even though they are somehow analogous).

Finally, the annotation @Controller associates a component with a MVC controller.

The benefits

At first it looks like frills, but actually there are a few advantages:

It helps separating the logical layers of the application.

It enables Aspect Oriented Programming (AOP), like Spring Data JPA module, which dynamically “implements” interfaces annotated with @Repository.

It allows you treat separately exceptions that are specific of a layer, using again the example of data access layer (@Repository), where Spring will translate specific database driver exceptions into standardized classes.

You can also create any new feature specific to a layer. Just use your imagination and creativity. 😉

Considerations

The performance of “component-scan” is my main reservation about annotations as a new standard against the traditional and verbose XMLs. If we configure a broad package, that is, containing many classes, it can slows down the application startup, since Spring will take some time to list all classes and check them for annotations. Maybe mapping your beans with XML will be better if startup time is an important requirement for you.

Tag: spring framework

Quais anotações usar nos componentes do Spring 3

Definindo quais classes o Spring deve considerar

Agrupando componentes com estereótipos

Alguns benefícios

Considerações

Which component annotations to use in Spring 3

Defining where Spring should look for annotations

Grouping components with stereotypes

The benefits

Considerations

Follow

Popular

Descubra

Categorias

Arquivos

Tags

Social