高考报名时间2022年11月1日还剩 天 距离2023年6月7日高考还有 天
栏目分类:
子分类:
返回
名师互学网用户登录
名师互学网
快速导航关闭
当前搜索
当前分类
前沿技术 软件开发 系统运维 产品运营 生活办公 面试经验 考试题库
子分类
人工智能 大数据 云计算 区块链 物联网 深度学习 机器学习 NLP 计算机视觉 语音识别 其他 大数据系统 数据可视化 数据挖掘与分析 其他 Docker/k8s 虚拟化 云平台 其他 基本原理 数字货币 智能合约 EOS应用 其他 通讯技术 嵌入式开发 单片机 物联网应用 HarmonyOS 其他 后端开发 Web开发 移动开发 游戏开发 Python Java 架构设计 C/C++/C# PHP .Net Go语言 R语言
实用工具
学习工具 小学数学练习 字帖生成 在线画板 函数绘制 拼音字母表 在线词典 黄历查询 亲戚关系计算 安全期计算 中国历史 Excel函数 模拟请求 json格式化 浏览器指纹
热门搜索
路由器设置 木托盘 宝塔面板 儿童python教程 心情低落 朋友圈 vim 双一流学科 专升本 我的学校 日记学校 西点培训学校 汽修学校 情书 化妆学校 塔沟武校 异形模板 西南大学排名 最精辟人生短句 6步教你追回被骗的钱 南昌大学排名 清朝十二帝 北京印刷学院排名 北方工业大学排名 北京航空航天大学排名 首都经济贸易大学排名 中国传媒大学排名 首都师范大学排名 中国地质大学(北京)排名 北京信息科技大学排名
名师互学网 > IT > 软件开发 > 后端开发 > Java

java SDK对接金蝶数据包装类（仅查询）

Java 更新时间： 发布时间： IT归档 最新发布 模块sitemap 名妆网 法律咨询 聚返吧 英语巴士网 伯小乐 网商动力

java SDK对接金蝶数据包装类（仅查询）

java SDK对接金蝶

SDK下载地址

  1. 如果是Maven管理，可以在pom.xml中加入如下依赖：

    

    com.kingdee
    k3cloud-webapi
    1.0.0
    system
    
    ${project.basedir}/lib/k3cloud-webapi-sdk7.9.2.jar

  2. 起步配置有官方教程：查看官方指南

  3. 官网只提供了一些查询数据方法。对于java代码来说写起来很不舒服。下面我做了一些工具类。
    3.1 序列化SFunction

    @FunctionalInterface
