指令数据采集（三）--Instruction 指令对象的创建

Instruction指令的实现

public class Instruction implements Cloneable {
    private static final String COMMAND_SPLITE="\\?";
    private static final String COMMAND_EMPTY=" ";
    //父指令ID
    private String parentInstId;
    //指令和指令关联的ID
    private String relaId;
    //指令ID
    private String instId;
    //指令
    private String instNo;
    private String instName;
    private int instType;
    //关联的接口ID
    private String relaIntfOjbId;
    //指令输入
    private List<Param> paramsInput;
    //指令输出 每次发送指令的时候 需要这边设置 paramKey 用来表示需要解释的结果
    private List<Param> paramsOutput;
    //上一条指令的输出 被分配到当前的指令当中的值
    private List<Param> paramOutputParent;
    private List<List<Param>> listsOutputResult;
    private List<InstructionRelaParam> instructionRelaParamList;
    //关联的指令
    private List<Instruction> children;
    //指令所在的位置
    private Integer seq;

    //当前的指令是否执行 指令默认执行
    private boolean isRun = true;
    private String woId;
    public List<Instruction> getChildren() {
        return children;
    }

    public void setChildren(List<Instruction> children) {
        this.children = children;
    }

    public String getInstId() {
        return instId;
    }

    public void setInstId(String instId) {
        this.instId = instId;
    }

    public String getInstNo() {
        return instNo;
    }

    public void setInstNo(String instNo) {
        this.instNo = instNo;
    }

    public List<Param> getParamsInput() {
        return paramsInput;
    }

    public void setParamsInput(List<Param> paramsInput) {
        this.paramsInput = paramsInput;
    }

    public List<Param> getParamsOutput() {
        return paramsOutput;
    }

    public void setParamsOutput(List<Param> paramsOutput) {
        this.paramsOutput = paramsOutput;
    }

    public Integer getSeq() {
        return seq;
    }

    public void setSeq(Integer seq) {
        this.seq = seq;
    }


    public List<InstructionRelaParam> getInstructionRelaParamList() {
        return instructionRelaParamList;
    }

    public void setInstructionRelaParamList(List<InstructionRelaParam> instructionRelaParamList) {
        this.instructionRelaParamList = instructionRelaParamList;
    }

    public String getInstName() {
        return instName;
    }

    public void setInstName(String instName) {
        this.instName = instName;
    }

    public int getInstType() {
        return instType;
    }

    public void setInstType(int instType) {
        this.instType = instType;
    }

    public boolean isRun() {
        return isRun;
    }

    public void setIsRun(boolean isRun) {
        this.isRun = isRun;
    }

    public String getRelaId() {
        return relaId;
    }

    public void setRelaId(String relaId) {
        this.relaId = relaId;
    }

    public String getWoId() {
        return woId;
    }

    public void setWoId(String woId) {
        this.woId = woId;
    }

    /**
     * 该接口用于获得参数的数组 解析数据
     * @return
     */
    public String[] getOutputParamKeys() {
        String [] parmkesString = null;
        if (this.paramsOutput != null && !this.paramsOutput.isEmpty()) {
            parmkesString = new String[this.paramsOutput.size()];
            for (int i = 0; i < this.paramsOutput.size(); i++) {
                if (this.paramsOutput.get(i) != null) {
                    ParamKey paramKey = this.paramsOutput.get(i).getParamKey();
                    parmkesString[i] = paramKey.getKeyDesc();
                }
            }
        }else {
            //没有分割 长度是1 一条也是一个数据
            parmkesString = new String[1];
        }
        return parmkesString;
    }

    /**
     * 获得输入的指令 同时解析 ？ 进行替换
     * @return
     */
    public String getInputInstruction() {
        if (this.paramsInput != null && !this.paramsInput.isEmpty()) {
            //首先拆分命令
            String[] stringArray = this.getInstNo().split(this.COMMAND_SPLITE);
            StringBuffer stringBuffer = new StringBuffer();
            //拼接命令第一个值
            stringBuffer.append(stringArray[0]);
//            stringBuffer.append(this.COMMAND_EMPTY);
            //这边不应该是直接拼接上一个命令的入参
            for (int start = 0; start < this.paramsInput.size(); start++) {
                Param param = this.paramsInput.get(start);
                ParamValue paramValue = param.getParamValue();
                stringBuffer.append(paramValue.getValue());
                //增加第二个
                if (start + 1 < stringArray.length) {
                    stringBuffer.append(stringArray[start + 1]);
//                    stringBuffer.append(this.COMMAND_EMPTY);
                }
            }
            return stringBuffer.toString();
        } else {
            return this.instNo;
        }
    }

