Can @Component, @Repositorye @Serviceanotações ser usados alternadamente na Primavera ou eles fornecem qualquer funcionalidade específica além de atuar como um dispositivo de notação?

Em outras palavras, se eu tiver uma classe de serviço e alterar a anotação de @Servicepara @Component, ela ainda se comportará da mesma maneira?

Ou a anotação também influencia o comportamento e a funcionalidade da classe?

Da documentação da primavera :

A @Repositoryanotação é um marcador para qualquer classe que cumpre a função ou estereótipo de um repositório (também conhecido como Data Access Object ou DAO). Entre os usos desse marcador está a tradução automática de exceções, conforme descrito em Conversão de exceções .

Spring fornece outras anotações de estereotipia: @Component, @Service, e @Controller. @Componenté um estereótipo genérico para qualquer componente gerenciado pelo Spring. @Repository,, @Servicee @Controllersão especializações de @Componentcasos de uso mais específicos (nas camadas persistência, serviço e apresentação, respectivamente). Portanto, você pode anotar suas classes de componentes com @Component, mas, anotando-los com @Repository, @Serviceou @Controller em vez disso, suas aulas são mais propriamente adequado para o processamento por ferramentas ou associar-se com aspectos.

Por exemplo, essas anotações de estereótipo são alvos ideais para cortes de pontos. @Repository,, @Servicee @Controllertambém pode transportar semânticas adicionais em versões futuras do Spring Framework. Portanto, se você escolher entre usar @Componentou @Servicepara sua camada de serviço, @Serviceé claramente a melhor escolha. Da mesma forma, como declarado anteriormente, @Repositoryjá é suportado como um marcador para conversão automática de exceções em sua camada de persistência.

┌──────────────┬─────────────────────────────────────────────────────┐
│ Annotation   │ Meaning                                             │
├──────────────┼─────────────────────────────────────────────────────┤
│  @Component  │ generic stereotype for any Spring-managed component │
│  @Repository │ stereotype for persistence layer                    │
│  @Service    │ stereotype for service layer                        │
│  @Controller │ stereotype for presentation layer (spring-mvc)      │
└──────────────┴─────────────────────────────────────────────────────┘

Como muitas das respostas já indicam para que essas anotações são usadas, aqui vamos nos concentrar em algumas pequenas diferenças entre elas.

Primeiro a semelhança

O primeiro ponto a ser destacado novamente é que, com relação à detecção automática de varredura e injeção de dependência para o BeanDefinition, todas essas anotações (a saber, @Component, @Service, @Repository, @Controller) são as mesmas. Podemos usar um no lugar do outro e ainda podemos dar a volta.

Diferenças entre @Component, @Repository, @Controller e @Service

@Componente

Esta é uma anotação de estereótipo de uso geral, indicando que a classe é um componente de mola.

O que há de especial no @Component
<context:component-scan> apenas verifica@Componente não procura@Controller,@Servicee@Repositoryem geral. Eles são verificados porque eles mesmos são anotados@Component.

Basta dar uma olhada @Controller, @Servicee @Repositorydefinições de anotação:

@Component
public @interface Service {
    ….
}

@Component
public @interface Repository {
    ….
}

@Component
public @interface Controller {
    …
}

Assim, não é errado dizer que @Controller, @Servicee @Repositorysão tipos especiais de @Componentanotação. <context:component-scan>as pega e registra as seguintes classes como beans, como se fossem anotadas @Component.

As anotações de tipo especial também são digitalizadas, porque elas próprias são anotadas com @Componentanotação, o que significa que também são @Components. Se definirmos nossa própria anotação personalizada e a anotamos @Component, ela também será digitalizada com<context:component-scan>

@Repositório

Isso é para indicar que a classe define um repositório de dados.

O que há de especial no @Repository?

Além de apontar que essa é uma configuração baseada em anotações , @Repositorya tarefa é capturar exceções específicas da plataforma e jogá-las novamente como uma das exceções não verificadas e unificadas do Spring. Para isso, somos PersistenceExceptionTranslationPostProcessorobrigados a adicionar no contexto de aplicativos do Spring assim:

<bean class="org.springframework.dao.annotation.PersistenceExceptionTranslationPostProcessor"/>

