Hibernate原生查询结果的数据类型识别与Java类型映射

import javax.persistence.EntityManager;
import javax.persistence.Query;
import java.math.BigDecimal;
import java.util.Date;
import java.util.List;
import java.util.logging.Logger; // 使用java.util.logging替代System.out.println

public class NativeQueryResultTypeIdentifier {

    private static final Logger logger = Logger.getLogger(NativeQueryResultTypeIdentifier.class.getName());

    /**
     * 处理Hibernate原生查询的结果，并识别各列的Java数据类型。
     *
     * @param em       EntityManager实例
     * @param sqlQuery 要执行的原生SQL查询
     */
    public void processNativeQueryResult(EntityManager em, String sqlQuery) {
        Query query = em.createNativeQuery(sqlQuery);
        List<Object[]> results; // 假设查询可能返回多列

        try {
            // 尝试获取结果，如果查询只返回单列，可能需要特殊处理
            // 这里为了简化，假设getResultList()返回List<Object[]>，即使是单列，也包装在Object[]中
            // 实际情况中，如果明确是单列，可以尝试 List<Object> singleColumnResults = query.getResultList();
            // 并根据返回类型进行判断。
            // Hibernate 6+ 可能会对单列查询返回 List<Object>
            // 为了兼容性，我们可以先尝试处理 List<Object[]>
            results = query.getResultList();
        } catch (ClassCastException e) {
            // 如果查询只返回单列，getResultList()可能直接返回 List<Object>
            // 此时需要进行转换或者单独处理
            logger.warning("Query returned List<Object> instead of List<Object[]>. Adapting processing. Error: " + e.getMessage());
            List<Object> singleColumnResults = query.getResultList();
            results = convertSingleColumnListToObjectArray(singleColumnResults);
        }


        logger.info("Processing results from native query: " + sqlQuery);

        if (results == null || results.isEmpty()) {
            logger.info("No results found for the query.");
            return;
        }

        for (Object[] row : results) {
            if (row == null) {
                logger.warning("Encountered a null row in the result set.");
                continue;
            }
            for (int i = 0; i < row.length; i++) {
                Object columnValue = row[i];

                if (columnValue == null) {
                    logger.info("Column " + (i + 1) + ": NULL");
                } else if (columnValue instanceof String) {
                    String value = (String) columnValue;
                    logger.info("Column " + (i + 1) + ": String - \"" + value + "\"");
                    // TODO: 在此处进行字符串相关的业务逻辑操作
                } else if (columnValue instanceof Number) {
                    Number value = (Number) columnValue;
                    logger.info("Column " + (i + 1) + ": Number - " + value + " (Actual type: " + value.getClass().getName() + ")");
                    // 根据具体的数字类型进行进一步处理或统一转换
                    if (value instanceof Long) {
                        Long longVal = (Long) value;
                        // TODO: 处理Long类型数据
                    } else if (value instanceof Integer) {
                        Integer intVal = (Integer) value;
                        // TODO: 处理Integer类型数据
                    } else if (value instanceof Double) {
                        Double doubleVal = (Double) value;
                        // TODO: 处理Double类型数据
                    } else if (value instanceof BigDecimal) {
                        BigDecimal bigDecimalVal = (BigDecimal) value;
                        // TODO: 处理BigDecimal类型数据
                    } else {
                        // 其他数字类型，例如Float, Short, Byte等
                        // 可以统一转换为一个通用数字类型，如longValue()或doubleValue()
                        // long longValue = value.longValue();
                        logger.info("    Converted to long: " + value.longValue());
                    }
                } else if (columnValue instanceof Date) {
                    Date value = (Date) columnValue;
                    logger.info("Column " + (i + 1) + ": Date - " + value + " (Actual type: " + value.getClass().getName() + ")");
                    // TODO: 进行日期相关的业务逻辑操作，注意可能是java.sql.Date, java.sql.Timestamp
                } else if (columnValue instanceof Boolean) {
                    Boolean value = (Boolean) columnValue;
                    logger.info("Column " + (i + 1) + ": Boolean - " + value);
                    // TODO: 处理布尔类型数据
                } else {
                    // 处理其他未明确列出的类型
                    logger.info("Column " + (i + 1) + ": Other type - " + columnValue.getClass().getName() + " - " + columnValue);
                }
            }
            logger.info("--- End of Row ---");
        }
    }

    /**
     * 辅助方法：将单列结果的 List<Object> 转换为 List<Object[]>
     * 以便与多列结果的处理逻辑统一。
     *
     * @param singleColumnList 单列结果列表
     * @return 转换为 List<Object[]> 的列表
     */
    private List<Object[]> convertSingleColumnListToObjectArray(List<Object> singleColumnList) {
        return singleColumnList.stream()
                .map(item -> new Object[]{item})
                .collect(java.util.stream.Collectors.toList());
    }

    // 示例用法 (需要一个配置好的EntityManagerFactory)
    /*
    public static void main(String[] args) {
        EntityManagerFactory emf = Persistence.createEntityManagerFactory("your-persistence-unit");
        EntityManager em = emf.createEntityManager();

        NativeQueryResultTypeIdentifier identifier = new NativeQueryResultTypeIdentifier();

        // 示例1: 查询多列
        String multiColumnSql = "SELECT id, name, age, salary, birth_date, is_active FROM users WHERE age > 25";
        identifier.processNativeQueryResult(em, multiColumnSql);

        // 示例2: 查询单列
        String singleColumnSql = "SELECT name FROM users WHERE id = 1";
        identifier.processNativeQueryResult(em, singleColumnSql);

        // 示例3: 查询一个计算值
        String calculatedValueSql = "SELECT COUNT(*) FROM users";
        identifier.processNativeQueryResult(em, calculatedValueSql);

        em.close();
        emf.close();
    }
    */
}