SpringBoot项目中控制自定义与外部Jar包内同类型Bean创建顺序的方法咨询

Got it, let's tackle this problem step by step. The core issue here is that both your custom EncryptablePropertyPlaceholderConfigurer and the one from the external JAR are BeanFactoryPostProcessors—special beans that modify the bean factory before regular beans are instantiated. @Order and @DependsOn don't work as expected here because Spring handles BeanFactoryPostProcessor execution order differently. Here are three practical solutions you can implement right away:

1. Remove the Conflicting Bean from the External JAR #

The most straightforward fix is to eliminate the JAR's bean entirely, since your custom one is the one you need. You can do this by using a BeanDefinitionRegistryPostProcessor—a bean that runs early in the context lifecycle to modify or remove bean definitions before any beans are created.

Implementation Code #

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanDefinition;
import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
import org.springframework.beans.factory.support.BeanDefinitionRegistry;
import org.springframework.beans.factory.support.BeanDefinitionRegistryPostProcessor;
import org.springframework.stereotype.Component;

@Component
public class ConflictingBeanRemover implements BeanDefinitionRegistryPostProcessor {

    @Override
    public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {
        // Iterate all registered bean definitions
        String[] allBeanNames = registry.getBeanDefinitionNames();
        for (String beanName : allBeanNames) {
            BeanDefinition beanDef = registry.getBeanDefinition(beanName);
            String beanClassName = beanDef.getBeanClassName();
            
            // Remove any EncryptablePropertyPlaceholderConfigurer that's not your custom one
            if (EncryptablePropertyPlaceholderConfigurer.class.getName().equals(beanClassName) &&
                !YourCustomEncryptablePlaceholder.class.getName().equals(beanClassName)) {
                registry.removeBeanDefinition(beanName);
                System.out.println("Removed conflicting JAR bean: " + beanName);
            }
        }
    }

    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
        // No additional action needed here
    }
}

Pros & Cons #

• Pros:彻底消除冲突，不用再担心顺序问题。不管外部JAR的Bean怎么配置都能生效。
• Cons:仅适用于你确定外部JAR的Bean不会影响其他功能的场景。

2. Force Your Custom Bean to Execute First with PriorityOrdered #

Spring processes BeanFactoryPostProcessors in a specific order: first beans implementing PriorityOrdered, then Ordered, then regular beans. By making your custom bean implement PriorityOrdered with the highest possible precedence, you ensure it runs before the JAR's bean—even if the JAR's bean is registered first.

Implementation Code #

import org.springframework.core.Ordered;
import org.springframework.core.PriorityOrdered;
import org.springframework.stereotype.Component;

@Component
public class YourCustomEncryptablePlaceholder extends EncryptablePropertyPlaceholderConfigurer implements PriorityOrdered {

    // Your existing encryption/decryption logic here...

    @Override
    public int getOrder() {
        // Set the highest possible priority so this runs first
        return Ordered.HIGHEST_PRECEDENCE;
    }
}

Pros & Cons #

• Pros:保留两个Bean（如果你需要外部JAR的Bean处理其他逻辑），同时保证自定义Bean优先执行。不需要修改外部JAR。
• Cons:如果外部JAR的Bean也实现了PriorityOrdered且优先级更高（这种情况极少），方案可能失效，但大部分第三方库不会这么配置。

3. Migrate to Spring Boot's Recommended Property Loading Mechanism #

PropertyPlaceholderConfigurer是Spring的旧特性，Spring Boot更推荐使用PropertySource和Environment处理属性。通过自定义PropertySourceLocator，你可以在不与外部JAR的旧Bean冲突的情况下处理加密属性。

Implementation Steps #

1. 创建自定义PropertySourceLocator：

import org.springframework.boot.env.PropertySourceLocator;
import org.springframework.core.env.Environment;
import org.springframework.core.env.MapPropertySource;
import org.springframework.core.env.PropertySource;

import java.util.HashMap;
import java.util.Map;

public class EncryptedPropertySourceLocator implements PropertySourceLocator {

    @Override
    public PropertySource<?> locate(Environment environment) {
        // 加载加密属性、解密后封装为PropertySource
        Map<String, Object> decryptedProps = new HashMap<>();
        
        // 示例：从配置文件读取加密属性并解密
        decryptedProps.put("your.encrypted.property", decrypt(environment.getProperty("your.encrypted.property")));
        
        return new MapPropertySource("customEncryptedProperties", decryptedProps);
    }

    private String decrypt(String encryptedValue) {
        // 你的解密逻辑
        return encryptedValue;
    }
}

2. 在src/main/resources下创建META-INF/spring.factories文件注册Locator：

org.springframework.boot.env.PropertySourceLocator=com.yourpackage.EncryptedPropertySourceLocator

Pros & Cons #

• Pros:遵循Spring Boot最佳实践，避免与旧的PropertyPlaceholderConfigurer冲突，长期维护性更好。
• Cons:需要将属性处理逻辑从PropertyPlaceholderConfigurer迁移过来，有一定重构成本。

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