Как зарегистрировать Singleton в активный контейнер

# Регистрация Singleton в активный Spring контейнер

Программатическая регистрация Bean (в том числе Singleton) в уже работающий ApplicationContext — важный навык при работе с динамическими конфигурациями. Есть несколько способов это сделать.

1. Использование GenericApplicationContext

Прямое добавление Bean определения в контейнер:

import org.springframework.context.support.GenericApplicationContext;
import org.springframework.beans.factory.support.DefaultListableBeanFactory;

public class SingletonRegistrationExample {
    
    public static void main(String[] args) {
        GenericApplicationContext context = new GenericApplicationContext();
        context.refresh();  // инициализируем контейнер
        
        // Регистрируем Singleton прямо в активный контейнер
        DefaultListableBeanFactory beanFactory = context.getDefaultListableBeanFactory();
        
        // Способ 1: регистрируем готовый объект
        MyService myService = new MyService();
        beanFactory.registerSingleton("myService", myService);
        
        // Теперь можем получить Bean
        MyService retrieved = context.getBean("myService", MyService.class);
        System.out.println(retrieved == myService);  // true
    }
}

public class MyService {
    public void doSomething() {
        System.out.println("Doing something");
    }
}

Метод registerSingleton() регистрирует готовый объект как Singleton. Spring не будет управлять инициализацией/разрушением этого объекта.

2. Использование BeanDefinitionRegistry

Регистрация Bean определения (более гибкий способ):

import org.springframework.context.support.GenericApplicationContext;
import org.springframework.beans.factory.support.BeanDefinitionBuilder;
import org.springframework.beans.factory.support.BeanDefinitionRegistry;

public class BeanRegistrationExample {
    
    public static void main(String[] args) {
        GenericApplicationContext context = new GenericApplicationContext();
        context.refresh();
        
        BeanDefinitionRegistry registry = context;
        
        // Регистрируем Bean определение
        BeanDefinitionBuilder builder = BeanDefinitionBuilder.rootBeanDefinition(MyService.class);
        builder.setScope("singleton");  // явно указываем Singleton scope
        registry.registerBeanDefinition("myService", builder.getBeanDefinition());
        
        // Spring создаст объект автоматически
        MyService service = context.getBean("myService", MyService.class);
        service.doSomething();
    }
}

Этот способ позволяет Spring управлять инициализацией и разрушением Bean.

3. Регистрация с параметрами конструктора

import org.springframework.beans.factory.config.ConstructorArgumentValues;
import org.springframework.beans.factory.support.GenericBeanDefinition;

public class ParameterizedBeanRegistration {
    
    public static void main(String[] args) {
        GenericApplicationContext context = new GenericApplicationContext();
        context.refresh();
        
        // Создаём определение Bean с параметрами
        GenericBeanDefinition beanDefinition = new GenericBeanDefinition();
        beanDefinition.setBeanClass(DatabaseConnection.class);
        beanDefinition.setScope("singleton");
        
        // Добавляем параметры конструктора
        ConstructorArgumentValues args = new ConstructorArgumentValues();
        args.addIndexedArgumentValue(0, "jdbc:mysql://localhost:3306/mydb");
        args.addIndexedArgumentValue(1, "root");
        beanDefinition.setConstructorArgumentValues(args);
        
        context.registerBeanDefinition("dbConnection", beanDefinition);
        
        DatabaseConnection db = context.getBean("dbConnection", DatabaseConnection.class);
        System.out.println(db.getUrl());
    }
}

public class DatabaseConnection {
    private String url;
    private String username;
    
    public DatabaseConnection(String url, String username) {
        this.url = url;
        this.username = username;
    }
    
    public String getUrl() {
        return url;
    }
}

4. Регистрация с использованием BeanFactory.registerSingleton

Для ActiveMQ, Camel и других контейнеров:

import org.springframework.beans.factory.support.DefaultListableBeanFactory;

public class ActiveContainerRegistration {
    
