int h = key.hashCode();
int hash = h ^ (h >>> 16);

int idx = hash & (table.length - 1);

@Service
public class UserService {
    public void registerUser() {
        createUser(); // ❌ Транзакция не работает!
    }

    @Transactional
    public void createUser() {
        // изменения в БД
    }
}

@Service
public class UserService {
    private final UserWriter writer;

    public UserService(UserWriter writer) {
        this.writer = writer;
    }

    public void registerUser() {
        writer.createUser(); // ✅ работает
    }
}

@Service
public class UserWriter {
    @Transactional
    public void createUser() {
        // изменения в БД
    }
}

@Autowired
private ApplicationContext context;

public void registerUser() {
    context.getBean(UserService.class).createUser(); // ✅ работает
}

@Service
@RequiredArgsConstructor
public class UserService {

    private final UserRepository userRepository;

    @Transactional(readOnly = true)
    public UserDto getUser(Long id) {
        User user = userRepository.findById(id)
            .orElseThrow(() -> new EntityNotFoundException("User not found"));
        return UserDto.from(user);
    }
}

@Component
public class OrderService {
    @Autowired
    private ApplicationEventPublisher publisher;

    public void createOrder(Order order) {
        // 1. Сохраняем заказ
        orderRepository.save(order);

        // 2. Публикуем ивент
        publisher.publishEvent(new OrderCreatedEvent(order));
        // 3. До выхода из метода все @EventListener уже будут выполнены
    }
}

@EventListener
public void sendEmail(OrderCreatedEvent event) {
    emailService.sendConfirmation(event.getOrder());
}

@Async
@EventListener
public void sendEmail(OrderCreatedEvent event) {
    emailService.sendConfirmation(event.getOrder());
}

@EnableAsync
@Configuration
public class AsyncConfig {}

@Component
@Lazy
public class HeavyComponent {
    public HeavyComponent() {
        System.out.println("HeavyComponent инициализирован");
    }
}

@Component
public class SomeService {
    private final HeavyComponent heavy;

    public SomeService(@Lazy HeavyComponent heavy) {
        this.heavy = heavy;
    }
}

spring:
  main:
    lazy-initialization: true

for (int i = 0; i < 5; i++) {
   if (i == 2) {
       continue;  // Skip iteration when i is 2
   }
   if (i == 4) {
       break;     // Exit loop when i is 4
   }
   System.out.println(i);
}

class Calculator {
   int add(int a, int b) {
       return a + b;
   }
   double add(double a, double b) {
       return a + b;
   }
}

var list = new ArrayList<String>();
list.add("Hello");
list.add("Java");

// Компилятор понимает, что list -> ArrayList<String>

public class CircleCalculator {
   private final double PI = 3.14159;
   public double calculateArea(double radius) {
       return PI * radius * radius;
   }
}

// Сервис с кэшем
@Service
public class CatalogService {
  @Cacheable(cacheNames = "products", key = "#id", unless = "#result == null")
  public Product getById(Long id) {
    // дорогой вызов в БД/REST
  }
}

// Прогрев после полной готовности приложения
@Component
@RequiredArgsConstructor
public class CacheWarmup {

  private final CatalogService catalog;

  @EventListener(org.springframework.boot.context.event.ApplicationReadyEvent.class)
  public void warm() {
    if (!isEnabled()) return;

    var hotIds = loadHotProductIds();      // топ-ключи из БД/конфига
    try (var exec = java.util.concurrent.Executors.newVirtualThreadPerTaskExecutor()) {
      // ограничьте параллелизм при необходимости (Semaphore)
      hotIds.stream()
            .map(id -> java.util.concurrent.CompletableFuture.supplyAsync(() -> catalog.getById(id), exec))
            .forEach(java.util.concurrent.CompletableFuture::join);
    }
  }

  private boolean isEnabled() { return true; } // читайте из настроек/профиля
  private List<Long> loadHotProductIds() { return List.of(1L,2L,3L,4L,5L); }
}

spring:
  cache:
    type: caffeine
    cache-names: products
    caffeine:
      spec: maximumSize=10000,expireAfterWrite=1h,recordStats
# Быстрый прогрев без блокировки потоков ОС (Java 21+)
spring.threads.virtual.enabled: true