￡漫步 云端彡
￡漫步 云端彡

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

java SDK对接金蝶

SDK下载地址

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

    
<dependency>
    <groupId>com.kingdeegroupId>
    <artifactId>k3cloud-webapiartifactId>
    <version>1.0.0version>
    <scope>systemscope>
    
    <systemPath>${project.basedir}/lib/k3cloud-webapi-sdk7.9.2.jarsystemPath>
dependency>

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

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

    @FunctionalInterface
public interface SFunction<T, R> extends Function<T, R>, Serializable {
}

    3.2 序列化解析类

    public final class SFunctionParse {
    /**
     * 解析多个表达式
     *
     * @param functions
     * @param 
     * @return
     * @throws Exception
     */
    public static final <T, R> String[] resolves(SFunction<T, R>... functions) {
        String[] fileNames = new String[functions.length];
        String fileName;
        try {
            for (int i = 0; i < functions.length; i++) {
                SFunction<T, R> 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;
    }

    /**
     * 解析一个表达式
     *
     * @param function
     * @param 
     * @return
     * @throws Exception
     */
    public static final <T, R> String resolve(SFunction<T, R> 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<T> {
	    /**
	     * 查询参数构造器
	     */
	
	    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.5 条件过滤构建器FilterRuleBuilder，类比mybatis

    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 and() {
        this.logic = LOGIC_AND;
        return this;
    }

    /**
     * 列表查询字段
     *
     * @param fieldKeys
     * @return
     */
    public FilterRuleBuilder select(List<String> fieldKeys) {
        this.fieldKeys = fieldKeys;
        return this;
    }

    /**
     * 查询具体类的所有字段：所有子字段用下划线代替，例如：FDocumentStatus.FCaption ==》FDocumentStatus_FCaption
     *
     * @param cls
     * @return
     */
    public FilterRuleBuilder selectAllFiled(Class cls) {
        Field[] fields = cls.getDeclaredFields();
        for (Field field : fields) {
            String fieldName = field.getName().replace("_", ".");
            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;
    }

    /**
     * 切换or逻辑
     *
     * @return
     */
    public FilterRuleBuilder or() {
        logic = LOGIC_OR;
        return this;
    }

    /**
     * 等于构造
     *
     * @param fieldName
     * @param value
     * @return
     */
    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;
    }

    /**
     * 不等于构造
     *
     * @param fieldName
     * @param value
     * @return
     */
    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;
    }

    /**
     * 小于构造
     *
     * @param fieldName
     * @param value
     * @return
     */
    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;
    }

    /**
     * 大于构造
     *
     * @param fieldName
     * @param value
     * @return
     */
    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;
    }

    /**
     * 小于等于构造
     *
     * @param fieldName
     * @param value
     * @return
     */
    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;
    }

    /**
     * 大于等于构造
     *
     * @param fieldName
     * @param value
     * @return
     */
    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;
    }

    /**
     * 模糊=构造
     *
     * @param fieldName
     * @param value
     * @return
     */
    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;
    }

    /**
     * 模糊<>构造
     *
     * @param fieldName
     * @param value
     * @return
     */
    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;
    }

    /**
     * 模糊Left构造
     *
     * @param fieldName
     * @param value
     * @return
     */
    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;
    }

    /**
     * 模糊Right构造
     *
     * @param fieldName
     * @param value
     * @return
     */
    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;
    }


    /**
     * between 连接
     *
     * @param fieldName
     * @param startVal
     * @param endVal
     * @return
     */
    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;
    }

    /**
     * netBetween 连接
     *
     * @param fieldName
     * @param startVal
     * @param endVal
     * @return
     */
    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;
    }

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

    /**
     * 构建查询字段
     *
     * @return
     */
    public String buildFieldKeys() {
        return String.join(",", fieldKeys);
    }

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

    /**
     * 总行数
     *
     * @param topRowCount
     * @return
     */
    public FilterRuleBuilder topRowCount(int topRowCount) {
        this.TopRowCount = topRowCount;
        return this;
    }

    /**
     * 起始行数
     *
     * @param startRow
     * @return
     */
    public FilterRuleBuilder startRow(int startRow) {
        this.StartRow = startRow;
        return this;
    }

    /**
     * 最大行数,不可超过2000
     *
     * @param limit
     * @return
     */
    public FilterRuleBuilder limit(int limit) {
        if (limit < 2000) {
            this.Limit = limit;
        } else {
            this.Limit = 2000;
        }
        return this;
    }

    /**
     * 构造查询条件
     *
     * @return
     */
    @Override
    public String buildFilter() {
        if (filterStrBuilder.length() != 0) {
            return this.filterStrBuilder.toString();
        } else {
            return "";
        }
    }

    /**
     * 构造排序条件
     *
     * @return
     */
    @Override
    public String buildOrder() {
        if (orderBuilder.length() != 0) {
            return this.orderBuilder.toString();
        } else {
            return "";
        }
    }

    /**
     * 构建总行数
     *
     * @return
     */
    @Override
    public int buildTopRowCount() {
        return this.TopRowCount;
    }

    /**
     * 构建起始行数
     *
     * @return
     */
    @Override
    public int buildStartRow() {
        return this.StartRow;
    }

    /**
     * 构建最大行数
     *
     * @return
     */
    @Override
    public int buildLimit() {
        return this.Limit;
    }
}

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

    public final class Builder<T> extends AbstractBuilder<T> {
    /**
     * 字段构建器，增强其功能
     */
    private FilterRuleBuilder ruleBuilder;

    /**
     * class类
     */
    private Class<T> cls;

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

    public Class<T> getObjClass() {
        return cls;
    }

    /**
     * 静态构造器
     * @param cls
     * @param 
     * @return
     */
    public static final <T> Builder<T> builder(Class<T> cls){
        return new Builder<>(cls);
    }



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

    public <R> Builder<T> select(SFunction<T, R>... fieldNames) {
        ruleBuilder.select(SFunctionParse.resolves(fieldNames));
        return this;
    }

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

    public <R> Builder<T> orderByAsc(SFunction<T, R> fieldName) {
        ruleBuilder.orderByAsc(SFunctionParse.resolve(fieldName));
        return this;
    }

    public <R> Builder<T> orderByDesc(SFunction<T, R> fieldName) {
        ruleBuilder.orderByDesc(SFunctionParse.resolve(fieldName));
        return this;
    }

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

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

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

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

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

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

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

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

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

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

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

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

    public <R> Builder<T> isNull(SFunction<T, R> fieldName) {
        ruleBuilder.isNull(SFunctionParse.resolve(fieldName));
        return this;
    }

    public <R> Builder<T> isNotNull(SFunction<T, R> fieldName) {
        ruleBuilder.isNotNull(SFunctionParse.resolve(fieldName));
        return this;
    }


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

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

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


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

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

    @Override
    public List<String> 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);
    /**
     * K3Cloud对象
     */
    private final K3CloudApi api = new K3CloudApi();

    /**
     * 当次查询字段
     */
    private List<String> fieldKeys;

    /**
     * 解析类上的注解FormId，获取表单Id
     *
     * @param cls
     * @param 
     * @return 存在返回FormId，不存在返回空字符
     */
    public <T> String getFormId(Class<T> cls) {
        FormId formId = cls.getDeclaredAnnotation(FormId.class);
        if (formId != null) {
            return formId.value();
        } else {
            return "";
        }
    }

    /**
     * 获取字段的值
     *
     * @param filedName 字段名称
     * @param obj       对象
     * @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;
        }
    }

    /**
     * 设置字段的值
     *
     * @param filedName 字段名称
     * @param value     字段值
     * @param obj       对象
     * @return
     */
    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) {
        }
    }

    /**
     * 主要用于查询列表中主键对象是否封装
     * 判断列表中是否包含某个子段元素
     *
     * @param list      查询列表
     * @param fieldName 字段名
     * @param value     值
     * @param 
     * @return 返回该元素
     */
    private final <T> T containObj(List<T> 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;
    }

    /**
     * 判断类中是否包含某个字段名
     *
     * @param clsMap
     * @param fileName
     * @return 返回包含字段名的类型
     */
    private final String containClass(Map<String, Class> clsMap, String fileName) {
        Set<Map.Entry<String, Class>> entries = clsMap.entrySet();
        Iterator<Map.Entry<String, Class>> iterator = entries.iterator();
        while (iterator.hasNext()) {
            Map.Entry<String, Class> entry = iterator.next();
            Field[] fields = entry.getValue().getDeclaredFields();
            for (Field field : fields) {
                if (field.getName().equals(fileName)) {
                    return entry.getKey();
                }
            }
        }
        return null;
    }

    /**
     * 查询数据 : 此方法需要在cls上添加注解@FormId
     * @param filter 类条件构建器
     * @param 
     * @return List-T
     */
    public <T> List<T> query(Builder<T> filter) {
        Class<T> cls = filter.getObjClass();
        String formId = getFormId(cls);
        return query(formId, filter, cls);
    }

    /**
     * 查询数据
     *
     * @param formId 查询表单ID
     * @param filter 条件构建器
     * @param cls    查询类
     * @param 
     * @return List-T
     */
    public <T> List<T> query(String formId, AbstractBuilder<T> filter, Class<T> 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<List<Object>> lists = api.executeBillQuery(queryParam.toJson());
            // 封装结果集
            List<T> 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;
    }

    /**
     * 查询数据
     *
     * @param formId    查询表单ID
     * @param fieldKeys 查询字段
     * @param cls       封装类
     * @param 
     * @return List-T
     */
    public <T> List<T> query(String formId, List<String> fieldKeys, Class<T> cls) {
        FilterRuleBuilder builder = new FilterRuleBuilder();
        builder.select(fieldKeys);
        return query(formId, builder, cls);
    }
    /**
     * 查询数据 : 此方法需要在cls上添加注解@FormId
     *
     * @param fieldKeys 查询字段
     * @param cls       封装类
     * @param 
     * @return List-T
     */
    public <T> List<T> query(List<String> fieldKeys, Class<T> cls) {
        String formId = getFormId(cls);
        FilterRuleBuilder builder = new FilterRuleBuilder();
        builder.select(fieldKeys);
        return query(formId, builder, cls);
    }

    /**
     * 查询数据
     *
     * @param formId 查询表单ID
     * @param filter 条件查询构造器
     * @return List-List
     */
    public List<List<Object>> 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<List<Object>> lists = api.executeBillQuery(queryParam.toJson());
            return lists;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * 查询数据
     *
     * @param formId    查询表单ID
     * @param fieldKeys 查询字段
     * @return List-Object
     */
    public List<List<Object>> query(String formId, List<String> fieldKeys) {
        FilterRuleBuilder builder = new FilterRuleBuilder();
        builder.select(fieldKeys);
        return query(formId, builder);
    }

    /**
     * 查询一条数据
     *
     * @param formId
     * @param filter 条件构建器
     * @param 
     * @return 数据存在一条返回，不存在返回null,多条报错
     */
    public <T> T queryOne(String formId, Builder<T> filter) {
        Class<T> cls = filter.getObjClass();
        List<T> 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() + "条数据");
        }
    }

    /**
     * 查询一条数据
     *
     * @param filter
     * @param 
     * @return 数据存在一条返回，不存在返回null,多条报错
     */
    public <T> T queryOne(Builder<T> filter) {
        // 获取查询类
        Class<T> cls = filter.getObjClass();
        String formId = getFormId(cls);
        return queryOne(formId,filter);
    }

    /**
     * 查询一条数据
     *
     * @param formId
     * @param filter
     * @return 数据存在一条返回，不存在返回null,多条报错
     */
    public List<Object> queryOne(String formId, AbstractBuilder filter) {
        List<List<Object>> 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() + "条数据");
        }
    }

    /**
     * 统计数量
     * FilterRuleBuilder的查询字段不生效
     *
     * @param formId
     * @return
     */
    public Long count(String formId, AbstractBuilder filter) {
        List<List<Object>> 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));
    }

    /**
     * 统计数量
     *
     * @param formId
     * @return
     */
    public long count(String formId) {
        return count(formId, null);
    }

    /**
     * 结果映射： 除请求参数的属性外，其他字段自动映射
     *
     * @param result     结果集
     * @param cls        映射对象
     * @param fieldId    主键Id
     * @param properties 映射对象中的映射字段，可以是对象或list,
     *                   但是list只能有一个，因为映射最小单元是list的单位
     * @param         对象类型
     * @return
     */
    public <T> List<T> resultMap(List result, Class<T> cls, String fieldId, String... properties) {
        List<T> returnResult = new ArrayList<>();
        try {
            //  对象子对象A集合
            Map<String, Class> subObjFields = new HashMap<>();
            //  对象的子列表对象集合
            Map<String, Class> 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;
    }

    /**
     * 结果映射： 除请求参数的属性外，其他字段自动映射
     *
     * @param result     结果集
     * @param cls        映射对象
     * @param fieldId    主键Id
     * @param properties 映射对象中的映射字段，可以是对象或list,
     *                   但是list只能有一个，因为映射最小单元是list的单位
     * @param         对象类型
     * @return
     */
    public <T, R> List<T> resultMap(List result, Class<T> cls, SFunction<T, R> fieldId, SFunction<T, R>... properties) {
        return resultMap(result, cls, SFunctionParse.resolve(fieldId), SFunctionParse.resolves(properties));
    }

    /**
     * 包装List结果集，通常指没有第一次包装对象
     *
     * @param returnResult  封装目标结果集
     * @param list          封装源对象
     * @param cls           目标对象
     * @param fieldId       主键字段
     * @param subObjFields  目标对象中的子对象 key: 属性名，value: 对象类
     * @param subListFields 目标对象中的子列表，key: 属性名，value: 子列表中的Class类
     * @param 
     * @return
     * @throws IllegalAccessException
     * @throws InstantiationException
     */
    private <T> List<T> packByList(List<T> returnResult, List list, Class<T> cls, String fieldId,
                                   Map<String, Class> subObjFields, Map<String, Class> subListFields) throws IllegalAccessException, InstantiationException {
        // 字段个数
        int size = list.size();
        // 单元素对象
        T t = null;
        Object subObj;
        // 子列表中对象
        Object listObj = null;
        // 子列表
        List<Object> 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<Object>) 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;
    }

    /**
     * 根据对象包装结果集
     *
     * @param returnResult  封装目标结果集
     * @param obj           包装源对象
     * @param cls           目标Class
     * @param fieldId       主键Id
     * @param subObjFields  目标对象中的子对象 key: 属性名，value: 对象类
     * @param subListFields 目标对象中的子列表，key: 属性名，value: 子列表中的Class类
     * @param 
     * @return
     * @throws IllegalAccessException
     * @throws InstantiationException
     */
    private <T> List<T> packByObject(List<T> returnResult, Object obj, Class<T> cls, String fieldId,
                                     Map<String, Class> subObjFields, Map<String, Class> subListFields)
            throws IllegalAccessException, InstantiationException {
        Field[] resultFields = obj.getClass().getDeclaredFields();
        // 单元素对象
        T t = null;
        Object subObj;
        // 子列表中对象
        Object listObj = null;
        // 子列表
        List<Object> 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<Object>) 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<Customer> 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<Customer> customers = k3Api.query("BD_Customer", builder, Customer.class);
        customers.forEach(System.out::println);
        // 3. 封装 Builder后
        List<Customer> customers1 = k3Api.query(Builder.builder(Customer.class)
            .select(Customer::getFCUSTID, Customer::getFName, Customer::getFCreateDate));
        customers.forEach(System.out::println);
        /**
         * 4. k3Api还封装了queryOne，count方法。
         * 5. query之后，数据可能需要映射，k3Api还封装了resultMap方法。
         *  resultMap的参数如下： 类比mybatis的结果映射
         *      @param result     query的结果集
         *      @param cls        映射对象的类
         *      @param fieldId    对象主键Id
         *      @param properties 需要映射的字段，可以是对象或list,
         *                        但是list只能有一个，因为映射最小单元是list的单位
         * 示例不介绍了。
         */
    }
}

     
    5.  
   
  

                            
                        
                    
                    
                    
    
                    
                    
                    
    
                
                
    
                    
                
    
            
        
    
    
    
        
    你可能感兴趣的:(java,开发语言,maven)
    
        
    
            
    
                
      
                    
    • Long类型前后端数据不一致
                        igotyback
