Собеседование по Spring Boot: продвинутые вопросы и ответы

@SpringBootApplication
public class MyApplication {
    public static void main(String[] args) {
        SpringApplication app = new SpringApplication(MyApplication.class);
        app.setLazyInitialization(true);
        app.run(args);
    }
}

@SpringBootApplication
public class Application { ... }

@SpringBootApplication(scanBasePackages = {"com.company.core", "com.company.api"})
public class Application { ... }

@ConfigurationProperties(prefix = "app")  
public class AppConfig {  
    private Database database;  
    private List<Service> services;  
    
    // Геттеры и сеттеры
  
    public static class Database {  
        private String url;  
        private String username;  
        private String password;
        // Геттеры и сеттеры
    }  
  
    public static class Service {  
        private String name;  
        private int timeout;
        // Геттеры и сеттеры  
    }  
}

@ConfigurationProperties(prefix = "app")
@Validated  
public class AppConfig {  
    @NotNull
    private Database database;
    
    @Valid
    private List<Service> services;
    // ...
}

@Configuration
@ConditionalOnClass(DataSource.class)
@EnableConfigurationProperties(MyStarterProperties.class)
public class MyStarterAutoConfiguration {
    
    @Autowired
    private MyStarterProperties properties;
    
    @Bean
    @ConditionalOnMissingBean
    public MyStarterService myStarterService() {
        return new MyStarterServiceImpl(properties.getConfig());
    }
}

@ConfigurationProperties(prefix = "mystarter")
public class MyStarterProperties {
    private String config = "default";
    // Геттеры и сеттеры
}

org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
com.example.mystarter.MyStarterAutoConfiguration

SpringApplication app = new SpringApplication(MyApp.class);
app.setAdditionalProfiles("production");
app.run(args);

@SpringBootApplication
@EnableConfigServer
public class ConfigServerApplication {
    public static void main(String[] args) {
        SpringApplication.run(ConfigServerApplication.class, args);
    }
}

spring.config.import=configserver:http://config-server:8888

@Bean
public VaultTemplate vaultTemplate(VaultEndpoint endpoint, ClientAuthentication clientAuthentication) {
    return new VaultTemplate(endpoint, clientAuthentication);
}
 
@Bean
public String databasePassword(VaultTemplate vaultTemplate) {
    return vaultTemplate.read("secret/myapp/database")
        .getData().get("password").toString();
}

@RestController
@RefreshScope
public class ConfigurationController {
    
    @Value("${dynamic.property}")
    private String dynamicProperty;
    
    @GetMapping("/config")
    public String getConfig() {
        return dynamicProperty;
    }
}

management.endpoints.web.exposure.include=health,metrics,prometheus
management.endpoint.health.show-details=when_authorized

@Component
public class ExternalServiceHealthIndicator extends AbstractHealthIndicator {
    
    private final ExternalServiceClient client;
    
    public ExternalServiceHealthIndicator(ExternalServiceClient client) {
        this.client = client;
    }
    
    @Override
    protected void doHealthCheck(Health.Builder builder) {
        try {
            ServiceStatus status = client.checkStatus();
            if (status.isOperational()) {
                builder.up()
                       .withDetail("version", status.getVersion())
                       .withDetail("latency", status.getResponseTime());
            } else {
                builder.down()
                       .withDetail("reason", status.getErrorMessage());
            }
        } catch (Exception e) {
            builder.down()
                   .withDetail("error", e.getMessage());
        }
    }
}

@Component
public class OrderMetrics {
    
    private final MeterRegistry meterRegistry;
    
    public OrderMetrics(MeterRegistry meterRegistry) {
        this.meterRegistry = meterRegistry;
        
        // Создаем счетчик заказов
        Counter.builder("app.orders.created")
              .description("Number of created orders")
              .register(meterRegistry);
    }
    
    public void recordOrderCreation(String orderType) {
        meterRegistry.counter("app.orders.created", "type", orderType).increment();
    }
}

@Configuration
@EnableWebSecurity
public class SecurityConfig {
    
    @Bean
    public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
        http.authorizeRequests()
            .antMatchers("/api/public/[B]").permitAll()
            .antMatchers("/api/admin/[/B]").hasRole("ADMIN")
            .anyRequest().authenticated()
            .and()
            .sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS)
            .and()
            .csrf().disable()
            .oauth2ResourceServer().jwt();
        
        return http.build();
    }
}

@Configuration
public class ResourceServerConfig {
    
    @Bean
    public JwtDecoder jwtDecoder(OAuth2ResourceServerProperties properties) {
        NimbusJwtDecoder jwtDecoder = NimbusJwtDecoder.withJwkSetUri(
            properties.getJwt().getJwkSetUri()
        ).build();
        
        // Добавляем валидацию аудитории
        OAuth2TokenValidator<Jwt> audienceValidator = token -> {
            if (token.getAudience().contains("my-api")) {
                return OAuth2TokenValidatorResult.success();
            }
            return OAuth2TokenValidatorResult.failure(
                new OAuth2Error("invalid_token", "Invalid audience", null)
            );
        };
        
        jwtDecoder.setJwtValidator(new DelegatingOAuth2TokenValidator<>(
            JwtValidators.createDefault(),
            audienceValidator
        ));
        
        return jwtDecoder;
    }
}

