指令数据采集（二）--Instruction 指令对象的实现

1.指令对象需要实现Cloneable接口，来保证每条指令都可以进行拷贝

2.同时指令对象需要有个包含本身的属性，需要能够存储子指令对象能够存储子指令

3.指令对象需要输入，输出参数的属性，保存当前的指令结果，指令的出参和入参也需要实现Cloneable接口，因为指令在复制的时候，属性也需要进行复制创建

下面开始进行代码实现

1.出入参数的设置

 

public class Param implements Cloneable{
    /**
     * 参数的关键字
     */
    private ParamKey paramKey;
    /**
     * 参数值
     */
    private ParamValue paramValue;

    public Param(){}
    public ParamKey getParamKey() {
        return paramKey;
    }

    public void setParamKey(ParamKey paramKey) {
        this.paramKey = paramKey;
    }

    public ParamValue getParamValue() {
        return paramValue;
    }

    public void setParamValue(ParamValue paramValue) {
        this.paramValue = paramValue;
    }


    @Override
    public Param clone() throws CloneNotSupportedException {
        Param param = (Param)(super.clone());
        if(this.paramValue!=null) {
            param.setParamValue(this.paramValue.clone());
        }
        if(this.paramKey!=null) {
            param.setParamKey(this.paramKey.clone());
        }
        return param;
    }

    @Override
    public String toString() {
        return "Param{" +
                "paramKey=" + paramKey +
                ", paramValue=" + paramValue +
                '}';
    }
}

2.出入参数的ParamKey ParamValue 对象的封装

类似于一种Key Value的方式，但是需要封装条件进行判断，并且需要将数据插入到对应的表和字段当中，所以这边还需要进行封装

public class ParamKey implements Cloneable{
    private String keyId;
    private String keyDesc;
    private String keyName;
    private Integer keySeq;
    //关联的指令ID
    private String relaInstId;
    /**
     * 指令关联的插入的列的ID
     */
    private String relaColumnId;
    private String relaColumnNo;
    private String tableNo;

    /**
     * 条件判断 的记录
     * 作为指令的上下入参的使用
     */
    /**
     * 是否是条件
     */
    public boolean isCondition;
    /**
     * 返回值枚举
     */
    public ConValueEnum conValueType;

    public ParamKey(){}
    public String getKeyId() {
        return keyId;
    }

    public void setKeyId(String keyId) {
        this.keyId = keyId;
    }

    public String getKeyDesc() {
        return keyDesc;
    }

    public void setKeyDesc(String keyDesc) {
        this.keyDesc = keyDesc;
    }

    public String getKeyName() {
        return keyName;
    }

    public void setKeyName(String keyName) {
        this.keyName = keyName;
    }

    public Integer getKeySeq() {
        return keySeq;
    }

    public void setKeySeq(Integer keySeq) {
        this.keySeq = keySeq;
    }

    public String getRelaInstId() {
        return relaInstId;
    }

    public void setRelaInstId(String relaInstId) {
        this.relaInstId = relaInstId;
    }

    @Override
    protected ParamKey clone() throws CloneNotSupportedException {
        ParamKey paramKey = (ParamKey)(super.clone());
        if(StringUtils.isNotBlank(keyId)) {
            paramKey.setKeyId(new String(this.keyId));
        }else {
            paramKey.setKeyId("");
        }
        if(StringUtils.isNotBlank(this.keyName)) {
            paramKey.setKeyName(new String(this.keyName));
        }else {
            paramKey.setKeyName("");
        }
        if(StringUtils.isNotBlank(this.keyDesc)) {
            paramKey.setKeyDesc(new String(this.keyDesc));
        }else {
            paramKey.setKeyDesc("");
        }
        if(this.keySeq!=null) {
            paramKey.setKeySeq(new Integer(this.keySeq));
        }else {
            paramKey.setKeySeq(new Integer(-1));
        }
        if(StringUtils.isNotBlank(this.relaInstId)){
            paramKey.setKeyDesc(new String(this.relaInstId));
        }else {
            paramKey.setRelaInstId("");
        }
        if(StringUtils.isNotBlank(this.relaColumnId)){
            paramKey.setRelaColumnId(new String(this.relaColumnId));
        }else {
            paramKey.setRelaColumnId("");
        }
        if(StringUtils.isNotBlank(this.relaColumnNo)){
            paramKey.setRelaColumnId(new String(this.relaColumnNo));
        }else {
            paramKey.setRelaColumnId("");
        }
        if(StringUtils.isNotBlank(this.tableNo)){
            paramKey.setTableNo(new String(this.tableNo));
        }else {
            paramKey.setRelaColumnId("");
        }
        if(this.isCondition){
            paramKey.setIsCondition(new Boolean(this.isCondition));
        }
        
        if(this.getConValueType()!=null){
            paramKey.setConValueType(this.getConValueType());
        }
        return paramKey;
    }