前端
                        
      响应给前端的数据浏览器控制台中response中看到的Long类型的数据是正常的到前端数据不一致前后端数据类型不匹配是一个常见问题，尤其是当后端使用Java的Long类型（64位）与前端JavaScript的Number类型（最大安全整数为2^53-1，即16位）进行数据交互时，很容易出现精度丢失的问题。这是因为JavaScript中的Number类型无法安全地表示超过16位的整数。为了解决这个问
      
                    
      • 
                    
    • LocalDateTime 转 String
                        igotyback
java开发语言
                        
      importjava.time.LocalDateTime;importjava.time.format.DateTimeFormatter;publicclassMain{publicstaticvoidmain(String[]args){//获取当前时间LocalDateTimenow=LocalDateTime.now();//定义日期格式化器DateTimeFormatterformat
      
                    
      • 
                    
    • Linux下QT开发的动态库界面弹出操作（SDL2）
                        13jjyao
QT类qt开发语言sdl2linux
                        
      需求：操作系统为linux，开发框架为qt，做成需带界面的qt动态库，调用方为java等非qt程序难点：调用方为java等非qt程序，也就是说调用方肯定不带QApplication::exec()，缺少了这个，QTimer等事件和QT创建的窗口将不能弹出(包括opencv也是不能弹出)；这与qt调用本身qt库是有本质的区别的思路：1.调用方缺QApplication::exec()，那么我们在接口
      
                    
      • 
                    
    • DIV+CSS+JavaScript技术制作网页（旅游主题网页设计与制作）云南大理
                        STU学生网页设计
网页设计期末网页作业html静态网页html5期末大作业网页设计web大作业
                        
      ️精彩专栏推荐作者主页:【进入主页—获取更多源码】web前端期末大作业：【HTML5网页期末作业(1000套)】程序员有趣的告白方式：【HTML七夕情人节表白网页制作(110套)】文章目录二、网站介绍三、网站效果▶️1.视频演示2.图片演示四、网站代码HTML结构代码CSS样式代码五、更多源码二、网站介绍网站布局方面：计划采用目前主流的、能兼容各大主流浏览器、显示效果稳定的浮动网页布局结构。网站程
      
                    
      • 
                    
    • 【华为OD机试真题2023B卷 JAVA&JS】We Are A Team
                        若博豆
java算法华为javascript
                        
      华为OD2023（B卷）机试题库全覆盖，刷题指南点这里WeAreATeam时间限制：1秒|内存限制：32768K|语言限制：不限题目描述：总共有n个人在机房，每个人有一个标号（1<=标号<=n），他们分成了多个团队，需要你根据收到的m条消息判定指定的两个人是否在一个团队中，具体的：1、消息构成为：abc，整数a、b分别代
      
                    
      • 
                    
    • 关于城市旅游的HTML网页设计——(旅游风景云南 5页)HTML+CSS+JavaScript
                        二挡起步
web前端期末大作业javascripthtmlcss旅游风景
                        
      ⛵源码获取文末联系✈Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业|游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作|HTML期末大学生网页设计作业，Web大学生网页HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScrip
      
                    
      • 
                    
    • HTML网页设计制作大作业（div+css） 云南我的家乡旅游景点 带文字滚动
                        二挡起步
web前端期末大作业web设计网页规划与设计htmlcssjavascriptdreamweaver前端
                        
      Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作HTML期末大学生网页设计作业HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScript：做与用户的交互行为文章目录前端学习路线
      
                    
      • 
                    
    • node.js学习
                        小猿L
node.jsnode.js学习vim
                        
      node.js学习实操及笔记温故node.js，node.js学习实操过程及笔记~node.js学习视频node.js官网node.js中文网实操笔记githubcsdn笔记为什么学node.js可以让别人访问我们编写的网页为后续的框架学习打下基础，三大框架vuereactangular离不开node.jsnode.js是什么官网：node.js是一个开源的、跨平台的运行JavaScript的运行
      
                    
      • 
                    
    • Java 重写(Override)与重载(Overload)
                        叨唧唧的

                        
      Java重写(Override)与重载(Overload)重写(Override)重写是子类对父类的允许访问的方法的实现过程进行重新编写,返回值和形参都不能改变。即外壳不变，核心重写！重写的好处在于子类可以根据需要，定义特定于自己的行为。也就是说子类能够根据需要实现父类的方法。重写方法不能抛出新的检查异常或者比被重写方法申明更加宽泛的异常。例如：父类的一个方法申明了一个检查异常IOExceptio
      
                    
      • 
                    
    • 简单了解 JVM
                        记得开心一点啊
jvm
                        
      目录♫什么是JVM♫JVM的运行流程♫JVM运行时数据区♪虚拟机栈♪本地方法栈♪堆♪程序计数器♪方法区/元数据区♫类加载的过程♫双亲委派模型♫垃圾回收机制♫什么是JVMJVM是JavaVirtualMachine的简称，意为Java虚拟机。虚拟机是指通过软件模拟的具有完整硬件功能的、运行在一个完全隔离的环境中的完整计算机系统（如：JVM、VMwave、VirtualBox）。JVM和其他两个虚拟机
      
                    
      • 
                    
    • 1分钟解决 -bash: mvn: command not found，在Centos 7中安装Maven
                        Energet!c
开发语言
                        
      1分钟解决-bash:mvn:commandnotfound，在Centos7中安装Maven检查Java环境1下载Maven2解压Maven3配置环境变量4验证安装5常见问题与注意事项6总结检查Java环境Maven依赖Java环境，请确保系统已经安装了Java并配置了环境变量。可以通过以下命令检查：java-version如果未安装，请先安装Java。1下载Maven从官网下载：前往Apach
      
                    
      • 
                    
    • Java企业面试题3
                        马龙强_
java
                        
      1.break和continue的作用(智*图)break：用于完全退出一个循环（如for,while）或一个switch语句。当在循环体内遇到break语句时，程序会立即跳出当前循环体，继续执行循环之后的代码。continue：用于跳过当前循环体中剩余的部分，并开始下一次循环。如果是在for循环中使用continue，则会直接进行条件判断以决定是否执行下一轮循环。2.if分支语句和switch分
      
                    
      • 
                    
    • JVM、JRE和 JDK：理解Java开发的三大核心组件
                        Y雨何时停T
Javajava
                        
      Java是一门跨平台的编程语言，它的成功离不开背后强大的运行环境与开发工具的支持。在Java的生态中，JVM（Java虚拟机）、JRE（Java运行时环境）和JDK（Java开发工具包）是三个至关重要的核心组件。本文将探讨JVM、JDK和JRE的区别，帮助你更好地理解Java的运行机制。1.JVM：Java虚拟机（JavaVirtualMachine）什么是JVM？JVM，即Java虚拟机，是Ja
      
                    
      • 
                    
    • Java面试题精选：消息队列(二)
                        芒果不是芒
Java面试题精选javakafka
                        
      一、Kafka的特性1.消息持久化：消息存储在磁盘，所以消息不会丢失2.高吞吐量：可以轻松实现单机百万级别的并发3.扩展性：扩展性强，还是动态扩展4.多客户端支持：支持多种语言（Java、C、C++、GO、）5.KafkaStreams（一个天生的流处理）:在双十一或者销售大屏就会用到这种流处理。使用KafkaStreams可以快速的把销售额统计出来6.安全机制：Kafka进行生产或者消费的时候会
      
                    
      • 
                    
    • 白骑士的Java教学基础篇 2.5 控制流语句
                        白骑士所长
Java教学java开发语言
                        
      欢迎继续学习Java编程的基础篇！在前面的章节中，我们了解了Java的变量、数据类型和运算符。接下来，我们将探讨Java中的控制流语句。控制流语句用于控制程序的执行顺序，使我们能够根据特定条件执行不同的代码块，或重复执行某段代码。这是编写复杂程序的基础。通过学习这一节内容，你将掌握如何使用条件语句和循环语句来编写更加灵活和高效的代码。条件语句条件语句用于根据条件的真假来执行不同的代码块。if语句‘
      
                    
      • 
                    
    • python语法——三目运算符
                        HappyRocking
pythonpython三目运算符
                        
      在java中，有三目运算符，如：intc=(a>b)?a:b表示c取两者中的较大值。但是在python，不能直接这样使用，估计是因为冒号在python有分行的关键作用。那么在python中，如何实现类似功能呢？可以使用ifelse语句，也是一行可以完成，格式为：aifbelsec表示如果b为True，则表达式等于a，否则等于c。如：c=(aif(a>b)elseb)同样是完成了取最大值的功能。
      
                    
      • 
                    
    • spring如何整合druid连接池？
                        惜.己
springspringjunit数据库javaidea后端xml
                        
      目录spring整合druid连接池1.新建maven项目2.新建mavenModule3.导入相关依赖4.配置log4j2.xml5.配置druid.xml1)xml中如何引入properties2)下面是配置文件6.准备jdbc.propertiesJDBC配置项解释7.配置druid8.测试spring整合druid连接池1.新建maven项目打开IDE（比如IntelliJIDEA,Ecl
      
                    
      • 
                    
    • ArrayList 源码解析
                        程序猿进阶