@Component
public class OrderAuthorizationAspect {
    
    @Autowired
    private UserService userService;
    
    @Around("@annotation(org.springframework.security.access.prepost.PreAuthorize) && " +
           "execution(* com.example.service.OrderService.updateOrder(..)) && args(orderId,..)")
    public Object checkOrderAccess(ProceedingJoinPoint joinPoint, Long orderId) throws Throwable {
        User currentUser = userService.getCurrentUser();
        Order order = orderRepository.findById(orderId).orElseThrow();
        
        if (currentUser.getId().equals(order.getUserId()) || 
            currentUser.hasRole("ADMIN")) {
            return joinPoint.proceed();
        }
        
        throw new AccessDeniedException("Not authorized to modify this order");
    }
}

@GetMapping("/users")
public Page<User> getUsers(
    @RequestParam(defaultValue = "0") int page,
    @RequestParam(defaultValue = "20") int size,
    @RequestParam(defaultValue = "lastName") String sortBy) {
    
    Pageable pageable = PageRequest.of(page, size, Sort.by(sortBy));
    return userRepository.findAll(pageable);
}

@Query(value = "SELECT u FROM User u WHERE u.id > :lastId ORDER BY u.id LIMIT :pageSize", 
       nativeQuery = true)
List<User> findByIdGreaterThan(@Param("lastId") Long lastId, 
                              @Param("pageSize") int pageSize);

public interface UserSummary {
    Long getId();
    String getFullName();
    
    @Value("#{target.firstName + ' ' + target.lastName}")
    String getFullName();
}
 
public interface UserRepository extends JpaRepository<User, Long> {
    List<UserSummary> findByLastNameContaining(String lastName);
}

@Configuration
@EnableCaching
public class CacheConfig {
    
    @Bean
    public CacheManager cacheManager() {
        CaffeineCacheManager cacheManager = new CaffeineCacheManager();
        
        cacheManager.setCaffeine(Caffeine.newBuilder()
            .maximumSize(500)
            .expireAfterWrite(10, TimeUnit.MINUTES)
            .recordStats());
        
        return cacheManager;
    }
}
 
@Service
public class ProductService {
    
    @Cacheable(value = "products", key = "#id", unless = "#result == null")
    public Product getProductById(Long id) {
        // Запрос к БД
    }
    
    @CachePut(value = "products", key = "#product.id")
    public Product updateProduct(Product product) {
        // Сохранение в БД
    }
    
    @CacheEvict(value = "products", key = "#id")
    public void deleteProduct(Long id) {
        // Удаление из БД
    }
}

@Bean
public CacheManager cacheManager(
        RedisConnectionFactory redisConnectionFactory) {
    
    // Для часто используемых, но редко меняющихся данных
    CaffeineCache localCache = new CaffeineCache("localProducts",
        Caffeine.newBuilder()
            .maximumSize(1000)
            .expireAfterWrite(5, TimeUnit.MINUTES)
            .build());
    
    // Для данных, которые должны быть синхронизированы между серверами
    RedisCacheManager redisCacheManager = RedisCacheManager.builder(redisConnectionFactory)
        .cacheDefaults(RedisCacheConfiguration.defaultCacheConfig()
            .entryTtl(Duration.ofHours(1)))
        .build();
    
    return new CompositeCacheManager(
        new SimpleCacheManager(Collections.singletonList(localCache)),
        redisCacheManager);
}

@Repository
public interface ProductRepository extends 
    JpaRepository<Product, Long>, 
    JpaSpecificationExecutor<Product> {
}
 
public static class ProductSpec {
    public static Specification<Product> hasCategory(String category) {
        return (root, query, cb) -> 
            cb.equal(root.get("category"), category);
    }
    
    public static Specification<Product> priceBetween(
            BigDecimal min, BigDecimal max) {
        return (root, query, cb) -> 
            cb.between(root.get("price"), min, max);
    }
    
    public static Specification<Product> hasStock() {
        return (root, query, cb) -> 
            cb.greaterThan(root.get("stockQuantity"), 0);
    }
}
 
// Использование:
Specification<Product> spec = Specification.where(null);
 
if (category != null) {
    spec = spec.and(ProductSpec.hasCategory(category));
}
 
if (minPrice != null && maxPrice != null) {
    spec = spec.and(ProductSpec.priceBetween(minPrice, maxPrice));
}
 
if (onlyInStock) {
    spec = spec.and(ProductSpec.hasStock());
}
 
List<Product> products = productRepository.findAll(spec);

public interface ProductRepository extends 
    JpaRepository<Product, Long>,
    QuerydslPredicateExecutor<Product> {
}
 
