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

Question

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

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

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

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

2574

java spring spring-mvc annotations

Источник

user863084 26 июл '11 в 09:10

39 ответов

Другие вопросы по тегам java spring spring-mvc annotations

user445543 01 авг '11 в 10:20 2011-08-01 10:20 · Answer 1 · 2011-08-01 10:20

Из весенней документации:

Весной 2.0 и позже @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)      │
└────────────┴─────────────────────────────────────────────────────┘

user2815219 24 июл '16 в 06:43 2016-07-24 06:43 · Answer 2 · 2016-07-24 06:43

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

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

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

@Составная часть

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

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

@Controller

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

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

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

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

@Services хранить бизнес-логику и вызывать метод на уровне хранилища.

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

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

Что-то еще?

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

user203907 26 июл '11 в 09:16 2011-07-26 09:16 · Answer 3 · 2011-07-26 09:16

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

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

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

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

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

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

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

user1984049 23 май '14 в 05:15 2014-05-23 05:15 · Answer 4 · 2014-05-23 05:15

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

<bean>

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

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

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

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

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

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

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

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

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

user3244185 25 мар '14 в 08:00 2014-03-25 08:00 · Answer 5 · 2014-03-25 08:00

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

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

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

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

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

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

user2334534 15 май '13 в 12:48 2013-05-15 12:48 · Answer 6 · 2013-05-15 12:48

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 Documentation - Сканирование пути к классам, управляемые компоненты и написание конфигураций с использованием Java

user5536695 27 июл '17 в 10:20 2017-07-27 10:20 · Answer 7 · 2017-07-27 10:20

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

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

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

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

Назначение каждой аннотации:

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

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

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

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

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

user1794781 02 ноя '12 в 16:05 2012-11-02 16:05 · Answer 8 · 2012-11-02 16:05

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

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

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

user1901896 16 дек '14 в 18:10 2014-12-16 18:10 · Answer 9 · 2014-12-16 18:10

@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 помечены @Component, Итак, мы можем использовать только @Component для всех компонентов для автоматического сканирования? Да, вы можете, и Spring автоматически проверит все ваши компоненты с аннотацией @Component.

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

user1245337 18 июл '14 в 11:23 2014-07-18 11:23 · Answer 10 · 2014-07-18 11:23

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

user1559147 10 окт '15 в 08:11 2015-10-10 08:11 · Answer 11 · 2015-10-10 08:11

Разница между @Component, @Service и @Repository

Основное различие между этими стереотипами заключается в том, что они используются для различной классификации.

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

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

Если технически они будут одинаковыми, то зачем нам их использовать на разных уровнях. Почему бы не использовать то же самое на всех слоях. Например, если мы используем @Service на всех уровнях будут реализованы все компоненты, и проблем не будет. Существует небольшая разница, например, рассмотреть @Repository,

Постпроцессор автоматически ищет все трансляторы исключений (реализации интерфейса PersistenceExceptionTranslator) и советует всем бинам, помеченным знаком @Repository аннотации, чтобы обнаруженные переводчики могли перехватить и применить соответствующий перевод к сгенерированным исключениям.

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

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

user3083363 25 апр '15 в 16:19 2015-04-25 16:19 · Answer 12 · 2015-04-25 16:19

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

Если мы добавим @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 аннотация будет существовать на вершине класса

user1392352 03 янв '16 в 05:10 2016-01-03 05:10 · Answer 13 · 2016-01-03 05:10

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

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

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

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

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

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

user5426099 26 ноя '15 в 05:10 2015-11-26 05:10 · Answer 14 · 2015-11-26 05:10

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

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

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

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

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

user4334162 09 ноя '17 в 13:32 2017-11-09 13:32 · Answer 15 · 2017-11-09 13:32

@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-компонент. Таким образом, при получении объекта боб CustomerService cust = (CustomerService)context.getBean("customerService"); По умолчанию Spring будет нижний регистр первого символа компонента - от CustomerService до customerService. И вы можете получить этот компонент с именем 'customerService'. Но если вы используете аннотацию @Service для класса компонента, вы можете указать конкретное имя компонента:

