봄철 @Component, @Repository 및 @Service 주석의 차이점은 무엇입니까?

봄철 @Component, @Repository 및 @Service 주석의 차이점은 무엇입니까?

봄철에 주석과 주석을 서로 바꿔 사용할 수 있습니까?아니면 표기 장치로서 기능하는 것 외에 특별한 기능을 제공합니까?

즉, 서비스 클래스가 있고 주석을 에서 변경할 경우@Service로.@Component, 여전히 동일하게 동작합니까?

아니면 주석이 수업의 행동과 기능에도 영향을 미칩니까?

봄 문서부터:

그@Repository주석은 저장소(데이터 액세스 개체 또는 DAO라고도 함)의 역할 또는 고정관념을 충족하는 모든 클래스의 마커입니다.이 마커의 용도에는 예외번역(Exception Translation)에 기재되어 있는 예외 자동번역이 있습니다.

스프링은 고정관념에 대한 주석을 추가로 제공합니다.@Component,@Service,그리고.@Controller.@Component는 스프링 관리 컴포넌트의 일반적인 고정관념입니다. @Repository,@Service,그리고.@Controller의 전문화입니다.@Component(각각 지속성 계층, 서비스 계층 및 프레젠테이션 계층에서) 보다 구체적인 사용 사례에 대해 설명합니다.따라서 컴포넌트 클래스에 주석을 달 수 있습니다.@Component단, 주석을 붙임으로써@Repository,@Service, 또는@Controller대신 클래스는 도구로 처리하거나 측면과 연결하기에 더 적합합니다.

예를 들어, 이러한 고정관념 주석은 포인트 컷의 이상적인 표적이 됩니다. @Repository,@Service,그리고.@Controller는 Spring Framework의 향후 릴리즈에서도 추가 의미론을 전달할 수 있습니다.따라서 다음 중 하나를 사용하는 경우@Component또는@Service서비스 레이어,@Service확실히 더 나은 선택입니다.마찬가지로 앞서 말한 바와 같이@Repository는 퍼시스텐스레이어에서 자동 예외 변환 마커로 이미 지원되고 있습니다.

주석	의미.
@Component	스프링 관리 컴포넌트에 대한 일반적인 고정관념
@Repository	지속층에 대한 고정관념
@Service	서비스 계층에 대한 고정관념
@Controller	프레젠테이션 레이어에 대한 고정관념(spring-mvc)

많은 답변이 이러한 주석의 용도를 이미 기술하고 있으므로, 여기서는 이들 주석의 몇 가지 사소한 차이점에 초점을 맞춥니다.

우선 유사성

다시 한 번 강조해야 할 첫 번째 포인트는 BeanDefinition의 스캔 자동 검출 및 의존성 주입과 관련하여 이러한 주석(viz, @Component, @Service, @Repository, @Controller)이 모두 동일하다는 것입니다.우리는 다른 것을 대신해서 사용할 수 있지만 여전히 우리의 길을 갈 수 있다.

---

@Component, @Repository, @Controller 및 @Service의 차이점

@컴포넌트

이것은 클래스가 스프링 컴포넌트임을 나타내는 범용 고정관념 주석입니다.

@Component의 특별한 점
<context:component-scan>스캔만@Component를 찾지 않습니다.@Controller,@Service그리고.@Repository일반적으로그 자체에는 다음과 같은 주석이 달렸기 때문에 스캔됩니다.@Component.

그냥 보세요@Controller,@Service그리고.@Repository주석 정의:

@Component
public @interface Service {
    ….
}

 

@Component
public @interface Repository {
    ….
}

 

@Component
public @interface Controller {
    …
}

그러므로, 라고 말하는 것은 틀린 말이 아니다.@Controller,@Service그리고.@Repository특별한 타입의@Component주석입니다. <context:component-scan>마치 그들이 주석을 달았다는 것처럼, 그들을 집어 들고 그들의 다음 클래스를 콩으로 등록한다.@Component.

특별한 유형의 주석도 스캔됩니다. 왜냐하면 주석 자체에는 다음과 같은 주석이 붙기 때문입니다.@Component주석(Annotation), 즉 주석(Annotation)도 있습니다.@Components. 커스텀 주석을 정의하고 주석을 붙이는 경우@Component, 또한, 이것은 로 스캔 됩니다.<context:component-scan>

---

@리포지토리

이는 클래스가 데이터 저장소를 정의함을 나타냅니다.

@Repository의 특별한 점은 무엇입니까?

이것은 주석 기반 구성임을 지적할 뿐만 아니라,@Repository님의 역할은 플랫폼 고유의 예외를 포착하여 Spring의 통합 체크되지 않은 예외 중 하나로 재투입하는 것입니다.이를 위해 우리는PersistenceExceptionTranslationPostProcessorSpring 어플리케이션 컨텍스트에 다음과 같이 추가해야 합니다.

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

이 콩 포스트 프로세서는 다음과 같은 주석이 달린 콩에 어드바이저를 추가합니다.@Repository플랫폼 고유의 예외가 검출되어 Spring의 체크되지 않은 데이터 액세스 예외 중 하나로 재스라운됩니다.

---

@컨트롤러

그@Controller주석은 특정 클래스가 컨트롤러 역할을 수행함을 나타냅니다.그@Controller주석은 주석이 달린 클래스에 대한 고정관념으로 작용하여 역할을 나타냅니다.