// Использование:
QProduct product = QProduct.product;
BooleanExpression predicate = product.isNotNull();
 
if (category != null) {
    predicate = predicate.and(product.category.eq(category));
}
 
if (minPrice != null && maxPrice != null) {
    predicate = predicate.and(
        product.price.between(minPrice, maxPrice));
}
 
Iterable<Product> products = productRepository.findAll(predicate);

@Service
public class OrderService {
    
    @Transactional(
        isolation = Isolation.READ_COMMITTED,
        propagation = Propagation.REQUIRED,
        rollbackFor = {DataIntegrityViolationException.class},
        noRollbackFor = {NotFoundException.class},
        timeout = 30
    )
    public OrderResult processOrder(Order order) {
        // Логика обработки заказа
    }
}

@Service
public class ComplexService {
    
    @Autowired
    private ComplexService self;
    
    public void outerMethod() {
        // Здесь нет транзакции
        self.innerTransactionalMethod(); // Транзакция открывается здесь
    }
    
    @Transactional
    public void innerTransactionalMethod() {
        // Транзакционный метод
    }
}

@Repository
public class JdbcProductRepository implements ProductRepository {
  
  private final NamedParameterJdbcTemplate jdbcTemplate;
  
  public JdbcProductRepository(NamedParameterJdbcTemplate jdbcTemplate) {
      this.jdbcTemplate = jdbcTemplate;
  }
  
  @Override
  public List<Product> findByCategory(String category, int limit) {
      String sql = "SELECT id, name, price, category, description " +
                  "FROM products WHERE category = :category " +
                  "ORDER BY created_at DESC LIMIT :limit";
      
      MapSqlParameterSource params = new MapSqlParameterSource()
          .addValue("category", category)
          .addValue("limit", limit);
      
      return jdbcTemplate.query(sql, params, 
          (rs, rowNum) -> new Product(
              rs.getLong("id"),
              rs.getString("name"),
              rs.getBigDecimal("price"),
              rs.getString("category"),
              rs.getString("description")
          )
      );
  }
}

@Repository
public class HybridOrderRepository {
  
  @PersistenceContext
  private EntityManager entityManager;
  
  @Autowired
  private JdbcTemplate jdbcTemplate;
  
  // Стандартные JPA операции для обычных сценариев
  
  // Оптимизированное массовое обновление статусов
  public int bulkUpdateStatus(List<Long> orderIds, String newStatus) {
      return jdbcTemplate.update(
          "UPDATE orders SET status = ? WHERE id IN (?)",
          newStatus, String.join(",", orderIds.stream()
                                .map(String::valueOf)
                                .collect(Collectors.toList()))
      );
  }
  
  // Сложный аналитический запрос
  public List<OrderStats> getOrderStatsByPeriod(LocalDate start, LocalDate end) {
      String sql = 
          "SELECT DATE(created_at) as order_date, " +
          "       COUNT(*) as order_count, " +
          "       SUM(total_amount) as daily_revenue " +
          "FROM orders " +
          "WHERE created_at BETWEEN ? AND ? " +
          "GROUP BY DATE(created_at) " +
          "ORDER BY order_date";
      
      return jdbcTemplate.query(
          sql, 
          new Object[]{start, end},
          (rs, rowNum) -> new OrderStats(
              rs.getDate("order_date").toLocalDate(),
              rs.getInt("order_count"),
              rs.getBigDecimal("daily_revenue")
          )
      );
  }
}

@Configuration
public class MultiTenantConfig {
  
  @Autowired
  private DataSourceProperties dataSourceProperties;
  
  @Bean
  public DataSource dataSource() {
      Map<Object, Object> dataSources = new HashMap<>();
      
      // Настраиваем пул соединений для каждого тенанта
      for (String tenant : getTenantList()) {
          DataSourceBuilder<?> builder = DataSourceBuilder.create()
              .url(dataSourceProperties.getUrl().replace("{tenant}", tenant))
              .username(dataSourceProperties.getUsername())
              .password(dataSourceProperties.getPassword());
          
          dataSources.put(tenant, builder.build());
      }
      
      AbstractRoutingDataSource dataSource = new TenantAwareDataSource();
      dataSource.setTargetDataSources(dataSources);
      dataSource.afterPropertiesSet();
      
      return dataSource;
  }
  
  // Определение текущего тенанта на основе контекста запроса
  private static class TenantAwareDataSource extends AbstractRoutingDataSource {
      @Override
      protected Object determineCurrentLookupKey() {
          return TenantContextHolder.getTenant();
      }
  }
}

@Component
public class TenantConnectionProvider implements MultiTenantConnectionProvider {
  
  @Autowired
  private DataSource dataSource;
  
  @Override
  public Connection getAnyConnection() throws SQLException {
      return dataSource.getConnection();
  }
  
  @Override
  public Connection getConnection(String tenantIdentifier) throws SQLException {
      Connection connection = getAnyConnection();
      connection.createStatement().execute("SET SCHEMA '" + tenantIdentifier + "'");
      return connection;
  }
  