Java基础ArrayListListjava面试性能优化架构设计idea
                        
      ArrayList是Java集合框架中的一个动态数组实现，提供了可变大小的数组功能。它继承自AbstractList并实现了List接口，是顺序容器，即元素存放的数据与放进去的顺序相同，允许放入null元素，底层通过数组实现。除该类未实现同步外，其余跟Vector大致相同。每个ArrayList都有一个容量capacity，表示底层数组的实际大小，容器内存储元素的个数不能多于当前容量。当向容器中添
      
                    
      • 
                    
    • Java爬虫框架（一）--架构设计
                        狼图腾-狼之传说
java框架java任务html解析器存储电子商务
                        
      一、架构图那里搜网络爬虫框架主要针对电子商务网站进行数据爬取，分析，存储，索引。爬虫：爬虫负责爬取，解析，处理电子商务网站的网页的内容数据库：存储商品信息索引：商品的全文搜索索引Task队列：需要爬取的网页列表Visited表：已经爬取过的网页列表爬虫监控平台：web平台可以启动，停止爬虫，管理爬虫，task队列，visited表。二、爬虫1.流程1)Scheduler启动爬虫器，TaskMast
      
                    
      • 
                    
    • Java：爬虫框架
                        dingcho
Javajava爬虫
                        
      一、ApacheNutch2【参考地址】Nutch是一个开源Java实现的搜索引擎。它提供了我们运行自己的搜索引擎所需的全部工具。包括全文搜索和Web爬虫。Nutch致力于让每个人能很容易,同时花费很少就可以配置世界一流的Web搜索引擎.为了完成这一宏伟的目标,Nutch必须能够做到:每个月取几十亿网页为这些网页维护一个索引对索引文件进行每秒上千次的搜索提供高质量的搜索结果简单来说Nutch支持分
      
                    
      • 
                    
    • python怎么将png转为tif_png转tif
                        weixin_39977276

                        
      发国外的文章要求图片是tif，cmyk色彩空间的。大小尺寸还有要求。比如网上大神多，找到了一段代码，感谢！https://www.jianshu.com/p/ec2af4311f56https://github.com/KevinZc007/image2Tifimportjava.awt.image.BufferedImage;importjava.io.File;importjava.io.Fi
      
                    
      • 
                    
    • JavaScript 中，深拷贝（Deep Copy）和浅拷贝（Shallow Copy）
                        跳房子的前端