@Controller의 특별한 점은 무엇입니까?

이 주석을 다음과 같은 다른 주석과 바꿀 수 없습니다.@Service또는@Repository똑같이 생겼는데도 말이죠.디스패처는 주석이 달린 클래스를 검색합니다.@Controller및 주석으로 기술된 방법을 검출합니다.@RequestMapping주석을 달 수 있습니다.사용할 수 있습니다.@RequestMapping클래스가 주석을 달고 있는 메서드만@Controller또, 이 기능을 사용할 수중에 없습니다.@Component,@Service,@Repository기타...

_{주의: 클래스가 bean으로 이미 등록되어 있는 경우(예: ~ )@Bean또는 경유로@Component,@Serviceetc... 주석,@RequestMapping클래스에도 주석이 붙어 있으면 선택할 수 있다.@RequestMapping주석입니다.하지만 그건 다른 시나리오입니다.}

---

@서비스

@Servicebeans는 저장소 계층의 비즈니스 로직과 콜 메서드를 유지합니다.

@Service의 특별한 점은 무엇입니까?

비즈니스 논리를 유지하고 있음을 나타내는 데 사용되는 것 외에 이 주석에는 눈에 띄는 것이 없습니다.하지만 Spring이 향후에 더 많은 것을 추가할 수도 있습니다.

---

물론이지.

위와 유사하게, 향후 봄에는 다음을 위한 특수 기능이 추가될 수 있습니다.@Service,@Controller그리고.@Repository그들의 계층화 관행에 근거해서요.따라서 규칙을 존중하여 레이어에 맞춰 사용하는 것이 항상 좋습니다.

그들은 거의 같다 – 그들 모두는 학급이 봄콩이라는 것을 의미한다. @Service,@Repository그리고.@Controller전문화되어 있다@Components. 특정 액션을 수행하도록 선택할 수 있습니다.예를 들어 다음과 같습니다.

• @Controller콩은 spring-mvc에 의해 사용된다
• @Repository콩은 지속성 예외 번역 대상입니다.

또 다른 것은 구성 요소를 의미론적으로 다른 계층에 지정하는 것입니다.

한 가지,@Component다른 주석에 주석을 추가한 후 다음과 같은 방법으로 사용할 수 있습니다.@Service.

예를 들어, 저는 최근에 다음과 같이 했습니다.

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

그래서 모든 클래스에서 주석을 달았습니다.@ScheduledJob봄콩과 더불어 석영 직업으로 등록되었습니다.특정 주석을 처리하는 코드를 제공하기만 하면 됩니다.

@Component는 다음과 같습니다.

<bean>

@Service, @Controller, @Repository = {@Component + 기타 특수 기능}

즉, 서비스, 컨트롤러 및 저장소는 기능적으로 동일합니다.

3개의 주석은 애플리케이션에서 "레이어"를 구분하는 데 사용됩니다.

• 컨트롤러는 디스패치, 포워딩, 콜서비스 방식 등의 작업을 수행합니다.
• 서비스 보류 비즈니스 논리, 계산 등
• 저장소는 DAO(데이터 액세스 개체)이며 데이터베이스에 직접 액세스합니다.

이제 왜 이들을 분리하는지 질문할 수 있습니다. (AOP-Aspect 지향 프로그래밍을 알고 있을 것입니다.)

DAO 계층의 활동만 모니터링한다고 가정합니다.DAO의 모든 메서드가 호출되기 전후에 로깅을 수행하는 Aspect(A 클래스) 클래스를 작성합니다.이 클래스는 3개의 다른 레이어가 있어 혼재하지 않기 때문에 AOP를 사용하여 로깅을 수행할 수 있습니다.

따라서 DAO 방식을 "주변", "전" 또는 "후"로 기록할 수 있습니다.애초에 DAO가 있었기 때문에 그렇게 할 수 있었어방금 달성한 것은 관심사 또는 태스크의 분리입니다.

@Controller의 주석이 하나뿐이라면 이 컴포넌트는 디스패치, 비즈니스 로직 및 데이터베이스 접근이 모두 뒤섞여 더러운 코드를 가지고 있다고 상상해 보십시오.

위에서 언급한 것은 매우 일반적인 시나리오 중 하나이며, 3개의 주석을 사용하는 이유에 대한 사용 사례는 더 많습니다.

봄에는@Component,@Service,@Controller,그리고.@Repository는 다음에 사용되는 고정관념 주석입니다.

@Controller: 프레젠테이션 페이지에서 요청을 매핑할 수 있습니다.프레젠테이션 레이어가 직접 전송되는 다른 파일로 이동하지 않음@Controller에서 요청된 경로를 확인합니다.@RequestMapping필요한 경우 메서드가 호출하기 전에 작성된 주석.

@Service: 모든 비즈니스 로직이 여기에 있습니다.데이터 관련 계산 및 모든 것.사용자가 지속성 메서드를 직접 호출하지 않으므로 이 주석을 사용하여 이 메서드를 호출합니다.사용자 요구에 따라 @Repository를 요구합니다.

@Repository: 데이터베이스에서 데이터를 가져오는 데 사용되는 애플리케이션의 지속성 계층(데이터 액세스 계층)입니다. 즉, 모든 데이터베이스 관련 작업이 저장소에 의해 수행됩니다.