  // Другие методы интерфейса...
}

@Entity
@Table(name = "customers")
@Filter(name = "tenantFilter", condition = "tenant_id = :tenantId")
public class Customer {
  
  @Id
  @GeneratedValue(strategy = GenerationType.IDENTITY)
  private Long id;
  
  private String name;
  
  @Column(name = "tenant_id")
  private String tenantId;
  
  // Геттеры и сеттеры
}
 
@Aspect
@Component
public class TenantFilterAspect {
  
  @PersistenceContext
  private EntityManager entityManager;
  
  @Around("execution(* com.example.repository.*.*(..))")
  public Object applyTenantFilter(ProceedingJoinPoint joinPoint) throws Throwable {
      Session session = entityManager.unwrap(Session.class);
      session.enableFilter("tenantFilter")
          .setParameter("tenantId", TenantContextHolder.getTenant());
      
      try {
          return joinPoint.proceed();
      } finally {
          session.disableFilter("tenantFilter");
      }
  }
}

@Service
public class CustomerServiceClient {
  
    private final RestTemplate restTemplate;
    private final String orderServiceUrl;
  
    public CustomerServiceClient(RestTemplate restTemplate,
                               @Value("${services.order.url}") String orderServiceUrl) {
        this.restTemplate = restTemplate;
        this.orderServiceUrl = orderServiceUrl;
    }
  
    public List<Order> getOrdersByCustomerId(Long customerId) {
        return restTemplate.exchange(
            orderServiceUrl + "/orders/customer/{id}",
            HttpMethod.GET,
            null,
            new ParameterizedTypeReference<List<Order>>(){},
            customerId
        ).getBody();
    }
}

@Service
public class ReactiveCustomerServiceClient {
    
    private final WebClient webClient;
    
    public ReactiveCustomerServiceClient(WebClient.Builder webClientBuilder,
                                     @Value("${services.order.url}") String orderServiceUrl) {
        this.webClient = webClientBuilder.baseUrl(orderServiceUrl).build();
    }
    
    public Flux<Order> getOrdersByCustomerId(Long customerId) {
        return webClient.get()
                      .uri("/orders/customer/{id}", customerId)
                      .retrieve()
                      .bodyToFlux(Order.class);
    }
}

@Service
public class OrderCreatedEventPublisher {
    
    private final KafkaTemplate<String, OrderCreatedEvent> kafkaTemplate;
    
    public OrderCreatedEventPublisher(KafkaTemplate<String, OrderCreatedEvent> kafkaTemplate) {
        this.kafkaTemplate = kafkaTemplate;
    }
    
    public void publishOrderCreatedEvent(Order order) {
        OrderCreatedEvent event = new OrderCreatedEvent(order.getId(), 
                                                      order.getCustomerId(),
                                                      order.getItems());
        
        kafkaTemplate.send("order-events", event);
    }
}
 
@Component
public class OrderEventConsumer {
    
    private final InventoryService inventoryService;
    
    @KafkaListener(topics = "order-events", groupId = "inventory-service")
    public void procesOrderCreatedEvent(OrderCreatedEvent event) {
        // Обработка события создания заказа
        inventoryService.reserveItems(event.getOrderId(), event.getItems());
    }
}

@Component
public class IdempotentOrderEventConsumer {
    
    private final InventoryService inventoryService;
    private final ProcessedEventsRepository processedEvents;
    
    @KafkaListener(topics = "order-events", groupId = "inventory-service")
    public void processOrderCreatedEvent(OrderCreatedEvent event) {
        String eventId = event.getEventId();
        
        // Проверяем, не обрабатывали ли мы уже это событие
        if (processedEvents.existsById(eventId)) {
            return;
        }
        
        try {
            inventoryService.reserveItems(event.getOrderId(), event.getItems());
            // Сохраняем идентификатор обработанного события
            processedEvents.save(new ProcessedEvent(eventId));
        } catch (Exception e) {
            // Обработка ошибок
        }
    }
}

// Eureka Server
@SpringBootApplication
@EnableEurekaServer
public class DiscoveryServiceApplication {
    public static void main(String[] args) {
        SpringApplication.run(DiscoveryServiceApplication.class, args);
    }
}
 
// Клиент Eureka
@SpringBootApplication
@EnableDiscoveryClient
public class OrderServiceApplication {
    public static void main(String[] args) {
        SpringApplication.run(OrderServiceApplication.class, args);
    }
    
    @Bean
    @LoadBalanced  // Включает клиентский балансировщик нагрузки
    public RestTemplate restTemplate() {
        return new RestTemplate();
    }
}

@Service
public class ProductClient {
    
    private final RestTemplate restTemplate;
    
    public ProductClient(RestTemplate restTemplate) {
        this.restTemplate = restTemplate;
    }
    
    public Product getProduct(Long id) {
        // 'product-service' - имя сервиса в Eureka
        return restTemplate.getForObject(
            "http://product-service/products/{id}", 
            Product.class, 
            id
        );
    }
}