前端面试javascript开发语言ecmascript
                        
      在JavaScript中，深拷贝（DeepCopy）和浅拷贝（ShallowCopy）是用于复制对象或数组的两种不同方法。了解它们的区别和应用场景对于避免潜在的bugs和高效地处理数据非常重要。以下是对深拷贝和浅拷贝的详细解释，包括它们的概念、用途、优缺点以及实现方式。1.浅拷贝（ShallowCopy）概念定义：浅拷贝是指创建一个新的对象或数组，其中包含了原对象或数组的基本数据类型的值和对引用数
      
                    
      • 
                    
    • JAVA·一个简单的登录窗口
                        MortalTom
java开发语言学习
                        
      文章目录概要整体架构流程技术名词解释技术细节资源概要JavaSwing是Java基础类库的一部分，主要用于开发图形用户界面（GUI）程序整体架构流程新建项目，导入sql.jar包（链接放在了文末），编译项目并运行技术名词解释一、特点丰富的组件提供了多种可视化组件，如按钮（JButton）、文本框（JTextField）、标签（JLabel）、下拉列表（JComboBox）等，可以满足不同的界面设计
      
                    
      • 
                    
    • WebMagic：强大的Java爬虫框架解析与实战
                        Aaron_945
Javajava爬虫开发语言
                        
      文章目录引言官网链接WebMagic原理概述基础使用1.添加依赖2.编写PageProcessor高级使用1.自定义Pipeline2.分布式抓取优点结论引言在大数据时代，网络爬虫作为数据收集的重要工具，扮演着不可或缺的角色。Java作为一门广泛使用的编程语言，在爬虫开发领域也有其独特的优势。WebMagic是一个开源的Java爬虫框架，它提供了简单灵活的API，支持多线程、分布式抓取，以及丰富的
      
                    
      • 
                    
    • 博客网站制作教程
                        2401_85194651