    public String getRelaColumnId() {
        return relaColumnId;
    }

    public void setRelaColumnId(String relaColumnId) {
        this.relaColumnId = relaColumnId;
    }

    public String getRelaColumnNo() {
        return relaColumnNo;
    }

    public void setRelaColumnNo(String relaColumnNo) {
        this.relaColumnNo = relaColumnNo;
    }

    public String getTableNo() {
        return tableNo;
    }

    public void setTableNo(String tableNo) {
        this.tableNo = tableNo;
    }

    public boolean isCondition() {
        return isCondition;
    }

    public void setIsCondition(boolean isCondition) {
        this.isCondition = isCondition;
    }

    public ConValueEnum getConValueType() {
        return conValueType;
    }

    public void setConValueType(ConValueEnum conValueType) {
        this.conValueType = conValueType;
    }

    @Override
    public String toString() {
        return "ParamKey{" +
                "keyId='" + keyId + '\'' +
                ", keyDesc='" + keyDesc + '\'' +
                ", keyName='" + keyName + '\'' +
                ", keySeq=" + keySeq +
                ", relaInstId='" + relaInstId + '\'' +
                ", relaColumnId='" + relaColumnId + '\'' +
                ", relaColumnNo='" + relaColumnNo + '\'' +
                ", tableNo='" + tableNo + '\'' +
                '}';
    }
}

public class ParamValue implements Cloneable{
    private String valueId;
    private String value;
    public ParamValue(){}
    public String getValueId() {
        return valueId;
    }

    public void setValueId(String valueId) {
        this.valueId = valueId;
    }

    public String getValue() {
        return value;
    }

    public void setValue(String value) {
        this.value = value;
    }

    @Override
    public ParamValue clone() throws CloneNotSupportedException{
        ParamValue paramValue = (ParamValue)(super.clone());
        if(StringUtils.isNotBlank(valueId)) {
            paramValue.setValueId(new String(valueId));
        }else {
            paramValue.setValueId("");
        }
        if(StringUtils.isNotBlank(value)) {
            paramValue.setValue(new String(value));
        }else {
            paramValue.setValue("");
        }
        return paramValue;
    }
    @Override
    public String toString() {
        return "ParamValue{" +
                "valueId='" + valueId + '\'' +
                ", value='" + value + '\'' +
                '}';
    }
}

ParamKey 定义的时候，需要关联的指令，关联的表，关联的表字段，关联的表和字段用于数据的插入，插入到配置好的表字段当中。是否是条件进行判断以及返回值的枚举，用于条件判断枚举类型存到数据库当中的字典值进行判断，正则则可以通过正则表达式来进行处理

public  enum  ConValueEnum {
    /**
     * 判断的值为正则表达式
     */
    REG("2002","REG"),
    /**
     * 判断的值为枚举类型
     */
    ENUM("2001","ENUM");
    private String conValueTypeDesc;
    private String conValueTypeNo;
    ConValueEnum(String conValueTypeNo,String conValueTypeDesc){
        this.conValueTypeDesc = conValueTypeDesc;
        this.conValueTypeNo = conValueTypeNo;
    }

    public String getConValueTypeDesc() {
        return conValueTypeDesc;
    }

    public String getConValueTypeNo() {
        return conValueTypeNo;
    }

    @Override
    public String toString() {
        return "ConValueEnum{" +
                "conValueTypeDesc='" + conValueTypeDesc + '\'' +
                ", conValueTypeNo='" + conValueTypeNo + '\'' +
                '}';
    }
}