@Configuration
@EnableKubernetesClient
public class K8sConfig {
    
    @Bean
    public DiscoveryClient kubernetesDiscoveryClient(
                        KubernetesClient client) {
        return new KubernetesDiscoveryClient(client);
    }
}

// Конфигурация трассировки
@Configuration
public class TracingConfig {
    
    @Bean
    public ObservationHandler<Observation.Context> observationTextHandler() {
        return new ObservationTextPublisher();
    }
}

management.tracing.sampling.probability=1.0
management.zipkin.tracing.endpoint=http://zipkin:9411/api/v2/spans

@Component
public class OrderProcessor {
    
    private final ObservationRegistry observationRegistry;
    
    public void processOrder(Order order) {
        
        Observation observation = Observation
            .createNotStarted("order-processing", observationRegistry)
            .lowCardinalityKeyValue("customerId", order.getCustomerId().toString())
            .highCardinalityKeyValue("orderId", order.getId().toString());
        
        try (Observation.Scope scope = observation.start().openScope()) {
            // Бизнес-логика обработки заказа
            validateOrder(order);
            reserveInventory(order);
            processPayment(order);
        } catch (Exception e) {
            observation.error(e);
            throw e;
        } finally {
            observation.stop();
        }
    }
}

@Service
public class ProductService {
    
    private final RestTemplate restTemplate;
    private final CircuitBreakerFactory circuitBreakerFactory;
    
    public Product getProductDetails(Long productId) {
        CircuitBreaker circuitBreaker = circuitBreakerFactory.create("productService");
        
        return circuitBreaker.run(
            () -> restTemplate.getForObject(
                "http://product-service/products/{id}", 
                Product.class, 
                productId
            ),
            throwable -> getProductFallback(productId)
        );
    }
    
    private Product getProductFallback(Long productId) {
        return new Product(productId, "Товар недоступен", BigDecimal.ZERO);
    }
}

@Configuration
public class Resilience4JConfig {
    
    @Bean
    public Customizer<Resilience4JCircuitBreakerFactory> resilience4JConfiguration() {
        
        // Настройка по умолчанию для всех Circuit Breaker'ов
        return factory -> factory.configureDefault(id -> {
            return new Resilience4JConfigBuilder(id)
                .circuitBreakerConfig(CircuitBreakerConfig.custom()
                    .slidingWindowSize(10)
                    .failureRateThreshold(50)
                    .waitDurationInOpenState(Duration.ofSeconds(10))
                    .permittedNumberOfCallsInHalfOpenState(5)
                    .build())
                .timeLimiterConfig(TimeLimiterConfig.custom()
                    .timeoutDuration(Duration.ofSeconds(3))
                    .build())
                .build();
        });
    }
}

@SpringBootApplication
@EnableDiscoveryClient
public class GatewayServiceApplication {
    public static void main(String[] args) {
        SpringApplication.run(GatewayServiceApplication.class, args);
    }
    
    @Bean
    public RouteLocator customRouteLocator(RouteLocatorBuilder builder) {
        return builder.routes()
            .route("product-service", r -> r.path("/api/products/**")
                .filters(f -> f.rewritePath("/api/products/(?<segment>.*)", "/products/${segment}")
                            .addResponseHeader("X-Response-Time", LocalDateTime.now().toString()))
                .uri("lb://product-service"))
            .route("order-service", r -> r.path("/api/orders/**")
                .filters(f -> f.circuitBreaker(c -> c.setName("orderCircuitBreaker")
                                           .setFallbackUri("forward:/fallback/orders")))
                .uri("lb://order-service"))
            .build();
    }
}

@RestController
@RequestMapping("/api/v1/products")
public class ProductControllerV1 {
    @GetMapping("/{id}")
    public ProductV1 getProduct(@PathVariable Long id) {
        // Реализация для версии 1
    }
}
 
@RestController
@RequestMapping("/api/v2/products")
public class ProductControllerV2 {
    @GetMapping("/{id}")
    public ProductV2 getProduct(@PathVariable Long id) {
        // Обновленная реализация для версии 2
    }
}

@RestController
@RequestMapping("/api/products")
public class ProductController {
    @GetMapping(value = "/{id}", headers = "API-Version=1")
    public ProductV1 getProductV1(@PathVariable Long id) {
        // Версия 1
    }
    
    @GetMapping(value = "/{id}", headers = "API-Version=2")
    public ProductV2 getProductV2(@PathVariable Long id) {
        // Версия 2
    }
}

@ExtendWith(MockitoExtension.class)
public class OrderServiceTest {
  
  @Mock
  private OrderRepository orderRepository;
  
  @Mock
  private PaymentService paymentService;
  
  @InjectMocks
  private OrderServiceImpl orderService;
  
