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

Posted 2022-11-25 ￡漫步 云端彡

java SDK对接金蝶

SDK下载地址

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

   <!--    金蝶云对接    -->
   <dependency>
       <groupId>com.kingdee</groupId>
       <artifactId>k3cloud-webapi</artifactId>
       <version>1.0.0</version>
       <scope>system</scope>
       <!-- jar包存放的位置 -->
       <systemPath>$project.basedir/lib/k3cloud-webapi-sdk7.9.2.jar</systemPath>
   </dependency>
   

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

3. 官网只提供了一些查询数据方法。对于java代码来说写起来很不舒服。下面我做了一些工具类。
   一共设计了10个java文件，下面简单的介绍一下
   (1) AbstractBuilder：抽象构造器，用于构建查询语句的SQL方法定义
   (2) FilterRuleBuilder： 通用的查询条件构造器，继承了AbstractBuilder，可构建常用的查询字段，条件等。使用方式类比mybatis-plus的QueryWrapper
   (3) Builder：针对于实体类的条件构造，继承了AbstractBuilder，修饰了FilterRuleBuilder。功能同上，使用方式类比mybatis-plus的Wrappers。注：如果不设置查询字段则查询类中所有字段
   (4) ConvertType：一个类型转换的枚举类，枚举了需要转换的位置。目的是为了将金蝶中查询字段和实体类的字段之间的_与.符号的转换处理。
   (5) SymbolConvert：符号转换注解，将需要指定特殊转换的字段写入该注解，即可，例：在金蝶中查询字段为A_B.C，java实体类中字段只能为A_B_C，故在该字段上标明@SymbolConvert(ConvertType.Last)，表示转换字符只转最后一个。不写注解默认为转换所有符号。
   (6) FormId：FormId 注解，看过API的都知道，这是标识查询金蝶的FormId值，不填默认为类名。
   (7) K3Const：K3使用的静态常量
   (8) SFunction：序列化函数式接口
   (9)SFunctionParse：函数式接口解析，很重要，其中解析了@SymbolConvert，解析了表达式
   (10) K3Api：金蝶数据接口工具类，最终使用的是这个查询，该类已注入Spring，可以通过@Autowired自动注入，作用域为一个Session。
   注：FilterRuleBuilder 和 Builder类提供特有的switchAND和switchOR来切换条件判断连接符，默认是and；可通过andLeft 和 orLeft 添加 ’ AND ( ’ 与 ’ OR ( '，通过right添加 ‘)’ 。以上类代码如下：

   3.1 AbstractBuilder抽象类

   
   import java.util.ArrayList;
   import java.util.Date;
   import java.util.List;
   
   /**
    * @Author
    * @Date 2022/5/16 10:03
    * @Description 抽象构造器
    */
   public abstract class AbstractBuilder<T> 
       /**
        * 定义所有的基本类型及包装类型，或者是String
        */
       protected static final List<String> generalType = new ArrayList<String>() 
           add(Date.class.getName());
           add(Integer.class.getName());
           add(Double.class.getName());
           add(Float.class.getName());
           add(Long.class.getName());
           add(Short.class.getName());
           add(Byte.class.getName());
           add(Boolean.class.getName());
           add(Character.class.getName());
           add(String.class.getName());
           add("int");
           add("double");
           add("float");
           add("long");
           add("short");
           add("byte");
           add("boolean");
           add("char");
       ;
   
       /**
        * 查询参数构造器
        */
   
       protected List<String> 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 ";
   
       /**
        * 获取查询字段
        *
        * @return
        */
       public abstract List<String> getFieldKeys();
   
   
       /**
        * 构建查询字段
        *
        * @return
        */
       public abstract String buildFieldKeys();
   
       /**
        * 构造查询条件
        *
        * @return
        */
       public abstract String buildFilter();
   
       /**
        * 构造排序条件
        *
        * @return
        */
       public abstract String buildOrder();
   
       /**
        * 构建总行数
        *
        * @return
        */
       public abstract int buildTopRowCount();
   
       /**
        * 构建起始行数
        *
        * @return
        */
       public abstract int buildStartRow();
   
       /**
        * 构建最大行数
        *
        * @return
        */
       public abstract int buildLimit();
   
   
   
   

   3.2 FilterRuleBuilder类

   import java.lang.reflect.Field;
   import java.util.Date;
   import java.util.List;
   
   /**
    * @Author
    * @Date 2022/5/12 9:54
    * @Description K3Cloud 查询条件构造
    */
   public class FilterRuleBuilder extends AbstractBuilder 
   
       public FilterRuleBuilder() 
       
   
   
       /**
        * 逻辑关系，默认and
        */
       protected String logic = LOGIC_AND;
   
       /**
        * 获取查询字段
        *
        * @return
        */
       public List<String> getFieldKeys() 
           return this.fieldKeys;
       
   
       /**
        * 切换and逻辑
        *
        * @return
        */
       public FilterRuleBuilder switchAND() 
           logic = LOGIC_AND;
           return this;
       
   
       /**
        * 切换or逻辑
        *
        * @return
        */
       public FilterRuleBuilder switchOR() 
           logic = LOGIC_OR;
           return this;
       
   
       /**
        * 添加and左括号
        *
        * @return
        */
       public FilterRuleBuilder andLeft() 
           if (filterStrBuilder.length() == 0) 
               filterStrBuilder.append("(");
            else 
               filterStrBuilder.append(LOGIC_AND + "(");
           
           return this;
       
   
       /**
        * 添加or左括号
        *
        * @return
        */
       public FilterRuleBuilder orLeft() 
           if (filterStrBuilder.length() == 0) 
               filterStrBuilder.append("(");
            else 
               filterStrBuilder.append(LOGIC_OR + "(");
           
           return this;
       
   
       /**
        * 添加右括号
        *
        * @return
        */
       public FilterRuleBuilder right() 
           filterStrBuilder.append(")");
           return this;
       
   
       /**
        * 列表查询字段
        *
        * @param fieldKeys
        * @return
        */
       public FilterRuleBuilder select(List<String> fieldKeys) 
           this.fieldKeys = fieldKeys;
           return this;
       
   
       /**
        * 查询具体类的所有字段
        *
        * @param cls
        * @return
        */
       public FilterRuleBuilder selectAllFiled(Class cls) 
           Field[] fields = cls.getDeclaredFields();
           for (Field field : fields) 
               String fieldName = SFunctionParse.convertField(cls, field.getName());
               select(fieldName);
           
           return this;
       
   
       /**
        * 添加查询字段
        *
        * @param fieldKey
        * @return
        */
       public FilterRuleBuilder select(String fieldKey) 
           fieldKeys.add(fieldKey);
           return this;
       
   
       /**
        * 添加多个查询字段
        *
        * @param fieldKeys
        * @return
        */
       public FilterRuleBuilder select(String... fieldKeys) 
           for (String fieldKey : fieldKeys) 
               select(fieldKey);
           
           return this;
       
   
   
       /**
        * 多字段排序
        *
        * @param fieldNames
        * @return
        */
       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;
       
   
       /**
        * 正序排序
        *
        * @param fieldName
        * @return
        */
       public FilterRuleBuilder orderByAsc(String fieldName) 
           // 不为空加逻辑关系
           if (orderBuilder.length() != 0) 
               orderBuilder.append(",");
           
           orderBuilder.append(String.format("%s ASC", fieldName));
           return this;
       
   
       /**
        * 倒序排序
        *
        * @param fieldName
        * @return
        */
       public FilterRuleBuilder orderByDesc(String fieldName) 
           // 不为空加逻辑关系
           if (orderBuilder.length() != 0) 
               orderBuilder.append(",");
           
           orderBuilder.append(String.format("%s DESC", fieldName));
           return this;
       
   
       /**
        * 等于构造
        *
        * @param fieldName
        * @param value
        * @return
        */
       public FilterRuleBuilder eq(String fieldName, Object value) 
           // 不为空加逻辑关系，或者前面为左括号不加
           if (filterStrBuilder.length() != 0 && filterStrBuilder.charAt(filterStrBuilder.length() - 1) != '(') 
               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;
       
   
       /**
        * 不等于构造
        *
        * @param fieldName
        * @param value
        * @return
        */
       public FilterRuleBuilder ne(String fieldName, Object value) 
           // 不为空加逻辑关系，或者前面为左括号不加
           if (filterStrBuilder.length() != 0 && filterStrBuilder.charAt(filterStrBuilder.length() - 1) != '(') 
               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;
       
   
       /**
        * 小于构造
        *
        * @param fieldName
        * @param value
        * @return
        */
       public FilterRuleBuilder lt(String fieldName, Object value) 
           // 不为空加逻辑关系，或者前面为左括号不加
           if (filterStrBuilder.length() != 0 && filterStrBuilder.charAt(filterStrBuilder.length() - 1) != '(') 
               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;
       
   
       /**
        * 大于构造
        *
        * @param fieldName
        * @param value
        * @return
        */
       public FilterRuleBuilder gt(String fieldName, Object value) 
           // 不为空加逻辑关系，或者前面为左括号不加
           if (filterStrBuilder.length() != 0 && filterStrBuilder.charAt(filterStrBuilder.length() - 1) != '(') 
               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;
       
   
       /**
        * 小于等于构造
        *
        * @param fieldName
        * @param value
        * @return
        */
       public FilterRuleBuilder le(String fieldName, Object value) 
           // 不为空加逻辑关系，或者前面为左括号不加
           if (filterStrBuilder.length() != 0 && filterStrBuilder.charAt(filterStrBuilder.length() - 1) != '(') 
               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;
       
   
       /**
        * 大于等于构造
        *
        * @param fieldName
        * @param value
        * @return
        */
       public FilterRuleBuilder ge(String fieldName, Object value) 
           // 不为空加逻辑关系，或者前面为左括号不加
           if (filterStrBuilder.length() != 0 && filterStrBuilder.charAt(filterStrBuilder.length() - 1) != '(') 
               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)",
   以上是关于java SDK对接金蝶数据包装类（仅查询）的主要内容，如果未能解决你的问题，请参考以下文章
    
    java SDK对接金蝶数据包装类（仅查询）
    金蝶云星空之WebAPI开发（Android）----单据查询
    php对接金蝶系统
    php对接金蝶系统
    金蝶单据清空记账标志
    金碟K3软件：没有对应单据体