25 Вопрос: В чем разница между аннотациями @Component, @Repository & @Service в Spring?

вопрос создан в Thu, Jun 15, 2017 12:00 AM

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

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

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

    
1869
  1. Будучи разработчиком с опытом работы в Microsoft, я вспоминаю семантическое определение сервисов в старой платформе MS SmartClientSoftwareFactory (теперь это давно устаревшая сложная среда для распределенных настольных приложений). Это определение ( = "nofollow noreferrer"> хорошо документированный Ричом Ньюманом) определил службы как повторно используемые объекты без сохранения состояния, предпочтительно с одноэлементной областью действия, которые используются для выполнения операций бизнес-логики над другими объектами, передаваемыми в качестве аргументов. Я склонен рассматривать службы Spring одинаково
    2015-11-10 15: 56: 52Z
  2. Не имеет значения !! Что бы ни работало для вас :) Я всегда ненавидел это в Spring, потому что они всегда стремятся определить «правила» для вас, которые только добавляют тривиальную ценность вашему приложению. Не говоря уже о Spring поставляется с огромным собственным стеком.
    2017-07-05 04: 45: 44Z
  3. @ TriCore Sprting - это фреймворк, определить "правила" для вас - его работа:)
    2017-09-28 15: 00: 59Z
25 ответов                              25                         

Из Spring Документация :

  

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

     

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

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

     

Таким образом, если вы выбираете между использованием @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)      │
└────────────┴─────────────────────────────────────────────────────┘
    
1366
2018-06-21 23: 54: 51Z
  1. Имеет ли смысл добавлять @Controller (или @Component) в @WebServlet? Это не контроллер Spring MVC, но это концептуально наиболее близкое соответствие. А как насчет фильтров сервлетов?
    2014-03-11 10: 08: 41Z
  2. Это относится к тому факту, что эти аннотации являются хорошими целями для АОП, и хотя другие аннотации еще не определяют pointcut, они могут сделать это в будущем. С другой стороны, @Repository уже является целью для pointcut в настоящее время. Этот pointcut используется для трансляций исключений, то есть для перевода специфичных для технологии исключений в более общие Spring-во избежание тесной связи.
    2015-03-20 11: 50: 17Z
  3. @ stivlo: Я действительно пытался понять термин «стереотип», но до сих пор не понял. Не могли бы вы помочь мне понять эту терминологию? Это очень помогает и большое спасибо
    2015-07-02 13: 24: 52Z
  4. @ xenoterracide Существует практически небольшая разница. Что-то, помеченное @Service , является также @Component (потому что сама аннотация @Service помечена @Component). Насколько я знаю, ничто в среде Spring явно не использует тот факт, что что-то является @Service, поэтому разница действительно только концептуальная.
    2016-05-31 09: 23: 45Z

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

  

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

     

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

Различия между @Component, @Repository, @Controller и @Service

  

@Component

Это аннотация стереотипа общего назначения, указывающая на то, что класс является пружинным компонентом.

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

  

@Repository

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

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

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

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

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

  

@Controller

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

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

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

Примечание. Если класс уже зарегистрирован как компонент с помощью какого-либо альтернативного метода, например, с помощью аннотаций @Bean или @Component, @Service и т. д., тогда можно выбрать @RequestMapping, если класс также аннотирован с аннотацией @RequestMapping. Но это другой сценарий. Суб>

  

@Service

@Service bean-компонентов содержат бизнес-логику и вызывают методы на уровне хранилища.

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

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

  

Что еще?

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

    
654
2019-05-23 08: 13: 39Z
  1. 'PersistenceExceptionTranslationPostProcessor' будет автоматически зарегистрирован при обнаружении JPA.
    2017-05-22 07: 49: 06Z
  2. Фантастическое объяснение. Вы выяснили много моих недоразумений. Исходя из университета, где мы строили все наши проекты снизу вверх, мне было трудно понять, почему Spring Applications просто работает, даже если вы сами явно не связываете программу. Теперь аннотации имеют большой смысл, спасибо!
    2018-06-27 08: 05: 41Z
  3. Тогда, что означает аннотация @Service для Hibernate (Persistence Layer), помимо функции DI, как насчет Proxy Layer Proxy для выборки и сопоставления некоторой сущности с соответствующим DTO? Этот слой очень важен для динамизма в слое постоянства. Если кто-то глубоко знает, как это влияет на JPA, это было бы очень полезно)))
    2018-07-27 14: 12: 07Z
  4. Существует небольшая дезинформация относительно аннотации @Controller. Это не требуется, если класс аннотирован @RequestMapping, и бин этого класса создается каким-либо образом. Любой компонент, помеченный @Controller ИЛИ @RequestMapping, будет участвовать в отображениях запросов Spring MVC. Это может быть полезно, например, для создания контроллеров программным способом (например, с использованием методов @Bean) и в то же время для предотвращения попыток Spring создать их посредством сканирования пакетов (если пакет не может быть исключен из сканирования).
    2019-05-19 02: 21: 10Z
  5. @ RuslanStelmachenko Вы делаете очень хорошее замечание. Однако моя точка зрения заключалась в том, что, если аннотация @RequestMapping находится на уровне метода, то для ее подбора необходимо аннотировать класс @Controller, иначе он не будет выбран. Хотя существует обходной путь, который заключается в том, что если класс зарегистрирован как компонент, то для облегчения регистрации аннотации @RequestMapping мы должны также аннотировать класс с помощью @RequestMapping. В любом случае, спасибо, что подняли его, я добавил небольшую заметку по этому вопросу.
    2019-05-22 10: 20: 07Z