@Service("AAA")
public class CustomerService{

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

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

user8450064 22 ноя '17 в 18:42 2017-11-22 18:42 · Answer 16 · 2017-11-22 18:42

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

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

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

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

@ Компонент весной

user2051454 08 май '20 в 16:25 2020-05-08 16:25 · Answer 17 · 2020-05-08 16:25

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

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

Современное программирование - это изобретение, искусство, техника и общение в разных пропорциях. Бит связи обычно очень важен, потому что код обычно читается гораздо чаще, чем его пишут. Как программист, вы не только пытаетесь решить техническую проблему, но и пытаетесь сообщить о своем намерении будущим программистам, читающим ваш код. Эти программисты могут не разделять ни ваш родной язык, ни вашу социальную среду, и вполне возможно, что они будут читать ваш код через 50 лет (это не так маловероятно, как вы думаете). В таком далеком будущем сложно эффективно общаться. Поэтому жизненно важно, чтобы мы использовали самый ясный, эффективный, правильный и коммуникативный язык, доступный нам.Что мы тщательно подбирали слова, чтобы добиться максимального воздействия и быть как можно более ясными в отношении наших намерений.

Например, очень важно, чтобы @Repository используется, когда мы пишем репозиторий, а не @Component. Последнее - очень плохой выбор аннотации для репозитория, потому что он не означает, что мы смотрим на репозиторий. Мы можем предположить, что репозиторий также является Spring-bean-компонентом, но не что компонент является репозиторием. С@Repositoryмы говорим четко и конкретно на нашем языке. Мы четко заявляем, что это репозиторий. С@Componentмы оставляем читателю самим решать, какой тип компонента он читает, и ему придется прочитать весь класс (и, возможно, дерево подклассов и интерфейсов), чтобы понять смысл. Тогда этот класс может быть неверно истолкован читателем в далеком будущем как не являющийся репозиторием, и мы были бы частично ответственны за эту ошибку, потому что мы, хорошо знавшие, что это репозиторий, не смогли указать конкретный язык на нашем языке. и эффективно сообщать о наших намерениях.

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

Примеры этого есть на протяжении всей весны (и программирования в целом). Вы не должны использовать@Controller при написании REST API, потому что @RestControllerдоступен. Вы не должны использовать@RequestMapping когда @GetMappingявляется допустимой альтернативой. И т. Д. И т. Д. И т. Д. Вы должны выбрать наиболее точный и точный язык, на котором вы можете сообщить свои намерения своим читателям, в противном случае вы вводите риски в свою систему, и риск имеет свою цену.

user1009686 10 фев '14 в 18:21 2014-02-10 18:21 · Answer 18 · 2014-02-10 18:21

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

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

22

Источник

user1009686 10 фев '14 в 18:21

user2648077 04 май '16 в 04:23 2016-05-04 04:23 · Answer 19 · 2016-05-04 04:23

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

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

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

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

user2915208 24 фев '15 в 12:49 2015-02-24 12:49 · Answer 20 · 2015-02-24 12:49

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

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

user3912516 21 дек '16 в 09:12 2016-12-21 09:12 · Answer 21 · 2016-12-21 09:12

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

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

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

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

Вот больше подробностей

user5370799 28 ноя '16 в 18:53 2016-11-28 18:53 · Answer 22 · 2016-11-28 18:53

1. Основное различие между этими стереотипами заключается в том, что они используются для различной классификации.

2. В многоуровневом приложении у нас будут разные уровни, такие как презентация, сервис, бизнес, доступ к данным и т. Д. Когда Spring должен быть аннотирован для автоматического обнаружения Spring, мы должны использовать соответствующий стереотип, как показано ниже.

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

Постпроцессор автоматически ищет все трансляторы исключений (реализации интерфейса PersistenceExceptionTranslator) и советует всем be an-компонентам, помеченным аннотацией @Repository, чтобы обнаруженные трансляторы могли перехватывать и применять соответствующий перевод к выданным исключениям.

Как и выше, в будущем Spring может принять решение добавить ценность для@Service, @Controller а также @Repository на основе их соглашений о слоях. Для этого дополнительного преимущества функции лучше соблюдать соглашение и использовать их в соответствии со слоями.
Помимо вышеупомянутого, в отношении автоматического обнаружения сканирования, внедрение зависимости для BeanDefinition @Component, @Service, @Repository,@Controller такие же.
Согласно документации Spring: аннотация @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 уже поддерживается в качестве маркера для автоматического преобразования исключений в вашем слое постоянства.

user5167492 20 июн '16 в 09:30 2016-06-20 09:30 · Answer 23 · 2016-06-20 09:30

Весной 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 уже поддерживается в качестве маркера для автоматического преобразования исключений в вашем слое постоянства.

user6850561 05 ноя '21 в 09:33 2021-11-05 09:33 · Answer 24 · 2021-11-05 09:33

Spring поддерживает аннотации нескольких типов, такие как @Component, @service, @Repository. Все тезисы можно найти в пакете org.springframework.stereotype.

Когда классы в нашем приложении аннотируются любой из вышеупомянутых аннотаций, тогда во время весеннего сканирования при запуске проекта (с использованием @ComponentScan) каждый класс и вставляет экземпляр классов в контейнер IOC. Еще одна вещь, которую мог бы сделать @ComponentScan, - это запустить методы с @Bean на нем и восстановить возвращаемый объект в контейнер Ioc как bean-компонент.

Прежде чем мы углубимся в (@Component vs @service vs @Repository), сначала мы должны понять различия между @Bean и @Component

@Component vs @Repository vs @Service

В большинстве типичных приложений у нас есть отдельные уровни, такие как доступ к данным, представление, обслуживание, бизнес и т. Д. Кроме того, на каждом уровне у нас есть различные bean-компоненты. Для автоматического обнаружения этих bean-компонентов Spring использует аннотации сканирования пути к классам. Затем он регистрирует каждый bean-компонент в ApplicationContext.

Вот краткий обзор некоторых из этих аннотаций:

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

@Component Annotation

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

Они зарегистрированы в ApplicationContext, потому что аннотированы @Component

Как уже говорилось, @Component является родителем всех аннотаций стереотипов. Когда Spring выполняет сканирование компонентов, он ищет только классы, отмеченные аннотациями @Component.

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

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

@Service Аннотация

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

@Service является дочерним по отношению к компоненту и используется для обозначения классов из уровня обслуживания приложения.

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

@Repository Annotation

Задача @Repository - перехватывать специфичные для персистентности исключения и повторно генерировать их как одно из унифицированных непроверенных исключений Spring.

Для этого Spring предоставляет PersistenceExceptionTranslationPostProcessor, который мы должны добавить в контекст нашего приложения (уже включенный, если мы используем Spring Boot):

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

Этот постпроцессор bean добавляет советника к любому bean-компоненту, помеченному @Repository.

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

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

Резюме

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

user4387470 02 апр '15 в 08:35 2015-04-02 08:35 · Answer 25 · 2015-04-02 08:35

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

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

Для всех этих аннотаций (стереотипов) технически основная цель одна и та же. Spring автоматически сканирует и идентифицирует все эти классы с пометкой " @Component, @Service, @Repository, @Controller И регистрирует определение бина в ApplicationContext,

user10961238 04 июл '19 в 10:22 2019-07-04 10:22 · Answer 26 · 2019-07-04 10:22

Здесь достаточно хороших ответов, чтобы объяснить аннотации в чем-то-разница-между-компонентами-репозиториями-сервисами. Хочу поделиться различием между@Controller & @RestController

`@Controller` против `RestController`

`@RestController`:

Эта аннотация является специализированной версией @Controller что добавляет @Controller а также @ResponseBodyаннотация автоматически. поэтому нам не нужно добавлять@ResponseBodyк нашим методам отображения. Это значит @ResponseBody активен по умолчанию.
Если вы используете @RestController вы не можете вернуть представление (используя Viewresolver в Spring/Spring-Boot)
@RestController также преобразует ответ в JSON/XML automatically как @ResponseBody превращает возвращенные объекты во что-то, что может быть в теле, e.g. JSON or XML

`@Controller`

@Controllerиспользуется для обозначения классов как Spring MVC Controller. Эта аннотация представляет собой специализированную версию@Component и позволяет автоматически определять классы контроллеров на основе сканирования пути к классам.
@Controller вы можете вернуть представление в Spring web MVC.

Более подробный вид

user992706 28 дек '16 в 08:18 2016-12-28 08:18 · Answer 27 · 2016-12-28 08:18

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

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

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

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

и Repository согласно Эрику Эвансу,

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

user10610826 19 апр '20 в 03:50 2020-04-19 03:50 · Answer 28 · 2020-04-19 03:50

@Component действует как аннотация @Bean в классе конфигурации, зарегистрируйте bean в контексте Spring. Также он является родительским для аннотаций @Service, @Repository и @Controller.

@Service, расширяет аннотацию @Component и имеет только различие в именах.

@Repository - расширяет аннотацию @Component и переводит все исключения базы данных в DataAccessException.

@Controller - действует как контроллер в шаблоне MVC. Диспетчер просканирует такие аннотированные классы на предмет сопоставленных методов, обнаруживая аннотации @RequestMapping.

user8411174 03 окт '18 в 02:32 2018-10-03 02:32 · Answer 29 · 2018-10-03 02:32

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

user5256337 06 авг '19 в 10:25 2019-08-06 10:25 · Answer 30 · 2019-08-06 10:25

Разница между аннотациями @Component, @Repository, @Controller и @Service

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

@Controller = @Component (внутренняя аннотация) + Функции уровня презентации
@Service = @Component (внутренняя аннотация) + Функции уровня сервиса
@Component = Фактические компоненты (бобы)
@Repository = @Component (внутренняя аннотация) + Функции уровня данных (используются для обработки доменных компонентов)

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

39 ответов

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

@ Компонент весной

@Component vs @Repository vs @Service

@Component Annotation

@Service Аннотация

@Repository Annotation

Резюме

@Controller против RestController

@RestController:

@Controller

`@Controller` против `RestController`

`@RestController`:

`@Controller`