Java 9 + Spring 5下如何注册多实例Exchange Bean并配置不同属性前缀

You absolutely can dynamically register multiple Exchange bean instances with prefix-specific configuration properties using BeanDefinitionRegistryPostProcessor (this is the better choice over ApplicationContextInitializer, which runs earlier and has less access to the bean registry context). Here's a step-by-step breakdown of how to implement this:

Step 1: Refactor Your Exchange and OtherService Classes for Dynamic Configuration #

First, move away from hardcoded annotations and field injection to constructor injection—this makes it far easier to customize properties per bean instance. We'll use SpEL for the @JmsListener destination to reference an instance-specific property:

// Refactored Exchange class
public class Exchange { 
    private final OtherService otherService;
    private final String targetQueue;

    // Constructor injection for easy customization
    public Exchange(OtherService otherService, String targetQueue) {
        this.otherService = otherService;
        this.targetQueue = targetQueue;
    }

    // Use SpEL to reference the instance's targetQueue property
    @JmsListener(destination = "#{@this.targetQueue}") 
    @Transactional 
    public void receive(String payload) { 
        otherService.send(payload); 
    } 
}

// Refactored OtherService (adjust based on your actual config needs)
public class OtherService {
    private final String serviceConfigProperty;

    public OtherService(String serviceConfigProperty) {
        this.serviceConfigProperty = serviceConfigProperty;
    }

    public void send(String payload) {
        // Use your serviceConfigProperty here
    }
}

Step 2: Define Prefix-Specific Configuration Properties #

Add your instance-specific configs to your application.properties (or YAML) file. We'll use a root property to list all instance prefixes:

# List all exchange instance prefixes
exchange.instances=orderExchange,userExchange

# Order exchange configs
orderExchange.queue=order-processing-queue
orderExchange.other.service.property=order-service-endpoint

# User exchange configs
userExchange.queue=user-updates-queue
userExchange.other.service.property=user-service-endpoint

Step 3: Implement BeanDefinitionRegistryPostProcessor to Register Beans #

Create a component that dynamically registers each Exchange and its corresponding OtherService bean, pulling values from the prefix-specific properties:

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanDefinition;
import org.springframework.beans.factory.support.BeanDefinitionBuilder;
import org.springframework.beans.factory.support.BeanDefinitionRegistry;
import org.springframework.beans.factory.support.BeanDefinitionRegistryPostProcessor;
import org.springframework.context.EnvironmentAware;
import org.springframework.core.env.Environment;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Transactional;

@Component
public class DynamicExchangeRegistrar implements BeanDefinitionRegistryPostProcessor, EnvironmentAware {

    private Environment environment;

    @Override
    public void setEnvironment(Environment environment) {
        this.environment = environment;
    }

    @Override
    public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {
        // Get list of instance prefixes from config
        String[] instancePrefixes = environment.getProperty("exchange.instances", String[].class, new String[0]);

        for (String prefix : instancePrefixes) {
            // 1. Register a dedicated OtherService bean for this prefix
            BeanDefinition otherServiceDef = BeanDefinitionBuilder.genericBeanDefinition(OtherService.class)
                    .addConstructorArgValue(environment.getProperty(prefix + ".other.service.property"))
                    .getBeanDefinition();
            registry.registerBeanDefinition(prefix + "OtherService", otherServiceDef);

            // 2. Register the Exchange bean, linking to its dedicated OtherService
            BeanDefinition exchangeDef = BeanDefinitionBuilder.genericBeanDefinition(Exchange.class)
                    .addConstructorArgReference(prefix + "OtherService")
                    .addConstructorArgValue(environment.getProperty(prefix + ".queue"))
                    // Add @Transactional annotation programmatically (matches your original setup)
                    .addAnnotation(Transactional.class)
                    .getBeanDefinition();
            registry.registerBeanDefinition(prefix + "Exchange", exchangeDef);
        }
    }

    @Override
    public void postProcessBeanFactory(org.springframework.beans.factory.config.ConfigurableListableBeanFactory beanFactory) throws BeansException {
        // No additional bean factory processing needed here
    }
}

Key Notes & Considerations #

• Why BeanDefinitionRegistryPostProcessor? It runs after the bean definition registry is initialized but before any beans are instantiated—perfect for dynamically adding or modifying bean definitions. ApplicationContextInitializer runs earlier and has limited access to the registry, so it's not ideal here.
• Java 9 Compatibility: Spring 5.0 and above fully supports Java 9, so this implementation will work without issues.
• Complex Configuration: If your OtherService or Exchange have more complex configs, you can use @ConfigurationProperties to bind prefix-specific properties to a dedicated config class, then inject that class into your beans instead of individual properties.
• SpEL for @JmsListener: Using #{@this.targetQueue} tells Spring to fetch the targetQueue property directly from the Exchange instance, ensuring each listener uses the correct queue.

内容的提问来源于stack exchange，提问作者Matthew Campbell