Esse processador de postagem de bean adiciona um orientador a qualquer bean anotado @Repositorypara que quaisquer exceções específicas da plataforma sejam capturadas e, em seguida, lançadas novamente como uma das exceções de acesso a dados não verificadas do Spring.

@Controlador

A @Controlleranotação indica que uma classe específica cumpre a função de um controlador. A @Controlleranotação atua como um estereótipo para a classe anotada, indicando sua função.

O que há de especial no @Controller?

Não podemos alternar esta anotação com outra igual @Serviceou @Repository, mesmo que pareçam iguais. O expedidor varre as classes anotadas com @Controllere detecta métodos anotados com @RequestMappinganotações dentro delas. Podemos usar @RequestMappingon / in apenas os métodos cujas aulas são anotados com @Controllere vai NÃO trabalhar com @Component, @Service, @Repositoryetc ...

_{Nota: Se uma classe já estiver registrada como um bean por meio de qualquer método alternativo, como anotações completas @Beanou completas @Component, @Serviceetc ..., @RequestMappingpoderá ser selecionada se a classe também for anotada com @RequestMappinganotação. Mas esse é um cenário diferente.}

@Serviço

@Service beans mantêm a lógica de negócios e chamam métodos na camada de repositório.

O que há de especial no @Service?

Além do fato de ser usado para indicar, de manter a lógica de negócios, não há mais nada perceptível nesta anotação; mas quem sabe, o Spring poderá adicionar mais algumas exceções no futuro.

O quê mais?

Semelhante ao anterior, no futuro Primavera pode adicionar funcionalidades especiais para @Service, @Controllere @Repositorycom base em suas convenções camadas. Portanto, é sempre uma boa idéia respeitar a convenção e usá-la de acordo com as camadas.

Eles são quase os mesmos - todos significam que a classe é um bean Spring. @Service, @RepositoryE @Controllersão especializada @Components. Você pode optar por executar ações específicas com eles. Por exemplo:

• @Controller feijão são usados ​​por spring-mvc
• @Repository beans são elegíveis para tradução de exceção de persistência

Outra coisa é que você designa os componentes semanticamente para diferentes camadas.

Uma coisa que @Componentoferece é que você pode fazer anotações com outras anotações e usá-las da mesma maneira que @Service.

Por exemplo, recentemente eu fiz:

@Component
@Scope("prototype")
public @interface ScheduledJob {..}

Portanto, todas as classes anotadas @ScheduledJobsão feijão verde e, além disso, são registradas como trabalhos de quartzo. Você apenas precisa fornecer um código que lide com a anotação específica.

@Component é equivalente a

<bean>

@Service, @Controller, @Repository = {@Component + algumas funcionalidades mais especiais}

Isso significa que Serviço, Controlador e Repositório são funcionalmente iguais.

As três anotações são usadas para separar "Camadas" em seu aplicativo,

• Os controladores fazem coisas como despachar, encaminhar, chamar métodos de serviço etc.
• Serviço Lógica comercial, cálculos, etc.
• Repositório são os DAOs (Data Access Objects), eles acessam o banco de dados diretamente.

Agora você pode perguntar por que os separa: (Presumo que você saiba Programação Orientada AOP)

Digamos que você queira monitorar apenas a atividade da camada DAO. Você escreverá uma classe Aspect (classe A) que faz alguns registros antes e depois de cada método do seu DAO ser invocado, você poderá fazer isso usando o AOP, pois possui três camadas distintas e não é misto.

Portanto, você pode fazer o log do DAO "em volta", "antes" ou "depois" dos métodos DAO. Você poderia fazer isso porque tinha um DAO em primeiro lugar. O que você acabou de conseguir é a separação de preocupações ou tarefas.

Imagine se houvesse apenas uma anotação no @Controller, esse componente terá despacho, lógica de negócios e acesso ao banco de dados todos misturados, código tão sujo!

Acima mencionado é um cenário muito comum, há muitos outros casos de uso do porquê usar três anotações.

Na Primavera @Component, @Service, @Controller, e @Repositorysão anotações estereótipo que são utilizados para:

