ti-enxame.com

Qual é a diferença entre as anotações @Component, @Repository e @Service no Spring?

As anotações @Component, @Repository e @Service podem ser usadas de forma intercambiável na Spring ou fornecem alguma 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 eu alterar a anotação de @Service para @Component, ela ainda se comportará da mesma maneira?

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

1863
Colin McCree

De documentação da primavera :

No Spring 2.0 e posterior, a anotação @Repository é um marcador para qualquer classe que atenda à função ou estereótipo (também conhecido como Data Access Object ou DAO) de um repositório. Entre os usos desse marcador está a tradução automática de exceções.

O Spring 2.5 introduz outras anotações de estereótipos: @Component, @Service e @Controller. @Component é um estereótipo genérico para qualquer componente gerenciado pelo Spring. @Repository, @Service e @Controller são especializações de @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 componentes com @Component, mas anotando-as com @Repository, @Service ou @Controller, suas classes são mais adequadas para processamento por ferramentas ou associação com aspectos. Por exemplo, essas anotações de estereótipos são ideais para os pontos de corte.

Assim, se você está escolhendo entre @Component ou @Service para sua camada de serviço, @Service é claramente a melhor escolha. Da mesma forma, como dito acima, @Repository já é suportado como um marcador para traduçã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)      │
└────────────┴─────────────────────────────────────────────────────┘
1365
stivlo

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

Primeiro o Similaridade

O primeiro ponto que merece ser ressaltado novamente é que no que diz respeito à detecção automática de varredura e injeção de dependência para BeanDefinition todas essas anotações (isto é, @Component, @Service, @Repository, @Controller) são as mesmas. Nós podemos usar um no lugar do outro e ainda podemos contornar.


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

@ Component

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

O que é especial sobre @Component
<context:component-scan> apenas verifica @Component e não procura @Controller, @Service e @Repository em geral. Eles são digitalizados porque eles mesmos são anotados com @Component.

Dê uma olhada nas definições das anotações @Controller, @Service e @Repository:

@Component
public @interface Service {
    ….
}

@Component
public @interface Repository {
    ….
}

@Component
public @interface Controller {
    …
}

Assim, não é errado dizer que @Controller, @Service e @Repository são tipos especiais de anotação @Component. <context:component-scan> os pega e registra as classes seguintes como beans, como se tivessem sido anotados com @Component.

As anotações de tipo especial também são verificadas, porque elas próprias são anotadas com a anotação @Component, o que significa que elas também são @Components. Se definirmos nossa própria anotação personalizada e anotá-la com @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 é especial sobre @Repository?

Além de ressaltar que essa é uma configuração Configuração baseada em anotações, @Repository é pegar exceções específicas da plataforma e lançá-las novamente como uma exceção não verificada unificada do Spring. Para isso, fornecemos PersistenceExceptionTranslationPostProcessor, que devemos incluir no contexto de nosso aplicativo do Spring, desta forma:

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

Esse pós-processador de bean adiciona um orientador a qualquer bean que tenha anotado com @Repository, para que as exceções específicas da plataforma sejam capturadas e, em seguida, reproduzidas como uma das exceções de acesso a dados não verificadas do Spring.


@ Controller

A anotação @Controller indica que uma determinada classe atende à função de um controlador. A anotação @Controller atua como um estereótipo para a classe anotada, indicando sua função.

O que é especial sobre o @Controller?

Não podemos mudar esta anotação com qualquer outra como @Service ou @Repository, mesmo que pareçam iguais. O dispatcher examina as classes anotadas com @Controller e detecta métodos anotados com anotações @RequestMapping dentro deles. Nós podemos usar @RequestMapping on/in somente aqueles métodos cujas classes são anotadas com @Controller e irá NÃO trabalhar com @Component, @Service, @Repository etc ...

Nota: Se uma classe já estiver registrada como um bean através de qualquer método alternativo, como @Bean ou @Component, @Service etc ..., então @RequestMapping pode ser selecionado se a classe também for anotada com a anotação @RequestMapping. Mas esse é um cenário diferente.


@ Service

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

O que há de especial no @Service?

Além do fato de que é usado para indicar que está mantendo a lógica de negócios, não há nada mais perceptível nessa anotação; mas quem sabe, a primavera pode adicionar alguns excepcionais adicionais no futuro.


O que mais?

Semelhante ao acima, no futuro, a Spring pode adicionar funcionalidades especiais para @Service, @Controller e @Repository com base em suas convenções de camadas. Portanto, é sempre uma boa ideia respeitar a convenção e usá-la de acordo com as camadas.

649
Raman Sahasi

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

  • @Controller beans são usados ​​pelo spring-mvc
  • @Repository beans estão qualificados para tradução de exceção de persistência

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

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