    public static void registerSingletonInActiveContainer(
            DefaultListableBeanFactory beanFactory,
            String beanName,
            Object singletonObject) {
        
        beanFactory.registerSingleton(beanName, singletonObject);
    }
    
    public static void main(String[] args) {
        // Получаем активный контейнер из приложения
        ApplicationContext appContext = getRunningApplicationContext();
        DefaultListableBeanFactory beanFactory = 
            (DefaultListableBeanFactory) appContext.getAutowireCapableBeanFactory();
        
        // Регистрируем новый Singleton
        MyService service = new MyService();
        registerSingletonInActiveContainer(beanFactory, "newService", service);
        
        // Используем
        MyService retrieved = appContext.getBean("newService", MyService.class);
    }
    
    private static ApplicationContext getRunningApplicationContext() {
        // Получение контекста из приложения
        return null;
    }
}

5. Регистрация с Proxy и Interceptors

Для более сложных сценариев с AOP:

import org.springframework.beans.factory.support.DefaultListableBeanFactory;
import org.springframework.aop.framework.ProxyFactory;

public class ProxiedSingletonRegistration {
    
    public static void main(String[] args) {
        GenericApplicationContext context = new GenericApplicationContext();
        context.refresh();
        
        DefaultListableBeanFactory beanFactory = context.getDefaultListableBeanFactory();
        
        // Создаём Singleton
        MyService target = new MyService();
        
        // Оборачиваем в Proxy с AOP
        ProxyFactory proxyFactory = new ProxyFactory();
        proxyFactory.setTarget(target);
        proxyFactory.addAdvice((org.aopalliance.intercept.MethodInterceptor) invocation -> {
            System.out.println("Before method: " + invocation.getMethod().getName());
            Object result = invocation.proceed();
            System.out.println("After method: " + invocation.getMethod().getName());
            return result;
        });
        
        Object proxy = proxyFactory.getProxy();
        beanFactory.registerSingleton("myServiceProxy", proxy);
        
        MyService service = context.getBean("myServiceProxy", MyService.class);
        service.doSomething();
    }
}

6. Важные замечания

Различие между registerSingleton и registerBeanDefinition

// registerSingleton — регистрируем готовый объект
beanFactory.registerSingleton("myService", new MyService());
// Spring НЕ вызовет @PostConstruct/@PreDestroy
// Spring НЕ будет внедрять зависимости

// registerBeanDefinition — регистрируем определение
BeanDefinitionBuilder builder = BeanDefinitionBuilder.rootBeanDefinition(MyService.class);
registry.registerBeanDefinition("myService", builder.getBeanDefinition());
// Spring ВЫЗОВЕТ @PostConstruct/@PreDestroy
// Spring БУДЕТ внедрять зависимости через конструктор/setter

Проблемы с регистрацией после refresh()

GenericApplicationContext context = new GenericApplicationContext();
context.refresh();  // контекст закрыт для регистраций

// Это работает, но нужно быть осторожным
DefaultListableBeanFactory factory = context.getDefaultListableBeanFactory();
factory.registerSingleton("late", new MyService());

Реальный пример из микросервисов

@Component
public class DynamicServiceRegistry {
    
    private final DefaultListableBeanFactory beanFactory;
    
    public DynamicServiceRegistry(ApplicationContext appContext) {
        this.beanFactory = (DefaultListableBeanFactory) appContext.getAutowireCapableBeanFactory();
    }
    
    public void registerService(String serviceName, Object serviceInstance) {
        beanFactory.registerSingleton(serviceName, serviceInstance);
    }
    
    public <T> T getService(String serviceName, Class<T> serviceClass) {
        return beanFactory.getBean(serviceName, serviceClass);
    }
}

// Использование
@RestController
public class ServiceController {
    
    @Autowired
    private DynamicServiceRegistry registry;
    
    @PostMapping("/register-service")
    public void registerNewService(@RequestBody ServiceConfig config) {
        MyService service = new MyService();
        registry.registerService(config.getName(), service);
    }
}

Это позволяет динамически регистрировать сервисы в runtime, что полезно при работе с плагинами или динамической конфигурацией приложения.