如何使用Spring Boot+JPA合并两个结构相似的表并补全空值

针对两个同结构表、AA表空值用同ID的BB表非空字段补全的需求，以下两种方案均可避免逐个手写字段判断，提升可维护性：

方案1：动态生成查询SQL（推荐，兼顾性能与可维护性） #

核心逻辑为反射读取公共字段列表，自动拼接COALESCE查询语句，性能和手动写SQL完全一致，适配字段新增场景。

实现步骤： #

1. 抽取公共字段父类，避免AA、BB实体重复定义字段

// 公共字段父类
@MappedSuperclass
public class BaseEntity {
    @Id
    private Long id;
    private String name;
    private Integer active;
    // 所有公共字段统一在此定义，后续新增字段只需要加在这里即可
    // 省略getter、setter
}

// AA表实体
@Entity
@Table(name = "AA")
public class Aa extends BaseEntity {}

// BB表实体
@Entity
@Table(name = "BB")
public class Bb extends BaseEntity {}

2. 自定义Repository实现动态SQL拼接

// 自定义查询接口
public interface CustomAaRepository {
    List<BaseEntity> findMergedAaList();
}

// 自定义接口实现类
public class CustomAaRepositoryImpl implements CustomAaRepository {
    @PersistenceContext
    private EntityManager entityManager;

    @Override
    public List<BaseEntity> findMergedAaList() {
        // 反射获取所有公共字段，过滤静态、瞬态字段
        List<String> columns = Arrays.stream(BaseEntity.class.getDeclaredFields())
                .filter(field -> !Modifier.isStatic(field.getModifiers())
                        && !Modifier.isTransient(field.getModifiers())
                        && !field.isAnnotationPresent(Transient.class))
                .map(Field::getName)
                // 驼峰转下划线，可根据自己的数据库命名策略调整
                .map(this::camelToUnderline)
                .toList();

        // 自动拼接COALESCE查询字段
        String selectPart = columns.stream()
                .map(col -> String.format("COALESCE(a.%s, b.%s) as %s", col, col, col))
                .collect(Collectors.joining(", "));

        String sql = String.format("SELECT %s FROM AA a LEFT JOIN BB b ON a.id = b.id", selectPart);

        // 执行查询并映射到实体
        Query query = entityManager.createNativeQuery(sql, BaseEntity.class);
        return query.getResultList();
    }

    // 驼峰转下划线工具方法
    private String camelToUnderline(String str) {
        return str.replaceAll("([A-Z])", "_$1").toLowerCase();
    }
}

3. 让你的AaRepository继承自定义接口即可直接调用方法：

public interface AaRepository extends JpaRepository<Aa, Long>, CustomAaRepository {
}

方案2：内存合并（实现最简单，适合小数据量场景） #

核心逻辑为先批量查询AA、BB表数据，在内存中通过反射合并字段，完全不需要写SQL，适合单表数据量小于1万的场景。

实现步骤： #

1. 同上先定义公共父类和AA、BB实体，以及对应的Repository
2. 业务层实现字段合并逻辑

@Service
public class AaService {
    @Autowired
    private AaRepository aaRepository;
    @Autowired
    private BbRepository bbRepository;

    public List<BaseEntity> getMergedAaList() throws IllegalAccessException {
        List<Aa> aaList = aaRepository.findAll();
        // 批量查询AA关联的BB数据
        List<Long> aaIds = aaList.stream().map(BaseEntity::getId).toList();
        Map<Long, Bb> bbIdMap = bbRepository.findAllById(aaIds).stream()
                .collect(Collectors.toMap(BaseEntity::getId, Function.identity()));

        List<BaseEntity> result = new ArrayList<>();
        for (Aa aa : aaList) {
            Bb matchedBb = bbIdMap.get(aa.getId());
            if (matchedBb == null) {
                result.add(aa);
                continue;
            }
            // 空字段合并
            result.add(mergeNullField(aa, matchedBb));
        }
        return result;
    }

    // 合并逻辑：AA的空字段用BB的非空字段补全
    private BaseEntity mergeNullField(Aa aa, Bb bb) throws IllegalAccessException {
        Field[] fields = BaseEntity.class.getDeclaredFields();
        for (Field field : fields) {
            field.setAccessible(true);
            if (field.get(aa) == null && field.get(bb) != null) {
                field.set(aa, field.get(bb));
            }
        }
        return aa;
    }
}

扩展说明 #

如果存在不需要补全的特殊字段，在反射读取字段时增加过滤规则即可，不需要修改核心逻辑。

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