@Controller:onde o seu mapeamento de solicitação da página de apresentação foi concluído, ou seja, a camada de apresentação não vai para nenhum outro arquivo, ela é direcionada diretamente para a @Controllerclasse e verifica o caminho solicitado na@RequestMapping anotação que foi escrita antes do método chamar, se necessário.

@Service: Toda a lógica de negócios está aqui, isto é, cálculos relacionados a dados e tudo. Esta anotação da camada de negócios na qual nosso usuário não chama diretamente o método de persistência, portanto, chamará esse método usando esta anotação. Ele solicitará @Repository conforme solicitação do usuário

@Repository: É a camada Persistência (camada de acesso a dados) do aplicativo que costumava obter dados do banco de dados. isto é, todas as operações relacionadas ao banco de dados são feitas pelo repositório.

@Component - Anote seus outros componentes (por exemplo, classes de recursos REST) ​​com um estereótipo de componente.

Indica que uma classe anotada é um " componente ". Essas classes são consideradas candidatas à detecção automática ao usar a configuração baseada em anotação e a verificação do caminho de classe.

Outras anotações em nível de classe também podem ser consideradas como identificando um componente, geralmente um tipo especial de componente: por exemplo, a anotação @Repository ou a anotação @Aspect do AspectJ.

O Spring 2.5 apresenta outras anotações de estereótipo: @Component, @Service e @Controller. O @Component serve como um estereótipo genérico para qualquer componente gerenciado pelo Spring; enquanto @Repository, @Service e @Controller servem como especializações de @Component para casos de uso mais específicos (por exemplo, nas camadas de persistência, serviço e apresentação, respectivamente). O que isto significa é que você pode anotar suas classes de componentes com @Component, mas anotando-as com @Repository, @Service ou @Controller, suas classes são mais adequadas para processamento por ferramentas ou associação a aspectos. Por exemplo, essas anotações de estereótipo são alvos ideais para cortes de pontos. Obviamente, também é possível que @Repository, @Service e @Controller possam ter semântica adicional em versões futuras do Spring Framework. Portanto, se você estiver tomando uma decisão entre usar o @Component ou o @Service para sua camada de serviço, o @Service é claramente a melhor escolha. Da mesma forma, conforme declarado acima, o @Repository já é suportado como um marcador para conversão automática de exceções na sua camada de persistência.

@Component – Indicates a auto scan component.
@Repository – Indicates DAO component in the persistence layer.
@Service – Indicates a Service component in the business layer.
@Controller – Indicates a controller component in the presentation layer.

referência: - Documentação Spring - Varredura de caminho de classe, componentes gerenciados e configurações de gravação usando Java

Tecnicamente @Controller, @Service, @Repositorysão todos iguais. Todos eles se estende@Component .

No código-fonte do Spring:

Indica que uma classe anotada é um "componente". Essas classes são consideradas candidatas à detecção automática ao usar a configuração baseada em anotação e a verificação do caminho de classe.

Nós podemos usar diretamente @Componentpara cada feijão, mas para melhor compreensão e manutenção de um aplicativo grande, usamos @Controller, @Service,@Repository .

Objetivo de cada anotação:

1. @Controller-> Classes anotadas com isso, destinam-se a receber uma solicitação do lado do cliente. A primeira solicitação chega ao Dispatcher Servlet, de onde passa a solicitação para o controlador específico usando o valor de@RequestMapping anotação.
2. @Service-> As classes anotadas com isso destinam-se a manipular dados que recebemos do cliente ou buscamos no banco de dados. Toda a manipulação com dados deve ser feita nesta camada.
3. @Repository-> Classes anotadas com isso, destinam-se a se conectar ao banco de dados. Também pode ser considerado como camada DAO (Data Access Object). Essa camada deve ser restrita apenas às operações CRUD (criar, recuperar, atualizar, excluir). Se qualquer manipulação for necessária, os dados devem ser enviados e enviados de volta para a camada @Service.

Se trocarmos seu lugar (use @Repositoryno lugar de @Controller), nosso aplicativo funcionará bem.

O principal objetivo do uso de três diferentes @annotationsé fornecer melhor modularidade ao aplicativo corporativo.

O uso @Servicee as @Repositoryanotações são importantes da perspectiva da conexão com o banco de dados.

1. Use @Servicepara todo o tipo de serviço da Web de conexões com o banco de dados
2. Use @Repositorypara todas as suas conexões de banco de dados proc armazenadas

