java - with - spring аннотации




В чем разница между комментариями @Component, @Repository и @Service весной? (16)

Могут ли @Component , @Repository и @Service аннотации использоваться взаимозаменяемо весной или они предоставляют какую-либо конкретную функциональность, помимо того, что вы выступаете в качестве устройства нотации?

Другими словами, если у меня есть класс службы, и я изменяю аннотацию из @Service на @Component , будет ли он по-прежнему вести себя одинаково?

Или аннотация также влияет на поведение и функциональность класса?


Spring 2.5 вводит дополнительные аннотации к стереотипам: @Component, @Service и @Controller. @Component служит общим стереотипом для любого компонента, управляемого Spring; тогда как @Repository, @Service и @Controller служат специализациями @Component для более конкретных случаев использования (например, в уровнях персистентности, обслуживания и представления соответственно). Это означает, что вы можете комментировать ваши классы компонентов с помощью @Component, но вместо этого добавив их в @Repository, @Service или @Controller, ваши классы более подходят для обработки инструментами или связывания с аспектами. Например, эти аннотации стереотипов делают идеальные цели для pointcut. Конечно, также возможно, что @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.

reference: - Spring Documentation - Сканирование классов, управляемые компоненты и записи с использованием Java


@Component эквивалентен

<bean>

@Service, @Controller, @Repository = {@Component + еще одна специальная функция}

Это означает, что Service, The Controller и Repository функционально одинаковы.

Три аннотации используются для разделения «Слои» в приложении,

  • Контроллеры просто делают такие вещи, как диспетчеризация, переадресация, вызов методов обслуживания и т. Д.
  • Служба Hold Business Logic, Расчеты и т. Д.
  • Репозиторий - это DAO (объекты доступа к данным), они напрямую обращаются к базе данных.

Теперь вы можете спросить, зачем их разделять: (я полагаю, вы знаете AOP-Aspect Oriented Programming)

Предположим, вы хотите контролировать только активность слоя DAO. Вы напишете класс Aspect (A class), который выполняет некоторую регистрацию до и после каждого метода вашего DAO, вы можете сделать это с помощью AOP, поскольку у вас есть три разных слоя и не смешиваются.

Таким образом, вы можете выполнять протоколирование DAO «вокруг», «до» или «после» методов DAO. Вы могли бы это сделать, потому что у вас был DAO в первую очередь. То, что вы только что достигли, - это разделение проблем или задач.

Представьте себе, что есть только одна аннотация @Controller, тогда этот компонент будет иметь диспетчерскую, бизнес-логику и доступ к базе данных, все смешанные, так грязные коды!

Вышеупомянутый - один очень распространенный сценарий, есть еще много примеров использования трех аннотаций.


Аннотировать другие компоненты с помощью @Component, например, классы ресурсов REST.

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

@Component - это общий стереотип для любого компонента, управляемого Spring.

@Controller, @Service и @Repository являются специализациями @Component для конкретных случаев использования.

@Component весной


Весной 4, последняя версия:

Аннотирование @Repository является маркером для любого класса, который выполняет роль или стереотип репозитория (также известного как объект доступа к данным или DAO). Среди применений этого маркера - автоматический перевод исключений, как описано в Разделе 20.2.2, «Перевод исключений».

Spring предоставляет дополнительные аннотации к стереотипам: @Component, @Service и @Controller. @Component - это общий стереотип для любого компонента, управляемого Spring. @Repository, @Service и @Controller являются специализациями @Component для более конкретных случаев использования, например, в уровнях персистентности, обслуживания и представления, соответственно. Таким образом, вы можете аннотировать свои классы компонентов с помощью @Component, но вместо этого аннотируя их с помощью @Repository, @Service или @Controller, ваши классы более подходят для обработки инструментами или связывания с аспектами. Например, эти аннотации стереотипов делают идеальные цели для pointcut. Также возможно, что @Repository, @Service и @Controller могут нести дополнительную семантику в будущих выпусках Spring Framework. Таким образом, если вы выбираете между использованием @Component или @Service для вашего уровня обслуживания, @Service, безусловно, лучший выбор. Аналогично, как указано выше, @Repository уже поддерживается как маркер автоматического перевода исключений в вашем уровне персистентности.


