java - service用法 - spring repository注解




Spring中的@Component,@Repository和@Service注释有什么区别? (17)

Spring 2.5引入了更多的构造型注释:@Component,@Service和@Controller。 @Component是任何Spring管理组件的通用构造型; 而@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编写配置

@Repository @Component@Repository@Service注释可以在Spring中互换使用,还是除了充当符号设备外,还可以提供任何特定的功能吗?

换句话说,如果我有一个Service类并将@Service的注释更改为@Component ,它的行为是否仍然相同?

或者注释是否也会影响课堂的行为和功能?


@ Component,@ Service,@ Controller和@ Repository之间没有区别。 @Component是表示我们MVC组件的通用注释。 但是会有几个组件作为MVC应用程序的一部分,如服务层组件,持久层组件和表示层组件。 所以为了区分他们春天人们也给了其他三个注释。

表示持久层组件:@Repository

表示服务层组件:@Service

表示表示层组件:@Controller

否则你可以使用@Component来处理它们。


Spring @Component @Service@Repository @Controller@Repository@Controller注释用于在Spring框架中使用类路径扫描进行自动Bean检测。

@Component是一个通用的注释。 @Repository @Controller@Repository@Controller@Component区别在于它们是@Component的特殊情况,并用于特定目的。 区别仅仅是分类。

对于所有这些注释(刻板印象),技术上核心目的是相同的。 Spring会自动扫描并标识所有这些用“ @Component @Service@Repository @Controller@Repository@Controller ”注解的@Component ,并使用ApplicationContext注册Bean Definition。


Spring提供了四种不同类型的自动组件扫描注释,它们是@Component Component, @Repository @Controller@Repository@Controller 。 从技术上讲,它们之间没有区别,但是每个汽车零部件扫描注释都应该用于特定目的,并且在定义的图层中使用。

@Component :这是一个基本的自动组件扫描注释,它表示带注释的类是一个自动扫描组件。

@Controller :带注释的类表示它是一个控制器组件,主要用于表示层。

@Service :它表示带注释的类是业务层中的Service组件。

@Repository :您需要在持久层中使用此注释,这就像数据库存储库一样。

在批注他们的类时,应该选择更具体的@Component形式,因为此注释可能包含未来的特定行为。


@Component : you annotate a class @Component, it tells hibernate that it is a Bean.

@Repository : you annotate a class @Repository, it tells hibernate it is a DAO class and treat it as DAO class. Means it makes the unchecked exceptions (thrown from DAO methods) eligible for translation into Spring DataAccessException.

@Service : This tells hibernate it is a Service class where you will have @Transactional etc Service layer annotations so hibernate treats it as a Service component.

Plus @Service is advance of @Component. Assume the bean class name is CustomerService, since you did not choose XML bean configuration way so you annotated the bean with @Component to indicate it as a Bean. So while getting the bean object CustomerService cust = (CustomerService)context.getBean("customerService"); By default, Spring will lower case the first character of the component – from 'CustomerService' to 'customerService'. And you can retrieve this component with name 'customerService'. But if you use @Service annotation for the bean class you can provide a specific bean name by

@Service("AAA")
public class CustomerService{

and you can get the bean object by

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

@Component,@Service和@Repository之间的区别

这些刻板印象之间的主要区别在于它们被用于不同的分类。

在一个多层应用程序中,我们将有不同的层次,如演示文稿,服务,业务,数据访问等。当一个类将被Spring注释为自动检测时,那么我们应该使用各自的构造型如下。

@Component - 通用的,可以跨应用程序使用。
@Service - 在服务层级别注释类。
@Repository - 在持久层注释类,它将充当数据库存储库。

如果技术上他们会一样,那么为什么我们需要在不同的层次上使用这些。 为什么不在所有图层上使用相同的图层。 例如,如果我们在所有图层中使用@Service ,则所有的bean都将被实例化并且没有问题。 有一个小小的区别,例如考虑@Repository

后处理器会自动查找所有异常转换器(PersistenceExceptionTranslator接口的实现),并建议所有标记有@Repository注释的bean,以便发现的转换器可以拦截并应用所抛出的异常的适当转换。

与上面类似,未来Spring可能会根据分层约定为@Service @Controller@Repository @Controller@Repository添加值。 为了达到这个附加的功能优势,它更好地遵守约定,并将它们与层次结合使用。

除上述以外,就扫描自动检测而言,BeanDefinition @Component @Service@Repository @Controller@Repository@Controller Controller的依赖注入是相同的。


Explanation of stereotypes :