Por exemplo recentemente eu fiz:

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

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

413
Bozho

@Component é equivalente a

<bean>

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

Isso significa Serviço, O Controlador e Repositório são funcionalmente os mesmos.

As três anotações são usadas para separar "Layers" em sua aplicação,

  • Controladores apenas fazem coisas como despachar, encaminhar, chamar métodos de serviço, etc.
  • Lógica de negócios, 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 separá-los: (Eu suponho que você sabe AOP-Aspect Oriented Programming)

Digamos que você queira Monitora somente a atividade da camada DAO. Você escreverá uma classe Aspect (classe A) que faz alguma criação de log antes e depois de cada método do DAO ser invocado, você pode fazer isso usando AOP, já que tem três camadas distintas e não são misturadas.

Portanto, você pode fazer o log do DAO "around", "before" ou "after" os métodos DAO. Você poderia fazer isso porque você tinha um DAO em primeiro lugar. O que você acabou de conseguir é Separação de preocupações ou tarefas.

Imagine se houvesse apenas uma anotação @Controller, então esse componente terá dispatching, lógica de negócios e acessando banco de dados todo código misto, tão sujo!

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

350
Oliver

No Spring, @Component, @Service, @Controller e @Repository são anotações de Estereótipo que são usadas para:

@Controller: onde seu pedido mapeamento da página de apresentação feito, por exemplo, camada de apresentação ganha ' Vá para qualquer outro arquivo que vá diretamente para a classe @Controller e verifique o caminho solicitado na anotação @RequestMapping que foi escrita antes das chamadas de método, se necessário.

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

@Repository: Esta é a camada Persistence (Data Access Layer) do aplicativo que costumava obter dados do banco de dados. ou seja, todas as operações relacionadas ao Banco de Dados são feitas pelo repositório.

@Component - Anote seus outros componentes (por exemplo REST classes de recurso) 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 configuração baseada em anotação e verificação de caminho de classe.

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

enter image description here

210
Harshal Patil

O Spring 2.5 introduz outras anotações de estereótipo: @Component, @Service e @Controller. @Component serve como um estereótipo genérico para qualquer componente gerenciado pelo Spring; enquanto que @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 isso 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 com aspectos. Por exemplo, essas anotações de estereótipos são ideais para os pontos de corte. Naturalmente, também é possível que @Repository, @Service e @Controller possam transportar semânticas adicionais em futuras versões do Spring Framework. Assim, se você está tomando uma decisão entre usar @Component ou @Service para sua camada de serviço, o @Service é claramente a melhor escolha. Da mesma forma, como dito acima, @Repository já é suportado como um marcador para tradução automática de exceções em 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 - Escaneamento de Classpath, componentes gerenciados e configurações de escrita usando Java

67
Ajit Singh

O uso de anotações @Service e @Repository é importante da perspectiva de conexão com o banco de dados.

  1. Use @Service para todos os tipos de conexões de banco de dados do serviço da web
  2. Use @Repository para todas as suas conexões de banco de dados de proc.

Se você não usar as anotações adequadas, poderá enfrentar exceções de confirmação sobrescritas por transações de reversão. Você verá exceções durante o teste de carga de tensão relacionado à reversão de transações JDBC.

43
Das

@ Repositório@ Service e @ Controller são servidos como especialização de @Component para uso mais específico com base nisso você pode substituir @Service to @Component mas neste 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.
26
atish shimpi

Tecnicamente @Controller, @Service, @Repository são todos iguais. Todos eles ampliam @Components.

A partir do código fonte do Spring:

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

Podemos usar diretamente @Component para cada bean, mas para melhor compreensão e manutenção de um aplicativo grande, usamos @Controller, @Service, @Repository.

Finalidade de cada anotação:

1) @Controller -> Classes anotadas com isto, destinam-se a receber um pedido do lado do cliente. A primeira solicitação chega ao Servlet do Dispatcher, de onde passa a solicitação para o controlador específico usando o valor da anotação @RequestMapping.

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 isto, destinam-se a conectar com o banco de dados. Também pode ser considerado como camada DAO (Data Access Object). Essa camada deve ser restrita somente às operações CRUD (criar, recuperar, atualizar, excluir). Se qualquer manipulação for necessária, os dados devem ser enviados para serem enviados para a camada @Service.

Se nós trocarmos o lugar deles (use @Repository no lugar de @Controller), nosso aplicativo funcionará bem.

O principal objetivo de usar três @annotations diferentes é fornecer melhor Modularidade ao aplicativo Enterprise.