javamaven
                        
      首先就是技术框架：后端：Java+SpringBoot数据库：MySQL前端：Vue.js数据库连接：JPA(JavaPersistenceAPI)1.项目结构blog-app/├──backend/│├──src/main/java/com/example/blogapp/││├──BlogApplication.java││├──config/│││└──DatabaseConfig.java
      
                    
      • 
                    
    • 00. 这里整理了最全的爬虫框架（Java + Python）
                        有一只柴犬
爬虫系列爬虫javapython
                        
      目录1、前言2、什么是网络爬虫3、常见的爬虫框架3.1、java框架3.1.1、WebMagic3.1.2、Jsoup3.1.3、HttpClient3.1.4、Crawler4j3.1.5、HtmlUnit3.1.6、Selenium3.2、Python框架3.2.1、Scrapy3.2.2、BeautifulSoup+Requests3.2.3、Selenium3.2.4、PyQuery3.2
      
                    
      • 
                    
    • JAVA学习笔记之23种设计模式学习
                        victorfreedom
Java技术设计模式androidjava常用设计模式
                        
      博主最近买了《设计模式》这本书来学习，无奈这本书是以C++语言为基础进行说明，整个学习流程下来效率不是很高，虽然有的设计模式通俗易懂，但感觉还是没有充分的掌握了所有的设计模式。于是博主百度了一番，发现有大神写过了这方面的问题，于是博主迅速拿来学习。一、设计模式的分类总体来说设计模式分为三大类：创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。结构型模式，共七种：适配器
      
                    
      • 
                    
    • JavaScript `Map` 和 `WeakMap`详细解释
                        跳房子的前端
