Когда @Repository нужна при наследовании?

Когда @Repository нужна при наследовании в Spring Data

@Repository — это условная аннотация в Spring Data JPA, которая имеет особое поведение при работе с наследованием. Нужно понимать, когда она действительно необходима, а когда её можно опустить.

Базовое наследование от JpaRepository

Случай 1: Простое наследование — @Repository НЕ нужна

// Это работает БЕЗ @Repository!
public interface UserRepository extends JpaRepository<User, Long> {
}

Spring Data JPA автоматически создаёт bean для интерфейса, наследующего JpaRepository, даже без аннотации.

Случай 2: Многоуровневое наследование интерфейсов

// Базовый интерфейс
public interface BaseRepository<T, ID> extends JpaRepository<T, ID> {
    List<T> findByCreatedAfter(LocalDateTime date);
}

// Наследование от BaseRepository
public interface UserRepository extends BaseRepository<User, Long> {
    User findByEmail(String email);
}

В этом случае @Repository тоже НЕ нужна. Spring Data JPA видит цепочку наследования и корректно создаёт bean.

Когда @Repository ОБЯЗАТЕЛЬНА

Случай 1: Наследование от JpaRepository + собственная реализация

// Интерфейс
@Repository
public interface UserRepository extends JpaRepository<User, Long> {
    User findByEmail(String email);
}

// Реализация
@Repository
public class UserRepositoryImpl implements UserRepository {
    @Override
    public User findByEmail(String email) {
        // кастомная реализация
        return new User();
    }
}

Здесь обе аннотации нужны:

• На интерфейсе: для Spring Data JPA
• На классе реализации: чтобы Spring зарегистрировал её как bean

Случай 2: Гибридная реализация (proxy + custom)

public interface UserRepository extends JpaRepository<User, Long> {
    User findByEmail(String email);
    List<User> findActiveUsers();  // custom query
}

// Spring Data JPA создаст proxy и добавит custom реализацию
@Repository
public class UserRepositoryImpl implements UserRepository {
    @Override
    public List<User> findActiveUsers() {
        // кастомная логика
        return new ArrayList<>();
    }
}

Здесь @Repository нужна на классе реализации, чтобы Spring узнал об этом bean.

Когда @Repository полезна для явности

Случай 1: Многоуровневое наследование с множественными репозиториями

// Базовый интерфейс
public interface BaseRepository<T, ID> extends JpaRepository<T, ID> {
}

// Специализированный интерфейс
@Repository
public interface UserRepository extends BaseRepository<User, Long> {
    User findByEmail(String email);
    List<User> findByDepartment(String dept);
}

// Другой специализированный интерфейс
@Repository
public interface ProductRepository extends BaseRepository<Product, Long> {
    List<Product> findByCategory(String category);
}

Здесь @Repository на конкретных репозиториях даёт явность и улучшает читаемость.

Важное правило: @Repository и исключения

Одна из главных причин использовать @Repository — это автоматическая трансляция исключений БД.

@Repository
public interface UserRepository extends JpaRepository<User, Long> {
}

Без @Repository Spring НЕ будет преобразовывать исключения:

• PersistenceException на DataAccessException
• EntityExistsException на DataIntegrityViolationException

Другими словами, даже если интерфейс работает, без @Repository ты получишь низкоуровневые исключения:

// БЕЗ @Repository:
try {
    userRepository.save(user);
} catch (PersistenceException e) {  // Low-level exception
    // Нужно ловить низкоуровневое исключение
}

// С @Repository:
try {
    userRepository.save(user);
} catch (DataIntegrityViolationException e) {  // Spring exception
    // Ловишь Spring exception - лучше для обработки
}

Конфигурация в application.yml

Есть способ игнорировать это правило глобально:

spring:
  jpa:
    repository:
      query:
        create-if-not-found: true

Но это антипаттерн — лучше явно писать @Repository.

Чеклист: Нужна ли @Repository?

Используй @Repository, если:

1. Ты хочешь явно обозначить компонент как репозиторий
2. У тебя есть кастомная реализация
3. Ты хочешь гарантировать преобразование исключений
4. Ты работаешь с многоуровневым наследованием
5. Проект большой и нужна явность

Можешь опустить @Repository, если:

1. Простой интерфейс, наследующий JpaRepository
2. Нет кастомной реализации
3. Мелкий проект, всё понятно из кода

Реальный пример полной иерархии

// 1. Базовый интерфейс (БЕЗ @Repository)
public interface BaseRepository<T, ID> extends JpaRepository<T, ID> {
    List<T> findAll(Sort sort);
    Optional<T> findByIdWithLock(ID id);
}

// 2. Специализированный интерфейс (можно С @Repository для явности)
@Repository
public interface UserRepository extends BaseRepository<User, Long> {
    Optional<User> findByEmail(String email);
    List<User> findByActive(boolean active);
}

// 3. Если есть кастомные методы — обязательна реализация
@Repository
public class UserRepositoryImpl implements UserRepository {
    private final EntityManager em;
    
    public UserRepositoryImpl(EntityManager em) {
        this.em = em;
    }
    
    @Override
    public Optional<User> findByIdWithLock(Long id) {
        // Кастомная реализация с блокировкой
        return em.createQuery(
            "SELECT u FROM User u WHERE u.id = :id",
            User.class
        ).getLockMode(LockModeType.PESSIMISTIC_WRITE)
         .setParameter("id", id)
         .getResultStream()
         .findFirst();
    }
}

// 4. Использование
@Service
public class UserService {
    private final UserRepository userRepository;
    
    public UserService(UserRepository userRepository) {
        this.userRepository = userRepository;  // Инжектится правильно
    }
    
    public void createUser(User user) {
        userRepository.save(user);
    }
}

Краткий вывод

@Repository при наследовании нужна, когда:

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

В простых случаях наследования от JpaRepository (@Repository не нужна):

public interface UserRepository extends JpaRepository<User, Long> {
    User findByEmail(String email);
}

Spring Data JPA сам всё сделает. Но добавить @Repository не будет ошибкой — это улучшит читаемость и явность кода.