如何在运行时动态禁用Spring的Redis或Elasticsearch注解？

你完全可以在运行时禁用特定注解，不用为Elasticsearch和Redis分别创建重复类，下面是几种可落地的实现方式：

方案一：通过BeanDefinitionRegistryPostProcessor修改Bean定义 #

在Spring Bean注册阶段，直接移除不需要的注解元数据，让Spring Data忽略对应的实体类处理逻辑。

首先在配置文件（比如application.properties）添加开关：

# 可选值：elasticsearch / redis
storage.type=elasticsearch

然后实现自定义的BeanDefinitionRegistryPostProcessor：

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.core.env.Environment;
import org.springframework.data.elasticsearch.annotations.Document;
import org.springframework.data.redis.core.RedisHash;
import org.springframework.stereotype.Component;

@Component
public class StorageAnnotationDisabler implements BeanDefinitionRegistryPostProcessor {

    private final Environment env;

    public StorageAnnotationDisabler(Environment env) {
        this.env = env;
    }

    @Override
    public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {
        String storageType = env.getProperty("storage.type", "elasticsearch");
        Class<?> targetAnnotation = "redis".equals(storageType) ? Document.class : RedisHash.class;

        // 遍历所有Bean定义，清理目标注解
        for (String beanName : registry.getBeanDefinitionNames()) {
            BeanDefinition beanDef = registry.getBeanDefinition(beanName);
            try {
                Class<?> beanClass = Class.forName(beanDef.getBeanClassName());
                if (beanClass.isAnnotationPresent(targetAnnotation)) {
                    // 移除注解元数据，让Spring Data跳过对该类的处理
                    beanDef.setAttribute("annotations", null);
                }
            } catch (ClassNotFoundException e) {
                // 忽略类加载异常
            }
        }
    }

    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
        // 无需额外操作
    }
}

方案二：条件性配置Spring Data Repository #

通过自定义Repository工厂Bean，根据配置决定是否初始化对应存储的Repository，间接实现注解的禁用效果。

以Elasticsearch为例，自定义Repository工厂：

import org.springframework.context.annotation.Configuration;
import org.springframework.data.elasticsearch.repository.config.EnableElasticsearchRepositories;
import org.springframework.data.elasticsearch.repository.support.ElasticsearchRepositoryFactoryBean;
import org.springframework.data.repository.core.RepositoryInformation;
import org.springframework.data.repository.core.RepositoryMetadata;
import org.springframework.data.repository.core.support.RepositoryFactorySupport;
import org.springframework.core.env.Environment;

@Configuration
public class ConditionalStorageConfig {

    @EnableElasticsearchRepositories(
            basePackages = "com.yourpackage.es.repository",
            repositoryFactoryBeanClass = ConditionalEsRepositoryFactoryBean.class
    )
    public static class ElasticsearchConfig {}

    static class ConditionalEsRepositoryFactoryBean extends ElasticsearchRepositoryFactoryBean {
        private final Environment env;

        public ConditionalEsRepositoryFactoryBean(Class<?> repositoryInterface, Environment env) {
            super(repositoryInterface);
            this.env = env;
        }

        @Override
        protected RepositoryFactorySupport createRepositoryFactory() {
            String storageType = env.getProperty("storage.type");
            if ("redis".equals(storageType)) {
                // 返回空工厂，不创建Elasticsearch Repository
                return new RepositoryFactorySupport() {
                    @Override
                    protected Object getTargetRepository(RepositoryInformation info) {
                        return null;
                    }

                    @Override
                    protected Class<?> getRepositoryBaseClass(RepositoryMetadata metadata) {
                        return Object.class;
                    }
                };
            }
            return super.createRepositoryFactory();
        }
    }
}

Redis的Repository配置可以用同样的逻辑处理，当存储类型为Elasticsearch时，跳过Redis Repository的初始化。

方案三：自定义统一注解+动态添加元数据 #

封装一个自定义注解替代@Document和@RedisHash，然后在运行时根据配置动态给类添加对应的Spring数据注解。

1. 定义自定义注解：

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface StorageEntity {
    String esIndex() default "";
    String redisHash() default "";
}

2. 给实体类添加这个注解：

@StorageEntity(esIndex = "index_name", redisHash = "filter_name")
class Index {}

3. 实现BeanPostProcessor动态添加注解：

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;
import org.springframework.core.annotation.AnnotationUtils;
import org.springframework.core.env.Environment;
import org.springframework.data.elasticsearch.annotations.Document;
import org.springframework.data.redis.core.RedisHash;
import org.springframework.stereotype.Component;

@Component
public class StorageAnnotationInjector implements BeanPostProcessor {

    private final Environment env;

    public StorageAnnotationInjector(Environment env) {
        this.env = env;
    }

    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        Class<?> beanClass = bean.getClass();
        if (beanClass.isAnnotationPresent(StorageEntity.class)) {
            StorageEntity entityAnn = beanClass.getAnnotation(StorageEntity.class);
            String storageType = env.getProperty("storage.type", "elasticsearch");

            if ("elasticsearch".equals(storageType)) {
                Document docAnn = Document.indexName(entityAnn.esIndex()).build();
                AnnotationUtils.addAnnotation(beanClass, docAnn);
            } else {
                RedisHash redisAnn = RedisHash.value(entityAnn.redisHash());
                AnnotationUtils.addAnnotation(beanClass, redisAnn);
            }
        }
        return bean;
    }
}

总结 #

• 方案一适合快速改造现有代码，直接干预Bean注册流程；
• 方案二更适合控制Repository的初始化，避免不必要的资源加载；
• 方案三是最优雅的长期方案，统一注解便于后续扩展其他存储类型。

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