Primavera @Component

@org.springframework.stereotype.Component A anotação é usada para denotar uma classe como Componente. Isso significa que o framework Spring detectará automaticamente essas classes para a injeção de dependência quando a configuração baseada em anotações e a varredura do classpath são usadas.

Componente Spring

Em termos leigos, um Componente é responsável por algumas operações. O framework Spring fornece outras três anotações específicas para serem usadas ao marcar uma classe como Componente.

1. Serviço: Denota que a classe fornece alguns serviços. Nossas classes de utilidade podem ser marcadas como classes de Serviço.
2. Repositório: Esta anotação indica que a classe lida com operações CRUD, geralmente é usada com implementações DAO que lidam com tabelas de banco de dados.
3. Controlador: Principalmente usado em aplicações web ou serviços web REST para especificar que a classe é um controlador frontal e responsável por lidar com a solicitação do usuário e retornar a resposta apropriada.

Observe que todas essas quatro anotações estão no pacote org.springframework.stereotype e fazem parte do arquivo spring-context JAR. Na maioria das vezes, nossas classes de componente se enquadrarão em uma das três anotações especializadas, então você pode não usar muito a anotação @Component.

Exemplo de Componente Spring

Vamos criar uma aplicação Spring Maven muito simples para demonstrar o uso da anotação de componente Spring e como o Spring a detecta com configuração baseada em anotações e varredura no classpath. Crie um projeto Maven e adicione a seguinte dependência principal do Spring.

<dependency>
	<groupId>org.springframework</groupId>
	<artifactId>spring-context</artifactId>
	<version>5.0.6.RELEASE</version>
</dependency>

Isso é tudo o que precisamos para obter os recursos principais do framework Spring. Vamos criar uma classe de componente simples e marcá-la com a anotação @Component.

package com.journaldev.spring;

import org.springframework.stereotype.Component;

@Component
public class MathComponent {

	public int add(int x, int y) {
		return x + y;
	}
}

Agora podemos criar um contexto Spring baseado em anotações e obter o bean MathComponent a partir dele.

package com.journaldev.spring;

import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class SpringMainClass {

	public static void main(String[] args) {
		AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
		context.scan("com.journaldev.spring");
		context.refresh();

		MathComponent ms = context.getBean(MathComponent.class);

		int result = ms.add(1, 2);
		System.out.println("Addition of 1 and 2 = " + result);

		context.close();
	}

}

Execute a classe acima como uma aplicação Java normal e você deverá obter a seguinte saída no console.

Jun 05, 2018 12:49:26 PM org.springframework.context.support.AbstractApplicationContext prepareRefresh
INFO: Refreshing org.springframework.context.annotation.AnnotationConfigApplicationContext@ff5b51f: startup date [Tue Jun 05 12:49:26 IST 2018]; root of context hierarchy
Addition of 1 and 2 = 3
Jun 05, 2018 12:49:26 PM org.springframework.context.support.AbstractApplicationContext doClose
INFO: Closing org.springframework.context.annotation.AnnotationConfigApplicationContext@ff5b51f: startup date [Tue Jun 05 12:49:26 IST 2018]; root of context hierarchy

Você percebeu o poder do Spring? Não precisamos fazer nada para injetar nosso componente no contexto do Spring. A imagem abaixo mostra a estrutura do diretório do nosso projeto de exemplo de componente Spring. Também podemos especificar o nome do componente e depois obtê-lo do contexto do Spring usando o mesmo nome.

@Component("mc")
public class MathComponent {
}

MathComponent ms = (MathComponent) context.getBean("mc");

Embora eu tenha usado a anotação @Component com MathComponent, na verdade é uma classe de serviço e devemos usar a anotação @Service. O resultado ainda será o mesmo.

Você pode verificar o projeto em nosso Repositório no GitHub.

Referência: Documentação da API