JavaScript原生方法javascript前端开发语言
                        
      在JavaScript中，Map和WeakMap都是用于存储键值对的数据结构，但它们有一些关键的不同之处。MapMap是一种可以存储任意类型的键值对的集合。它保持了键值对的插入顺序，并且可以通过键快速查找对应的值。Map提供了一些非常有用的方法和属性来操作这些数据对：set(key,value):将一个键值对添加到Map中。如果键已经存在，则更新其对应的值。get(key):获取指定键的值。如果键
      
                    
      • 
                    
    • 切换淘宝最新npm镜像源是
                        hai40587
npm前端node.js
                        
      切换淘宝最新npm镜像源是一个相对简单的过程，但首先需要明确当前淘宝npm镜像源的状态和最新的镜像地址。由于网络环境和服务更新，镜像源的具体地址可能会发生变化，因此，我将基于当前可获取的信息，提供一个通用的切换步骤，并附上最新的镜像地址（截至回答时）。一、了解npm镜像源npm（NodePackageManager）是JavaScript的包管理器，用于安装、更新和管理项目依赖。由于npm官方仓库
      
                    
      • 
                    
    • 【Java】已解决：java.util.concurrent.CompletionException
                        屿小夏
java开发语言
                        
      文章目录一、分析问题背景出现问题的场景代码片段二、可能出错的原因三、错误代码示例四、正确代码示例五、注意事项已解决：java.util.concurrent.CompletionException一、分析问题背景在Java并发编程中，java.util.concurrent.CompletionException是一种常见的运行时异常，通常在使用CompletableFuture进行异步计算时出现
      
                    
      • 
                                
    • ASM系列四 利用Method 组件动态注入方法逻辑
                                    lijingyao8206
字节码技术jvmAOP动态代理ASM
                                    
              这篇继续结合例子来深入了解下Method组件动态变更方法字节码的实现。通过前面一篇，知道ClassVisitor 的visitMethod()方法可以返回一个MethodVisitor的实例。那么我们也基本可以知道，同ClassVisitor改变类成员一样，MethodVIsistor如果需要改变方法成员，注入逻辑，也可以
      
                                
      • 
                                
    • java编程思想 --内部类
                                    百合不是茶
java内部类匿名内部类
                                    
      内部类;了解外部类 并能与之通信 内部类写出来的代码更加整洁与优雅 
  
1,内部类的创建  内部类是创建在类中的 
 
package com.wj.InsideClass;

/*
 * 内部类的创建
 */
public class CreateInsideClass {

