Spring Boot中如何将配置文件值传入@Scope与@Collection注解？

针对你遇到的@Scope和@Collection注解无法解析Spring占位符（${...}）的问题，以下是适配Spring Boot 2.7.3 + spring-data-couchbase 2.7.3的可行方案：

方案1：全局默认Scope/Collection配置（推荐，适合统一配置场景） #

如果所有Repository都使用相同的Scope和Collection，可直接在application.properties配置全局默认值，无需在Repository接口上添加@Scope/@Collection注解：

# 全局默认Scope
spring.data.couchbase.scope=_default
# 全局默认Collection
spring.data.couchbase.collection=_default

配置生效后，所有继承CouchbaseRepository的接口会自动使用该全局配置，替代默认的_default值。

方案2：自定义BeanPostProcessor动态解析注解占位符（适合多Repository不同配置场景） #

若需为不同Repository配置不同的Scope/Collection，且要从配置文件读取，可通过BeanPostProcessor动态修改Repository接口上的注解属性：

1. 编写自定义BeanPostProcessor类：

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;
import org.springframework.context.EnvironmentAware;
import org.springframework.core.env.Environment;
import org.springframework.data.couchbase.repository.Collection;
import org.springframework.data.couchbase.repository.Scope;
import org.springframework.stereotype.Component;
import org.springframework.util.StringValueResolver;

import java.lang.annotation.Annotation;
import java.lang.reflect.Field;

@Component
public class CouchbaseAnnotationPlaceholderResolver implements BeanPostProcessor, EnvironmentAware {

    private StringValueResolver valueResolver;

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

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        Class<?> repositoryInterface = findRepositoryInterface(bean.getClass());
        if (repositoryInterface != null) {
            resolveAnnotationPlaceholder(repositoryInterface, Scope.class);
            resolveAnnotationPlaceholder(repositoryInterface, Collection.class);
        }
        return bean;
    }

    private Class<?> findRepositoryInterface(Class<?> beanClass) {
        for (Class<?> iface : beanClass.getInterfaces()) {
            if (iface.getName().endsWith("Repository") && iface.isAnnotationPresent(org.springframework.stereotype.Repository.class)) {
                return iface;
            }
        }
        return null;
    }

    private <A extends Annotation> void resolveAnnotationPlaceholder(Class<?> targetClass, Class<A> annotationType) {
        A annotation = targetClass.getAnnotation(annotationType);
        if (annotation != null) {
            try {
                Field valueField = annotationType.getDeclaredField("value");
                valueField.setAccessible(true);
                String originalValue = (String) valueField.get(annotation);
                String resolvedValue = valueResolver.resolveStringValue(originalValue);
                valueField.set(annotation, resolvedValue);
            } catch (NoSuchFieldException | IllegalAccessException e) {
                throw new RuntimeException("Failed to resolve placeholder in Couchbase annotation", e);
            }
        }
    }
}

2. 保持Repository上的注解写法不变：

@Repository
@Scope("${couchbase.scope}")
@Collection("${couchbase.collection}")
public interface MyDocumentRepository extends CouchbaseRepository<MyDocument, String> {
}

3. application.properties配置维持原样：

couchbase.scope=_default
couchbase.collection=_default

该处理器会在Spring初始化Repository Bean后，自动解析注解中的占位符并替换为配置文件的实际值。

方案3：自定义RepositoryFactoryBean（进阶定制场景） #

若需深度定制Repository创建逻辑，可自定义CouchbaseRepositoryFactoryBean动态指定Scope和Collection：

1. 编写自定义FactoryBean类：

import org.springframework.data.couchbase.core.CouchbaseOperations;
import org.springframework.data.couchbase.repository.CouchbaseEntityInformation;
import org.springframework.data.couchbase.repository.support.CouchbaseRepositoryFactory;
import org.springframework.data.couchbase.repository.support.CouchbaseRepositoryFactoryBean;
import org.springframework.data.repository.core.RepositoryFactorySupport;

import java.io.Serializable;

public class CustomCouchbaseRepositoryFactoryBean<T extends org.springframework.data.repository.Repository<S, ID>, S, ID extends Serializable>
        extends CouchbaseRepositoryFactoryBean<T, S, ID> {

    private String scopeName;
    private String collectionName;

    public void setScopeName(String scopeName) {
        this.scopeName = scopeName;
    }

    public void setCollectionName(String collectionName) {
        this.collectionName = collectionName;
    }

    @Override
    protected RepositoryFactorySupport createRepositoryFactory() {
        return new CustomCouchbaseRepositoryFactory(getCouchbaseOperations(), scopeName, collectionName);
    }

    private static class CustomCouchbaseRepositoryFactory extends CouchbaseRepositoryFactory {

        private final String scopeName;
        private final String collectionName;

        public CustomCouchbaseRepositoryFactory(CouchbaseOperations operations, String scopeName, String collectionName) {
            super(operations);
            this.scopeName = scopeName;
            this.collectionName = collectionName;
        }

        @Override
        protected CouchbaseEntityInformation<?, Serializable> getEntityInformation(Class<?> domainClass) {
            CouchbaseEntityInformation<?, Serializable> entityInfo = super.getEntityInformation(domainClass);
            return new CouchbaseEntityInformation<>(entityInfo.getDomainType(), entityInfo.getIdAttribute()) {
                @Override
                public String getScope() {
                    return scopeName != null ? scopeName : super.getScope();
                }

                @Override
                public String getCollection() {
                    return collectionName != null ? collectionName : super.getCollection();
                }
            };
        }
    }
}

2. 在Repository接口上指定自定义FactoryBean：

@Repository
@RepositoryFactoryBean(CustomCouchbaseRepositoryFactoryBean.class)
public interface MyDocumentRepository extends CouchbaseRepository<MyDocument, String> {
}

3. 在配置类中注入FactoryBean参数：

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.env.Environment;
import org.springframework.data.couchbase.core.CouchbaseOperations;

@Configuration
public class CouchbaseConfig {

    @Bean
    public CustomCouchbaseRepositoryFactoryBean<?, ?, ?> customCouchbaseRepositoryFactoryBean(CouchbaseOperations couchbaseOperations,
                                                                                               Environment environment) {
        CustomCouchbaseRepositoryFactoryBean<?, ?, ?> factoryBean = new CustomCouchbaseRepositoryFactoryBean<>();
        factoryBean.setCouchbaseOperations(couchbaseOperations);
        factoryBean.setScopeName(environment.getProperty("couchbase.scope"));
        factoryBean.setCollectionName(environment.getProperty("couchbase.collection"));
        return factoryBean;
    }
}

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