  @Test
  void shouldCreateOrder() {
      // Arrange
      Order order = new Order(1L, "Test Customer", new BigDecimal("99.99"));
      when(orderRepository.save(any(Order.class))).thenReturn(order);
      
      // Act
      Order result = orderService.createOrder(order);
      
      // Assert
      assertThat(result).isNotNull();
      assertThat(result.getId()).isEqualTo(1L);
      
      verify(paymentService).processPayment(any(PaymentRequest.class));
      verify(orderRepository).save(any(Order.class));
  }
}

@SpringBootTest
@Transactional
public class OrderIntegrationTest {
  
  @Autowired
  private OrderService orderService;
  
  @Autowired
  private OrderRepository orderRepository;
  
  @Autowired
  private TestEntityManager entityManager;
  
  @Test
  void shouldSaveOrderWithItems() {
      // Создаем тестовые данные
      Customer customer = new Customer();
      customer.setName("Test Customer");
      entityManager.persist(customer);
      
      Product product = new Product();
      product.setName("Test Product");
      product.setPrice(new BigDecimal("29.99"));
      entityManager.persist(product);
      
      // Создаем заказ
      Order order = new Order();
      order.setCustomer(customer);
      order.setStatus(OrderStatus.PENDING);
      
      OrderItem item = new OrderItem();
      item.setProduct(product);
      item.setQuantity(2);
      order.addItem(item);
      
      // Сохраняем и проверяем
      Order savedOrder = orderService.createOrder(order);
      
      Order found = orderRepository.findById(savedOrder.getId())
             .orElseThrow(() -> new AssertionError("Order not found"));
             
      assertThat(found.getItems()).hasSize(1);
      assertThat(found.getTotalAmount()).isEqualByComparingTo(new BigDecimal("59.98"));
  }
}

@WebMvcTest(ProductController.class)
public class ProductControllerTest {
  
  @Autowired
  private MockMvc mockMvc;
  
  @MockBean
  private ProductService productService;
  
  @Test
  void shouldReturnProductById() throws Exception {
      // Arrange
      Product product = new Product(1L, "iPhone", new BigDecimal("999.99"));
      when(productService.getProductById(1L)).thenReturn(Optional.of(product));
      
      // Act & Assert
      mockMvc.perform(get("/api/products/1")
              .contentType(MediaType.APPLICATION_JSON))
              .andExpect(status().isOk())
              .andExpect(jsonPath("$.id").value(1))
              .andExpect(jsonPath("$.name").value("iPhone"))
              .andExpect(jsonPath("$.price").value(999.99));
  }
  
  @Test
  void shouldReturn404WhenProductNotFound() throws Exception {
      // Arrange
      when(productService.getProductById(999L)).thenReturn(Optional.empty());
      
      // Act & Assert
      mockMvc.perform(get("/api/products/999")
              .contentType(MediaType.APPLICATION_JSON))
              .andExpect(status().isNotFound());
  }
}

@SpringBootTest
@Testcontainers
public class OrderRepositoryPostgresTest {
  
  @Container
  static PostgreSQLContainer<?> postgres = new PostgreSQLContainer<>("postgres:13")
          .withDatabaseName("testdb")
          .withUsername("test")
          .withPassword("test");
  
  @DynamicPropertySource
  static void postgresProperties(DynamicPropertyRegistry registry) {
      registry.add("spring.datasource.url", postgres::getJdbcUrl);
      registry.add("spring.datasource.username", postgres::getUsername);
      registry.add("spring.datasource.password", postgres::getPassword);
  }
  
  @Autowired
  private OrderRepository orderRepository;
  
  @Test
  void shouldFindOrdersByCustomerId() {
      // Тест с реальной базой PostgreSQL
  }
}

@SpringBootTest
@Testcontainers
public class OrderEventPublisherTest {
 
  @Container
  static KafkaContainer kafka = new KafkaContainer(DockerImageName.parse("confluentinc/cp-kafka:6.2.1"));
  
  @DynamicPropertySource
  static void kafkaProperties(DynamicPropertyRegistry registry) {
      registry.add("spring.kafka.bootstrap-servers", kafka::getBootstrapServers);
  }
  
  @Autowired
  private KafkaTemplate<String, OrderCreatedEvent> kafkaTemplate;
  
  @Autowired
  private OrderEventPublisher eventPublisher;
  
  @Test
  void shouldPublishOrderCreatedEvent() throws Exception {
      // Тест отправки и получения реальных сообщений через Kafka
  }
}

@SpringBootTest
@AutoConfigureWireMock(port = 0)
public class ProductClientTest {
  
  @Autowired
  private ProductClient productClient;
  
  @Value("${wiremock.server.port}")
  private int port;
  
  @BeforeEach
  void setup() {
      // Настраиваем мок-ответ
      stubFor(get(urlPathMatching("/api/products/1"))
              .willReturn(aResponse()
                      .withStatus(200)
                      .withHeader("Content-Type", "application/json")
                      .withBody("{\"id\":1,\"name\":\"Test Product\",\"price\":99.99}")));
  }
  
