Java Spring中如何自动生成RepositoryHelper接口的运行时实现？

针对你提出的重复Repository调用逻辑复用需求，以下是几种可行的实现方案，涵盖你提到的代理、AOP以及更简洁的泛型复用方式：

一、泛型基础服务类（最简洁方案） #

无需依赖代理或AOP，直接通过Java泛型封装通用逻辑，是最易维护的方案：

1. 定义泛型基类 #

public abstract class BaseEntityService<T, ID> {
    protected final MongoRepository<T, ID> repository;

    // 构造函数注入Repository
    protected BaseEntityService(MongoRepository<T, ID> repository) {
        this.repository = repository;
    }

    // 通用的retrieveById逻辑
    public T retrieveById(ID id) {
        return repository.findById(id).orElseThrow();
    }
}

2. 业务服务类继承基类 #

@Service
public class CatService extends BaseEntityService<Cat, String> {
    // 直接继承基类的构造函数，注入CatRepository
    public CatService(CatRepository catRepository) {
        super(catRepository);
    }

    // 可添加Cat专属业务方法
}

@Service
public class DogService extends BaseEntityService<Dog, String> {
    public DogService(DogRepository dogRepository) {
        super(dogRepository);
    }
}

此方案完全利用Spring的依赖注入机制，代码简洁且易于扩展，适合绝大多数场景。

二、动态代理实现Helper接口 #

如果坚持要使用RepositoryHelper接口的形式，可以通过动态代理生成实现类：

1. 通用InvocationHandler #

public class RepositoryHandler<T, ID> implements InvocationHandler {
    private final MongoRepository<T, ID> repository;

    public RepositoryHandler(MongoRepository<T, ID> repository) {
        this.repository = repository;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        // 仅处理retrieveById方法
        if ("retrieveById".equals(method.getName()) && args.length == 1) {
            ID id = (ID) args[0];
            return repository.findById(id).orElseThrow();
        }
        throw new UnsupportedOperationException("不支持的方法：" + method.getName());
    }
}

2. 代理工厂类 #

@Component
public class HelperProxyFactory {
    @Autowired
    private ApplicationContext context;

    @SuppressWarnings("unchecked")
    public <H> H createHelper(Class<H> helperInterface, Class<? extends MongoRepository<?, ?>> repoClass) {
        MongoRepository<?, String> repository = context.getBean(repoClass);
        return (H) Proxy.newProxyInstance(
                helperInterface.getClassLoader(),
                new Class[]{helperInterface},
                new RepositoryHandler<>(repository)
        );
    }
}

3. 使用示例 #

@Service
public class BusinessService {
    private final CatRepositoryHelper catHelper;

    public BusinessService(HelperProxyFactory factory) {
        this.catHelper = factory.createHelper(CatRepositoryHelper.class, CatRepository.class);
    }

    public void processCat(String catId) {
        Cat cat = catHelper.retrieveById(catId);
        // 业务逻辑处理
    }
}

三、AOP切面实现 #

通过AOP拦截Helper接口的方法调用，统一实现通用逻辑：

1. 自定义注解标记Helper接口 #

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface BindRepository {
    Class<? extends MongoRepository<?, ?>> value();
}

2. 定义AOP切面 #

@Aspect
@Component
public class RepositoryHelperAspect {
    @Autowired
    private ApplicationContext context;

    // 拦截所有标记@BindRepository的接口的retrieveById方法
    @Around("execution(* *.retrieveById(String)) && @target(com.yourpackage.BindRepository)")
    public Object handleRetrieveById(ProceedingJoinPoint joinPoint) throws Throwable {
        // 获取Helper接口上的注解，拿到对应的Repository类
        Class<?> helperInterface = joinPoint.getTarget().getClass().getInterfaces()[0];
        BindRepository bindAnno = helperInterface.getAnnotation(BindRepository.class);
        MongoRepository<?, String> repository = context.getBean(bindAnno.value());
        
        String id = (String) joinPoint.getArgs()[0];
        return repository.findById(id).orElseThrow();
    }
}

3. 配置Helper接口并使用 #

@BindRepository(CatRepository.class)
public interface CatRepositoryHelper {
    Cat retrieveById(String id);
}

// 在业务类中直接注入Helper接口
@Service
public class BusinessService {
    private final CatRepositoryHelper catHelper;

    public BusinessService(CatRepositoryHelper catHelper) {
        this.catHelper = catHelper;
    }
}

4. 开启AOP支持 #

在Spring配置类中添加：

@Configuration
@EnableAspectJAutoProxy
public class AopConfiguration {
}

方案对比 #

内容的提问来源于stack exchange，提问作者Robert Vanden Eynde