Когда стоит использовать Lazy инициализацию Bean в Spring?

Когда использовать Lazy инициализацию Bean в Spring

Что такое Lazy инициализация

Lazy инициализация (ленивая инициализация) — это механизм, при котором Bean создается не при запуске приложения, а только при первом обращении к нему. По умолчанию Spring создает все singleton beans при инициализации контекста.

Включение Lazy инициализации

// Вариант 1: аннотация @Lazy
@Configuration
public class AppConfig {
    @Bean
    @Lazy
    public HeavyService heavyService() {
        return new HeavyService();
    }
}

// Вариант 2: на классе
@Component
@Lazy
public class DataProcessor {
    public void process() {
        System.out.println("Обработка данных");
    }
}

// Вариант 3: в XML конфигурации
<bean id="lazyBean" class="com.example.MyService" lazy-init="true"/>

// Вариант 4: глобально для всех beans
<beans default-lazy-init="true">
    <!-- Все beans будут ленивыми -->
</beans>

Сценарии использования Lazy инициализации

1. Тяжелые вычисления при инициализации

@Component
@Lazy
public class DatabaseConnectionPool {
    private List<Connection> connections;
    
    // Конструктор выполняет дорогостоящую операцию
    public DatabaseConnectionPool() {
        System.out.println("Инициализация пула подключений...");
        this.connections = new ArrayList<>();
        for (int i = 0; i < 100; i++) {
            connections.add(createConnection());
        }
        System.out.println("Пул готов");
    }
    
    private Connection createConnection() {
        // Создание подключения
        return null;
    }
}

// Использование
@RestController
public class UserController {
    @Autowired
    private DatabaseConnectionPool pool;  // Инициализация происходит здесь!
    
    @GetMapping("/users")
    public List<User> getUsers() {
        return pool.getUsers();
    }
}

2. Условные зависимости

@Configuration
public class PaymentConfig {
    @Bean
    @Lazy
    @ConditionalOnProperty(name = "payment.stripe.enabled", havingValue = "true")
    public StripePaymentService stripeService() {
        System.out.println("Инициализация Stripe (если включен)");
        return new StripePaymentService();
    }
    
    @Bean
    @Lazy
    @ConditionalOnProperty(name = "payment.paypal.enabled", havingValue = "true")
    public PayPalPaymentService paypalService() {
        System.out.println("Инициализация PayPal (если включен)");
        return new PayPalPaymentService();
    }
}

// Использование
@Service
public class OrderService {
    @Autowired(required = false)
    private StripePaymentService stripe;
    
    @Autowired(required = false)
    private PayPalPaymentService paypal;
    
    public void processPayment(String provider) {
        if ("stripe".equals(provider)) {
            stripe.pay();  // Инициализация Stripe при первом обращении
        } else if ("paypal".equals(provider)) {
            paypal.pay();  // Инициализация PayPal при первом обращении
        }
    }
}

3. Опциональные сервисы

@Configuration
public class CacheConfig {
    @Bean
    @Lazy
    public RedisCache redisCache() {
        System.out.println("Инициализация Redis кеша");
        return new RedisCache();
    }
    
    @Bean
    @Lazy
    public LocalCache localCache() {
        System.out.println("Инициализация локального кеша");
        return new LocalCache();
    }
}

// Использование: используется только нужный кеш
@Service
public class CacheService {
    @Autowired(required = false)
    private RedisCache redisCache;
    
    public void getValue(String key) {
        // Если Redis отключен, инициализация не произойдет
        if (redisCache != null) {
            return redisCache.get(key);
        }
    }
}

4. Медленная инициализация внешних сервисов

@Component
@Lazy
public class ExternalApiClient {
    private RestTemplate restTemplate;
    private String apiKey;
    
    public ExternalApiClient(RestTemplate restTemplate, 
                            @Value("${external.api.key}") String apiKey) {
        System.out.println("Инициализация External API Client");
        this.restTemplate = restTemplate;
        this.apiKey = apiKey;
        // Проверка соединения
        validateConnection();
    }
    
    private void validateConnection() {
        // Медленная проверка соединения
        System.out.println("Проверка соединения с внешним API...");
    }
    
    public String callApi(String endpoint) {
        return restTemplate.getForObject(
            "https://api.example.com/" + endpoint,
            String.class
        );
    }
}

// Использование
@Service
public class DataService {
    @Autowired
    private ExternalApiClient apiClient;
    
    public void fetchData() {
        // Инициализация происходит здесь при первом обращении
        apiClient.callApi("/data");
    }
}

Сравнение: Eager vs Lazy инициализация

// Eager инициализация (по умолчанию)
@Component
public class EagerService {
    public EagerService() {
        System.out.println("EagerService инициализирован при запуске");
    }
}

// Lazy инициализация
@Component
@Lazy
public class LazyService {
    public LazyService() {
        System.out.println("LazyService инициализирован при первом использовании");
    }
}

// Основное приложение
@SpringBootApplication
public class Application {
    public static void main(String[] args) {
        System.out.println("Запуск приложения...");
        ApplicationContext context = SpringApplication.run(Application.class, args);
        // Вывод:
        // "Запуск приложения..."
        // "EagerService инициализирован при запуске"
        // (LazyService еще не инициализирован)
        
        System.out.println("Запросим LazyService...");
        LazyService lazyService = context.getBean(LazyService.class);
        // Вывод:
        // "LazyService инициализирован при первом использовании"
    }
}

Таблица сценариев

Комбинирование с ObjectProvider

@Service
public class PaymentService {
    private final ObjectProvider<LazyPaymentProcessor> processorProvider;
    
    public PaymentService(ObjectProvider<LazyPaymentProcessor> processorProvider) {
        this.processorProvider = processorProvider;
    }
    
    public void processPayment() {
        // getIfAvailable возвращает Optional, инициализация только если нужна
        processorProvider.ifAvailable(processor -> {
            System.out.println("Обработка платежа");
            processor.process();
        });
    }
}

@Component
@Lazy
class LazyPaymentProcessor {
    public void process() {
        System.out.println("Платеж обработан");
    }
}

Когда НЕ использовать Lazy инициализацию

// ❌ Плохая идея: ошибки инициализации будут найдены позже
@Component
@Lazy
public class CriticalService {
    public CriticalService() {
        // Если здесь ошибка, она проявится только при первом обращении
        throw new RuntimeException("Ошибка инициализации");
    }
}

// ✅ Правильно: критические сервисы должны быть eager
@Component
public class AuthenticationService {
    public AuthenticationService() {
        System.out.println("Инициализация при запуске");
    }
}

Лучшие практики

1. Используй @Lazy для необязательных зависимостей

@Component
@Lazy
public class OptionalFeature {
    // Инициализируется только если используется
}

2. Комбинируй с @ConditionalOnProperty

@Configuration
public class FeatureConfig {
    @Bean
    @Lazy
    @ConditionalOnProperty(
        name = "features.advanced.enabled",
        havingValue = "true"
    )
    public AdvancedFeature advancedFeature() {
        return new AdvancedFeature();
    }
}

3. Не используй для критических сервисов

// ❌ Не делай так
@Component
@Lazy
public class DatabaseService {
    // Ошибки БД должны быть найдены при запуске
}

Заключение

Ленивая инициализация в Spring полезна для:

• Оптимизации времени запуска приложения
• Экономии ресурсов на неиспользуемые beans
• Отложения ошибок инициализации на момент первого использования

Однако используй осторожно для критических сервисов, так как ошибки проявятся не при запуске, а при первом обращении к bean'у. Идеальное применение — опциональные сервисы, платежные шлюзы, внешние API клиенты.