  @Test
  void shouldFetchProductFromExternalService() {
      Product product = productClient.getProductById(1L);
      
      assertThat(product).isNotNull();
      assertThat(product.getName()).isEqualTo("Test Product");
      assertThat(product.getPrice()).isEqualByComparingTo(new BigDecimal("99.99"));
  }
}

@SpringBootTest(webEnvironment = WebEnvironment.RANDOM_PORT)
public class PerformanceTest {
  
  @LocalServerPort
  private int port;
  
  @Autowired
  private ProductRepository productRepository;
  
  @BeforeEach
  void setupData() {
      // Создаем тестовые данные
      List<Product> products = IntStream.range(1, 1001)
              .mapToObj(i -> new Product(
                      (long) i, 
                      "Product " + i, 
                      new BigDecimal(ThreadLocalRandom.current().nextInt(10, 1000))))
              .collect(Collectors.toList());
      
      productRepository.saveAll(products);
  }
  
  @Test
  void loadTest() throws IOException {
      // Конфигурация Gatling
      HttpProtocolBuilder httpProtocol = http
              .baseUrl("http://localhost:" + port)
              .acceptHeader("application/json");
      
      ScenarioBuilder scenario = scenario("Load test API")
              .exec(http("List products")
                      .get("/api/products?page=0&size=20")
                      .check(status().is(200)))
              .pause(1)
              .exec(http("Get single product")
                      .get("/api/products/1")
                      .check(status().is(200)));
      
      // Настройка симуляции для 100 пользователей в течение 1 минуты
      setUp(
          scenario.injectOpen(
              rampUsers(100).during(Duration.ofSeconds(60))
          )
      ).protocols(httpProtocol)
      .assertions(
          global().responseTime().max().lt(1000),
          global().successfulRequests().percent().gt(95)
      );
  }
}

@Configuration
public class MetricsConfig {
  
  @Bean
  public MeterRegistryCustomizer<MeterRegistry> metricsCommonTags() {
      return registry -> registry.config()
              .commonTags("application", "my-app")
              .meterFilter(new MeterFilter() {
                  @Override
                  public DistributionStatisticConfig configure(Meter.Id id, DistributionStatisticConfig config) {
                      if (id.getName().startsWith("http.server.requests")) {
                          return DistributionStatisticConfig.builder()
                                  .percentilesHistogram(true)
                                  .percentiles(0.5, 0.95, 0.99)
                                  .build()
                                  .merge(config);
                      }
                      return config;
                  }
              });
  }
}

@WebMvcTest(controllers = AdminController.class)
public class AdminControllerSecurityTest {
  
  @Autowired
  private MockMvc mockMvc;
  
  @MockBean
  private AdminService adminService;
  
  @Test
  @WithMockUser(roles = "USER")
  void regularUserCannotAccessAdminEndpoint() throws Exception {
      mockMvc.perform(get("/api/admin/stats"))
              .andExpect(status().isForbidden());
  }
  
  @Test
  @WithMockUser(roles = "ADMIN")
  void adminCanAccessAdminEndpoint() throws Exception {
      when(adminService.getStats()).thenReturn(new AdminStats(10, 5));
      
      mockMvc.perform(get("/api/admin/stats"))
              .andExpect(status().isOk())
              .andExpect(jsonPath("$.totalUsers").value(10));
  }
  
  @Test
  void unauthenticatedUserCannotAccess() throws Exception {
      mockMvc.perform(get("/api/admin/stats"))
              .andExpect(status().isUnauthorized());
  }
}

@WebMvcTest(controllers = ProductController.class)
public class ProductControllerSecurityTest {
  
  @Autowired
  private MockMvc mockMvc;
  
  @MockBean
  private ProductService productService;
  
  @MockBean
  private JwtTokenUtil jwtTokenUtil;
  
  @Test
  void shouldAllowRequestWithValidToken() throws Exception {
      // Arrange
      String token = "valid.jwt.token";
      when(jwtTokenUtil.validateToken(token)).thenReturn(true);
      when(jwtTokenUtil.getUsernameFromToken(token)).thenReturn("user");
      when(jwtTokenUtil.getRolesFromToken(token)).thenReturn(Arrays.asList("ROLE_USER"));
      
      when(productService.getProductById(1L)).thenReturn(Optional.of(new Product(1L, "Test", BigDecimal.TEN)));
      
      // Act & Assert
      mockMvc.perform(get("/api/products/1")
              .header("Authorization", "Bearer " + token))
              .andExpect(status().isOk());
  }
}

@ExtendWith(MockitoExtension.class)
public class NotificationServiceTest {
  
  @Mock
  private EmailSender emailSender;
  
  @Mock
  private SmsSender smsSender;
  
  @InjectMocks
  private NotificationServiceImpl notificationService;
  