  • @Service - Annotate all your service classes with @Service. This layer knows the unit of work. All your business logic will be in Service classes. Generally methods of service layer are covered under transaction. You can make multiple DAO calls from service method, if one transaction fails all transactions should rollback.
  • @Repository - Annotate all your DAO classes with @Repository. All your database access logic should be in DAO classes.
  • @Component - Annotate your other components (for example REST resource classes) with component stereotype.
  • @Autowired - Let Spring auto-wire other beans into your classes using @Autowired annotation.

@Component是任何Spring管理组件的通用原型。@Repository@Service并且@Controller@Component更具体的用例的专门化,例如,分别在持久性,服务和表示层中。

最初here回答。


A @Service to quote spring documentation,

Indicates that an annotated class is a "Service", originally defined by Domain-Driven Design (Evans, 2003) as "an operation offered as an interface that stands alone in the model, with no encapsulated state." May also indicate that a class is a "Business Service Facade" (in the Core J2EE patterns sense), or something similar. This annotation is a general-purpose stereotype and individual teams may narrow their semantics and use as appropriate.

If you look at domain driven design by eric evans,

A SERVICE is an operation offered as an interface that stands alone in the model, without encapsulating state, as ENTITIES and VALUE OBJECTS do. SERVICES are a common pattern in technical frameworks, but they can also apply in the domain layer. The name service emphasizes the relationship with other objects. Unlike ENTITIES and VALUE OBJECTS, it is defined purely in terms of what it can do for a client. A SERVICE tends to be named for an activity, rather than an entity—a verb rather than a noun. A SERVICE can still have an abstract, intentional definition; it just has a different flavor than the definition of an object. A SERVICE should still have a defined responsibility, and that responsibility and the interface fulfilling it should be defined as part of the domain model. Operation names should come from the UBIQUITOUS LANGUAGE or be introduced into it. Parameters and results should be domain objects. SERVICES should be used judiciously and not allowed to strip the ENTITIES and VALUE OBJECTS of all their behavior. But when an operation is actually an important domain concept, a SERVICE forms a natural part of a MODEL-DRIVEN DESIGN. Declared in the model as a SERVICE, rather than as a phony object that doesn't actually represent anything, the standalone operation will not mislead anyone.

and a Repository as per Eric Evans,

A REPOSITORY represents all objects of a certain type as a conceptual set (usually emulated). It acts like a collection, except with more elaborate querying capability. Objects of the appropriate type are added and removed, and the machinery behind the REPOSITORY inserts them or deletes them from the database. This definition gathers a cohesive set of responsibilities for providing access to the roots of AGGREGATES from early life cycle through the end.


从数据库连接的角度来看,使用@Service@Repository注释非常重要。

  1. 对所有Web服务类型的数据库连接使用@Service
  2. 为所有存储的proc数据库连接使用@Repository

如果您没有使用正确的注释,则可能会面临由回滚事务覆盖的提交异常。 在压力负载测试期间,您会看到与回滚JDBC事务相关的异常。


使用@Component注释其他组件,例如REST资源类。

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

@Component是任何Spring托管组件的通用构造型。

@Controller,@Service和@Repository是针对特定用例的@Component的专业化版本。

@ Spring中的组件


在Spring @Component@Service @Controller@Repository @Controller@Repository是Stereotype注释,用于:

@Controller:你的请求 映射从演示文稿页面完成,即表示层不会转到任何其他文件,它将直接转到@Controller类,并在必要时在方法调用之前编写的@RequestMapping注释中检查请求的路径。

@Service :所有业务逻辑都在这里,即数据相关的计算和所有。这是业务层的注释,我们的用户不直接调用持久化方法,所以它会使用这个注解调用这个方法。 它将根据用户请求请求@Repository

@Repository :这是用于从数据库获取数据的应用程序的持久层(数据访问层)。 即所有与数据库相关的操作都由存储库完成。

@Component - 用组件原型注释其他组件(例如REST资源类)。

表示注释类是“ component ”。 当使用基于注释的配置和类路径扫描时,这些类被认为是自动检测的候选对象。

其他类级别的注释也可以被视为标识组件,通常是一种特殊的组件:例如@Repository注释或AspectJ's @Aspect注释。

component


在一个多层应用程序中,我们将有不同的层次,如演示文稿,服务,业务,数据访问等。当一个类将被Spring注释为自动检测时,那么我们应该使用各自的构造型如下。

  • @Component - 通用的,可以跨应用程序使用。
  • @Service - 在服务层级别注释类。
  • @Controller - 在表示层级注释类,主要用于Spring MVC。
  • @Repository - 在持久层注释类,它将充当数据库存储库。

它们几乎是一样的 - 它们都意味着这个类是一个Spring bean。 @Service @Controller@Repository@Controller是专用的@Component 。 您可以选择执行特定的操作。 例如:

  • @Controller bean被spring-mvc使用
  • @Repository bean有资格进行持久性异常转换

另一件事是你指定组件在语义上不同的层。

@Component提供的一件事是您可以使用它注释其他注释,然后以与@Service相同的方式使用它们。

例如最近我做了:

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

所以所有使用@ScheduledJob注解的类都是spring bean,除此之外,它们@ScheduledJob注册为石英作业。 您只需提供处理特定注释的代码。


我们可以根据java标准回答这个问题

参考Spring现在支持的JSR-330 ,你只能使用@Named来定义一个bean(一些how @[email protected] )。 所以根据这个标准,似乎没有必要定义立体声类型(比如@Repository@Service @Repository@Service @Controller )来分类bean。

但是,春季用户将这些不同的注释用于特定用途,例如:

