Jfinal 联合查询返回数据库以外结构字段并返回json

在使用jfinal的过程中遇到了一个奇怪的问题，就是列表查询的时候，联合查询，一对多的表结构，比如订单和订单明细表，这种一个model里含有另外一个model类型的List的结构官方有解决方案，现在要说的是左链接查询明细表，是明细表中包含订单的某几个字段，这几个字段不是详情表的字段结构，但是是订单表的。

一开始的解决方案是在明细表中添加了几个字段，并给其get，set方法，但是这样弄以后，
new BuyOrderDetail().dao().paginate 通过此分页方法查询后，我自己填写的那几个字段无法赋值，因为是list列表查询，我感觉官方提供的那个getStr方法循环去赋值太麻烦了，要是所有联合查询，都这么弄不要累死人。

然后通过搜索解决方案，最后发现可以用Jfinal的Record类来操作，默认你select 查询的是那些字段，他都会给你返回，挺好，但是因为我程序是都是返回json的接口数据，数据库字段命名又都是下划线方式命名的，使用Record 竟然原方不动给我返回了，我还要转成驼峰命名，最后在网上找了一个别人写的工具类，附在下方，以防忘记：

使用方法
List类型数据的json驼峰命名转换：ControllerUtils.modelToCamelCaseMap方法即可
Page类型数据的json驼峰命名转换：用ControllerUtils. recordsToCamelCaseMaps方法即可

我的使用方法：
Page<Map<String, Object>> mapPage = ControllerUtils.recordsToCamelCaseMaps(paginate);
result.addSuccessData(“分页查询列表成功！”,paginate,mapPage.getList());
工具类：`

package com.rfid.assets.utils;

import com.jfinal.core.Controller;
import com.jfinal.kit.JsonKit;
import com.jfinal.kit.Ret;
import com.jfinal.kit.StrKit;
import com.jfinal.plugin.activerecord.Db;
import com.jfinal.plugin.activerecord.Model;
import com.jfinal.plugin.activerecord.Page;
import com.jfinal.plugin.activerecord.Record;

import org.apache.commons.lang3.StringUtils;
import java.util.List;
import java.util.ArrayList;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.Map;

/**
 * 
 */
public class ControllerUtils {

    /**
     * 乐观锁验证
     *
     * @param controller
     * @param tableName 数据库表名
     * @return
     */
    public static String validateIdAndVersion(Controller controller, String tableName) {
        String id = controller.getPara("id");
        if (StrKit.isBlank(id)) {
            id = controller.getPara("id_");
        }
        if (StrKit.isBlank(id))
            return null;
        String version = controller.getPara("version");
        if (StrKit.isBlank(version)) {
            version = controller.getPara("rev");
        }
        if (null == version)
            return null;
        if (!StringUtils.isNumeric(version)) {
            return "version参数只能是数字！";
        }
        Record record = Db.findById(tableName, id);
        if (null == record) {
            return "根据id查询不到数据！";
        }
        if (null == record.get("VERSION"))
            return null;
        if (record.get("VERSION") != Integer.valueOf(version)) {
            return "表单数据版本号和数据库数据版本号不一致，可能数据已经被其他人修改，请重新编辑！";
        }
        return null;
    }

    /**
     * 把model转为map，驼峰命名
     *
     * @param model
     * @return
     */
    public static Map<String, Object> modelToCamelCaseMap(Model model) {
        if (null == model) {
            return null;
        }
        String[] keys = model._getAttrNames();
        Map<String, Object> map = new HashMap<>();
        for (String key : keys) {
            Object value = model.get(key);
            key = StrKit.toCamelCase(key.toLowerCase());
//避免输出null的json，过滤掉空值
            if(null != value){
                map.put(key, value);
            }

        }
        return map;
    }

    /**
     * Record转为Map，驼峰命名
     *
     * @param record
     * @return
     */
    public static Map<String, Object> recordToCamelCaseMap(Record record) {
        if (null == record) {
            return null;
        }
        String[] keys = record.getColumnNames();
        Map<String, Object> map = new HashMap<>();
        for (String key : keys) {
            Object value = record.get(key);
            key = StrKit.toCamelCase(key.toLowerCase());
//避免输出null的json，过滤掉空值
            if(null != value){
                map.put(key, value);
            }
        }
        return map;
    }

    /**
     * List<Record>转为List<Map<String, Object>>，驼峰命名
     *
     * @param records
     * @return
     */
    public static List<Map<String, Object>> recordsToCamelCaseMaps(List<Record> records) {
        List<Map<String, Object>> maps = new ArrayList<>();
        for (Record record : records) {
            maps.add(recordToCamelCaseMap(record));
        }
        return maps;
    }

    /**
     * List<? extends Model>转为List<Map<String, Object>>，驼峰命名
     *
     * @param models
     * @return
     */
    public static List<Map<String, Object>> modelsToCamelCaseMaps(List<? extends Model> models) {
        List<Map<String, Object>> maps = new ArrayList<>();
        for (Model model : models) {
            maps.add(modelToCamelCaseMap(model));
        }
        return maps;
    }

    /**
     * Page<Record>转为Page<Map<String, Object>>，驼峰命名
     *
     * @param records
     * @return
     */
    public static Page<Map<String, Object>> recordsToCamelCaseMaps(Page<Record> records) {
        List<Record> recordList = records.getList();
        List<Map<String, Object>> maps = new ArrayList<>();
        for (Record record : recordList) {
            maps.add(recordToCamelCaseMap(record));
        }
        return new Page<Map<String, Object>>(maps, records.getPageNumber(), records.getPageSize(),
                records.getTotalPage(), records.getTotalRow());
    }

    /**
     * Page<Page<? extends Model>转为Page<Map<String, Object>>，驼峰命名
     *
     * @param models
     * @return
     */
    public static Page<Map<String, Object>> modelsToCamelCaseMaps(Page<? extends Model> models) {
        List<? extends Model> modelList = models.getList();
        List<Map<String, Object>> maps = new ArrayList<>();
        for (Model model : modelList) {
            maps.add(modelToCamelCaseMap(model));
        }
        return new Page<Map<String, Object>>(maps, models.getPageNumber(), models.getPageSize(), models.getTotalPage(),
                models.getTotalRow());
    }

}

`