@Value("${app.timeout:30}")
private int timeout;

@ConfigurationProperties(prefix = "app")
@Configuration
public class AppProperties {
    private Duration timeout = Duration.ofSeconds(30);
    
    // геттеры/сеттеры
}

app:
  timeout: 30s

@EnableConfigurationProperties(AppProperties.class)

@Service
@Lazy
public class MyService {
  
  @Transactional
  public void doSomething() {
    // ...
  }
}

@Service
public class MyService {

  private final MyService self;

  public MyService(@Lazy MyService self) {
    this.self = self;
  }

  public void doWrapper() {
    self.doTransactional(); // прокси работает
  }

  @Transactional
  public void doTransactional() {
    // ...
  }
}

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

spring:
  main:
    lazy-initialization: true

@Lazy
@Component
public class HeavyService {
    // ...
}

@Service
public class UserService {

    public void createUser() {
        // вызов внутреннего метода — транзакция не активируется
        saveUser(); 
    }

    @Transactional
    private void saveUser() {
        // НЕ будет работать как транзакционный
    }
}

@Service
public class UserSaver {

    @Transactional
    public void saveUser() {
        // теперь работает!
    }
}

@Service
public class UserService {
    private final UserSaver userSaver;

    public UserService(UserSaver userSaver) {
        this.userSaver = userSaver;
    }

    public void createUser() {
        userSaver.saveUser(); // транзакция начнётся
    }
}

// Репозиторий без оптимизации
public interface UserRepository extends JpaRepository<User, Long> {}
// Сущности
@Entity
public class User {
    @OneToMany(mappedBy = "user")
    private List<Order> orders;
}

@Query("SELECT u FROM User u JOIN FETCH u.orders WHERE u.active = true")
List<User> findAllActiveWithOrders();

✅ Все нужные данные подтягиваются одним запросом.
❌ Но не всегда удобно, если нужно динамически выбирать связи.

@Entity
@NamedEntityGraph(
    name = "User.withOrders",
    attributeNodes = @NamedAttributeNode("orders")
)
public class User {
    @OneToMany(mappedBy = "user", fetch = FetchType.LAZY)
    private List<Order> orders;
    // ...
}

public interface UserRepository extends JpaRepository<User, Long> {
    @EntityGraph(value = "User.withOrders", type = EntityGraph.EntityGraphType.LOAD)
    List<User> findAllByActiveTrue();
}

public List<User> findActiveWithDynamicGraph() {
    EntityGraph<User> graph = entityManager.createEntityGraph(User.class);
    graph.addAttributeNodes("orders", "profile");
    TypedQuery<User> query = entityManager.createQuery(
        "SELECT u FROM User u WHERE u.active = true", User.class
    );
    query.setHint("javax.persistence.fetchgraph", graph);
    return query.getResultList();
}

  @Query("SELECT DISTINCT u FROM User u JOIN FETCH u.orders WHERE u.active = true")
  

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 {}