  1. 帮助开发人员为主管人员定义更好的类别。 这种分类在某些情况下可能会有所帮助。 (例如,当您使用aspect oriented ,这些可能是point cuts好选择)
  2. @Repository注释会为您的bean添加一些功能(一些自动异常转换到您的bean持久层)。
  3. 如果您使用的是spring mvc,则@RequestMapping只能添加到由@Controller注释的类中。

技术上@Controller,@Service和@Repository都是一样的。 所有这些扩展@Components。

源自Spring源代码:

表示注释类是“组件”。 当使用基于注释的配置和类路径扫描时,这些类被认为是自动检测的候选对象。

我们可以为每个bean直接使用@Component,但为了更好地理解和维护大型应用程序,我们使用@Controller,@Service和@Repository。

每个注释的目的:

1)@Controller - >用这个注解的类,旨在接收来自客户端的请求。 First request comes to the Dispatcher Servlet, from where it passes the request to the particular controller using value of @RequestMapping annotation.

2) @Service -> Classes annotated with this, are intended to manipulate data, that we receive from client or fetch from database. All the manipulation with data should be done in this layer.

3) @Repository -> Classes annotated with this, are intended to connect with database. It can also be considered as DAO(Data access Object) layer. This layer should be restricted to CRUD (create,retrieve,update,delete) operations only. If any manipulation is required, data should be send be send back to @Service layer.

If we interchange their place(use @Repository in place of @Controller), our application will work fine.

The main purpose of using three different @annotations is to provide better Modularity to the Enterprise application.


由于许多答案已经说明了这些注释的用途,我们在这里将重点讨论它们之间的一些细微差别。

首先是相似性

值得再次强调的一点是, 对于BeanDefinition的扫描自动检测和依赖注入,所有这些注释(即@Component,@Service,@ Repository,@Controller)都是相同的。 我们可以用一个替代另一个,仍然可以解决问题。

@Component,@Repository,@Controller和@Service之间的差异

@零件

这是一个通用的构造型注释,指示该类是一个弹簧组件。

@Component有什么特别之处
<context:component-scan>仅扫描@Component ,通常不会查找@Controller@Service @Controller@Repository 。 他们被扫描,因为他们自己用@Component注释。

只要看看@Controller@Service @Controller@Repository注释定义:

@Component
public @interface Service {
    ….
}

@Component
public @interface Repository {
    ….
}

@Component
public @interface Controller {
    …
}

因此,说@Controller@Service @Controller@Repository@Component注释的特殊类型是没有错的。 <context:component-scan>选取它们并将它们的以下类注册为bean,就像它们使用@Component注释一样。

他们被扫描,因为他们自己用@Component注释进行了注释。 如果我们定义自己的自定义注释并使用@Component注释它,那么它也将使用<context:component-scan>

@Repository

这表示该类定义了一个数据存储库。

@Repository有什么特别之处?

除了指出这是一个基于注解的配置之外@Repository的工作是捕获特定于平台的异常,并将它们重新引用为Spring的统一非检查异常。 为此,我们提供了PersistenceExceptionTranslationPostProcessor ,我们需要在Spring的应用程序上下文中添加如下内容:

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

这个bean后期处理器将一个顾问程序添加到任何使用@Repository注释的bean中,以便捕获任何特定于平台的异常,然后重新将其作为Spring未经检查的数据访问异常之一。

@Controller

@Controller注释表示特定的类用作控制器的角色。 @Controller批注充当注释类的刻板印象,表明其作用。

@Controller有什么特别之处?

我们无法使用任何其他类似@Service@Repository来切换此注释,即使它们看起来相同。 调度程序扫描用@Controller注释的类并检测其中的@RequestMapping注释。 我们只能在@Controller注释类上使用@RequestMapping

@服务

@Services在仓库层中保存业务逻辑和调用方法。

@Service有什么特别之处?

除了它被用来表明它拥有业务逻辑的事实之外,这个注释并没有明显的特点,但是谁知道,spring可能会在未来增加一些额外的特性。

还有什么?

与上面类似,未来Spring可能会根据分层约定为@Service @Controller@Repository @Controller@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.  

您会注意到所有@Repository@Service @Controller@Controller都使用@Component进行了注释。 那么,我们可以只使用@Component来进行自动扫描的所有组件吗? 是的,你可以,Spring将自动扫描所有你的组件带有注解的@Component。

它工作正常,但不是一个好的做法,为了可读性,您应该总是为指定图层声明@Repository@Service @Controller@Controller ,以使您的代码更易于阅读。







annotations