Какие взаимодействия в Spring можно использовать для создания приложения

# Взаимодействия в Spring для создания приложения

Обзор

Spring предоставляет множество механизмов взаимодействия между компонентами (бинами) для построения гибких, слабо связанных приложений.

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

Constructor Injection ✓ РЕКОМЕНДУЕТСЯ

@Component
public class UserService {
    private final UserRepository repository;
    
    public UserService(UserRepository repository) {
        this.repository = repository;
    }
}

Преимущества: Неизменяемые зависимости, явный контракт, легко тестировать

Setter Injection

@Component
public class UserService {
    private UserRepository repository;
    
    @Autowired
    public void setRepository(UserRepository repository) {
        this.repository = repository;
    }
}

Минусы: Может быть null, нарушает неизменяемость

Field Injection

@Component
public class UserService {
    @Autowired
    private UserRepository repository;
}

Минусы: Сложнее тестировать, скрытые зависимости

2. Lifecycle Callbacks (Обратные вызовы жизненного цикла)

@Component
public class DataSourceConfig {
    
    @PostConstruct
    public void init() {
        // Вызывается после создания бина и внедрения всех зависимостей
        System.out.println("Инициализация DataSource");
    }
    
    @PreDestroy
    public void cleanup() {
        // Вызывается перед удалением бина
        System.out.println("Очистка ресурсов");
    }
}

3. Events (События)

Публикация события

@Component
public class UserService {
    private final ApplicationEventPublisher eventPublisher;
    
    public UserService(ApplicationEventPublisher eventPublisher) {
        this.eventPublisher = eventPublisher;
    }
    
    public void registerUser(String email) {
        // бизнес-логика
        eventPublisher.publishEvent(new UserRegisteredEvent(this, email));
    }
}

Слушатель события

@Component
public class EmailNotificationListener {
    
    @EventListener
    public void onUserRegistered(UserRegisteredEvent event) {
        System.out.println("Отправляем письмо на: " + event.getEmail());
    }
}

Преимущества: Слабая связанность, асинхронная обработка

4. Messaging (Обмен сообщениями)

JMS

@Component
public class OrderService {
    private final JmsTemplate jmsTemplate;
    
    public OrderService(JmsTemplate jmsTemplate) {
        this.jmsTemplate = jmsTemplate;
    }
    
    public void processOrder(Order order) {
        jmsTemplate.convertAndSend("orders-queue", order);
    }
}

RabbitMQ

@Component
public class OrderPublisher {
    private final RabbitTemplate rabbitTemplate;
    
    public OrderPublisher(RabbitTemplate rabbitTemplate) {
        this.rabbitTemplate = rabbitTemplate;
    }
    
    public void publishOrder(Order order) {
        rabbitTemplate.convertAndSend("orders-exchange", "order.created", order);
    }
}

@Component
public class OrderListener {
    
    @RabbitListener(queues = "orders-queue")
    public void handleOrder(Order order) {
        System.out.println("Заказ получен: " + order.getId());
    }
}

5. REST API (Взаимодействие через HTTP)

@RestController
@RequestMapping("/api/users")
public class UserController {
    private final UserService userService;
    
    public UserController(UserService userService) {
        this.userService = userService;
    }
    
    @PostMapping
    public ResponseEntity<User> createUser(@RequestBody CreateUserRequest request) {
        User user = userService.create(request);
        return ResponseEntity.status(HttpStatus.CREATED).body(user);
    }
    
    @GetMapping("/{id}")
    public ResponseEntity<User> getUser(@PathVariable Long id) {
        return userService.findById(id)
            .map(ResponseEntity::ok)
            .orElse(ResponseEntity.notFound().build());
    }
}

6. Scheduled Tasks (Планируемые задачи)

@Component
public class ScheduledTasks {
    
    @Scheduled(cron = "0 0 * * * *")
    public void cleanupExpiredTokens() {
        System.out.println("Удаляем истекшие токены");
    }
    
    @Scheduled(fixedDelay = 5000)
    public void sendNotifications() {
        System.out.println("Отправляем уведомления");
    }
}

7. Async Processing (Асинхронная обработка)

@Configuration
@EnableAsync
public class AsyncConfig {
}

@Component
public class EmailService {
    
    @Async
    public CompletableFuture<Void> sendEmailAsync(String to, String body) {
        System.out.println("Отправляем письмо на: " + to);
        return CompletableFuture.completedFuture(null);
    }
}

@Component
public class UserService {
    private final EmailService emailService;
    
    public UserService(EmailService emailService) {
        this.emailService = emailService;
    }
    
    public void registerUser(String email) {
        // бизнес-логика
        emailService.sendEmailAsync(email, "Добро пожаловать!");
    }
}

8. Reactive Programming (Реактивное программирование)

@RestController
@RequestMapping("/api/users")
public class ReactiveUserController {
    private final UserService userService;
    
    public ReactiveUserController(UserService userService) {
        this.userService = userService;
    }
    
    @GetMapping
    public Flux<User> getAllUsers() {
        return userService.getAllUsersReactive();
    }
    
    @GetMapping("/{id}")
    public Mono<User> getUserById(@PathVariable Long id) {
        return userService.getUserByIdReactive(id);
    }
}

9. AOP (Aspect-Oriented Programming)

@Aspect
@Component
public class LoggingAspect {
    
    @Before("execution(* com.example.service..*(..))") 
    public void logBefore(JoinPoint joinPoint) {
        System.out.println("Вызов: " + joinPoint.getSignature().getName());
    }
    
    @After("execution(* com.example.service..*(..))") 
    public void logAfter(JoinPoint joinPoint) {
        System.out.println("Завершение: " + joinPoint.getSignature().getName());
    }
}

10. Reactive Streams with WebFlux

@Configuration
public class WebFluxConfig implements WebFluxConfigurer {
    @Override
    public void configurePathMatching(PathMatchConfigurer configurer) {
        // конфигурация
    }
}

@RestController
public class ReactiveStreamController {
    
    @GetMapping("/stream")
    public Flux<String> stream() {
        return Flux.interval(Duration.ofSeconds(1))
            .map(n -> "Сообщение " + n);
    }
}

Выбор механизма в зависимости от задачи

Best Practices

1. Предпочитай Constructor Injection для обязательных зависимостей
2. Используй Events для слабо связанного взаимодействия
3. Выбирай Reactive только если есть необходимость (I/O-bound операции)
4. Комбинируй механизмы — разные слои могут использовать разные подходы
5. Тестируй взаимодействия через unit и integration тесты