    @Override
    public Instruction clone() throws CloneNotSupportedException {
        Instruction instruction = (Instruction)(super.clone());
        //
        if(this.paramsInput!=null) {
            List<Param> paramInput = this.paramsInput;
            List<Param> paramListInputColone = new ArrayList<Param>();
            for (Param param : paramInput) {
                paramListInputColone.add(param.clone());
            }
            instruction.setParamsInput(paramListInputColone);
        }
        //
        if(StringUtils.isNotBlank(this.getInstId())) {
            instruction.setInstId(new String(this.getInstId()));
        }else {
            instruction.setInstId("");
        }
        if(StringUtils.isNotBlank(this.getInstNo())) {
            instruction.setInstNo(new String(this.getInstNo()));
        }else {
            instruction.setInstNo("");
        }
        if(StringUtils.isNotBlank(this.getInstName())) {
            instruction.setInstName(new String(this.getInstName()));
        }else {
            instruction.setInstName("");
        }
        instruction.setInstType(this.getInstType());
        if(StringUtils.isNotBlank(this.getRelaIntfOjbId())) {
            instruction.setRelaIntfOjbId(new String(this.getRelaIntfOjbId()));
        }else {
            instruction.setRelaIntfOjbId("");
        }

        if(StringUtils.isNotBlank(this.getParentInstId())) {
            instruction.setParentInstId(new String(this.getParentInstId()));
        }else {
            instruction.setParentInstId("");
        }

        if(StringUtils.isNotBlank(this.getRelaId())){
            instruction.setRelaId(new String(this.getRelaId()));
        }else {
            instruction.setRelaId("");
        }
        //
        if(this.paramsOutput!=null) {
            List<Param> paramOuput = this.paramsOutput;
            List<Param> paramListOutputColone = new ArrayList<Param>();
            for (Param param : paramOuput) {
                paramListOutputColone.add(param.clone());
            }
            instruction.setParamsOutput(paramListOutputColone);
        }
        //
        if(this.instructionRelaParamList!=null) {
            List<InstructionRelaParam> instructionRelaParamList = this.instructionRelaParamList;
            List<InstructionRelaParam> instructionRelaParamListColone = new ArrayList<InstructionRelaParam>();
            for (InstructionRelaParam instructionRelaParam : instructionRelaParamList) {
                instructionRelaParamListColone.add(instructionRelaParam.clone());
            }
            instruction.setInstructionRelaParamList(instructionRelaParamListColone);
        }
        //
        if(this.children!=null) {
            List<Instruction> relaInstructions = this.children;
            List<Instruction> relaInstructionsColone = new ArrayList<Instruction>();
            for (Instruction instruction1 : relaInstructions) {
                relaInstructionsColone.add(instruction1.clone());
            }
            instruction.setChildren(relaInstructionsColone);
        }
        //
        if(this.seq!=null) {
            instruction.setSeq(new Integer(this.seq));
        }else {
            instruction.setSeq(new Integer(-1));
        }
        // 是否执行
        instruction.setIsRun(this.isRun);
        //被分配的条件
        if(this.paramOutputParent!=null&&!this.paramOutputParent.isEmpty()){
            List<Param> paramList = new ArrayList<Param>();
            for(Param param:this.getParamOutputParent()){
                paramList.add(param.clone());
            }
            instruction.setParamOutputParent(paramList);
        }
        return instruction;
    }

    public List<Param> getParamOutputParent() {
        return paramOutputParent;
    }

    public void setParamOutputParent(List<Param> paramOutputParent) {
        this.paramOutputParent = paramOutputParent;
    }

    public String getRelaIntfOjbId() {
        return relaIntfOjbId;
    }

    public void setRelaIntfOjbId(String relaIntfOjbId) {
        this.relaIntfOjbId = relaIntfOjbId;
    }

    public String getParentInstId() {
        return parentInstId;
    }

    public void setParentInstId(String parentInstId) {
        this.parentInstId = parentInstId;
    }

    public List<List<Param>> getListsOutputResult() {
        return listsOutputResult;
    }

    public void setListsOutputResult(List<List<Param>> listsOutputResult) {
        this.listsOutputResult = listsOutputResult;
    }

    @Override
    public String toString() {
        return "Instruction{" +
                "parentInstId='" + parentInstId + '\'' +
                ", instId='" + instId + '\'' +
                ", instNo='" + instNo + '\'' +
                ", instName='" + instName + '\'' +
                ", instType=" + instType +
                ", relaIntfOjbId='" + relaIntfOjbId + '\'' +
                ", paramsInput=" + paramsInput +
                ", paramsOutput=" + paramsOutput +
                ", listsOutputResult=" + listsOutputResult +
                ", instructionRelaParamList=" + instructionRelaParamList +
                ", children=" + children +
                ", seq=" + seq +
                '}';
    }
}

Instruction指令比较重要的属性有

1.父指令ID（private String parentInstId）

2.指令的出入参数（private List<Param> paramsInput）

3.指令的出参（private List<Param> paramsOutput），被分配到当前指令的结果，也就是父指令的执行，经过复制创建的子指令，同于前一个篇幅说明的Param对象

4.分配的不同的入参（private List<Param> paramOutputParent）

5.当前指令的执行结果设置（private List<List<Param>> listsOutputResult），当前的执行结果也会封装成一个Param进行处理

6.子指令 （private List<Instruction> children） 用来存储子指令

7.是否执行，通过条件判断 默认执行（private boolean isRun = true）

8.获得指令，用于真正执行指令的时候进行调用处理的

public String getInputInstruction() {
        if (this.paramsInput != null && !this.paramsInput.isEmpty()) {
            //首先拆分命令
            String[] stringArray = this.getInstNo().split(this.COMMAND_SPLITE);
            StringBuffer stringBuffer = new StringBuffer();
            //拼接命令第一个值
            stringBuffer.append(stringArray[0]);
//            stringBuffer.append(this.COMMAND_EMPTY);
            //这边不应该是直接拼接上一个命令的入参
            for (int start = 0; start < this.paramsInput.size(); start++) {
                Param param = this.paramsInput.get(start);
                ParamValue paramValue = param.getParamValue();
                stringBuffer.append(paramValue.getValue());
                //增加第二个
                if (start + 1 < stringArray.length) {
                    stringBuffer.append(stringArray[start + 1]);
//                    stringBuffer.append(this.COMMAND_EMPTY);
                }
            }
            return stringBuffer.toString();
        } else {
            return this.instNo;
        }
    }

数据库当中对于指令的入参使用的是？来进行表示的，在动态执行的时候，把需要的入参数据替换？进行处理