	public CreateInsideClass(
      
                                
      • 
                                
    • web.xml报错
                                    crabdave
web.xml
                                    
      web.xml报错 
  
The content of element type "web-app" must match "(icon?,display- 
 name?,description?,distributable?,context-param*,filter*,filter-mapping*,listener*,servlet*,s
      
                                
      • 
                                
    • 泛型类的自定义
                                    麦田的设计者
javaandroid泛型
                                    
         为什么要定义泛型类，当类中要操作的引用数据类型不确定的时候。 
采用泛型类，完成扩展。 
  例如有一个学生类 
    
Student{
  Student(){
   System.out.println("I'm a student.....");
  }
} 
 有一个老师类 
  

      
                                
      • 
                                
    • CSS清除浮动的4中方法
                                    IT独行者
JavaScriptUIcss
                                    
      清除浮动这个问题，做前端的应该再熟悉不过了，咱是个新人，所以还是记个笔记，做个积累，努力学习向大神靠近。CSS清除浮动的方法网上一搜，大概有N多种，用过几种，说下个人感受。 
1、结尾处加空div标签 clear:both      1   2   3   4      
.div 
1 
{ 
background 
: 
#000080 
; 
border 
: 
1px   
s
      
                                
      • 
                                
    • Cygwin使用windows的jdk 配置方法
                                    _wy_
jdkwindowscygwin
                                    
      1.[vim /etc/profile] 
   JAVA_HOME="/cgydrive/d/Java/jdk1.6.0_43"  (windows下jdk路径为D:\Java\jdk1.6.0_43) 
   PATH="$JAVA_HOME/bin:${PATH}" 
   CLAS
      
                                
      • 
                                
    • linux下安装maven
                                    无量
mavenlinux安装
                                    
      Linux下安装maven(转)  1.首先到Maven官网 
下载安装文件，目前最新版本为3.0.3，下载文件为 
apache-maven-3.0.3-bin.tar.gz，下载可以使用wget命令； 
 
2.进入下载文件夹，找到下载的文件，运行如下命令解压 
  tar -xvf  apache-maven-2.2.1-bin.tar.gz  
解压后的文件夹
      
                                
      • 
                                
    • tomcat的https 配置,syslog-ng配置
                                    aichenglong
tomcathttp跳转到httpssyslong-ng配置syslog配置
                                    
      1) tomcat配置https,以及http自动跳转到https的配置 
    1)TOMCAT_HOME目录下生成密钥(keytool是jdk中的命令) 
     keytool -genkey -alias tomcat -keyalg RSA -keypass changeit -storepass changeit
      
                                
      • 
                                
    • 关于领号活动总结
                                    alafqq
活动
                                    
      关于某彩票活动的总结 
具体需求，每个用户进活动页面，领取一个号码，1000中的一个； 
活动要求 
1，随机性，一定要有随机性； 
2，最少中奖概率，如果注数为3200注，则最多中4注 
3，效率问题，（不能每个人来都产生一个随机数，这样效率不高）； 
4，支持断电（仍然从下一个开始），重启服务；（存数据库有点大材小用，因此不能存放在数据库） 
 
解决方案 
1，事先产生随机数1000个，并打
      
                                
      • 
                                
    • java数据结构 冒泡排序的遍历与排序
                                    百合不是茶
java
                                    
      java的冒泡排序是一种简单的排序规则 
  
冒泡排序的原理：  
         比较两个相邻的数，首先将最大的排在第一个，第二次比较第二个 ，此后一样； 
        针对所有的元素重复以上的步骤，除了最后一个 
  
  
例题；将int array[] 
      
                                
      • 
                                
    • JS检查输入框输入的是否是数字的一种校验方法
                                    bijian1013
js
                                    
      如下是JS检查输入框输入的是否是数字的一种校验方法： 
<form method=post target="_blank">
   数字：<input type="text" name=num onkeypress="checkNum(this.form)"><br>
</form>

      
                                
      • 
                                
    • Test注解的两个属性：expected和timeout
                                    bijian1013
javaJUnitexpectedtimeout
                                    
      JUnit4：Test文档中的解释： 
　　The Test annotation supports two optional parameters. 
　　The first, expected, declares that a test method should throw an exception. 
　　If it doesn't throw an exception or if it 
      
                                
      • 
                                
    • [Gson二]继承关系的POJO的反序列化
                                    bit1129
POJO
                                    
      父类 
  
  
package inheritance.test2;

import java.util.Map;

public class Model {
    private String field1;
    private String field2;

    private Map<String, String> infoMap
      
                                
      • 
                                
    • 【Spark八十四】Spark零碎知识点记录
                                    bit1129
spark
                                    
      1. ShuffleMapTask的shuffle数据在什么地方记录到MapOutputTracker中的 
ShuffleMapTask的runTask方法负责写数据到shuffle map文件中。当任务执行完成成功，DAGScheduler会收到通知，在DAGScheduler的handleTaskCompletion方法中完成记录到MapOutputTracker中 
  
   
      
                                
      • 
                                
    • WAS各种脚本作用大全
                                    ronin47
WAS 脚本
                                    
      　　　http://www.ibm.com/developerworks/cn/websphere/library/samples/SampleScripts.html 
　　　无意中，在WAS官网上发现的各种脚本作用，感觉很有作用，先与各位分享一下 
　　　 
获取下载 
这些示例 jacl 和 Jython 脚本可用于在 WebSphere Application Server 的不同版本中自
      
                                
      • 
                                
    • java-12.求 1+2+3+..n不能使用乘除法、 for 、 while 、 if 、 else 、 switch 、 case 等关键字以及条件判断语句
                                    bylijinnan
switch
                                    
      借鉴网上的思路，用java实现： 
 




public class NoIfWhile {