Даже если мы меняем @Component или @Repository или @service

Он будет вести себя одинаково, но один аспект заключается в том, что они не смогут поймать какое-то конкретное исключение, связанное с DAO, а не с репозиторием, если мы используем компонент или службу @


Из весны Документация :

В Spring 2.0 и более поздних @Repository аннотация @Repository является маркером для любого класса, который выполняет роль или стереотип (также известный как объект доступа к данным или DAO) репозитория. Среди применений этого маркера - автоматический перевод исключений.

Spring 2.5 вводит дополнительные аннотации к стереотипам: @Component , @Service и @Controller . @Component - это общий стереотип для любого компонента, управляемого Spring. @Repository , @Service и @Controller являются специализациями @Component для более конкретных случаев использования, например, в уровнях персистентности, обслуживания и представления, соответственно.

Таким образом, вы можете аннотировать свои классы компонентов с помощью @Component , но вместо этого аннотируя их с помощью @Repository , @Service или @Controller , ваши классы более подходят для обработки инструментами или связывания с аспектами. Например, эти аннотации стереотипов делают идеальные цели для pointcut.

Таким образом, если вы выбираете между использованием @Component или @Service для вашего уровня обслуживания, @Service , безусловно, лучший выбор. Аналогично, как указано выше, @Repository уже поддерживается как маркер автоматического перевода исключений в вашем уровне персистентности.

┌────────────┬─────────────────────────────────────────────────────┐
│ 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)      │
└────────────┴─────────────────────────────────────────────────────┘

Мы можем ответить на это по стандарту java

Ссылаясь на JSR-330 , который теперь поддерживается весной, вы можете использовать @Named для определения компонента ( @Named @[email protected] ). Таким образом, согласно этому стандарту, нет смысла определять стереотипы (например, @Repository , @Service , @Controller ) для категорий beans.

Но весенний пользователь эти разные аннотации в разных для конкретного использования, например:

  1. Помогите разработчикам определить лучшую категорию для компетентных. В некоторых случаях эта категоризация может оказаться полезной. (Например, когда вы используете aspect-oriented , это может быть хорошим кандидатом для pointcuts )
  2. Аннотации @Repository добавят некоторую функциональность вашему bean-компоненту (некоторый автоматический перевод исключений на ваш уровень @Repository компонента).
  3. Если вы используете @RequestMapping MVC, @RequestMapping может быть добавлен только в классы, которые аннотируются @Controller .

Нет никакой разницы между @ Component, @ Service, @ Controller, @ Repository. @Component - это общая аннотация для представления компонента нашего MVC. Но в составе нашего MVC-приложения будут использоваться несколько компонентов, таких как компоненты уровня обслуживания, компоненты уровня persistence и компоненты уровня представления. Поэтому, чтобы отличить их, люди весны также дали еще три аннотации.

Представление компонентов уровня сохранения: @Repository

Чтобы представить компоненты уровня обслуживания: @Service

Чтобы представить компоненты уровня презентации: @Controller

или вы можете использовать @Component для всех из них.


Поскольку многие ответы уже указывают, для чего используются эти аннотации, мы остановимся на некоторых незначительных различиях между ними.

Сначала сходство