public interface SFunction extends Function, Serializable {
}

    3.2 序列化解析类

    public final class SFunctionParse {
    
    public static final  String[] resolves(SFunction... functions) {
        String[] fileNames = new String[functions.length];
        String fileName;
        try {
            for (int i = 0; i < functions.length; i++) {
                SFunction function = functions[i];
                // 直接调用writeReplace
                Method methods = function.getClass().getDeclaredMethod("writeReplace");
                methods.setAccessible(true);
                //反射调用
                Object sl = methods.invoke(function);
                SerializedLambda serializedLambda = (SerializedLambda) sl;
                String methodName = serializedLambda.getImplMethodName();
                String name = methodName.replace("get", "");
                fileName = name.substring(0, 1).toLowerCase() + name.substring(1);
                // 将_替换为.改成查询字段
                fileName = fileName.replace("_", ".");
                fileNames[i] = fileName;
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return fileNames;
    }

    
    public static final  String resolve(SFunction function) {
        return resolves(function)[0];
    }
}

    3.3 @FomId注解类

    @Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface FormId {
    String value() default "";
}

    3.4 抽象构建类

    	public abstract class AbstractBuilder {
	    
	
	    protected List fieldKeys = new ArrayList<>();
	    
	    protected StringBuilder filterStrBuilder = new StringBuilder();
	    
	    protected StringBuilder orderBuilder = new StringBuilder();
	    
	    protected int TopRowCount = 0;
	    
	    protected int StartRow = 0;
	    
	    protected int Limit = 0;
	
	    protected final String LOGIC_AND = " AND ";
	
	    protected final String LOGIC_OR = " OR ";
	
	    
	    public abstract List getFieldKeys();
	
	
	    
	    public abstract String buildFieldKeys();
	
	    
	    public abstract String buildFilter();
	
	    
	    public abstract String buildOrder();
	
	    
	    public abstract int buildTopRowCount();
	
	    
	    public abstract int buildStartRow();
	
	    
	    public abstract int buildLimit();
	}

    3.5 条件过滤构建器FilterRuleBuilder，类比mybatis

    public class FilterRuleBuilder extends AbstractBuilder{

    public FilterRuleBuilder() {
    }


    
    protected String logic = LOGIC_AND;

    
    public List getFieldKeys() {
        return this.fieldKeys;
    }

    
    public FilterRuleBuilder and() {
        this.logic = LOGIC_AND;
        return this;
    }

    
    public FilterRuleBuilder select(List fieldKeys) {
        this.fieldKeys = fieldKeys;
        return this;
    }

    
    public FilterRuleBuilder selectAllFiled(Class cls) {
        Field[] fields = cls.getDeclaredFields();
        for (Field field : fields) {
            String fieldName = field.getName().replace("_", ".");
            select(fieldName);
        }
        return this;
    }

    
    public FilterRuleBuilder select(String fieldKey) {
        fieldKeys.add(fieldKey);
        return this;
    }

    
    public FilterRuleBuilder select(String... fieldKeys) {
        for (String fieldKey : fieldKeys) {
            select(fieldKey);
        }
        return this;
    }


    
    public FilterRuleBuilder orderBy(boolean isDesc, String... fieldNames) {
        // 不为空加逻辑关系
        if (orderBuilder.length() != 0) {
            orderBuilder.append(",");
        }
        for (String fieldName : fieldNames) {
            if (isDesc) {
                orderBuilder.append(String.format("%s DESC,", fieldName));
            } else {
                orderBuilder.append(String.format("%s ASC,", fieldName));
            }

        }
        // 删除最后一个字符
        orderBuilder.deleteCharAt(orderBuilder.length() - 1);

        return this;
    }

    
    public FilterRuleBuilder orderByAsc(String fieldName) {
        // 不为空加逻辑关系
        if (orderBuilder.length() != 0) {
            orderBuilder.append(",");
        }
        orderBuilder.append(String.format("%s ASC", fieldName));
        return this;
    }

    
    public FilterRuleBuilder orderByDesc(String fieldName) {
        // 不为空加逻辑关系
        if (orderBuilder.length() != 0) {
            orderBuilder.append(",");
        }
        orderBuilder.append(String.format("%s DESC", fieldName));
        return this;
    }

    
    public FilterRuleBuilder or() {
        logic = LOGIC_OR;
        return this;
    }

    
    public FilterRuleBuilder eq(String fieldName, Object value) {
        // 不为空加逻辑关系
        if (filterStrBuilder.length() != 0) {
            filterStrBuilder.append(logic);
        }
        // 字母或数字要加引号
        if (value instanceof String || value instanceof Date) {
            filterStrBuilder.append(String.format("(%s = '%s')", fieldName, value));
        } else {
            filterStrBuilder.append(String.format("(%s = %s)", fieldName, value));
        }
        return this;
    }

    
    public FilterRuleBuilder ne(String fieldName, Object value) {
        // 不为空加逻辑关系
        if (filterStrBuilder.length() != 0) {
            filterStrBuilder.append(logic);
        }
        // 字母或数字要加引号
        if (value instanceof String || value instanceof Date) {
            filterStrBuilder.append(String.format("(%s <> '%s')", fieldName, value));
        } else {
            filterStrBuilder.append(String.format("(%s <> %s)", fieldName, value));
        }
        return this;
    }

    
    public FilterRuleBuilder lt(String fieldName, Object value) {
        // 不为空加逻辑关系
        if (filterStrBuilder.length() != 0) {
            filterStrBuilder.append(logic);
        }
        // 字母或数字要加引号
        if (value instanceof String || value instanceof Date) {
            filterStrBuilder.append(String.format("(%s < '%s')", fieldName, value));
        } else {
            filterStrBuilder.append(String.format("(%s < %s)", fieldName, value));
        }
        return this;
    }

    
    public FilterRuleBuilder gt(String fieldName, Object value) {
        // 不为空加逻辑关系
        if (filterStrBuilder.length() != 0) {
            filterStrBuilder.append(logic);
        }
        // 字母或数字要加引号
        if (value instanceof String || value instanceof Date) {
            filterStrBuilder.append(String.format("(%s > '%s')", fieldName, value));
        } else {
            filterStrBuilder.append(String.format("(%s > %s)", fieldName, value));
        }
        return this;
    }

    
    public FilterRuleBuilder le(String fieldName, Object value) {
        // 不为空加逻辑关系
        if (filterStrBuilder.length() != 0) {
            filterStrBuilder.append(logic);
        }
        // 字母或数字要加引号
        if (value instanceof String || value instanceof Date) {
            filterStrBuilder.append(String.format("(%s <= '%s')", fieldName, value));
        } else {
            filterStrBuilder.append(String.format("(%s <= %s)", fieldName, value));
        }
        return this;
    }

    
    public FilterRuleBuilder ge(String fieldName, Object value) {
        // 不为空加逻辑关系
        if (filterStrBuilder.length() != 0) {
            filterStrBuilder.append(logic);
        }
        // 字母或数字要加引号
        if (value instanceof String || value instanceof Date) {
            filterStrBuilder.append(String.format("(%s >= '%s')", fieldName, value));
        } else {
            filterStrBuilder.append(String.format("(%s >= %s)", fieldName, value));
        }
        return this;
    }

    
    public FilterRuleBuilder like(String fieldName, Object value) {
        // 不为空加逻辑关系
        if (filterStrBuilder.length() != 0) {
            filterStrBuilder.append(logic);
        }
        // 字母或数字要加引号
        if (value instanceof String || value instanceof Date) {
            filterStrBuilder.append("(" + fieldName + " LIKE '%" + value + "%')");
        }
        return this;
    }

    
    public FilterRuleBuilder notLike(String fieldName, Object value) {
        // 不为空加逻辑关系
        if (filterStrBuilder.length() != 0) {
            filterStrBuilder.append(logic);
        }
        // 字母或数字要加引号
        if (value instanceof String || value instanceof Date) {
            filterStrBuilder.append("(" + fieldName + " NOT LIKE '%" + value + "%')");
        }
        return this;
    }

    
    public FilterRuleBuilder likeLeft(String fieldName, Object value) {
        // 不为空加逻辑关系
        if (filterStrBuilder.length() != 0) {
            filterStrBuilder.append(logic);
        }
        // 字母或数字要加引号
        if (value instanceof String || value instanceof Date) {
            filterStrBuilder.append("(" + fieldName + " LIKE '%" + value + "')");
        }
        return this;
    }

    
    public FilterRuleBuilder likeRight(String fieldName, Object value) {
        // 不为空加逻辑关系
        if (filterStrBuilder.length() != 0) {
            filterStrBuilder.append(logic);
        }
        // 字母或数字要加引号
        if (value instanceof String || value instanceof Date) {
            filterStrBuilder.append("(" + fieldName + " LIKE '" + value + "%')");
        }
        return this;
    }


    
    public FilterRuleBuilder between(String fieldName, Object startVal, Object endVal) {
        // 不为空加逻辑关系
        if (filterStrBuilder.length() != 0) {
            filterStrBuilder.append(logic);
        }
        // 字母或数字要加引号
        if (startVal instanceof String || startVal instanceof Date) {
            filterStrBuilder.append(String.format("(%s BETWEEN '%s'", fieldName, startVal));
        } else {
            filterStrBuilder.append(String.format("(%s BETWEEN %s", fieldName, startVal));
        }
        if (endVal instanceof String || endVal instanceof Date) {
            filterStrBuilder.append(String.format(" AND '%s')", endVal));
        } else {
            filterStrBuilder.append(String.format(" AND '%s')", endVal));
        }
        return this;
    }

    
    public FilterRuleBuilder notBetween(String fieldName, Object startVal, Object endVal) {
        // 不为空加逻辑关系
        if (filterStrBuilder.length() != 0) {
            filterStrBuilder.append(logic);
        }
        // 字母或数字要加引号
        if (startVal instanceof String || startVal instanceof Date) {
            filterStrBuilder.append(String.format("(%s NOT BETWEEN '%s'", fieldName, startVal));
        } else {
            filterStrBuilder.append(String.format("(%s NOT BETWEEN %s", fieldName, startVal));
        }
        if (endVal instanceof String || endVal instanceof Date) {
            filterStrBuilder.append(String.format(" AND '%s')", endVal));
        } else {
            filterStrBuilder.append(String.format(" AND '%s')", endVal));
        }
        return this;
    }

    
    public FilterRuleBuilder isNull(String fieldName) {
        // 不为空加逻辑关系
        if (filterStrBuilder.length() != 0) {
            filterStrBuilder.append(logic);
        }
        filterStrBuilder.append(String.format("(%s IS NULL)", fieldName));
        return this;
    }

    
    public String buildFieldKeys() {
        return String.join(",", fieldKeys);
    }

    
    public FilterRuleBuilder isNotNull(String fieldName) {
        // 不为空加逻辑关系
        if (filterStrBuilder.length() != 0) {
            filterStrBuilder.append(logic);
        }
        filterStrBuilder.append(String.format("(%s IS NOT NULL)", fieldName));
        return this;
    }

    
    public FilterRuleBuilder topRowCount(int topRowCount) {
        this.TopRowCount = topRowCount;
        return this;
    }

    
    public FilterRuleBuilder startRow(int startRow) {
        this.StartRow = startRow;
        return this;
    }

    
    public FilterRuleBuilder limit(int limit) {
        if (limit < 2000) {
            this.Limit = limit;
        } else {
            this.Limit = 2000;
        }
        return this;
    }

    
    @Override
    public String buildFilter() {
        if (filterStrBuilder.length() != 0) {
            return this.filterStrBuilder.toString();
        } else {
            return "";
        }
    }

    
    @Override
    public String buildOrder() {
        if (orderBuilder.length() != 0) {
            return this.orderBuilder.toString();
        } else {
            return "";
        }
    }

    
    @Override
    public int buildTopRowCount() {
        return this.TopRowCount;
    }

    
    @Override
    public int buildStartRow() {
        return this.StartRow;
    }

    
    @Override
    public int buildLimit() {
        return this.Limit;
    }
}

    3.6 Builder，FilterRuleBuilder的增强类，仅对于类的构建器，限制字段字符串输入，优于输入字符串，类比Mybatis-Plus 的 Wrappers

    public final class Builder extends AbstractBuilder {
    
    private FilterRuleBuilder ruleBuilder;

    
    private Class cls;

    public Builder(Class cls) {
        this.cls = cls;
        this.ruleBuilder = new FilterRuleBuilder();
    }

    public Class getObjClass() {
        return cls;
    }

    
    public static final  Builder builder(Class cls){
        return new Builder<>(cls);
    }



    public Builder selectAll() {
        ruleBuilder.selectAllFiled(cls);
        return this;
    }

    public  Builder select(SFunction... fieldNames) {
        ruleBuilder.select(SFunctionParse.resolves(fieldNames));
        return this;
    }

    public  Builder orderBy(boolean isDesc, SFunction... fieldNames) {
        ruleBuilder.orderBy(isDesc, SFunctionParse.resolves(fieldNames));
        return this;
    }

    public  Builder orderByAsc(SFunction fieldName) {
        ruleBuilder.orderByAsc(SFunctionParse.resolve(fieldName));
        return this;
    }

    public  Builder orderByDesc(SFunction fieldName) {
        ruleBuilder.orderByDesc(SFunctionParse.resolve(fieldName));
        return this;
    }

    public  Builder eq(SFunction fieldName, Object value) {
        ruleBuilder.eq(SFunctionParse.resolve(fieldName), value);
        return this;
    }

    public  Builder ne(SFunction fieldName, Object value) {
        ruleBuilder.ne(SFunctionParse.resolve(fieldName), value);
        return this;
    }

    public  Builder lt(SFunction fieldName, Object value) {
        ruleBuilder.lt(SFunctionParse.resolve(fieldName), value);
        return this;
    }

    public  Builder gt(SFunction fieldName, Object value) {
        ruleBuilder.gt(SFunctionParse.resolve(fieldName), value);
        return this;
    }

    public  Builder le(SFunction fieldName, Object value) {
        ruleBuilder.le(SFunctionParse.resolve(fieldName), value);
        return this;
    }

    public  Builder ge(SFunction fieldName, Object value) {
        ruleBuilder.ge(SFunctionParse.resolve(fieldName), value);
        return this;
    }

    public  Builder like(SFunction fieldName, Object value) {
        ruleBuilder.like(SFunctionParse.resolve(fieldName), value);
        return this;
    }

    public  Builder notLike(SFunction fieldName, Object value) {
        ruleBuilder.notLike(SFunctionParse.resolve(fieldName), value);
        return this;
    }

    public  Builder likeLeft(SFunction fieldName, Object value) {
        ruleBuilder.likeLeft(SFunctionParse.resolve(fieldName), value);
        return this;
    }

    public  Builder likeRight(SFunction fieldName, Object value) {
        ruleBuilder.likeRight(SFunctionParse.resolve(fieldName), value);
        return this;
    }

    public  Builder between(SFunction fieldName, Object startVal, Object endVal) {
        ruleBuilder.between(SFunctionParse.resolve(fieldName), startVal, endVal);
        return this;
    }

    public  Builder notBetween(SFunction fieldName, Object startVal, Object endVal) {
        ruleBuilder.notBetween(SFunctionParse.resolve(fieldName), startVal, endVal);
        return this;
    }

    public  Builder isNull(SFunction fieldName) {
        ruleBuilder.isNull(SFunctionParse.resolve(fieldName));
        return this;
    }

    public  Builder isNotNull(SFunction fieldName) {
        ruleBuilder.isNotNull(SFunctionParse.resolve(fieldName));
        return this;
    }


    public Builder and() {
        ruleBuilder.and();
        return this;
    }

    public Builder or() {
        ruleBuilder.or();
        return this;
    }

    public Builder topRowCount(int topRowCount) {
        ruleBuilder.topRowCount(topRowCount);
        return this;
    }


    public Builder startRow(int startRow) {
        ruleBuilder.startRow(startRow);
        return this;
    }

    public Builder limit(int limit) {
        ruleBuilder.limit(limit);
        return this;
    }

    @Override
    public List getFieldKeys() {
        return ruleBuilder.getFieldKeys();
    }

    @Override
    public String buildFieldKeys() {
        return ruleBuilder.buildFieldKeys();
    }

    @Override
    public String buildFilter() {
        return ruleBuilder.buildFilter();
    }

    @Override
    public String buildOrder() {
        return ruleBuilder.buildOrder();
    }

    @Override
    public int buildTopRowCount() {
        return ruleBuilder.buildTopRowCount();
    }

    @Override
    public int buildStartRow() {
        return ruleBuilder.buildStartRow();
    }

    @Override
    public int buildLimit() {
        return ruleBuilder.buildLimit();
    }
}

    3.7 K3Api，数据连接查询，这里将其注入Spring容器中，便于使用

    @Component
public final class K3Api {

    private final Logger log = LoggerFactory.getLogger(K3Api.class);
    
    private final K3CloudApi api = new K3CloudApi();

    
    private List fieldKeys;

    
    public  String getFormId(Class cls) {
        FormId formId = cls.getDeclaredAnnotation(FormId.class);
        if (formId != null) {
            return formId.value();
        } else {
            return "";
        }
    }

    
    private final Object getFieldValue(String filedName, Object obj) {
        try {
            Class objCls = obj.getClass();
            String firstLetter = filedName.substring(0, 1).toUpperCase();
            String getter = "get" + firstLetter + filedName.substring(1);
            Method method = objCls.getMethod(getter, new Class[]{});
            Object value = method.invoke(obj, new Object[]{});
            return value;
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    
    private final void setFieldValue(String filedName, Object value, Object obj) {
        try {
            Class objClass = obj.getClass();
            Field field = objClass.getDeclaredField(filedName);
            String firstLetter = filedName.substring(0, 1).toUpperCase();
            String setter = "set" + firstLetter + filedName.substring(1);
            Method method = objClass.getMethod(setter, field.getType());
            // 日期格式如果值为字符换需要转换
            if (field.getType() == Date.class && !(value instanceof Date)) {
                // 对标准时间处理
                String d = value.toString().replace("T", " ").replace("Z", "");
                SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
                method.invoke(obj, format.parse(d));
            } else {
                method.invoke(obj, value);
            }
        } catch (Exception e) {
        }
    }

    
    private final  T containObj(List list, String fieldName, Object value) {
        T t;
        for (T item : list) {
            Object oldValue = getFieldValue(fieldName, item);
            // 字段相同，表示录入同一对象
            if (oldValue.equals(value)) {
                t = item;
                return t;
            }
        }
        return null;
    }

    
    private final String containClass(Map clsMap, String fileName) {
        Set> entries = clsMap.entrySet();
        Iterator> iterator = entries.iterator();
        while (iterator.hasNext()) {
            Map.Entry entry = iterator.next();
            Field[] fields = entry.getValue().getDeclaredFields();
            for (Field field : fields) {
                if (field.getName().equals(fileName)) {
                    return entry.getKey();
                }
            }
        }
        return null;
    }

    
    public  List query(Builder filter) {
        Class cls = filter.getObjClass();
        String formId = getFormId(cls);
        return query(formId, filter, cls);
    }

    
    public  List query(String formId, AbstractBuilder filter, Class cls) {
        try {
            // 保存当前查询字段
            fieldKeys = filter.getFieldKeys();
            QueryParam queryParam = new QueryParam();
            queryParam.setFormId(formId);
            queryParam.setFieldKeys(filter.buildFieldKeys());
            queryParam.setFilterString(filter.buildFilter());
            queryParam.setOrderString(filter.buildOrder());
            queryParam.setTopRowCount(filter.buildTopRowCount());
            queryParam.setStartRow(filter.buildStartRow());
            queryParam.setLimit(filter.buildLimit());
            // 打印日志
            log.info("请求信息：{}", queryParam.toJson());
            // 查询结果集
            List> lists = api.executeBillQuery(queryParam.toJson());
            // 封装结果集
            List resultList = new ArrayList<>();
            lists.forEach(item -> {
                try {
                    T result = cls.newInstance();
                    for (int i = 0; i < fieldKeys.size(); i++) {
                        // 将所有字段中.替换为_
                        String fieldName = fieldKeys.get(i).replace(".","_");
                        setFieldValue(fieldName, item.get(i), result);
                    }
                    resultList.add(result);
                } catch (InstantiationException e) {
                    e.printStackTrace();
                } catch (IllegalAccessException e) {
                    e.printStackTrace();
                }
            });
            return resultList;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    
    public  List query(String formId, List fieldKeys, Class cls) {
        FilterRuleBuilder builder = new FilterRuleBuilder();
        builder.select(fieldKeys);
        return query(formId, builder, cls);
    }
    
    public  List query(List fieldKeys, Class cls) {
        String formId = getFormId(cls);
        FilterRuleBuilder builder = new FilterRuleBuilder();
        builder.select(fieldKeys);
        return query(formId, builder, cls);
    }

    
    public List> query(String formId, AbstractBuilder filter) {
        try {
            fieldKeys = filter.getFieldKeys();
            QueryParam queryParam = new QueryParam();
            queryParam.setFormId(formId).setFieldKeys(filter.buildFieldKeys());
            queryParam.setFilterString(filter.buildFilter());
            queryParam.setOrderString(filter.buildOrder());
            queryParam.setTopRowCount(filter.buildTopRowCount());
            queryParam.setLimit(filter.buildLimit());
            queryParam.setStartRow(filter.buildStartRow());
            // 打印日志
            log.info("请求信息：{}", queryParam.toJson());
            List> lists = api.executeBillQuery(queryParam.toJson());
            return lists;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    
    public List> query(String formId, List fieldKeys) {
        FilterRuleBuilder builder = new FilterRuleBuilder();
        builder.select(fieldKeys);
        return query(formId, builder);
    }

    
    public  T queryOne(String formId, Builder filter) {
        Class cls = filter.getObjClass();
        List query = query(formId, filter, cls);
        int size = query.size();
        if (size == 1) {
            return query.get(0);
        } else if (size == 0) {
            return null;
        } else {
            throw new RuntimeException("查询一条记录，但发现" + query.size() + "条数据");
        }
    }

    
    public  T queryOne(Builder filter) {
        // 获取查询类
        Class cls = filter.getObjClass();
        String formId = getFormId(cls);
        return queryOne(formId,filter);
    }

    
    public List queryOne(String formId, AbstractBuilder filter) {
        List> query = query(formId, filter);
        int size = query.size();
        if (size == 1) {
            return query.get(0);
        } else if (size == 0) {
            return null;
        } else {
            throw new RuntimeException("查询一条记录，但发现" + query.size() + "条数据");
        }
    }

    
    public Long count(String formId, AbstractBuilder filter) {
        List> query = null;
        try {
            QueryParam queryParam = new QueryParam();
            queryParam.setFormId(formId);
            queryParam.setFieldKeys("count(1)");
            if (filter != null) {
                queryParam.setFilterString(filter.buildFilter());
            }
            query = api.executeBillQuery(queryParam.toJson());
        } catch (Exception e) {
            e.printStackTrace();
        }
        return Long.parseLong((String) query.get(0).get(0));
    }

    
    public long count(String formId) {
        return count(formId, null);
    }

    
    public  List resultMap(List result, Class cls, String fieldId, String... properties) {
        List returnResult = new ArrayList<>();
        try {
            //  对象子对象A集合
            Map subObjFields = new HashMap<>();
            //  对象的子列表对象集合
            Map subListFields = new HashMap<>();
            for (String property : properties) {
                Field field = cls.getDeclaredField(property);
                if (field.getType() == List.class) {// 列表先获取列表泛型的对象，然后获取对象的字段
                    // 获取列表中的泛型
                    Type genericType = field.getGenericType();
                    // 获取类型Class
                    if (genericType instanceof ParameterizedType) {
                        ParameterizedType typeCls = (ParameterizedType) genericType;
                        Class subGenericClass = (Class) typeCls.getActualTypeArguments()[0];
                        subListFields.put(property, subGenericClass);
                    }
                } else {// 对象直接获取对象的字段
                    Class subObjClass = cls.getDeclaredField(property).getType();
                    subObjFields.put(property, subObjClass);
                }
            }
            int size = result.size();
            // 封装结果
            for (int i = 0; i < size; i++) {
                Object obj = result.get(i);
                // obj是一个对象，根据对象封装
                if (obj instanceof List) {// 列表类型的操作
                    List list = (List) obj;
                    packByList(returnResult, list, cls, fieldId, subObjFields, subListFields);
                } else {// 对象类型的操作
                    packByObject(returnResult, obj, cls, fieldId, subObjFields, subListFields);
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return returnResult;
    }

    
    public  List resultMap(List result, Class cls, SFunction fieldId, SFunction... properties) {
        return resultMap(result, cls, SFunctionParse.resolve(fieldId), SFunctionParse.resolves(properties));
    }

    
    private  List packByList(List returnResult, List list, Class cls, String fieldId,
                                   Map subObjFields, Map subListFields) throws IllegalAccessException, InstantiationException {
        // 字段个数
        int size = list.size();
        // 单元素对象
        T t = null;
        Object subObj;
        // 子列表中对象
        Object listObj = null;
        // 子列表
        List subList;
        for (int j = 0; j < size; j++) {
            // 字段名，将点替换为字段
            String fieldName = fieldKeys.get(j).replace(".", "_");
            // 字段值
            Object value = list.get(j);
            // 主键字段创建新对象
            if (fieldName.equals(fieldId)) {// 主键字段赋值
                // 获取对象或创建对象
                t = containObj(returnResult, fieldName, value);
                // 同时添加到
                if (t == null) {
                    t = cls.newInstance();
                    setFieldValue(fieldName, value, t);
                    // 创建新的对象并添加到结果集
                    returnResult.add(t);
                }
            } else {
                // 判断是否为子对象,返回子对象的属性名
                String subFieldName = containClass(subObjFields, fieldName);
                // 获取子对象Class
                Class subCls = subObjFields.get(subFieldName);
                // 不为空表示在子对象中
                if (subFieldName != null) {
                    // 获取当前对象的子对象
                    subObj = getFieldValue(subFieldName, t);
                    // 子对象为空，创建子对象
                    if (subObj == null) {
                        subObj = subCls.newInstance();
                    }
                    // 赋值子对象属性
                    setFieldValue(fieldName, value, subObj);
                    // 赋值对象属性
                    setFieldValue(subFieldName, subObj, t);
                } else {// 不为子对象判断是否为子
                    // 判断是否为子列表
                    String subListFieldName = containClass(subListFields, fieldName);

                    if (subListFieldName == null) {// 为空表示普通属性，自动封装
                        setFieldValue(fieldName, value, t);
                    } else {
                        // 查询对象是否包含子列表，不包含创建，包含赋值
                        subList = (List) getFieldValue(subListFieldName, t);
                        if (subList == null) {
                            // 并将列表添加在对象中
                            subList = new ArrayList<>();
                            setFieldValue(subListFieldName, subList, t);
                        }
                        // 列表中的子对象是否存在,不存在创建并添加在列表中
                        if (listObj == null) {
                            // 获取子列表中的对象Class
                            Class subListCls = subListFields.get(subListFieldName);
                            listObj = subListCls.newInstance();
                            // 添加到子列表中
                            subList.add(listObj);
                        }
                        // 给列表对象赋值属性
                        setFieldValue(fieldName, value, listObj);
                    }
                }
                // 给对象赋值，如果包装对象外也存在该属性，同样进行赋值
                setFieldValue(fieldName, value, t);
            }
        }
        return returnResult;
    }

    
    private  List packByObject(List returnResult, Object obj, Class cls, String fieldId,
                                     Map subObjFields, Map subListFields)
            throws IllegalAccessException, InstantiationException {
        Field[] resultFields = obj.getClass().getDeclaredFields();
        // 单元素对象
        T t = null;
        Object subObj;
        // 子列表中对象
        Object listObj = null;
        // 子列表
        List subList;
        for (int j = 0; j < resultFields.length; j++) {
            Field field = resultFields[j];
            // 字段名
            String fieldName = field.getName();
            // 字段值
            Object value = getFieldValue(fieldName, obj);
            // 主键字段创建新对象
            if (fieldName.equals(fieldId)) {// 主键字段赋值
                // 获取对象或创建对象
                t = containObj(returnResult, fieldName, value);
                // 同时添加到
                if (t == null) {
                    t = cls.newInstance();
                    setFieldValue(fieldName, value, t);
                    // 创建新的对象并添加到结果集
                    returnResult.add(t);
                }

            } else {
                // 判断是否为子对象,返回子对象的属性名
                String subFieldName = containClass(subObjFields, fieldName);
                // 获取子对象Class
                Class subCls = subObjFields.get(subFieldName);
                // 不为空表示在子对象中
                if (subFieldName != null) {
                    // 获取当前对象的子对象
                    subObj = getFieldValue(subFieldName, t);
                    // 子对象为空，创建子对象
                    if (subObj == null) {
                        subObj = subCls.newInstance();
                    }
                    // 赋值子对象属性
                    setFieldValue(fieldName, value, subObj);
                    // 赋值对象属性
                    setFieldValue(subFieldName, subObj, t);
                } else {// 不为子对象判断是否为子
                    // 判断是否为子列表
                    String subListFieldName = containClass(subListFields, fieldName);

                    if (subListFieldName == null) {// 为空表示普通属性，自动封装
                        setFieldValue(fieldName, value, t);
                    } else {
                        // 查询对象是否包含子列表，不包含创建，包含赋值
                        subList = (List) getFieldValue(subListFieldName, t);
                        if (subList == null) {
                            // 并将列表添加在对象中
                            subList = new ArrayList<>();
                            setFieldValue(subListFieldName, subList, t);
                        }
                        // 列表中的子对象是否存在,不存在创建并添加在列表中
                        if (listObj == null) {
                            // 获取子列表中的对象Class
                            Class subListCls = subListFields.get(subListFieldName);
                            listObj = subListCls.newInstance();
                            // 添加到子列表中
                            subList.add(listObj);
                        }
                        // 给列表对象赋值属性
                        setFieldValue(fieldName, value, listObj);
                    }
                }
                // 给对象赋值，如果包装对象外也存在该属性，同样进行赋值
                setFieldValue(fieldName, value, t);
            }
        }
        return returnResult;
    }

}
 
  4.  
    使用示例： 提示: 实体类首字母必须小写
     
    @Data
@NoArgsConstructor
@AllArgsConstructor
@FormId("BD_Customer")
public class Customer {
    private long fCUSTID;
    private String fNumber;
    private String fName;
    private String fShortName;


    public static void main(String[] args) {
        // 1. 原始方式
        K3CloudApi api = new K3CloudApi();
        List datas;
        try {
            QueryParam queryParam = new QueryParam();
            queryParam.setFormId("BD_Customer")
                    .setFieldKeys("fCUSTID,fNumber,fName,fCreateDate")
                    .setFilterString("fCUSTID <= '***'");
            datas = api.executeBillQuery(queryParam, Customer.class);
            datas.forEach(System.out::println);
        } catch (Exception e) {
            e.printStackTrace();
        }
        // 2. 封装 FilterRuleBuilder后
        K3Api k3Api = new K3Api();
        FilterRuleBuilder builder = new FilterRuleBuilder();
        builder.select("fCUSTID", "fNumber", "fName", "fCreateDate")
                .le("fCUSTID", "***");
        List customers = k3Api.query("BD_Customer", builder, Customer.class);
        customers.forEach(System.out::println);
        // 3. 封装 Builder后
        List customers1 = k3Api.query(Builder.builder(Customer.class)
            .select(Customer::getFCUSTID, Customer::getFName, Customer::getFCreateDate));
        customers.forEach(System.out::println);
        
    }
}

     
    5. 


    

    

    转载请注明：文章转载自 www.mshxw.com
    


    


    

    


    

    

    Java相关栏目本月热门文章
    


    

    



    

    
热门相关搜索

    

    

    
路由器设置
木托盘
宝塔面板
儿童python教程
心情低落
朋友圈
vim
双一流学科
专升本
我的学校
日记学校
西点培训学校
汽修学校
情书
化妆学校
塔沟武校
异形模板
西南大学排名
最精辟人生短句
6步教你追回被骗的钱
南昌大学排名
清朝十二帝
北京印刷学院排名
北方工业大学排名
北京航空航天大学排名
首都经济贸易大学排名
中国传媒大学排名
首都师范大学排名
中国地质大学(北京)排名
北京信息科技大学排名
中央民族大学排名
北京舞蹈学院排名
北京电影学院排名
中国戏曲学院排名
河北政法职业学院排名
河北经贸大学排名
天津中德应用技术大学排名
天津医学高等专科学校排名
天津美术学院排名
天津音乐学院排名
天津工业大学排名
北京工业大学耿丹学院排名
北京警察学院排名
天津科技大学排名
北京邮电大学(宏福校区)排名
北京网络职业学院排名
北京大学医学部排名
河北科技大学排名
河北地质大学排名
河北体育学院排名

    

    

    

    

    

    

    

    学习工具
    

    代数计算器
    

    三角函数
    

    解析几何
    

    立体几何
    

    

    

    知识解答
    

    教育知识
    

    百科知识
    

    生活知识
    

    常识知识
    

    

    

    写作必备
    

    作文大全
    

    作文素材
    

    句子大全
    


    实用范文
    

    

    

    关于我们
    

    关于我们
    

    联系我们
    

    网站地图
    

    

    

     交流群

    名师互学网交流群
    

    

    名师互学网客服

    名师互学网客服
    

    

    

    

    

    

    名师互学网 版权所有 (c)2021-2022      ICP备案号：晋ICP备2021003244-6号
 
    

    

    


    
我们一直用心在做
    
关于我们
文章归档
网站地图
联系我们

    版权所有 (c)2021-2022 MSHXW.COM
    

    ICP备案号：晋ICP备2021003244-6号