@Component- 다른 컴포넌트(예를 들어 REST 리소스 클래스)에 컴포넌트 고정관념으로 주석을 붙입니다.

주석이 달린 클래스가 "구성 요소"임을 나타냅니다.이러한 클래스는 주석 기반 구성 및 클래스 경로 검색을 사용할 때 자동 탐지 후보로 간주됩니다.

다른 클래스 레벨의 주석도 컴포넌트, 일반적으로 @Repository 주석 또는 Aspect J의 @Aspect 주석과 같은 특수한 종류의 컴포넌트를 식별하는 것으로 간주할 수 있습니다.

Spring 2.5에서는 @Component, @Service 및 @Controller라는 고정관념의 주석을 추가로 도입하고 있습니다.@Component는 스프링 관리 대상 컴포넌트에 대한 일반적인 고정관념 역할을 하는 반면 @Repository, @Service 및 @Controller는 보다 구체적인 사용 사례(각각 지속성, 서비스 및 프레젠테이션 계층)에 대한 @Component의 전문화 역할을 합니다.즉, 컴포넌트 클래스에 @Component를 사용하여 주석을 달 수 있지만 대신 @Repository, @Service 또는 @Controller를 사용하여 주석을 달면 클래스가 툴에 의한 처리 또는 애스펙트와의 관련성에 보다 적합합니다.예를 들어, 이러한 고정관념 주석은 포인트 컷의 이상적인 표적이 됩니다.물론 @Repository, @Service 및 @Controller는 향후 Spring Framework 릴리즈에서 추가 의미론을 전달할 수도 있습니다.따라서 서비스 계층에 @Component를 사용할지 @Service를 사용할지를 결정할 경우에는 @Service를 선택하는 것이 좋습니다.마찬가지로 위에서 설명한 바와 같이 @Repository는 지속성 레이어에서 자동 예외 변환 마커로 이미 지원됩니다.

@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.

참조:- Spring Documentation - Java를 사용한 클래스 패스 스캔, 관리 대상 컴포넌트 및 설정 기입

엄밀히 말하면@Controller,@Service,@Repository다 똑같아요.모두 확장@Component.

스프링 소스 코드:

주석이 달린 클래스가 "구성 요소"임을 나타냅니다.이러한 클래스는 주석 기반 구성 및 클래스 경로 검색을 사용할 때 자동 탐지 후보로 간주됩니다.

직접 사용할 수 있습니다.@Component모든 콩을 대상으로 하지만 대규모 애플리케이션의 이해와 유지보수를 위해@Controller,@Service,@Repository.

각 주석의 목적:

1. @Controller-> 이 주석이 달린 클래스는 클라이언트 측에서 요청을 수신하기 위한 것입니다.첫 번째 요구는 Dispatcher Servlet으로 전송되며, 여기서 다음 값을 사용하여 특정 컨트롤러로 요청을 전달합니다.@RequestMapping주석입니다.
2. @Service-> 이 주석이 달린 클래스는 클라이언트로부터 수신하거나 데이터베이스에서 가져오는 데이터를 조작하기 위한 것입니다.데이터를 사용한 모든 조작은 이 레이어에서 수행해야 합니다.
3. @Repository-> 이 주석이 달린 클래스는 데이터베이스와의 접속을 목적으로 합니다.DAO(Data Access Object) 계층으로도 간주할 수 있습니다.이 레이어는 CRUD(create, retrieve, update, delete) 조작으로만 제한해야 합니다.조작이 필요한 경우는, 데이터를 @Service 레이어로 반송할 필요가 있습니다.

만약 우리가 그들의 자리를 바꾸면 (사용)@Repository대신해서@Controller어플리케이션은 정상적으로 동작합니다.

세 가지 다른 기능을 사용하는 주된 목적은@annotations는 엔터프라이즈애플리케이션에 보다 나은 모듈성을 제공하는 것입니다.

사용방법@Service그리고.@Repository주석은 데이터베이스 연결 관점에서 중요합니다.

1. 사용하다@ServiceDB 접속의 모든 웹 서비스 유형에 대해
2. 사용하다@Repository저장된 모든 proc DB 접속에 대해

적절한 주석을 사용하지 않으면 롤백 트랜잭션에 의해 덮어쓰기되는 커밋 예외가 발생할 수 있습니다.JDBC 트랜잭션과 관련된 스트레스 부하 테스트 중 예외가 표시됩니다.

@Repository @Service 및 @Controller는 @Component의 전문화 역할을 하므로 @Service를 @Component로 대체할 수 있지만 이 경우 전문화가 느슨해집니다.

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.

이 모든 주석들은 스테레오 유형의 주석이다. 이 세 주석들 사이의 차이는 다음과 같다.

• @Component를 추가하면 클래스의 역할이 컴포넌트 클래스임을 알 수 있습니다.이것은 어떤 로직으로 이루어진 클래스라는 것을 의미하지만 특정 비즈니스 또는 지속성 또는 컨트롤러 로직을 포함하는 클래스가 있는지 알 수 없기 때문에 이 @Component 주석을 직접 사용하지 않습니다.
• @Service 주석을 추가하면 비즈니스 로직을 구성하는 클래스의 역할이 나타납니다.
• 클래스 위에 @Repository를 추가하면 지속 로직으로 구성된 클래스가
• @Component는 @Service, @Repository 및 @Controller 주석의 기본 주석입니다.