Они почти одинаковы - все они означают, что класс является бобом Spring. @Service, @Repository и @Controller являются специализированными @Component с. Вы можете выполнять определенные действия с ними. Например:

  •  @Controller бобов используются Spring-MVC
  •  @Repository бобов имеют право на перевод исключений постоянства

Другое дело, что вы семантически назначаете компоненты разным слоям.

Одна вещь, которую предлагает @Component, - это то, что вы можете аннотировать другие аннотации вместе с ними, а затем использовать их так же, как @Service.

Например, недавно я сделал:

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

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

    
415
2011-08-01 12: 20: 15Z
  1. @ Компонент означает только пружинный боб, есть ли для него какая-либо другая цель?
    2013-10-18 13: 08: 34Z
  2. @ Компонентные бины автоматически обнаруживаются контейнером Spring. Вам не нужно определять bean-компонент в файле конфигурации, он будет автоматически обнаружен Spring во время выполнения.
    2014-12-16 18: 07: 30Z
  3. Мне очень нравится универсальный @Component ... особенно в сочетании с @Scope (proxyMode = ScopedProxyMode .//MODE)
    2015-02-21 01: 35: 34Z

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

 
<bean>

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

Это означает, что Сервис, Контроллер и Хранилище функционально одинаковы.

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

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

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

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

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

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

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

    
351
2017-03-07 13: 30: 48Z
  1. У меня возник фундаментальный вопрос - используются ли аннотации пружинным механизмом или они просто для программиста, чтобы запомнить, что делают эти части кода?
    2015-09-06 11: 29: 22Z
  2. @ user107986 Они предназначены в основном для того, чтобы программист запоминал слои в приложении. Однако @Respository также имеет функцию автоматического перевода исключений. Например, когда в @Repository возникает исключение, для этого исключения обычно есть обработчик, и нет необходимости добавлять блоки try catch в класс DAO. Он используется вместе с PersistenceExceptionTranslationPostProcessor
    2015-09-11 12: 37: 59Z
  3. не могли бы вы написать пример кода, как написать точки соединения для всех классов "@Repository". Либо мы используем выражения, либо используем имя компонента, но как мы можем сказать, что этот совет будет применяться ко всем классам "@Repository". Я пытался получить пример этого, но не смог найти. Ваша помощь действительно приветствуется.
    2016-01-29 21: 55: 04Z
  4. Кроме того, хотя все аннотации в настоящее время работают одинаково функционально, возможно, что в будущем могут быть добавлены определенные функциональные возможности для данного атрибута.
    2017-04-10 01: 05: 24Z

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

@Controller:, где ваш запрос сопоставление со страницы презентации выполнен, т.е. слой презентации не перейдет ни в какой другой файл, он перейдет непосредственно в класс @Controller и проверит запрошенный путь в @RequestMapping аннотация, написанная перед вызовом метода, если это необходимо.

@Service: здесь представлена ​​вся бизнес-логика, т.е. расчет данныхs и все. Это аннотация бизнес-уровня, в которой наш пользователь напрямую не вызывает метод постоянства, поэтому он будет вызывать этот метод с помощью этой аннотации. Он будет запрашивать @Repository в соответствии с запросом пользователя

@Repository: Это постоянный уровень (Data Access Layer) приложения, который используется для получения данных из базы данных. то есть все операции с базой данных выполняются хранилищем.

@Component - Аннотируйте другие ваши компоненты (например, классы ресурсов REST) ​​со стереотипом компонента.

  

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

     

Другие аннотации на уровне класса могут рассматриваться как идентифицирующие   компонент, как правило, особый вид компонента: например,   Аннотация @Repository или аннотация AspectJ @Aspect.

введите описание изображения здесь

    
210
2018-04-10 21: 28: 43Z
  1. все эти ответы хороши и все, но я почти уверен, что большинство из нас хочет, это примеры кода функций, которые предлагают такие компоненты, как сервис, которые мы можем более конкретно поместить в наша голова, а не просто общее описание, как «бизнес-логика», принадлежит этому объекту. в противном случае мы по-прежнему предполагаем: «о, это здорово, и все, но я все еще могу применить тот же код к компоненту»
    2016-04-26 21: 05: 12Z
  2. Не вся бизнес-логика всей должна идти в сервисы! Сервисы, с точки зрения DDD, должны содержать только доменную логику, которая затрагивает более одного объекта. См. Ответ stackoverflow.com/a/41358034/238134
    2017-04-26 20: 57: 34Z
  3. @ deamon Да, но это зависит от подхода разработчиков
    2017-04-27 06: 33: 37Z
  4. @ HarshalPatil Конечно, вы можете написать приложение со всей бизнес-логикой в ​​сервисах, но это приведет к анемичной модели предметной области и сделает ненужным сложное применение ограничений и консистенция на сущностях.
    2017-04-27 07: 34: 43Z
  5. Конечно, это зависит от подхода разработчика. Все делает. Если вы подходите к проблеме неправильно, то есть пишите все, что хотите, без какой-либо структуры и говорите, что это «ваш подход», хотя это не делает это правильно. «Правильно» и «неправильно», конечно, используется в качестве терминов для описания хороших практик разработки программного обеспечения, таких как SOLID и других принципов, в отличие от плохих практик программного обеспечения, таких как «Я просто хочу, чтобы это было сейчас так» и тому подобное.
    2018-11-30 11: 31: 21Z
  

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.

ссылка: - Документация Spring - сканирование путей к классам , управляемые компоненты и написание конфигураций с использованием Java

    
68
2018-03-26 02: 26: 06Z

Использование аннотаций @Service и @Repository важно с точки зрения подключения к базе данных.

  1. Используйте @Service для всех типов подключений к БД вашего веб-сервиса
  2. Используйте @Repository для всех ваших сохраненных подключений к БД proc

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

    
43
2012-11-02 16: 27: 16Z
  1. Можно ли использовать @Repository для вызовов RestAPI вместо операций с БД?
    2018-11-30 16: 56: 39Z
  2. @ С технической точки зрения вы можете аннотировать сервисы как контроллеры, а репозитории как сервисы, внедрение зависимостей будет работать точно так же. Но зачем ты это делаешь? Если он не работает с объектами базы данных - это не репозиторий, а @Repository специально предназначен для работы с постоянным слоем. Если вы работаете с rest api - вы работаете с DTO, а не с DAO.
    2018-11-30 17: 29: 37Z

Технически @Controller, @Service, @Repository одинаковы. Все они простираются на @Component.

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

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

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

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

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

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

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

    
28
2019-06-20 06: 00: 31Z

@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.
    
27
2014-07-18 11: 23: 01Z

все эти аннотации являются типом стерео типа, типом аннотацииn, разница между этими тремя аннотациями составляет

  
  • Если мы добавим @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 будет существовать поверх класса
26
2017-04-03 04: 06: 26Z

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

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

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

@Service: указывает, что аннотированный класс является компонентом службы на бизнес-уровне.

@Repository: вам нужно использовать эту аннотацию на уровне персистентности, она действует как хранилище базы данных.

Нужно выбрать более специализированную форму @Component при аннотировании их класса, поскольку эта аннотация может содержать определенное поведение в будущем.

    
20
2018-06-16 20: 23: 56Z

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

Обращаясь к JSR-330, который теперь поддерживается пружиной, вы можете использовать только @Named для определения бина (почему-то @Named=@Component). Таким образом, согласно этому стандарту, кажется, что нет смысла определять стереотипы (такие как @Repository, @Service, @Controller) для категорий bean-компонентов.

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

  1. Помогите разработчикам определить лучшую категорию для компетентных. Эта классификация может стать полезной в некоторых случаях. (Например, когда вы используете aspect-oriented, это может быть хорошим кандидатом на pointcuts)
  2.  Аннотация @Repository добавит некоторую функциональность вашему компоненту (некоторая автоматическая трансляция исключений для вашего уровня сохраняемости компонента).
  3. Если вы используете пружинный MVC, @RequestMapping можно добавить только к классам, аннотированным @Controller.
19
2018-06-16 20: 08: 28Z
  1. Относительно вашего третьего пункта. Это не правда. Я могу добавить аннотацию @RequestMapping даже в методы класса обслуживания (я имею в виду классы, аннотированные @Service).
    2018-08-24 07: 44: 57Z

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

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

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

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

@Component in Spring

" Специализация компонентов "

    
18
2018-01-02 07: 42: 30Z

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

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

    
16
2014-02-10 18: 21: 37Z

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

  

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

     

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

    
15
2016-06-20 12: 39: 02Z

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

Для представления компонентов персистентного слоя: @Repository

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

Для представления компонентов уровня представления: @Controller

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

    
12
2015-11-26 05: 10: 33Z

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

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

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

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

Вот больше 11

2017-07-07 17: 26: 03Z

A @Service для цитирования весенней документации,

  

Указывает, что аннотированный класс является «Сервисом», изначально определенным   по доменно-управляемой конструкции (Эванс, 2003) как «операция, предлагаемая как   интерфейс, который стоит отдельно в модели, без инкапсулированного состояния. "   Может также указывать, что класс является «Фасадом бизнес-услуг» (в   Основные J2EE-шаблоны имеют смысл) или что-то подобное. Эта аннотация   универсальный стереотип и отдельные команды могут сузить   семантика и использование по мере необходимости.

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

  

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

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

  

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

    
10
2016-12-28 08: 18: 59Z

@Component : вы аннотируете класс @Component, он сообщает hibernate, что это Бин.

@Repository : вы аннотируете класс @Repository, он сообщает hibernate, что это класс DAO, и обрабатывает его как класс DAO. Это означает, что непроверенные исключения (создаваемые методами DAO) могут быть преобразованы в Spring DataAccessException.

@Service : это говорит hibernate, что это класс Service, где у вас будут аннотации на уровне @Transactional и т. д., поэтому hibernate рассматривает его как компонент Service.

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

 
@Service("AAA")
public class CustomerService{

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

 
CustomerService cust = (CustomerService)context.getBean("AAA");
    
9
2017-11-09 13: 32: 10Z

Репозиторий и Служба являются потомками аннотации Компонент . Итак, все они являются Компонентом . Репозиторий и Сервис просто разверните его. Как именно? Сервис имеет только идеологическое отличие: мы используем его для сервисов. Репозиторий имеет особый обработчик исключений.

    
9
2018-10-03 02: 32: 44Z

Объяснение стереотипов:

  •  @Service - аннотируйте все свои классы обслуживания с помощью @Service. Этот слой знает единицу работы. Вся ваша бизнес-логика будет в классах обслуживания. Как правило, методы уровня обслуживания охватываются транзакцией. Вы можете сделать несколько вызовов DAO из метода сервиса, если одна транзакция не удалась, все транзакции должны быть откатаны.
  •  @Repository - аннотировать все ваши DAOклассы с @Repository. Вся логика доступа к базе данных должна быть в классах DAO.
  •  @Component - Аннотируйте другие ваши компоненты (например, классы ресурсов REST) ​​со стереотипом компонента.
  •  @Autowired - Пусть Spring автоматически подключит другие bean-компоненты к вашим классам с помощью аннотации @Autowired.

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

Первоначально ответили здесь .

    
5
2018-03-21 07: 03: 05Z

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

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

  • @ Репозиторий для постоянства
  • @Service для услуг и транзакций
  • @Controller для контроллеров MVC

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

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

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

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

    
2
2018-06-21 00: 30: 32Z

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

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

    
2
2018-07-05 19: 11: 57Z

Чтобы упростить эту иллюстрацию, давайте рассмотрим техническую специфику в зависимости от случая использования. Эти аннотации используются для инъекции, и, как я сказал буквально « Раньше для инъекции », это означает, что если вы знаете, как использовать Dependency Injection "DI" , и вы должны это делать, тогда вы всегда будете искать эти аннотации, и, пометив классы этими стерео типами , вы сообщаете DI для сканирования их, чтобы быть готовым к инъекции в других местах, это практическая цель.

Теперь давайте перейдем к каждому; во-первых, @Service . Если вы строите некоторую логику для конкретного бизнес-кейса, вам нужно отделить ее от места, в котором будет содержаться ваша бизнес-логика, этот сервис является обычным классом или вы можете использовать его в качестве интерфейса, если вы хочу, и так написано

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

Когда вы вводите их, все одинаково, @Repository - это интерфейс, который применяет реализацию для шаблона репозитория шаблон проектирования репозитория , обычно он используется, когда вы имеете дело с каким-либо хранилищем данных или базой данных, и вы обнаружите, что он содержит несколько готовых реализаций для обработки операций с базой данных; это может быть CrudRepository , JpaRepository и т. д.

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

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

    
1
2019-04-30 20: 21: 52Z
 
@component
@controller
@Repository
@service
@RestController

Все это аннотации StereoType. Они полезны для того, чтобы сделать наши классы пружинными компонентами в контейнере ioc,

    
- 7
2019-04-23 06: 30: 00Z
источник размещен Вот