26
Yogendra123

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

  • Se adicionarmos o @Component então ele diz que a função de classe é uma classe de componente significa que é uma classe que consiste em alguma lógica, mas não diz se uma classe contendo uma lógica de negócio ou persistência ou controlador especificamente diretamente esta anotação @Component
  • Se adicionarmos a anotação @Service, ela informará que uma função de classe consiste em lógica de negócios
  • Se adicionarmos @Repository na parte superior da classe, ele informará que uma classe consistindo em lógica de persistência
  • Aqui @Component é uma anotação base para 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 @Service ou @Repositroy ou @Controller por padrão @Component anotação vai existir no topo da classe
25
Anil Amane

O Spring fornece quatro tipos diferentes de anotações de verificação automática de componentes, eles são @Component, @Service, @Repository e @Controller. Tecnicamente, não há diferença entre eles, mas todas as anotações de verificação de componente automático devem ser usadas 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 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 essa anotação na camada de persistência, isso funciona como um repositório de banco de dados.

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

20
hardeep thakur

Nós podemos responder isso de acordo com o padrão Java

Referindo-se a JSR-330, que agora é suportado pela mola, você só pode usar @Named para definir um bean (Somehow @[email protected]). Portanto, de acordo com esse padrão, parece não haver uso para definir estereótipos (como @Repository, @Service, @Controller) para as categorias beans.

Mas o usuário da primavera estas anotações diferentes em diferentes para o uso específico, 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ê está usando aspect-oriented, eles podem ser bons candidatos para pointcuts)
  2. A anotação @Repository adicionará algumas funcionalidades ao seu bean (alguma tradução automática de exceções para sua camada de persistência de bean).
  3. Se você estiver usando o Spring MVC, o @RequestMapping só poderá ser adicionado a classes anotadas por @Controller.
18
Alireza Fattahi

Anote outros componentes com @Component, por exemplo REST Classes de recursos.

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

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

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

@Componente na Primavera

"Component Specialization"

18
Anil Nivargi

Mesmo se nós trocarmos @Component ou @Repository ou @service

Ele se comportará da mesma forma, mas um aspecto é que eles não conseguirão capturar alguma exceção específica relacionada ao DAO em vez do Repositório se usarmos componente ou @ service

15
Manjush

Na primavera 4, última versão:

A anotação @Repository é um marcador para qualquer classe que atenda à 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 na Seção 20.2.2, “Tradução de exceção”.

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 de @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 com aspectos. Por exemplo, essas anotações de estereótipos são ideais para os pontos de corte. Também é possível que @Repository, @Service e @Controller possam transportar semânticas adicionais em futuras versões do Spring Framework. Assim, se você está escolhendo entre usar @Component ou @Service para sua camada de serviço, o @Service é claramente a melhor escolha. Da mesma forma, como dito acima, @Repository já é suportado como um marcador para tradução automática de exceções em sua camada de persistência.

15
Quan Nguyen

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, as pessoas da Primavera deram as outras três anotações também.

Para representar componentes da camada de persistência: @Repository

Para representar componentes da camada de serviço: @Service

Para representar componentes da camada de apresentação: @Controller

ou então você pode usar o @Component para todos eles.

12
tech.yenduri

@Component é a anotação genérica de nível superior que faz com que o bean anotado seja verificado e esteja 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 é anotação especializada. não traz nenhum novo recurso a partir de agora, mas esclarece a intenção do bean

@Controller é uma anotação especializada que torna o bean MVC ciente e permite o uso de outras anotações como @RequestMapping e todas elas

Aqui estão mais detalhes

11
Amol Dixit

Um @Service para 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 encapsulado state. " Também pode indicar que uma classe é um" Business Service Facade "(no sentido de padrões do Core J2EE), ou algo similar. Essa anotação é um estereótipo de propósito geral e equipes individuais podem restringir sua semântica e usar conforme apropriado.

Se você olhar para o design dirigido por domínio por eric evans,

Um SERVIÇO é uma operação oferecida como uma interface que fica sozinha no modelo, sem encapsular o estado, como ENTIDADES e OBJETOS DE VALOR. Os serviços são um padrão comum em estruturas técnicas, mas também podem se aplicar na camada de domínio. O serviço de nomes enfatiza o relacionamento com outros objetos. Diferentemente de ENTITIES e VALUE OBJECTS, ele é definido puramente em termos do que ele pode fazer por um cliente. Um SERVIÇO tende a ser nomeado para uma atividade, em vez de uma entidade - um verbo em vez de um substantivo. Um SERVIÇO ainda pode ter uma definição abstrata e intencional; só 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 a cumpre devem ser definidas como parte do modelo de domínio. Os nomes das operações devem vir do idioma UBIQUITOUS ou ser introduzidos nele. Parâmetros e resultados devem ser objetos de domínio. Os SERVIÇOS devem ser usados ​​judiciosamente e não podem retirar as ENTIDADES e os OBJETOS DE VALOR de todo o seu comportamento. Mas quando uma operação é realmente um conceito de domínio importante, um SERVIÇO forma uma parte natural de um DESIGN MODELADO. 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 Repository como por 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 uma capacidade de consulta mais elaborada. Os objetos do tipo apropriado são adicionados e removidos, e o mecanismo por trás do REPOSITORY os insere ou exclui do banco de dados. Esta definição reúne um conjunto coeso de responsabilidades para fornecer acesso às raízes dos AGREGADOS desde o início do ciclo de vida até o final.