Se você não usar as anotações adequadas, poderá enfrentar exceções de confirmação substituídas por transações de reversão. Você verá exceções durante o teste de carga de estresse relacionadas à reversão de transações JDBC.

O @Repository @Service e o @Controller servem como especialização do @Component para uso mais específico nessa base. Você pode substituir o @Service por @Component, mas nesse caso você perde a especialização.

1. **@Repository**   - Automatic exception translation in your persistence layer.
2. **@Service**      - It indicates that the annotated class is providing a business service to other layers within the application.

todas essas anotações são do tipo estéreo, a diferença entre essas três anotações é

• Se adicionarmos o @Component, ele informará que o papel da classe é uma classe componente, significa que é uma classe que consiste em alguma lógica, mas não informa se uma classe contém uma lógica específica de negócios ou persistência ou controlador, para que não utilizemos diretamente esta anotação @Component
• Se adicionarmos a anotação @Service, será informado que uma função da classe consiste em lógica de negócios
• Se adicionarmos o @Repository no topo da classe, ele informará que uma classe consiste em lógica de persistência
• Aqui, @Component é uma anotação básica para as anotações @ Service, @ Repository e @Controller

por exemplo

package com.spring.anno;
@Service
public class TestBean
{
    public void m1()
    {
       //business code
    }
}

package com.spring.anno;
@Repository
public class TestBean
{
    public void update()
    {
       //persistence code
    }
}

• sempre que adicionarmos a anotação @Serviceor @Repositroyou @Controllerpor padrão, @Componenta existência no topo da classe

Spring fornece quatro tipos diferentes de componentes auto anotações de digitalização, são @Component, @Service, @Repositorye@Controller . Tecnicamente, não há diferença entre eles, mas cada anotação de varredura de componente automático deve ser usada para uma finalidade especial e dentro da camada definida.

@Component: É uma anotação básica de verificação automática de componentes, indica que a classe anotada é um componente de verificação automática.

@Controller: A classe anotada indica que é um componente do controlador e usado principalmente na camada de apresentação.

@Service: Indica que a classe anotada é um componente de serviço na camada de negócios.

@Repository: Você precisa usar esta anotação na camada de persistência, que age como um repositório de banco de dados.

Deve-se escolher uma forma mais especializada de @Componentanotar sua classe, pois essa anotação pode conter um comportamento específico daqui para frente.

Podemos responder isso de acordo com o padrão java

Referindo-se a JSR-330, que agora é suportado pela primavera, você só pode usar @Namedpara definir um bean (De alguma forma @Named=@Component). Assim, de acordo com esta norma, parece que não há nenhum uso para definir estereótipos (como @Repository, @Service, @Controller) a categorias feijão.

Mas o usuário seleciona essas anotações diferentes para diferentes usos, por exemplo:

1. Ajude os desenvolvedores a definir uma categoria melhor para os competentes. Essa categorização pode se tornar útil em alguns casos. (Por exemplo, quando você estiver usando aspect-oriented, pode ser um bom candidato para pointcuts)
2. @Repository A anotação adicionará alguma funcionalidade ao seu bean (alguma conversão automática de exceção à camada de persistência do bean).
3. Se você estiver usando o Spring MVC, ele @RequestMappingpoderá ser adicionado apenas às classes anotadas por @Controller.

Anote outros componentes com @Component, por exemplo, classes REST Resource.

@Component
public class AdressComp{
    .......
    ...//some code here    
}

@Component é um estereótipo genérico para qualquer componente gerenciado do Spring.

@Controller, @Service e @Repository são Especializações de @Component para casos de uso específicos.

@Componente na primavera

Não há diferença entre @Component , @Service, @Controller, @Repository. @Componenté a anotação genérica para representar o componente do nosso MVC. Mas haverá vários componentes como parte de nosso aplicativo MVC, como componentes da camada de serviço, componentes da camada de persistência e componentes da camada de apresentação. Então, para diferenciá-los, o pessoal da Primavera também deu as outras três anotações.

• Para representar componentes da camada de persistência: @Repository
• Para representar os componentes da camada de serviço: @Service
• Para representar os componentes da camada de apresentação: @Controller
• ou então você pode usar @Componentpara todos eles.