Еще один момент, который стоит подчеркнуть, заключается в том, что в отношении сканирования-автоматического обнаружения и зависимостей для BeanDefinition все эти аннотации (а именно @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 . Если мы определим нашу собственную аннотацию и аннотируем ее с помощью @Component , она также будет проверена с помощью <context:component-scan>

@Repository

Это означает, что класс определяет репозиторий данных.

Что особенного в @Repository?

В дополнение к тому, что это конфигурация на основе аннотаций , работа @Repository заключается в том, чтобы улавливать специфические исключения для платформы и повторно бросать их как одно из исключенных исключенных исключений Spring. И для этого нам предоставлен PersistenceExceptionTranslationPostProcessor , который мы должны добавить в контексте приложения Spring, например:

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

Этот обработчик @Repository добавляет советника к любому bean-компоненту, который аннотируется с @Repository так что любые исключения для конкретной платформы пойманы, а затем возвращаются как один из исключенных исключений доступа к данным Spring.

@Controller

Аннотация @Controller указывает, что конкретный класс служит ролью контроллера. @Controller действует как стереотип для аннотированного класса с указанием его роли.

Что особенного в @Controller?

Мы не можем переключать эту аннотацию на любой другой, такой как @Service или @Repository , хотя они выглядят одинаково. Диспетчер просматривает классы, аннотированные с помощью @Controller и обнаруживает в них аннотации @RequestMapping . Мы можем использовать @RequestMapping @Controller аннотированных классов @Controller .

@Обслуживание

@Services содержат бизнес-логику и метод вызова в слое репозитория.

Что особенного в @Service?

Помимо того, что он используется для обозначения того, что он держит бизнес-логику, нет заметной специальности, которую предоставляет эта аннотация, но кто знает, весна может добавить в будущем дополнительные дополнительные возможности.

Что-то еще?

Как и в @Service @Controller , в будущем Spring может предпочесть добавить специальные функции для @Service , @Controller и @Repository на основе их соглашений о @Repository . Следовательно, всегда хорошая идея соблюдать соглашение и использовать их в соответствии со слоями.


Технически @Controller, @Service, @Repository - все те же. Все они расширяют @Components.

Из исходного кода Spring:

Указывает, что аннотированный класс является «компонентом». Такие классы рассматриваются как кандидаты на автоматическое обнаружение при использовании конфигурации на основе аннотаций и сканирования пути к классам.

Мы можем напрямую использовать @Component для каждого компонента, но для лучшего понимания и поддержки большого приложения мы используем @Controller, @Service, @Repository.

Цель каждой аннотации:

1) @Controller -> Классы, аннотированные с этим, предназначены для получения запроса со стороны клиента. Первый запрос поступает в диспетчерский сервлет, откуда он передает запрос конкретному контроллеру, используя значение аннотации @RequestMapping.

2) @Service -> Классы, аннотированные этим, предназначены для управления данными, которые мы получаем от клиента или извлечения из базы данных. Все манипуляции с данными должны выполняться в этом слое.

3) @Repository -> Классы, аннотированные этим, предназначены для подключения к базе данных. Его также можно рассматривать как слой DAO (Data Access Object). Этот слой должен быть ограничен только CRUD (создавать, извлекать, обновлять, удалять). Если требуется какая-либо манипуляция, данные должны быть отправлены обратно на уровень @Service.

Если мы заменим их место (используйте @Repository вместо @Controller), наше приложение будет работать нормально.

Основная цель использования трех разных @annotations - обеспечить лучшую модульность для приложения Enterprise.


@Component - это общая аннотация верхнего уровня, которая заставляет аннотированный компонент быть отсканированным и доступным в контейнере DI

@Repository - это специализированная аннотация, которая привносит особенность преобразования всех исключенных исключений из классов DAO

@Service - специализированная аннотация. он не привносит никакой новой функции на данный момент, но он разъясняет намерение компонента

@Controller - это специализированная аннотация, которая делает bean MVC @RequestMapping и позволяет использовать дополнительную аннотацию, такую ​​как @RequestMapping и все такие

Вот более details


@Service чтобы процитировать весеннюю документацию,

Указывает, что аннотированный класс - это «Служба», первоначально определенная Domain-Driven Design (Evans, 2003) как «операция, предлагаемая как интерфейс, который стоит отдельно в модели, без инкапсулированного состояния». Может также указать, что класс - это «Бизнес-фасад» (в смысле ядра J2EE) или что-то подобное. Это аннотирование является стереотипом общего назначения, и отдельные команды могут сузить семантику и использовать по мере необходимости.

Если вы посмотрите на дизайн, управляемый доменом,