10
Bharath

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

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

@ Service: Isto diz ao hibernate que é uma classe de serviço onde você terá anotações de camada de serviço @Transactional etc, então o hibernate a trata como um componente de serviço.

Plus @Service é o avanço do @Component. Suponha que o nome da classe do bean seja CustomerService, desde que você não tenha escolhido a forma de configuração do bean XML, então anotou o bean com @Component para indicar como um Bean. Portanto, ao obter o objeto bean CustomerService cust = (CustomerService)context.getBean("customerService"); Por padrão, o Spring irá diminuir o primeiro caractere do componente - de ‘CustomerService’ para ‘customerService’. E você pode recuperar esse componente com o nome "customerService". Mas se você usar a anotação @Service para a classe do bean, você pode fornecer um nome de bean específico

@Service("AAA")
public class CustomerService{

e você pode obter o objeto bean por

CustomerService cust = (CustomerService)context.getBean("AAA");
9
Arun Raaj

Repositório e Serviço são filhos de Componente anotação. Então, todos eles são Componente. Repositório e Serviço apenas expandi-lo. Como exatamente? Serviço tem apenas diferença ideológica: usamos para serviços. Repositório tem um manipulador de exceções específico.

8
Maria Karpikova

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á em classes de serviço. Geralmente, os métodos de 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 devem ser recuperadas.
  • @Repository - Anote todas as suas classes DAO com @Repository. Toda a lógica de acesso do banco de dados deve estar nas classes DAO.
  • @Component - Anote seus outros componentes (por exemplo REST classes de recursos) com o estereótipo do componente.
  • @Autowired - Deixe o Spring ligar automaticamente outros beans em suas classes usando a anotação @Autowired.

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

Originalmente respondida aqui .

4
Jeevan Patil

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

@Component é um estereótipo genérico para os componentes gerenciados pelo Spring @ Repository, @Service e @Controller são especializações @Component para usos mais específicos:

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

Por que usar @Repository, @Service, @Controller over @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 "@Repository" tem uma melhor tradução e tratamento de erros legível com org.springframework.dao.DataAccessException. Ideal para implementar componentes que acessam dados (DataAccessObject ou DAO).

Uma classe anotada com "@Controller" desempenha uma função de controlador em um aplicativo Spring Web MVC

Uma classe anotada com "@Service" desempenha um papel nos serviços de lógica de negócios, por exemplo, padrão Facade para DAO Manager (Facade) e manipulação de transações

2
UHDante

Na estrutura de primavera fornece algum tipo especial de anotações, chamadas anotações 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> no arquivo xxx-servlet.xml, a mola criará automaticamente o objeto das classes que são anotadas com a anotação acima durante a fase de criação/carregamento do contexto.

2
Brajesh

A fim de 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 " Usado para ser injetado ", que significa, se você sabe como usar Injeção de dependência "DI" e você deve, então você sempre irá procurar por estas anotações, e anotando as classes com estas Tipos Estéreo , você está informando o container DI para verificá-los para estarem prontos para Injeção em outros lugares , este é o alvo prático.

Agora vamos nos mover para cada um deles; primeiro @ Service , Se você está criando alguma lógica para casos de negócios específicos, é necessário separá-la em um local que contenha sua lógica de negócios, esse serviço é classe normal ou você pode usá-lo como interface, se quiser, e está escrito assim

@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, @ Repositório é uma interface que aplica a implementação para o Padrão de Repositório Padrão de design do Repositório =, geralmente é usado quando você está lidando com algum armazenamento de dados ou banco de dados, e você descobrirá que ele contém várias implementações prontas para você manipular as operações do 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 é a primavera está sempre procurando pelo bean marcado com @Component para ser registrado, então tanto @Service como @Repository são casos especiais de @Component, no entanto, o caso de uso comum para componente é quando você está fazendo algo puramente técnico, não para cobrir casos de negócios diretos! como datas de formatação ou entregando o mecanismo de serialização de solicitação especial e assim por diante.

1
Mohamed Sweelam