Mesmo se trocarmos @Component ou @Repository ou @service

O comportamento será o mesmo, mas um aspecto é que eles não conseguirão capturar alguma exceção específica relacionada ao DAO em vez do Repository, se usarmos o componente ou o serviço @

Na primavera 4, versão mais recente:

A anotação @Repository é um marcador para qualquer classe que cumpre a função ou o estereótipo de um repositório (também conhecido como Data Access Object ou DAO). Entre os usos desse marcador está a tradução automática de exceções, conforme descrito na Seção 20.2.2, “Tradução de exceções”.

O Spring fornece outras anotações de estereótipo: @Component, @Service e @Controller. @Component é um estereótipo genérico para qualquer componente gerenciado pelo Spring. @Repository, @Service e @Controller são especializações do @Component para casos de uso mais específicos, por exemplo, nas camadas de persistência, serviço e apresentação, respectivamente. Portanto, você pode anotar suas classes de componentes com @Component, mas anotando-as com @Repository, @Service ou @Controller, suas classes são mais adequadas para processamento por ferramentas ou associação a aspectos. Por exemplo, essas anotações de estereótipo são alvos ideais para cortes de pontos. Também é possível que @Repository, @Service e @Controller possam transportar semânticas adicionais em versões futuras do Spring Framework. Portanto, se você escolher entre usar o @Component ou o @Service para sua camada de serviço, o @Service é claramente a melhor escolha. Da mesma forma, conforme declarado acima, o @Repository já é suportado como um marcador para conversão automática de exceções na sua camada de persistência.

@ Componente : você anota uma classe @Component, ela diz ao hibernar que é um Bean.

@ Repository : você anota uma classe @Repository, diz ao hibernate que é uma classe DAO e a trata como classe DAO. Significa que torna as exceções não verificadas (lançadas dos métodos DAO) elegíveis para tradução no Spring DataAccessException.

@ Service : Isso indica ao hibernate que é uma classe de serviço onde você terá@Transactional etc anotações da camada de serviço, para que o hibernate o trate como um componente de serviço.

Plus @Serviceé avanço de @Component. Suponha que o nome da classe de bean seja CustomerService, como você não escolheu a maneira de configuração do bean XML, portanto, você anotou o bean @Componentpara indicá-lo como um Bean. Portanto, ao obter o objeto de bean CustomerService cust = (CustomerService)context.getBean("customerService");Por padrão, o Spring irá minúscula para o primeiro caractere do componente - de 'CustomerService' para 'customerService'. E você pode recuperar esse componente com o nome 'customerService'. Mas se você usar @Serviceanotação para a classe de bean, poderá fornecer um nome de bean específico,

