如何通过Spring注解实现Composite设计模式？求最优实现方案

你这个思路完全没问题，自定义配置类确实是Spring注解实现Composite设计模式的常用且靠谱的方案，而且还有几种更简洁的方式可以选，我来给你拆解下：

1. 自定义配置类手动组装（你最初想到的方向，完全可行） #

如果需要对组件的组装逻辑有完全的控制权（比如动态决定哪些组件加入、调整顺序），自定义配置类是最优解。你可以在配置类中逐个注册CourseRepository实例，然后手动注入到CompositeRepository中：

@Configuration
public class RepositoryConfig {

    @Bean("primaryRepo")
    public CourseRepository primaryCourseRepository() {
        return new PrimaryCourseRepository();
    }

    @Bean("fallbackRepo")
    public CourseRepository fallbackCourseRepository() {
        return new FallbackCourseRepository();
    }

    @Bean("courseRepository")
    public CompositeRepository compositeRepository() {
        CompositeRepository composite = new CompositeRepository();
        // 手动控制组件顺序，优先调用primary，失败则fallback
        composite.setRepos(Arrays.asList(primaryCourseRepository(), fallbackCourseRepository()));
        return composite;
    }
}

这种方式的好处是逻辑清晰，你可以在配置类中加入任意判断逻辑（比如根据环境变量选择不同的fallback组件），非常灵活。

2. 利用Spring自动注入集合+@Order控制顺序（更简洁的方案） #

Spring有个很实用的特性：当你注入List<X>类型的依赖时，它会自动收集所有类型为X的Bean并注入。结合@Order注解，你可以轻松控制组件的调用顺序，完全不需要手动配置类：

首先修改你的CompositeRepository，用构造注入接收所有CourseRepository实例，同时排序：

@Slf4j
@Repository("courseRepository")
public class CompositeRepository implements CourseRepository {
    private final List<CourseRepository> repos;

    // Spring自动注入所有CourseRepository类型的Bean
    public CompositeRepository(List<CourseRepository> repos) {
        // 按@Order注解的值排序，值越小优先级越高
        this.repos = repos.stream()
                          .sorted(Comparator.comparingInt(bean -> {
                              Order order = bean.getClass().getAnnotation(Order.class);
                              return order != null ? order.value() : Integer.MAX_VALUE;
                          }))
                          .collect(Collectors.toList());
    }

    @Override
    public Page<Subject> findSubjects(AcademicCareer career, Pageable pageable) {
        for (CourseRepository r : repos) {
            try {
                return r.findSubjects(career, pageable);
            } catch (Exception e) {
                log.info("Unable to invoke findSubjects on {}", r, e);
            }
        }
        throw new IllegalStateException("Unable to complete findSubjects");
    }
}

然后给你的具体实现类加上@Order注解，指定调用顺序：

@Repository
@Order(1) // 优先级最高，第一个被调用
public class PrimaryCourseRepository implements CourseRepository {
    // ...你的业务实现
}

@Repository
@Order(2) // 降级用，primary失败后调用
public class FallbackCourseRepository implements CourseRepository {
    // ...你的业务实现
}

这种方式最简洁，不需要额外的配置类，适合大多数常规场景。

3. 用@Qualifier精准筛选组件（适合只需要特定组件的场景） #

如果你的Composite不需要包含所有CourseRepository，只需要特定的几个，可以用@Qualifier注解配合构造注入，精准选择需要的组件：

@Slf4j
@Repository("courseRepository")
public class CompositeRepository implements CourseRepository {
    private final List<CourseRepository> repos;

    public CompositeRepository(
        @Qualifier("primaryRepo") CourseRepository primaryRepo,
        @Qualifier("fallbackRepo") CourseRepository fallbackRepo
    ) {
        this.repos = Arrays.asList(primaryRepo, fallbackRepo);
    }

    // ...findSubjects方法不变
}

对应的具体实现类需要加上@Qualifier或者用@Bean指定名称：

@Repository("primaryRepo")
public class PrimaryCourseRepository implements CourseRepository {
    // ...实现
}

@Repository("fallbackRepo")
public class FallbackCourseRepository implements CourseRepository {
    // ...实现
}

这种方式适合组件数量不多、需要明确指定的场景。

总结 #

你最初想到的自定义配置类是完全正确的方向，尤其是当你需要复杂组装逻辑时。但如果是常规的降级场景，Spring的自动注入集合+@Order会更高效简洁。可以根据你的实际业务需求选择最合适的方案。

内容的提问来源于stack exchange，提问作者Nick G.