예를들면

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
    }
}

• 를 추가할 때마다@Service또는@Repositroy또는@Controller기본적으로 주석@Component주석은 클래스 맨 위에 존재하게 됩니다.

스프링은 네 가지 유형의 자동 구성 요소 스캔 주석을 제공합니다.@Component,@Service,@Repository그리고.@Controller. 기술적으로는 차이가 없지만 모든 자동 컴포넌트 스캔 주석은 정의된 레이어 내에서 특별한 목적으로 사용해야 합니다.

@Component: 기본 자동 컴포넌트 스캔 주석으로, 주석이 달린 클래스가 자동 스캔 컴포넌트임을 나타냅니다.

@Controller: 주석 클래스는 컨트롤러 컴포넌트임을 나타내며 주로 프레젠테이션레이어에서 사용됩니다.

@Service: 주석 클래스가 비즈니스 계층의 서비스 구성 요소임을 나타냅니다.

@Repository: 지속성 계층 내에서 이 주석을 사용해야 합니다.이것은 데이터베이스 저장소처럼 동작합니다.

보다 전문화된 형식을 선택해야 합니다.@Component클래스에 주석을 다는 동안 이 주석에는 향후의 특정 동작이 포함될 수 있습니다.

와는 차이가 없다.@Component,@Service,@Controller,@Repository.@ComponentMVC의 컴포넌트를 나타내는 범용 주석입니다.그러나 MVC 애플리케이션에는 서비스 계층 구성 요소, 지속성 계층 구성 요소 및 프레젠테이션 계층 구성 요소와 같은 여러 구성 요소가 포함될 것입니다.그래서 그것들을 구별하기 위해 봄 사람들은 다른 세 가지 주석도 달았다.

• 지속성 레이어 컴포넌트를 나타내는 방법@Repository
• 서비스 레이어 컴포넌트를 나타내려면:@Service
• 프레젠테이션 레이어 컴포넌트를 나타내는 방법:@Controller
• 그렇지 않으면@Component모든 걸 위해서요

@Component를 사용하여 다른 컴포넌트에 주석을 추가합니다(예: REST Resource 클래스).

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

@Component는 스프링 관리 컴포넌트의 일반적인 고정관념입니다.

@Controller, @Service 및 @Repository는 특정 사용 사례에 대한 @Component의 전문화입니다.

@봄의 컴포넌트

Java 표준에 따라 답변할 수 있습니다.

참조JSR-330이제 봄에 의해 지원되고 있습니다.사용할 수 있는 것은@Named콩을 정의하다@Named=@Component따라서 이 기준에 따르면 고정관념을 정의할 필요가 없는 것 같습니다(예:@Repository,@Service,@Controller)를 사용하여 콩을 분류합니다.

그러나 스프링 사용자는 특정 용도에 따라 서로 다른 주석을 사용합니다. 예를 들어 다음과 같습니다.

1. 개발자가 유능한 사용자를 위해 더 나은 카테고리를 정의할 수 있도록 지원합니다.이 분류는 경우에 따라서는 도움이 될 수 있습니다.(예를 들어aspect-oriented, 이것들은 좋은 후보가 될 수 있습니다.pointcuts)
2. @Repository주석을 사용하면 콩에 몇 가지 기능이 추가됩니다(콩 지속성 계층에 대한 일부 자동 예외 변환).
3. 봄 MVC를 사용하는 경우@RequestMapping주석이 달린 클래스에만 추가할 수 있습니다.@Controller.

@Component: 클래스에 주석을 추가합니다.@Component, 그것은 그것이 빈이라고 겨울잠을 잔다.

@Repository: 클래스에 주석을 추가합니다.@Repository, 최대 절전 모드인 DAO 클래스임을 알려주고 DAO 클래스로 취급합니다.체크되지 않은 예외(DAO 방식에서 제외)를 봄으로 변환하는 것을 의미합니다.DataAccessException.

@서비스:이것은 이 서비스가 서비스 클래스임을 나타냅니다.@Transactionaletc 서비스 레이어 주석으로 인해 휴지 상태가 되어 서비스 컴포넌트로 취급됩니다.

플러스@Service의 진보이다@Componentbean 클래스명은 다음과 같습니다.CustomerServiceXML bean 설정 방식을 선택하지 않았기 때문에 빈에 주석을 달았습니다.@Component빈으로 표시해 주세요.그래서 콩 오브젝트를 얻으면서CustomerService cust = (CustomerService)context.getBean("customerService");기본적으로 스프링은 구성 요소의 첫 번째 문자('고객 서비스'에서 '고객 서비스')를 소문자로 구분합니다.이 컴포넌트는 '고객 서비스'라는 이름으로 검색할 수 있습니다.단,@Service특정 콩 이름을 지정할 수 있는 콩 클래스에 대한 주석

