Для чего нужны стереотипные аннотации в Spring?

# Стереотипные аннотации в Spring

Стереотипные аннотации (@Component, @Service, @Repository, @Controller) — это механизм Spring для автоматической регистрации бинов, их управления и явного обозначения роли класса в архитектуре.

Основное назначение

1. Автоматическая регистрация в контексте

Без аннотаций нужно было вручную регистрировать каждый класс:

// Без Spring: ручное управление
UserService service = new UserService(userRepository);

// С аннотациями: Spring сам создаёт и управляет
@Service
public class UserService {
    private final UserRepository userRepository;
    
    public UserService(UserRepository userRepository) {
        this.userRepository = userRepository;  // Spring внедрит
    }
}

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

2. Явность архитектуры

Каждая аннотация говорит о роли класса в системе:

// @Component - общий случай (переиспользуемый компонент)
@Component
public class EmailValidator {
    public boolean isValid(String email) { ... }
}

// @Repository - работа с данными
@Repository
public class UserRepository {
    public User findById(Long id) { ... }
}

// @Service - бизнес-логика
@Service
public class UserService {
    private final UserRepository repo;
    public User createUser(String name) { ... }
}

// @Controller - HTTP endpoints
@Controller
public class UserController {
    private final UserService service;
    @GetMapping("/users/{id}")
    public ResponseEntity<User> getUser(@PathVariable Long id) { ... }
}

Это самодокументирующийся код — разработчик сразу видит архитектурный слой класса.

Различия между аннотациями

@Component (базовая)

@Component
public class DataProcessor {
    public void process(String data) { ... }
}

• Универсальный компонент
• Используется, когда роль не специализирована
• Регистрируется как синглтон в контексте

@Service (специализация @Component)

@Service
public class OrderService {
    private final OrderRepository repository;
    private final PaymentGateway payment;
    
    public Order createOrder(OrderRequest request) {
        // Сложная бизнес-логика
        Order order = repository.save(request.toEntity());
        payment.charge(order);
        return order;
    }
}

• Содержит бизнес-логику
• Оркестрирует работу репозиториев и других сервисов
• Транзакции обычно управляются здесь

@Repository (специализация @Component)

@Repository
public class UserRepository extends JpaRepository<User, Long> {
    User findByEmail(String email);
    
    @Query("SELECT u FROM User u WHERE u.active = true")
    List<User> findAllActive();
}

• Доступ к данным (DAO - Data Access Object)
• Преобразование исключений БД в Spring DataAccessException
• Обычно наследует JpaRepository

@Controller (специализация @Component)

@Controller
@RequestMapping("/api/users")
public class UserController {
    private final UserService service;
    
    @GetMapping("/{id}")
    public ResponseEntity<UserDto> getUser(@PathVariable Long id) {
        return ResponseEntity.ok(service.getUserDto(id));
    }
}

• HTTP endpoints (MVC контроллеры)
• Обработка запросов и ответов
• @RestController = @Controller + @ResponseBody

Преимущества стереотипных аннотаций

1. Dependency Injection (автоматическое внедрение зависимостей)

@Service
public class UserService {
    // Spring автоматически создаст UserRepository и внедрит его
    private final UserRepository userRepository;
    
    public UserService(UserRepository userRepository) {
        this.userRepository = userRepository;
    }
}

@Controller
public class UserController {
    private final UserService userService;  // Spring внедрит
    
    public UserController(UserService userService) {
        this.userService = userService;
    }
}

2. Управление жизненным циклом

Spring управляет созданием и уничтожением объектов:

@Service
public class DatabaseConnection {
    @PostConstruct
    public void initialize() {
        // Вызовется после создания объекта
        connectToDatabase();
    }
    
    @PreDestroy
    public void cleanup() {
        // Вызовется перед уничтожением
        closeConnection();
    }
}

3. Кроссовые озабоченности (AOP)

Spring может применять логику ко всем бинам определённого типа:

// Кэширование для всех @Service методов
@Service
public class UserService {
    @Cacheable("users")
    public User getUser(Long id) { ... }
}

// Логирование для всех @Repository вызовов
@Aspect
@Component
public class RepositoryAspect {
    @Before("@annotation(org.springframework.stereotype.Repository)")
    public void logQuery() {
        logger.info("Executing database query");
    }
}

4. Тестирование

С аннотациями легко мокировать и тестировать:

@SpringBootTest
class UserServiceTest {
    @MockBean
    private UserRepository userRepository;
    
    @Autowired
    private UserService userService;
    
    @Test
    public void testGetUser() {
        User mockUser = new User(1L, "John");
        given(userRepository.findById(1L)).willReturn(Optional.of(mockUser));
        
        User result = userService.getUser(1L);
        assertEquals("John", result.getName());
    }
}

Практический пример: слои архитектуры

// Слой 1: Entity/Domain
@Entity
public class User {
    @Id @GeneratedValue
    private Long id;
    private String email;
}

// Слой 2: Repository (доступ к данным)
@Repository
public class UserRepository extends JpaRepository<User, Long> {}

// Слой 3: Service (бизнес-логика)
@Service
@Transactional
public class UserService {
    private final UserRepository repository;
    private final EmailService emailService;
    
    public User registerUser(String email) {
        User user = new User(email);
        repository.save(user);
        emailService.sendWelcome(user);
        return user;
    }
}

// Слой 4: Controller (HTTP API)
@RestController
@RequestMapping("/api/users")
public class UserController {
    private final UserService service;
    
    @PostMapping
    public ResponseEntity<User> register(@RequestBody UserRequest request) {
        return ResponseEntity.ok(service.registerUser(request.getEmail()));
    }
}

Вывод

Стереотипные аннотации — это основа Spring Framework. Они:

1. Автоматизируют регистрацию и управление бинами
2. Делают архитектуру явной и понятной
3. Включают мощные фичи (DI, AOP, транзакции)
4. Упрощают тестирование
5. Следуют принципам Clean Architecture

Это фундамент для построения масштабируемых и поддерживаемых Java приложений.