	/**
	 * @param args
	 * 
	 * find x=1+2+3+....n
	 */
	public static void main(String[] args) {
		int n=10;
		int re=find(n);
		System.o
      
                                
      • 
                                
    • Netty源码学习-ObjectEncoder和ObjectDecoder
                                    bylijinnan
javanetty
                                    
      Netty中传递对象的思路很直观： 
Netty中数据的传递是基于ChannelBuffer（也就是byte[]）； 
那把对象序列化为字节流，就可以在Netty中传递对象了 
相应的从ChannelBuffer恢复对象，就是反序列化的过程 
 
Netty已经封装好ObjectEncoder和ObjectDecoder 
 
先看ObjectEncoder 
ObjectEncoder是往外发送
      
                                
      • 
                                
    • spring 定时任务中cronExpression表达式含义
                                    chicony
cronExpression
                                    
      一个cron表达式有6个必选的元素和一个可选的元素，各个元素之间是以空格分隔的，从左至右，这些元素的含义如下表所示： 
代表含义            是否必须 允许的取值范围         &nb
      
                                
      • 
                                
    • Nutz配置Jndi
                                    ctrain
JNDI
                                    
      1、使用JNDI获取指定资源： 
 

var ioc = {
    dao : {
        type :"org.nutz.dao.impl.NutDao",
        args : [ {jndi :"jdbc/dataSource"} ]
    }
}
 
以上方法,仅需要在容器中配置好数据源,注入到NutDao即可. 
      
                                
      • 
                                
    • 解决 /bin/sh^M: bad interpreter: No such file or directory
                                    daizj
shell
                                    
      在Linux中执行.sh脚本，异常/bin/sh^M: bad interpreter: No such file or directory。 
  
分析：这是不同系统编码格式引起的：在windows系统中编辑的.sh文件可能有不可见字符，所以在Linux系统下执行会报以上异常信息。 
解决： 
1）在windows下转换： 
利用一些编辑器如UltraEdit或EditPlus等工具
      
                                
      • 
                                
    • [转]for 循环为何可恨？
                                    dcj3sjt126com
程序员读书
                                    
        
Java的闭包(Closure)特征最近成为了一个热门话题。 一些精英正在起草一份议案，要在Java将来的版本中加入闭包特征。 然而，提议中的闭包语法以及语言上的这种扩充受到了众多Java程序员的猛烈抨击。 
不久前，出版过数十本编程书籍的大作家Elliotte Rusty Harold发表了对Java中闭包的价值的质疑。 尤其是他问道“for 循环为何可恨？”[http://ju
      
                                
      • 
                                
    • Android实用小技巧
                                    dcj3sjt126com
android
                                    
      1、去掉所有Activity界面的标题栏 
　　修改AndroidManifest.xml 　　在application 标签中添加android:theme="@android:style/Theme.NoTitleBar" 
  
2、去掉所有Activity界面的TitleBar 和StatusBar  
　　修改AndroidManifes
      
                                
      • 
                                
    • Oracle 复习笔记之序列
                                    eksliang
Oracle 序列sequenceOracle sequence
                                    
      转载请出自出处：http://eksliang.iteye.com/blog/2098859 
1.序列的作用 
 
 序列是用于生成唯一、连续序号的对象 
 一般用序列来充当数据库表的主键值 
 
2.创建序列语法如下： 
  
create sequence s_emp
start with 1      --开始值
increment by 1    --増长值
maxval
      
                                
      • 
                                
    • 有“品”的程序员
                                    gongmeitao
工作
                                    
      完美程序员的10种品质　　 
  
 完美程序员的每种品质都有一个范围，这个范围取决于具体的问题和背景。没有能解决所有问题的 
  
完美程序员（至少在我们这个星球上），并且对于特定问题，完美程序员应该具有以下品质： 
　　1. 才智非凡- 能够理解问题、能够用清晰可读的代码翻译并表达想法、善于分析并且逻辑思维能力强 
  
（范围：用简单方式解决复杂问题）　　 
 
      
                                
      • 
                                
    • 使用KeleyiSQLHelper类进行分页查询
                                    hvt
sql.netC#asp.nethovertree
                                    
      本文适用于sql server单主键表或者视图进行分页查询，支持多字段排序。KeleyiSQLHelper类的最新代码请到http://hovertree.codeplex.com/SourceControl/latest下载整个解决方案源代码查看。或者直接在线查看类的代码：http://hovertree.codeplex.com/SourceControl/latest#HoverTree.D
      
                                
      • 
                                
    • SVG 教程 （三）圆形，椭圆，直线
                                    天梯梦
svg
                                    
      SVG <circle>   SVG 圆形 - <circle> 
<circle> 标签可用来创建一个圆： 
下面是SVG代码： 
<svg xmlns="http://www.w3.org/2000/svg" version="1.1">
  <circle cx="100" c
      
                                
      • 
                                
    • 链表栈
                                    luyulong
java数据结构
                                    
      
public class Node {
	private Object object;
	private Node next;

	public Node() {
		this.next = null;
		this.object = null;
	}

	public Object getObject() {
		return object;
	}

	public
      
                                
      • 
                                
    • 基础数据结构和算法十：2-3 search tree
                                    sunwinner
Algorithm2-3 search tree
                                    
        
Binary search tree works well for a wide variety of applications, but they have poor worst-case performance. Now we introduce a type of binary search tree where costs are guaranteed to be loga
      
                                
      • 
                                
    • spring配置定时任务
                                    stunizhengjia
springtimer
                                    
      最近因工作的需要，用到了spring的定时任务的功能,觉得spring还是很智能化的,只需要配置一下配置文件就可以了,在此记录一下，以便以后用到： 
  
  
//------------------------定时任务调用的方法------------------------------
    /**
     * 存储过程定时器
    */
    publi
      
                                
      • 
                                
    • ITeye 8月技术图书有奖试读获奖名单公布
                                    ITeye管理员
活动
                                    
      ITeye携手博文视点举办的8月技术图书有奖试读活动已圆满结束，非常感谢广大用户对本次活动的关注与参与。 
 
 
8月试读活动回顾： 
http://webmaster.iteye.com/blog/2102830 
 
 
本次技术图书试读活动的优秀奖获奖名单及相应作品如下（优秀文章有很多，但名额有限，没获奖并不代表不优秀）： 
 
 
《跨终端Web》 
 
 
 
 gleams：http
      
                                
      •