@Service("AAA")
public class CustomerService{

콩의 오브젝트를 입수할 수 있습니다.

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

@Component, @Repository 또는 @service를 교환해도

동작은 동일하지만 컴포넌트 또는 @ 서비스를 사용하는 경우 Repository 대신 DAO와 관련된 특정 예외를 검출할 수 없습니다.

여기에 제시된 답변은 기술적으로도 부분적으로 맞지만, 응답 리스트는 길고, 이것은 맨 아래가 되겠지만, 누군가 실수하여 가치 있는 것을 배울 경우를 대비해서 여기에 실제로 맞는 답변을 넣을 가치가 있다고 생각했다.나머지 답이 완전히 틀린 것이 아니라, 단지 그들이 맞지 않을 뿐이다.그리고 수많은 트롤들을 막기 위해, 네, 저는 이 주석들이 기술적으로 지금 같은 것이고 심지어 봄 5까지 대부분 서로 교환할 수 있다는 것을 알고 있습니다.자, 정답은 다음과 같습니다.

이 세 가지 주석은 완전히 다른 것으로 서로 교환할 수 없습니다.한 개가 아니라 세 개가 있기 때문에 알 수 있습니다.호환성을 의도한 것이 아니라 우아함과 편리함에서 구현된 것입니다.

현대 프로그래밍은 다양한 비율로 발명, 예술, 기술, 커뮤니케이션이다.일반적으로 코드는 쓰여진 것보다 훨씬 더 자주 읽히기 때문에 통신 비트는 매우 중요합니다.프로그래머로서 기술적인 문제를 해결하는 것뿐만 아니라 코드를 읽는 미래의 프로그래머에게도 자신의 의도를 전달하려고 합니다.이 프로그래머들은 당신의 모국어나 사회 환경을 공유하지 않을 수도 있고, 그들이 당신의 코드를 50년 후에 읽을 수도 있습니다(생각만큼 가능성이 낮지는 않습니다).그렇게 먼 미래에 효과적으로 소통하는 것은 어렵다.따라서 우리가 사용할 수 있는 가장 명확하고, 가장 효율적이고, 올바르고, 의사소통 가능한 언어를 사용하는 것이 중요합니다.최대한의 영향을 주고 우리의 의도를 명확히 하기 위해 우리의 말을 신중하게 선택했다는 것이다.

예를 들어, 는 매우 중요합니다.@Repository저장소를 작성할 때 사용됩니다.@Component후자는 저장소에 대한 주석 선택이 매우 좋지 않습니다. 왜냐하면 저장소는 우리가 저장소를 보고 있다는 것을 나타내지 않기 때문입니다.저장소도 스프링빈이라고 가정할 수 있지만 구성 요소가 저장소라고 가정할 수는 없습니다.와 함께@Repository우리는 우리의 언어로 명확하고 구체적입니다.우리는 이것이 저장소라고 분명히 말하고 있다.와 함께@Component우리는 그들이 읽고 있는 컴포넌트의 종류를 결정하는 것을 독자에게 맡기고, 그들은 의미를 추론하기 위해 전체 클래스(그리고 아마도 하위 클래스 및 인터페이스의 트리)를 읽어야 할 것이다.이 클래스는 먼 훗날 독자에 의해 저장소가 아닌 것으로 오해될 수 있으며, 이것이 저장소라는 것을 충분히 알고 있던 우리가 우리의 언어로 특정하고 우리의 의도를 효과적으로 전달하지 못했기 때문에 우리는 이 실수에 대해 부분적으로 책임이 있을 것이다.

다른 예로는 설명하지 않고 가능한 한 명확하게 설명하겠습니다.이러한 주석은 완전히 다른 것으로, 목적에 따라서 적절히 사용할 필요가 있습니다. @Repository스토리지 저장소용이며 다른 주석은 정확하지 않습니다. @Service는 서비스용이며 다른 주석은 정확하지 않습니다. @Component저장소도 서비스도 아닌 컴포넌트용입니다.이들 중 하나를 그 자리에서 사용하는 것도 올바르지 않습니다.컴파일이나 테스트에 합격할 수도 있지만 틀릴 수도 있습니다.이렇게 하면 (전문적으로) 당신을 얕잡아 볼 수도 있습니다.

봄 내내(및 일반적으로 프로그래밍) 이러한 예가 있습니다.사용해서는 안 됩니다.@ControllerREST API를 작성할 때, 그 이유는@RestController사용할 수 있습니다.사용해서는 안 됩니다.@RequestMapping언제@GetMapping유효한 대체 수단입니다.등독자에게 자신의 의도를 전달할 수 있는 가장 구체적이고 정확한 언어를 선택해야 합니다.그렇지 않으면 시스템에 리스크가 발생하고 리스크에는 대가가 따릅니다.

마지막으로 객체 지향 시스템에 대한 주문 포인트를 말씀드리겠습니다.기본 규칙 중 하나는 구현은 다양하지만 인터페이스는 다양하지 않아야 한다는 것입니다.이 주석들이 동일하다고 가정하는 것은 매우 미끄러운 경사면이며 OO에 완전히 반하는 것입니다.현재는 서로 다른 방식으로 구현될 수 있지만, 미래에 구현될 것이라는 보장은 없습니다.또한 같은 팀 내에서도 엔지니어는 애스펙트를 사용하여 이들 주석 중 하나 또는 여러 개에서 일부 동작을 수행하거나 플랫폼 엔지니어가 운영상의 이유로 이들 중 하나의 구현을 대체하는 것을 선택할 수 있습니다.OO에서는 구현이 아닌 인터페이스에 의존합니다.

Spring 4의 최신 버전:

@Repository 주석은 저장소(데이터 액세스 개체 또는 DAO라고도 함)의 역할 또는 고정관념을 충족하는 모든 클래스의 마커입니다.이 마커의 용도 중에는 섹션 20.2.2 "예외 번역"에 설명된 예외 자동 번역이 있습니다.

봄에는 @Component, @Service 및 @Controller와 같은 고정관념 주석이 제공됩니다.@Component는 스프링 관리 컴포넌트의 일반적인 고정관념입니다.@Repository, @Service 및 @Controller는 각각 지속성, 서비스 및 프레젠테이션 계층 등 보다 구체적인 사용 사례에 대한 @Component의 전문화입니다.따라서 @Component를 사용하여 컴포넌트클래스에 주석을 붙일 수 있지만 대신 @Repository, @Service 또는 @Controller로 주석을 붙이면 클래스가 툴에 의한 처리나 애스펙트와의 관련성에 보다 적합합니다.예를 들어, 이러한 고정관념 주석은 포인트 컷의 이상적인 표적이 됩니다.또한 @Repository, @Service 및 @Controller는 향후 Spring Framework 릴리즈에서 추가 시멘틱스를 전달할 수 있습니다.따라서 서비스 계층에 @Component와 @Service 중 하나를 사용하는 경우 @Service가 더 나은 선택입니다.마찬가지로 위에서 설명한 바와 같이 @Repository는 지속성 레이어에서 자동 예외 변환 마커로 이미 지원됩니다.

@Component주석 달린 콩을 스캔하여 DI 컨테이너에서 사용할 수 있도록 하는 최상위 일반 주석입니다.

@Repository특수한 주석으로 DAO 클래스에서 체크되지 않은 모든 예외를 변환하는 기능을 제공합니다.

@Service전용 주석입니다.현재로선 새로운 특징이 없지만 콩의 의도를 명확히 한다.

@Controller는 빈 MVC를 인식하고 다음과 같은 추가 주석을 사용할 수 있도록 하는 특수한 주석입니다.@RequestMapping기타 등등

자세한 내용은 이쪽

여기에서는 컴포넌트 간 차이, 저장소 서비스 주석에 대해 설명하기에 충분한 답변을 제공합니다.이 두 가지 차이점을 공유하고 싶습니다.@Controller & @RestController

@Controller vs RestController

다음과 같습니다@RestController.

• 이 주석은 의 특수 버전입니다.@Controller그 때문에,@Controller그리고.@ResponseBody주석을 자동으로 추가할 필요가 없습니다.@ResponseBody맵핑 방법에 따라 달라집니다.즉,@ResponseBody는 디폴트로 액티브입니다.
• 사용하시는 경우@RestController보기를 반환할 수 없습니다(사용:Viewresolver스프링/스프링-부트에서)
• @RestController응답도 에 변환한다.JSON/XML automatically~하듯이@ResponseBody돌려받은 물건을 몸 안에 있을 수 있는 것으로 만들고e.g. JSON or XML

---

@Controller

• @Controller는 클래스를 Spring MVC 컨트롤러로 마크하기 위해 사용됩니다.이 주석은 의 특수한 버전일 뿐입니다.@Component클래스 패스 스캔에 근거해 컨트롤러 클래스를 자동 검출할 수 있습니다.
• @ControllerSpring web MVC에서 뷰를 반환할 수 있습니다.

상세보기

A @Service스프링 문서를 인용하려면

주석이 달린 클래스가 Domain-Driven Design(Evans, 2003)에 의해 원래 "캡슐화된 상태를 가지지 않고 모델 내에서 독립된 인터페이스로 제공되는 작업"으로 정의된 "Service"임을 나타냅니다.클래스가 (코어 J2EE 패턴의 의미에서) "비즈니스 서비스 외관" 또는 이와 유사한 것임을 나타낼 수도 있습니다.이 주석은 범용 고정관념이며 개별 팀은 의미를 좁혀 적절하게 사용할 수 있다.

에릭 에반스의 도메인 주도 디자인을 보면

SERVICE는 ENTITES 및 VALUE OBJETES와 같이 캡슐화 상태를 사용하지 않고 모델 내에서 단독으로 제공되는 인터페이스입니다.SERVICE는 기술 프레임워크에서 일반적인 패턴이지만 도메인 계층에도 적용할 수 있습니다.네임 서비스는 다른 오브젝트와의 관계를 강조합니다.ENTITES 및 VALUE OBJETES와는 달리 클라이언트에 대해 무엇을 할 수 있는지에 따라 정의됩니다.서비스(SERVICE)는 실체보다는 활동에 대해 명사보다는 동사라는 이름을 붙이는 경향이 있다.SERVICE는 여전히 추상적이고 의도적인 정의를 가질 수 있습니다.단, 객체의 정의와는 다른 맛을 가지고 있을 뿐입니다.서비스에는 여전히 정의된 책임이 있어야 하며, 이러한 책임과 그 책임을 수행하는 인터페이스를 도메인 모델의 일부로 정의해야 합니다.작업명은 유비쿼터스 언어에서 유래하거나 도입해야 합니다.매개 변수 및 결과는 도메인 개체여야 합니다.SERVICES는 신중하게 사용해야 하며 ENTITES 및 VALUE OBJETE의 모든 동작을 제거해서는 안 됩니다.그러나 실제로 운영이 중요한 도메인 개념인 경우, SERVICE는 MODEL-DRIVEN DESIGN의 자연스러운 부분을 형성합니다.실제로는 아무것도 나타내지 않는 가짜 오브젝트가 아니라 SERVICE로 모델에서 선언된 독립형 오퍼레이션은 누구도 오인하지 않습니다.

및 aRepository에릭 에반스에 따르면

저장소는 특정 유형의 모든 개체를 개념 집합(일반적으로 에뮬레이트됨)으로 나타냅니다.보다 정교한 쿼리 기능이 있는 경우를 제외하고는 컬렉션과 같이 작동합니다.적절한 유형의 개체가 추가 및 제거되고, REPORITORITORY 뒤에 있는 시스템이 해당 개체를 삽입하거나 데이터베이스에서 삭제합니다.이 정의에서는 초기 라이프 사이클부터 최종 라이프 사이클까지 Aggregates의 루트에 대한 액세스를 제공하기 위한 일련의 일관된 책임을 수집합니다.

Repository 및 Service는 구성 요소 주석의 하위 항목입니다.모두 컴포넌트입니다.Repository 및 Service에서 확장만 하면 됩니다.정확히 말해서 어떻게요?서비스에는 이념적인 차이만 있습니다.서비스에는 그것을 사용합니다.리포지토리에 특정 예외 처리기가 있습니다.

고정관념 설명:

• @Service- @Service를 사용하여 모든 서비스 클래스에 주석을 추가합니다.이 계층은 작업 단위를 알고 있습니다.비즈니스 로직은 모두 서비스 클래스에서 이루어집니다.일반적으로 서비스 계층의 방법은 트랜잭션 대상입니다.서비스 메서드에서 DAO 콜을 여러 번 발신할 수 있습니다.하나의 트랜잭션이 실패하면 모든 트랜잭션이 롤백됩니다.
• @Repository- @Repository를 사용하여 모든 DAO 클래스에 주석을 추가합니다.모든 데이터베이스 액세스 논리는 DAO 클래스에 있어야 합니다.
• @Component- 다른 컴포넌트(예를 들어 REST 리소스 클래스)에 컴포넌트 고정관념으로 주석을 붙입니다.
• @Autowired- Spring이 @Autowired 주석을 사용하여 다른 콩을 클래스에 자동 배선할 수 있도록 합니다.

@Component는 스프링 관리 컴포넌트의 일반적인 고정관념입니다. @Repository,@Service,그리고.@Controller의 전문화입니다.@Component예를 들어 지속성 계층, 서비스 계층 및 프레젠테이션 계층에서 각각 보다 구체적인 사용 사례에 대해 설명합니다.

원래 여기에 대답했습니다.

@Component는 컨피규레이션클래스에서 @Bean 주석으로 동작하며 봄 컨텍스트에서 bean을 등록합니다.또한 @Service, @Repository 및 @Controller 주석의 부모이기도 합니다.

@Service, @Component 주석을 확장하며 이름만 다릅니다.

@Repository - @Component 주석을 확장하고 모든 데이터베이스 예외를 Data Access로 변환합니다.예외입니다.

@Controller - MVC 패턴에서 컨트롤러로 동작합니다.디스패처는 이러한 주석 클래스에서 매핑된 메서드를 스캔하여 @RequestMapping 주석을 검출합니다.

@Component, @Repository, @Controller 및 @Service 주석의 차이점

@Component – 범용으로 어플리케이션 전체에서 사용할 수 있습니다.
@Service – 서비스 계층 수준에서 클래스에 주석을 추가합니다.
@Controller – 주로 봄 MVC에서 사용되는 프레젠테이션 레이어 수준의 클래스에 주석을 추가합니다.
@Repository – 데이터베이스 저장소 역할을 하는 지속성 계층에서 클래스에 주석을 추가합니다.

@Controller= @Component(내부 주석) + 프레젠테이션 레이어 특징
@Service= @Component (내부 주석) + 서비스 계층 기능
@Component= 실제 구성품 (콩 )
@Repository= @Component(내부 주석) + 데이터 계층 기능(도메인 빈 취급에 사용)

스프링은 @Component, @service, @Repository 등 여러 유형의 주석을 지원합니다.모든 내용은 org.springframework.streotype 패키지에 있고 @Bean은 org.springframework.context.annotation 패키지에 있습니다.

응용 프로그램의 클래스에 상기 주석 중 하나가 주석을 달면 프로젝트 시작 시 스프링 스캔(@ComponentScan 사용) 동안 각 클래스가 주석을 달고 IOC 컨테이너에 클래스 인스턴스를 주입합니다.또한 @ComponentScan은 @Bean을 사용하여 메서드를 실행하여 반환 개체를 빈으로 IOC 컨테이너에 복원합니다.

(@Component vs @service vs @Repository)에 대해 자세히 설명하기 전에 먼저 @Bean과 @Component의 차이를 이해하는 것이 좋습니다.

---

@Component vs @Repository vs @Service

---

대부분의 일반적인 애플리케이션에는 데이터 액세스, 프레젠테이션, 서비스, 비즈니스 등의 계층이 있습니다.또한 각 층마다 다양한 콩이 있습니다.이러한 콩을 자동으로 검출하기 위해 Spring에서는 클래스 패스스캔 주석을 사용합니다.그런 다음 Application Context에 각 빈을 등록합니다.

다음은 이러한 주석의 일부에 대한 간략한 개요입니다.

• @Component는 스프링 관리 컴포넌트의 일반적인 고정관념입니다.
• @Service는 서비스 계층의 클래스에 주석을 추가합니다.
• @Repository는 데이터베이스 저장소 역할을 하는 지속성 계층의 클래스에 주석을 추가합니다.

@컴포넌트 주석

@Component는 클래스 수준의 주석입니다.어플리케이션 전체에서 @Component를 사용하여 콩을 Spring의 관리 대상 컴포넌트로 표시할 수 있습니다.Spring은 @Component에만 콩을 픽업하여 등록하며 일반적으로 @Service 및 @Repository는 검색하지 않습니다.

@Component로 주석이 붙어 있기 때문에 ApplicationContext에 등록됩니다.

앞에서 설명한 바와 같이 @Component는 모든 고정관념 주석의 부모입니다.스프링은 구성 요소 스캔을 수행할 때 @Component 주석이 표시된 클래스만 찾습니다.

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Indexed
public @interface Component {
    String value() default "";
}

이 주석은 모든 클래스에 사용할 수 있으며 아무런 차이가 없습니다.

@서비스 주석

델은 비즈니스 로직을 보유하고 있음을 나타내기 위해 @Service로 콩을 표시합니다.서비스 계층에서 사용되는 것 외에 이 주석에는 특별한 용도가 없습니다.

@Service는 컴포넌트의 하위 항목으로 응용 프로그램의 서비스 계층에서 클래스를 나타내기 위해 사용됩니다.

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Component
public @interface Service {
   @AliasFor(
       annotation = Component.class
   )
   String value() default "";
}

@리포지토리 주석

@Repository의 역할은 지속성 고유의 예외를 포착하여 Spring의 통합된 체크되지 않은 예외 중 하나로 다시 던지는 것입니다.

이를 위해 Spring은 PersistenceExceptionTranslationPostProcessor를 제공합니다.이것을 어플리케이션 컨텍스트에 추가해야 합니다(Spring Boot을 사용하는 경우 이미 포함되어 있습니다).

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

이 bean 포스트 프로세서는 @Repository 주석이 달린 bean에 어드바이저를 추가합니다.

마찬가지로 @Repository는 컴포넌트 주석의 하위 항목이며 지속성 데이터 액세스 계층에 속하며 데이터 저장소 역할을 하는 클래스에 사용됩니다.

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Component
public @interface Repository {
    @AliasFor(
        annotation = Component.class
    )
    String value() default "";
}

요약

@Service 및 @Repository는 @Component의 특수한 경우입니다.그것들은 기술적으로 동일하지만, 우리는 그것들을 다른 용도로 사용한다.항상 레이어 규칙에 따라 주석을 선택하는 것이 좋습니다.

봄철 프레임워크는 고정관념 주석이라고 불리는 특별한 유형의 주석을 제공합니다.다음은 다음과 같습니다.

@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.

위의 선언된 주석은 특별합니다. 왜냐하면 우리가 추가할 때<context:component-scan>xxx-servlet.xml 파일로 spring은 컨텍스트 작성/로드 단계 중에 위의 주석이 추가된 클래스의 개체를 자동으로 만듭니다.

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

@Component스프링이 관리하는 컴포넌트에 대한 일반적인 고정관념입니다.@Repository,@Service,그리고.@Controller이다@Component보다 구체적인 용도를 위한 전문화:

• @Repository끈기 있게
• @Service서비스 및 트랜잭션용
• @ControllerMVC 컨트롤러의 경우

사용하는 이유@Repository,@Service,@Controller에 걸쳐서@Component컴포넌트 클래스를 @Component로 표시할 수 있지만, 그 대신 예상되는 기능에 맞는 대체 기능을 사용할 경우.우리의 클래스는 각각의 경우에 기대되는 기능에 더 적합하다.

A class annotated with @Repository has a better translation and readable error handling with org.springframework.dao.DataAccessException. Ideal for implementing components that access data (DataAccessObject or DAO).

An annotated class with @Controller plays a controller role in a Spring Web MVC application

An annotated class with @Service plays a role in business logic services, example Facade pattern for DAO Manager (Facade) and transaction handling

In order to simplify this illustration, let us consider technicality by use case, These annotations are used to be injected and as I said literally "Used to be injected" , that mean, if you know how to use Dependency Injection "DI" and you should, then you will always look for these annotations, and by annotating the classes with these Stereo Types, you are informing the DI container to scan them to be ready for Injection on other places, this is the practical target.

Now lets move to each one; first @Service, If you are building some logic for specific business case you need to separate that in a place which will contain your business logic, this service is normal Class or you can use it as interface if you want , and it is written like this

@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;

    // Your logic
}

All are the same way when you inject them, @Repository it's an interface which apply the implementation for the Repository PatternRepository design pattern, generally it's used when you are dealing with some data store or database, and you will find that, it contains multiple ready implementation for you to handle database operations; it can be CrudRepository, JpaRepository etc.

For example:

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

Finally the @Component, this is the generic form for registered beans in Spring, that's spring is always looking for bean marked with @Component to be registered, then both @Service and @Repository are special cases of @Component, however the common use case for component is when you're making something purely technical not for covering direct business case! like formatting dates or handing special request serialization mechanism and so on.

@Component
@Controller
@Repository
@Service
@RestController

These are all StereoType annotations.this are usefull for the making our classes as spring beans in ioc container,

언급URL : https://stackoverflow.com/questions/6827752/whats-the-difference-between-component-repository-service-annotations-in