  @Test
  void shouldSendBothEmailAndSmsForPremiumUser() {
      // Arrange
      Customer customer = new Customer();
      customer.setEmail("test@example.com");
      customer.setPhone("+1234567890");
      customer.setPremiumMember(true);
      
      Notification notification = new Notification();
      notification.setCustomer(customer);
      notification.setMessage("Test message");
      
      // Act
      notificationService.sendNotification(notification);
      
      // Assert
      verify(emailSender).sendEmail(
              eq("test@example.com"), 
              anyString(), 
              eq("Test message"));
              
      verify(smsSender).sendSms(
              eq("+1234567890"), 
              eq("Test message"));
  }
  
  @Test
  void shouldSendOnlyEmailForRegularUser() {
      // Arrange
      Customer customer = new Customer();
      customer.setEmail("test@example.com");
      customer.setPhone("+1234567890");
      customer.setPremiumMember(false);
      
      Notification notification = new Notification();
      notification.setCustomer(customer);
      notification.setMessage("Test message");
      
      // Act
      notificationService.sendNotification(notification);
      
      // Assert
      verify(emailSender).sendEmail(
              eq("test@example.com"), 
              anyString(), 
              eq("Test message"));
              
      verifyNoInteractions(smsSender);
  }
}

@SpringBootTest
public class UserServiceWithContextTest {
  
  @MockBean
  private UserRepository userRepository;
  
  @Autowired
  private UserService userService;
  
  @Test
  void shouldReturnUserDetails() {
      // Arrange
      User user = new User();
      user.setId(1L);
      user.setUsername("testuser");
      user.setEmail("test@example.com");
      
      when(userRepository.findById(1L)).thenReturn(Optional.of(user));
      
      // Act
      UserDetails userDetails = userService.getUserDetails(1L);
      
      // Assert
      assertThat(userDetails).isNotNull();
      assertThat(userDetails.getUsername()).isEqualTo("testuser");
      assertThat(userDetails.getEmail()).isEqualTo("test@example.com");
  }
}

// Todo: Создать значимый проект с пояснительной документацией

// Пример неоптимального запроса
@Query("SELECT o FROM Order o JOIN FETCH o.items JOIN FETCH o.customer WHERE o.status = :status")
List<Order> findAllWithDetails(@Param("status") OrderStatus status);
 
// Оптимизированная версия с пагинацией
@Query(value = "SELECT o FROM Order o JOIN FETCH o.items JOIN FETCH o.customer " +
       "WHERE o.status = :status AND o.id > :lastId ORDER BY o.id LIMIT :limit",
       nativeQuery = true)
List<Order> findWithDetailsPaginated(
    @Param("status") OrderStatus status,
    @Param("lastId") Long lastId,
    @Param("limit") int limit);

// Как Spring Boot находит и загружает автоконфигурации?
// Типичный неполный ответ: "Через аннотацию @SpringBootApplication"
 
// Более полный ответ должен включать понимание:
// - Механизма spring.factories
// - Работы ClassLoader для сканирования classpath
// - Порядка разрешения конфликтов автоконфигураций
// - Условных аннотаций (@ConditionalOn*)

// Антипаттерн: обработка исключений в контроллере
@GetMapping("/{id}")
public Product getProduct(@PathVariable Long id) {
    try {
        return productService.getById(id);
    } catch (ProductNotFoundException e) {
        throw new ResponseStatusException(HttpStatus.NOT_FOUND, "Product not found");
    }
}
 
// Правильный подход: глобальный обработчик исключений
@ControllerAdvice
public class GlobalExceptionHandler {
    @ExceptionHandler(ProductNotFoundException.class)
    public ResponseEntity<ErrorResponse> handleProductNotFound(ProductNotFoundException ex) {
        ErrorResponse error = new ErrorResponse("PRODUCT_NOT_FOUND", ex.getMessage());
        return new ResponseEntity<>(error, HttpStatus.NOT_FOUND);
    }
}

@Configuration
@EnableCaching
public class CacheConfig {
 
    @Bean("customerCache")
    public Cache customerCache() {
        return new CaffeineCache("customers", 
                Caffeine.newBuilder()
                        .expireAfterWrite(5, TimeUnit.MINUTES)
                        .maximumSize(1000)
                        .build());
    }
    
    @Bean
    public RedisCacheManager redisCacheManager(RedisConnectionFactory connectionFactory) {
        RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig()
                .entryTtl(Duration.ofHours(1))
                .serializeKeysWith(RedisSerializationContext.SerializationPair
                        .fromSerializer(new StringRedisSerializer()))
                .serializeValuesWith(RedisSerializationContext.SerializationPair
                        .fromSerializer(new GenericJackson2JsonRedisSerializer()));
        
        return RedisCacheManager.builder(connectionFactory)
                .cacheDefaults(config)
                .build();
    }
    
    @Bean
    public CacheManager cacheManager(CaffeineCache customerCache, 
                                     RedisCacheManager redisCacheManager) {
        CompositeCacheManager compositeCacheManager = new CompositeCacheManager();
        compositeCacheManager.setCacheCandidates(Arrays.asList(
                new SimpleCacheManager(Collections.singleton(customerCache)),
                redisCacheManager
        ));
        return compositeCacheManager;
    }
}