СЕРВИС - это операция, предлагаемая в качестве интерфейса, который стоит отдельно в модели, без инкапсулирующего состояния, как это делают объекты и объекты VALUE. УСЛУГИ являются общей схемой в технических рамках, но они также могут применяться на уровне домена. Служба имен подчеркивает взаимосвязь с другими объектами. В отличие от ОБЪЕКТОВ И ОБЪЕКТОВ VALUE, он определяется исключительно с точки зрения того, что он может сделать для клиента. СЛУЖБА имеет тенденцию быть названным для действия, а не для сущности-глагола, а не для существительного. СЕРВИС все еще может иметь абстрактное, преднамеренное определение; у него просто отличный вкус, чем определение объекта. Служба SERVICE должна по-прежнему иметь определенную ответственность, а ответственность и выполняемый интерфейс должны быть определены как часть модели домена. Названия операций должны поступать из UBIQUITOUS LANGUAGE или вводиться в нее. Параметры и результаты должны быть объектами домена. УСЛУГИ следует использовать разумно и не разрешать лишать ОБЪЕКТОВ И ЦЕННОСТЕЙ ОБЪЕКТОВ всех своих действий. Но когда операция на самом деле является важной концепцией домена, СЕРВИС образует естественную часть МОДЕЛЬ-ДВИЖЕНИЯ. Объявленная в модели как служба, а не как фальшивый объект, который на самом деле ничего не представляет, автономная операция никого не вводит в заблуждение.

и Repository в соответствии с Эриком Эвансом,

REPOSITORY представляет все объекты определенного типа в качестве концептуального набора (обычно эмулируемого). Он действует как сборник, за исключением более сложных запросов. Объекты соответствующего типа добавляются и удаляются, а оборудование, расположенное за REPOSITORY, вставляет их или удаляет из базы данных. Это определение собирает сплоченный набор обязанностей для обеспечения доступа к корням AGGREGATES из раннего жизненного цикла до конца.


@Component : вы комментируете класс @Component, он сообщает спящему, что это Bean.

@Repository : вы комментируете класс @Repository, он говорит, что спящий режим является классом DAO и рассматривает его как класс DAO. Означает, что он делает исключенные исключения (брошенные из методов DAO), подходящие для перевода в Spring DataAccessException.

@Service : это говорит о спящем режиме, это класс обслуживания, где у вас будут @Transactional и т. Д. Аннотации уровня сервиса, поэтому hibernate рассматривает его как компонент службы.

Plus @Service продвигается @Component. Предположим, что имя класса компонента - CustomerService, так как вы не выбрали конфигурацию XML-компонента, поэтому вы аннотировали компонент с @Component, чтобы указать его как Bean. Таким образом, при получении объекта компонента CustomerService cust = (CustomerService)context.getBean("customerService"); По умолчанию Spring уменьшит регистр первого символа компонента - от «CustomerService» до «customerService». И вы можете получить этот компонент с именем «customerService». Но если вы используете аннотацию @Service для класса bean, вы можете указать конкретное имя компонента

@Service("AAA")
public class CustomerService{

и вы можете получить объект bean

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

@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, @ Repository, @ Service, @Controller:

@Component - общий стереотип для компонентов, управляемых Spring @Repository, @Service и @Controller - это @Component специализации для более конкретных целей:

  • @ Репозиторий для настойчивости
  • @ Сервис для обслуживания и транзакций
  • @ Контроллер для контроллеров MVC

Зачем использовать @Repository, @Service, @Controller над @Component? Мы можем отметить наши классы компонентов с помощью @Component, но вместо этого мы используем альтернативу, которая адаптируется к ожидаемой функциональности. Наши классы лучше подходят для функциональности, ожидаемой в каждом конкретном случае.

Класс, аннотированный с помощью «@Repository», имеет улучшенную обработку перевода и чтения с помощью org.springframework.dao.DataAccessException. Идеально подходит для реализации компонентов, которые обращаются к данным (DataAccessObject или DAO).

Аннотированный класс с «@Controller» играет роль контроллера в приложении Spring Web MVC

Аннотированный класс с «@Service» играет роль в бизнес-логике, например, шаблон фасада для DAO Manager (Facade) и обработки транзакций


В весеннем каркасе предусмотрен специальный аннотация, называемая аннотациями стереотипов. Они следующие: -

@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 автоматически создаст объект тех классов, которые аннотируются с помощью аннотации в течение фазы создания / загрузки контекста.





annotations