Java Spring Boot中如何为抽象实体实现通用Repository？

先修正现有代码的错误 #

你的CatRepository中findByTag方法返回Dog是笔误，应该返回Cat：

@Repository
public interface CatRepository extends AnimalRepository<Cat> {
    Cat findByTag(String tag);
}

方案一：利用Spring上下文自动匹配Repository #

通过Spring的ApplicationContext根据实体类型动态获取对应的Repository实例，彻底消除instanceof判断：

@Service
public class AnimalService {

    private final ApplicationContext applicationContext;

    @Autowired
    public AnimalService(ApplicationContext applicationContext) {
        this.applicationContext = applicationContext;
    }

    @SuppressWarnings("unchecked")
    public <T extends Animal> T saveSubclassEntity(T animal) {
        // 根据实体类名生成Repository的Bean名称（Spring默认小写开头+Repository后缀）
        String repoBeanName = Character.toLowerCase(animal.getClass().getSimpleName().charAt(0))
                + animal.getClass().getSimpleName().substring(1) + "Repository";
        
        // 获取对应类型的Repository并执行保存
        AnimalRepository<T> repository = (AnimalRepository<T>) applicationContext.getBean(repoBeanName);
        return repository.save(animal);
    }
}

方案优势：

• 代码极简，不需要额外定义接口或类
• 完全复用现有Repository结构，无侵入性

注意：

如果你的Repository Bean名称不是Spring默认生成的（比如自定义了@Repository("customCatRepo")），需要调整repoBeanName的生成逻辑，或者通过applicationContext.getBean(Class<T>)重载方法获取（需确保每个实体的Repository类型唯一）。

方案二：策略模式+Handler注册表（扩展性更强） #

通过定义实体对应的处理类，将保存逻辑与实体类型绑定，符合开闭原则，未来新增实体时无需修改Service代码：

1. 定义通用处理接口

public interface AnimalHandler<T extends Animal> {
    T save(T animal);
}

2. 为每个实体实现Handler

@Component
public class DogHandler implements AnimalHandler<Dog> {
    private final DogRepository dogRepository;

    @Autowired
    public DogHandler(DogRepository dogRepository) {
        this.dogRepository = dogRepository;
    }

    @Override
    public Dog save(Dog animal) {
        return dogRepository.save(animal);
    }
}

@Component
public class CatHandler implements AnimalHandler<Cat> {
    private final CatRepository catRepository;

    @Autowired
    public CatHandler(CatRepository catRepository) {
        this.catRepository = catRepository;
    }

    @Override
    public Cat save(Cat animal) {
        return catRepository.save(animal);
    }
}

3. 在Service中初始化Handler映射并调用

@Service
public class AnimalService {

    private final Map<Class<? extends Animal>, AnimalHandler<? extends Animal>> handlerMap;

    // Spring自动注入所有AnimalHandler实现类，构建类型与Handler的映射
    @Autowired
    public AnimalService(List<AnimalHandler<? extends Animal>> handlers) {
        this.handlerMap = handlers.stream()
                .collect(Collectors.toMap(this::resolveEntityType, Function.identity()));
    }

    @SuppressWarnings("unchecked")
    public <T extends Animal> T saveSubclassEntity(T animal) {
        AnimalHandler<T> handler = (AnimalHandler<T>) handlerMap.get(animal.getClass());
        if (handler == null) {
            throw new IllegalArgumentException("未找到对应实体类型的处理器：" + animal.getClass().getName());
        }
        return handler.save(animal);
    }

    // 通过反射解析Handler的泛型实体类型
    private Class<? extends Animal> resolveEntityType(AnimalHandler<? extends Animal> handler) {
        Type genericInterface = handler.getClass().getGenericInterfaces()[0];
        if (genericInterface instanceof ParameterizedType) {
            return (Class<? extends Animal>) ((ParameterizedType) genericInterface).getActualTypeArguments()[0];
        }
        throw new IllegalArgumentException("处理器泛型定义错误：" + handler.getClass().getName());
    }
}

方案优势：

• 完全符合开闭原则，新增实体时只需新增对应的Handler类，无需修改现有代码
• 逻辑解耦，每个实体的保存逻辑可以独立扩展（比如未来需要为Cat添加特殊保存逻辑时，直接修改CatHandler即可）
• 错误处理更清晰，能快速定位未配置Handler的实体类型

关于跨数据库迁移的适配 #

未来将Cat迁移至数据库B时，只需修改CatRepository的数据源配置（比如通过@Qualifier指定对应数据库的EntityManagerFactory），上述两种方案的Service层代码完全不需要修改，完美满足无缝迁移的需求。

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