@Service("AAA")
public class CustomerService{

e você pode obter o objeto bean

CustomerService cust = (CustomerService)context.getBean("AAA");

@Component é a anotação genérica de nível superior que torna o bean anotado a ser verificado e disponível no contêiner DI

@Repository é uma anotação especializada e traz o recurso de converter todas as exceções não verificadas das classes DAO

@Serviceé uma anotação especializada. ele não traz nenhum novo recurso a partir de agora, mas esclarece a intenção do bean

O @Controller é uma anotação especializada que conscientiza o bean MVC e permite o uso de anotações adicionais, como @RequestMapping e todas

Aqui estão mais detalhes

A @Servicepara citar a documentação da primavera,

Indica que uma classe anotada é um "Serviço", originalmente definido por Domain-Driven Design (Evans, 2003) como "uma operação oferecida como uma interface que fica sozinha no modelo, sem estado encapsulado". Também pode indicar que uma classe é uma "Business Service Facade" (no sentido de padrões do Core J2EE) ou algo semelhante. Essa anotação é um estereótipo de uso geral e as equipes individuais podem restringir sua semântica e usá-las conforme apropriado.

Se você observar o design orientado a domínio por eric evans,

Um SERVIÇO é uma operação oferecida como uma interface que fica sozinha no modelo, sem estado de encapsulamento, como fazem ENTITIES e VALUE OBJECTS. SERVIÇOS são um padrão comum em estruturas técnicas, mas também podem ser aplicados na camada de domínio. O serviço de nomes enfatiza o relacionamento com outros objetos. Ao contrário de ENTIDADES e OBJETOS DE VALOR, é definido puramente em termos do que pode fazer por um cliente. Um SERVIÇO tende a ser nomeado para uma atividade, e não para uma entidade - um verbo em vez de um substantivo. Um SERVIÇO ainda pode ter uma definição abstrata e intencional; apenas tem um sabor diferente da definição de um objeto. Um SERVIÇO ainda deve ter uma responsabilidade definida e essa responsabilidade e a interface que o cumpre devem ser definidas como parte do modelo de domínio. Os nomes das operações devem vir do UBIQUITOUS LANGUAGE ou ser introduzidos nele. Parâmetros e resultados devem ser objetos de domínio. Os SERVIÇOS devem ser utilizados com prudência e não devem retirar as ENTIDADES e os OBJETOS DE VALOR de todo o seu comportamento. Porém, quando uma operação é realmente um conceito de domínio importante, um SERVIÇO forma uma parte natural de um PROJETO CONTRATADO POR MODELOS. Declarada no modelo como um SERVIÇO, e não como um objeto falso que na verdade não representa nada, a operação independente não enganará ninguém. um SERVIÇO faz parte natural de um PROJETO CONTRATADO POR MODELOS. Declarada no modelo como um SERVIÇO, e não como um objeto falso que na verdade não representa nada, a operação independente não enganará ninguém. um SERVIÇO faz parte natural de um PROJETO CONTRATADO POR MODELOS. Declarada no modelo como um SERVIÇO, e não como um objeto falso que na verdade não representa nada, a operação independente não enganará ninguém.

e um Repositorypor Eric Evans,

Um REPOSITÓRIO representa todos os objetos de um determinado tipo como um conjunto conceitual (geralmente emulado). Ele age como uma coleção, exceto com capacidade de consulta mais elaborada. Objetos do tipo apropriado são adicionados e removidos, e o mecanismo por trás do REPOSITORY os insere ou os exclui do banco de dados. Essa definição reúne um conjunto coeso de responsabilidades por fornecer acesso às raízes dos AGREGADOS desde o início do ciclo de vida até o final.

Respostas boas o suficiente estão aqui para explicar as diferenças entre as anotações de serviço do repositório de componentes. Eu gostaria de compartilhar a diferença entre@Controller & @RestController

@Controller vs RestController

@RestController:

• Essa anotação é uma versão especializada, @Controllerque adiciona @Controllere @ResponseBodyanota automaticamente. portanto, não precisamos adicionar @ResponseBodynossos métodos de mapeamento. Que significa @ResponseBody padrão é ativo.
• Se você usar, @RestControllernão poderá retornar uma visualização (usando Viewresolver em Spring / Spring-Boot)
• @RestControllertambém converte a resposta JSON/XML automaticallycomo @ResponseBodyfaz os objetos retornados em algo que poderia estar no corpo,e.g. JSON or XML

@Controller

• @Controlleré usado para marcar classes como Spring MVC Controller. Esta anotação é apenas uma versão especializada de@Component e permite que as classes do controlador sejam detectadas automaticamente com base na varredura do caminho de classe.
• @Controller você pode retornar uma visualização no Spring Web MVC.

Vista mais detalhada

Repositório e Serviço são filhos da anotação de Componente . Então, todos eles são componentes . Repositório e Serviço apenas expandem-no. Como exatamente? O serviço tem apenas uma diferença ideológica: nós o usamos para serviços. O repositório possui um manipulador de exceção específico.

Explicação dos estereótipos:

• @Service- Anote todas as suas classes de serviço com @Service. Essa camada conhece a unidade de trabalho. Toda a sua lógica de negócios estará nas classes de serviço. Geralmente os métodos da camada de serviço são cobertos pela transação. Você pode fazer várias chamadas DAO a partir do método de serviço, se uma transação falhar, todas as transações deverão reverter.
• @Repository- Anote todas as suas classes DAO com @Repository. Toda a lógica de acesso ao banco de dados deve estar nas classes DAO.
• @Component - Anote seus outros componentes (por exemplo, classes de recursos REST) ​​com estereótipo de componente.
• @Autowired - Deixe o Spring conectar automaticamente outros beans em suas classes usando a anotação @Autowired.

@Componenté um estereótipo genérico para qualquer componente gerenciado pelo Spring. @Repository,, @Servicee @Controllersão especializações de@Component casos de uso mais específicos, por exemplo, nas camadas de persistência, serviço e apresentação, respectivamente.

Originalmente respondida aqui .

Diferença entre as anotações @Component, @Repository, @Controller & @Service

@ Component - genérico e pode ser usado em todos os aplicativos.
@Service - anote classes no nível da camada de serviço.
@ Controlador - anote classes no nível das camadas de apresentação, usadas principalmente no Spring MVC.
@Repository - anote classes na camada de persistência, que atuará como repositório de banco de dados.

@Controller= @Component (anotação interna) + Recursos da camada de apresentação
@Service= @Component (anotação interna) + Recursos da camada de serviço
@Component= Componentes reais (Beans)
@Repository= @Component (anotação interna) + Recursos da camada de dados (use para manipular os beans de domínio)

Na estrutura de primavera, fornece algum tipo especial de anotação, chamado anotação de estereótipo. Estes são os seguintes: -

@RestController- Declare at controller level.
@Controller – Declare at controller level.
@Component – Declare at Bean/entity level.
@Repository – Declare at DAO level.
@Service – Declare at BO level.

as anotações declaradas acima são especiais porque, quando adicionamos <context:component-scan>ao arquivo xxx-servlet.xml, o spring cria automaticamente o objeto daquelas classes que são anotadas com a anotação acima durante a fase de criação / carregamento de contexto.

@Component, @ Repository, @ Service, @Controller:

@Componenté um estereótipo genérico para os componentes gerenciados pelo Spring @Repository, @Servicee @Controllersão @Componentespecializações para usos mais específicos:

• @Repository para persistência
• @Service para serviços e transações
• @Controller para controladores MVC

Por que usar @Repository, @Service, @Controllerao longo @Component? Podemos marcar nossas classes de componentes com @Component, mas se usarmos a alternativa que se adapta à funcionalidade esperada. Nossas aulas são mais adequadas à funcionalidade esperada em cada caso específico.

Uma classe anotada com @Repositoryuma tradução melhor e um tratamento de erro legível com org.springframework.dao.DataAccessException. Ideal para implementar componentes que acessam dados (DataAccessObject ou DAO).

Uma classe anotada com @Controlleruma função de controlador em um aplicativo Spring Web MVC

Uma classe anotada com @Serviceuma função nos serviços de lógica de negócios, exemplo padrão de fachada para o Gerenciador de DAO (fachada) e manipulação de transações

As respostas apresentadas aqui são em grande parte tecnicamente corretas, mas, embora a lista de respostas seja longa e esta esteja no final, achei que valeria a pena colocar aqui uma resposta realmente correta também, para o caso de alguém tropeçar nela e aprender algo valioso isto. Não é que o restante das respostas esteja errado, apenas que elas não estão certas. E, para parar as hordas de trolls, sim, eu sei que tecnicamente essas anotações são efetivamente a mesma coisa e mais intercambiáveis ​​até a primavera 5. Agora, para a resposta certa:

Essas três anotações são coisas completamente diferentes e não são intercambiáveis. Você pode dizer isso porque há três deles em vez de apenas um. Eles não devem ser intercambiáveis, apenas implementados dessa maneira por elegância e conveniência.

A programação moderna é invenção, arte, técnica e comunicação, em proporções variadas. O bit de comunicação geralmente é muito importante porque o código geralmente é lido com muito mais frequência do que o escrito. Como programador, você não está apenas tentando resolver o problema técnico, mas também tentando comunicar sua intenção a futuros programadores que leem seu código. Esses programadores podem não compartilhar seu idioma nativo, nem seu ambiente social, e é possível que eles estejam lendo seu código daqui a 50 anos (não é tão improvável quanto você imagina). É difícil se comunicar efetivamente tão longe no futuro. Portanto, é vital que usemos a linguagem mais clara, mais eficiente, correta e comunicativa disponível para nós.

Por exemplo, é vital que @Repositoryseja usado quando estamos escrevendo um repositório, em vez de @Component. A última é uma escolha muito ruim de anotação para um repositório, porque não indica que estamos vendo um repositório. Podemos assumir que um repositório também é um spring bean, mas não que um componente seja um repositório. Com @Repositoryisso, estamos sendo claros e específicos em nosso idioma. Estamos afirmando claramente que este é um repositório. Com@Componentestamos deixando para o leitor decidir que tipo de componente eles estão lendo e eles terão que ler toda a classe (e possivelmente uma árvore de subclasses e interfaces) para inferir o significado. A classe poderia, então, ser mal interpretada por um leitor em um futuro distante como não sendo um repositório, e seríamos parcialmente responsáveis ​​por esse erro, porque nós, que sabíamos muito bem que esse é um repositório, deixamos de ser específicos em nosso idioma. e comunicar efetivamente nossa intenção.

Não vou entrar nos outros exemplos, mas declararei da forma mais clara possível: essas anotações são coisas completamente diferentes e devem ser usadas adequadamente, conforme a intenção delas. @Repositoryé para repositórios de armazenamento e nenhuma outra anotação está correta. @Serviceé para serviços e nenhuma outra anotação está correta. @Componenté para componentes que não são nem repositórios nem serviços, e o uso de um desses em seu lugar também seria incorreto. Pode ser compilado, pode até executar e passar nos testes, mas estaria errado e eu pensaria menos em você (profissionalmente) se você fizesse isso.

Existem exemplos disso ao longo da primavera (e programação em geral). Você não deve usar @Controllerao escrever uma API REST, porque @RestControllerestá disponível. Você não deve usar @RequestMappingquando @GetMappingé uma alternativa válida. Etc. Etc. Etc. Você deve escolher o idioma exato e correto mais específico possível para comunicar sua intenção aos seus leitores; caso contrário, você está introduzindo riscos em seu sistema, e o risco tem um custo.

Para simplificar esta ilustração, vamos considerar a tecnicidade por caso de uso. Essas anotações são usadas para serem injetadas e, como eu disse literalmente " costumavam ser injetadas ", isto é, se você souber usar a Injeção de Dependência "DI" e você você sempre procurará essas anotações e, anotando as classes com esses tipos estéreo , estará informando o contêiner de DI para digitalizá-los para que estejam prontos para a injeção em outros locais; esse é o objetivo prático.

Agora vamos passar para cada um; first @Service , Se você estiver construindo alguma lógica para um caso de negócios específico, precisará separar aquela em um local que contenha sua lógica de negócios, esse serviço é uma classe normal ou você pode usá-lo como interface, se quiser, e está escrito como isto

@Service
public class Doer {
   // Your logic 
}

// To use it in another class, suppose in Controller 
@Controller
public class XController {
 // You have to inject it like this 
 @Autowired 
 private Doer doer;
}

Todos são da mesma maneira quando você os injeta. O @Repository é uma interface que aplica a implementação ao padrão de design do Repository Pattern Repository , geralmente usado quando você está lidando com algum armazenamento de dados ou banco de dados, e verá que ele contém vários implementação pronta para você lidar com operações de banco de dados; pode ser CrudRepository , JpaRepository etc.

// For example
public interface DoerRepository implements JpaRepository<Long, XEntity> {}

Finalmente, o @Component , este é o formulário genérico para beans registrados no Spring, que está sempre procurando o feijão marcado com @Component a ser registrado, então @Service e @Repository são casos especiais de @Component, no entanto, o caso de uso comum para componente é quando você está criando algo puramente técnico, não para cobrir casos de negócios diretos! como formatação de datas ou entrega de mecanismo de serialização de solicitação especial e assim por diante.

@Component atua como anotação @Bean na classe de configuração, registra o bean no contexto da primavera. Também é pai das anotações @Service, @Repository e @Controller.

@Service , estende a anotação @Component e possui apenas diferença de nome.

@Repository - estende a anotação @Component e converte todas as exceções do banco de dados em DataAccessException .

@ Controlador - atua como controlador no padrão MVC. O expedidor examinará essas classes anotadas em busca de métodos mapeados, detectando anotações @RequestMapping.

@Component
@Controller
@Repository
@Service
@RestController

Essas são todas as anotações do StereoType. São úteis para criar nossas classes como feijão verde em um recipiente ioc,