管道灾源

modelsrc/com/miniframe/model/system/DNodeVal.java

@@ -0,0 +1,211 @@
+package com.miniframe.model.system;
+
+import com.miniframe.system.MiniserviceBaseModel;
+import java.io.Serializable;
+import javax.persistence.*;
+
+@Table(name = "d_node_val")
+public class DNodeVal extends MiniserviceBaseModel implements Serializable {
+    @Id
+    private Integer id;
+
+    /**
+     * node Id
+     */
+    private Integer nid;
+
+    /**
+     * 事故编号
+     */
+    private Integer aid;
+
+    /**
+     * 水位
+     */
+    private Float val1;
+
+    /**
+     * 温度
+     */
+    private Float val2;
+
+    /**
+     * so2浓度
+     */
+    private Float val3;
+
+    /**
+     * co2浓度
+     */
+    private Float val4;
+
+    /**
+     * 名称
+     */
+    private String nname;
+
+    /**
+     * 类型
+     */
+    private String ntype;
+
+    private static final long serialVersionUID = 1L;
+
+    /**
+     * @return id
+     */
+    public Integer getId() {
+        return id;
+    }
+
+    /**
+     * @param id
+     */
+    public void setId(Integer id) {
+        this.id = id;
+    }
+
+    /**
+     * 获取node Id
+     *
+     * @return nid - node Id
+     */
+    public Integer getNid() {
+        return nid;
+    }
+
+    /**
+     * 设置node Id
+     *
+     * @param nid node Id
+     */
+    public void setNid(Integer nid) {
+        this.nid = nid;
+    }
+
+    /**
+     * 获取事故编号
+     *
+     * @return aid - 事故编号
+     */
+    public Integer getAid() {
+        return aid;
+    }
+
+    /**
+     * 设置事故编号
+     *
+     * @param aid 事故编号
+     */
+    public void setAid(Integer aid) {
+        this.aid = aid;
+    }
+
+    /**
+     * 获取水位
+     *
+     * @return val1 - 水位
+     */
+    public Float getVal1() {
+        return val1;
+    }
+
+    /**
+     * 设置水位
+     *
+     * @param val1 水位
+     */
+    public void setVal1(Float val1) {
+        this.val1 = val1;
+    }
+
+    /**
+     * 获取温度
+     *
+     * @return val2 - 温度
+     */
+    public Float getVal2() {
+        return val2;
+    }
+
+    /**
+     * 设置温度
+     *
+     * @param val2 温度
+     */
+    public void setVal2(Float val2) {
+        this.val2 = val2;
+    }
+
+    /**
+     * 获取so2浓度
+     *
+     * @return val3 - so2浓度
+     */
+    public Float getVal3() {
+        return val3;
+    }
+
+    /**
+     * 设置so2浓度
+     *
+     * @param val3 so2浓度
+     */
+    public void setVal3(Float val3) {
+        this.val3 = val3;
+    }
+
+    /**
+     * 获取co2浓度
+     *
+     * @return val4 - co2浓度
+     */
+    public Float getVal4() {
+        return val4;
+    }
+
+    /**
+     * 设置co2浓度
+     *
+     * @param val4 co2浓度
+     */
+    public void setVal4(Float val4) {
+        this.val4 = val4;
+    }
+
+    /**
+     * 获取名称
+     *
+     * @return nname - 名称
+     */
+    public String getNname() {
+        return nname;
+    }
+
+    /**
+     * 设置名称
+     *
+     * @param nname 名称
+     */
+    public void setNname(String nname) {
+        this.nname = nname == null ? null : nname.trim();
+    }
+
+    /**
+     * 获取类型
+     *
+     * @return ntype - 类型
+     */
+    public String getNtype() {
+        return ntype;
+    }
+
+    /**
+     * 设置类型
+     *
+     * @param ntype 类型
+     */
+    public void setNtype(String ntype) {
+        this.ntype = ntype == null ? null : ntype.trim();
+    }
+}

modelsrc/com/miniframe/model/system/DNodeValSQLBuilder.java

@@ -0,0 +1,760 @@
+package com.miniframe.model.system;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class DNodeValSQLBuilder {
+    protected String orderByClause;
+
+    protected boolean distinct;
+
+    protected List<Criteria> oredCriteria;
+
+    public DNodeValSQLBuilder() {
+        oredCriteria = new ArrayList<Criteria>();
+    }
+
+    public void setOrderByClause(String orderByClause) {
+        this.orderByClause = orderByClause;
+    }
+
+    public String getOrderByClause() {
+        return orderByClause;
+    }
+
+    public void setDistinct(boolean distinct) {
+        this.distinct = distinct;
+    }
+
+    public boolean isDistinct() {
+        return distinct;
+    }
+
+    public List<Criteria> getOredCriteria() {
+        return oredCriteria;
+    }
+
+    public void or(Criteria criteria) {
+        oredCriteria.add(criteria);
+    }
+
+    public Criteria or() {
+        Criteria criteria = createCriteriaInternal();
+        oredCriteria.add(criteria);
+        return criteria;
+    }
+
+    public Criteria createCriteria() {
+        Criteria criteria = createCriteriaInternal();
+        if (oredCriteria.size() == 0) {
+            oredCriteria.add(criteria);
+        }
+        return criteria;
+    }
+
+    protected Criteria createCriteriaInternal() {
+        Criteria criteria = new Criteria();
+        return criteria;
+    }
+
+    public void clear() {
+        oredCriteria.clear();
+        orderByClause = null;
+        distinct = false;
+    }
+
+    protected abstract static class GeneratedCriteria {
+        protected List<Criterion> criteria;
+
+        protected GeneratedCriteria() {
+            super();
+            criteria = new ArrayList<Criterion>();
+        }
+
+        public boolean isValid() {
+            return criteria.size() > 0;
+        }
+
+        public List<Criterion> getAllCriteria() {
+            return criteria;
+        }
+
+        public List<Criterion> getCriteria() {
+            return criteria;
+        }
+
+        protected void addCriterion(String condition) {
+            if (condition == null) {
+                throw new RuntimeException("Value for condition cannot be null");
+            }
+            criteria.add(new Criterion(condition));
+        }
+
+        protected void addCriterion(String condition, Object value, String property) {
+            if (value == null) {
+                throw new RuntimeException("Value for " + property + " cannot be null");
+            }
+            criteria.add(new Criterion(condition, value));
+        }
+
+        protected void addCriterion(String condition, Object value1, Object value2, String property) {
+            if (value1 == null || value2 == null) {
+                throw new RuntimeException("Between values for " + property + " cannot be null");
+            }
+            criteria.add(new Criterion(condition, value1, value2));
+        }
+
+        public Criteria andIdIsNull() {
+            addCriterion("id is null");
+            return (Criteria) this;
+        }
+
+        public Criteria andIdIsNotNull() {
+            addCriterion("id is not null");
+            return (Criteria) this;
+        }
+
+        public Criteria andIdEqualTo(Integer value) {
+            addCriterion("id =", value, "id");
+            return (Criteria) this;
+        }
+
+        public Criteria andIdNotEqualTo(Integer value) {
+            addCriterion("id <>", value, "id");
+            return (Criteria) this;
+        }
+
+        public Criteria andIdGreaterThan(Integer value) {
+            addCriterion("id >", value, "id");
+            return (Criteria) this;
+        }
+
+        public Criteria andIdGreaterThanOrEqualTo(Integer value) {
+            addCriterion("id >=", value, "id");
+            return (Criteria) this;
+        }
+
+        public Criteria andIdLessThan(Integer value) {
+            addCriterion("id <", value, "id");
+            return (Criteria) this;
+        }
+
+        public Criteria andIdLessThanOrEqualTo(Integer value) {
+            addCriterion("id <=", value, "id");
+            return (Criteria) this;
+        }
+
+        public Criteria andIdIn(List<Integer> values) {
+            addCriterion("id in", values, "id");
+            return (Criteria) this;
+        }
+
+        public Criteria andIdNotIn(List<Integer> values) {
+            addCriterion("id not in", values, "id");
+            return (Criteria) this;
+        }
+
+        public Criteria andIdBetween(Integer value1, Integer value2) {
+            addCriterion("id between", value1, value2, "id");
+            return (Criteria) this;
+        }
+
+        public Criteria andIdNotBetween(Integer value1, Integer value2) {
+            addCriterion("id not between", value1, value2, "id");
+            return (Criteria) this;
+        }
+
+        public Criteria andNidIsNull() {
+            addCriterion("nid is null");
+            return (Criteria) this;
+        }
+
+        public Criteria andNidIsNotNull() {
+            addCriterion("nid is not null");
+            return (Criteria) this;
+        }
+
+        public Criteria andNidEqualTo(Integer value) {
+            addCriterion("nid =", value, "nid");
+            return (Criteria) this;
+        }
+
+        public Criteria andNidNotEqualTo(Integer value) {
+            addCriterion("nid <>", value, "nid");
+            return (Criteria) this;
+        }
+
+        public Criteria andNidGreaterThan(Integer value) {
+            addCriterion("nid >", value, "nid");
+            return (Criteria) this;
+        }
+
+        public Criteria andNidGreaterThanOrEqualTo(Integer value) {
+            addCriterion("nid >=", value, "nid");
+            return (Criteria) this;
+        }
+
+        public Criteria andNidLessThan(Integer value) {
+            addCriterion("nid <", value, "nid");
+            return (Criteria) this;
+        }
+
+        public Criteria andNidLessThanOrEqualTo(Integer value) {
+            addCriterion("nid <=", value, "nid");
+            return (Criteria) this;
+        }
+
+        public Criteria andNidIn(List<Integer> values) {
+            addCriterion("nid in", values, "nid");
+            return (Criteria) this;
+        }
+
+        public Criteria andNidNotIn(List<Integer> values) {
+            addCriterion("nid not in", values, "nid");
+            return (Criteria) this;
+        }
+
+        public Criteria andNidBetween(Integer value1, Integer value2) {
+            addCriterion("nid between", value1, value2, "nid");
+            return (Criteria) this;
+        }
+
+        public Criteria andNidNotBetween(Integer value1, Integer value2) {
+            addCriterion("nid not between", value1, value2, "nid");
+            return (Criteria) this;
+        }
+
+        public Criteria andAidIsNull() {
+            addCriterion("aid is null");
+            return (Criteria) this;
+        }
+
+        public Criteria andAidIsNotNull() {
+            addCriterion("aid is not null");
+            return (Criteria) this;
+        }
+
+        public Criteria andAidEqualTo(Integer value) {
+            addCriterion("aid =", value, "aid");
+            return (Criteria) this;
+        }
+
+        public Criteria andAidNotEqualTo(Integer value) {
+            addCriterion("aid <>", value, "aid");
+            return (Criteria) this;
+        }
+
+        public Criteria andAidGreaterThan(Integer value) {
+            addCriterion("aid >", value, "aid");
+            return (Criteria) this;
+        }
+
+        public Criteria andAidGreaterThanOrEqualTo(Integer value) {
+            addCriterion("aid >=", value, "aid");
+            return (Criteria) this;
+        }
+
+        public Criteria andAidLessThan(Integer value) {
+            addCriterion("aid <", value, "aid");
+            return (Criteria) this;
+        }
+
+        public Criteria andAidLessThanOrEqualTo(Integer value) {
+            addCriterion("aid <=", value, "aid");
+            return (Criteria) this;
+        }
+
+        public Criteria andAidIn(List<Integer> values) {
+            addCriterion("aid in", values, "aid");
+            return (Criteria) this;
+        }
+
+        public Criteria andAidNotIn(List<Integer> values) {
+            addCriterion("aid not in", values, "aid");
+            return (Criteria) this;
+        }
+
+        public Criteria andAidBetween(Integer value1, Integer value2) {
+            addCriterion("aid between", value1, value2, "aid");
+            return (Criteria) this;
+        }
+
+        public Criteria andAidNotBetween(Integer value1, Integer value2) {
+            addCriterion("aid not between", value1, value2, "aid");
+            return (Criteria) this;
+        }
+
+        public Criteria andVal1IsNull() {
+            addCriterion("val1 is null");
+            return (Criteria) this;
+        }
+
+        public Criteria andVal1IsNotNull() {
+            addCriterion("val1 is not null");
+            return (Criteria) this;
+        }
+
+        public Criteria andVal1EqualTo(Float value) {
+            addCriterion("val1 =", value, "val1");
+            return (Criteria) this;
+        }
+
+        public Criteria andVal1NotEqualTo(Float value) {
+            addCriterion("val1 <>", value, "val1");
+            return (Criteria) this;
+        }
+
+        public Criteria andVal1GreaterThan(Float value) {
+            addCriterion("val1 >", value, "val1");
+            return (Criteria) this;
+        }
+
+        public Criteria andVal1GreaterThanOrEqualTo(Float value) {
+            addCriterion("val1 >=", value, "val1");
+            return (Criteria) this;
+        }
+
+        public Criteria andVal1LessThan(Float value) {
+            addCriterion("val1 <", value, "val1");
+            return (Criteria) this;
+        }
+
+        public Criteria andVal1LessThanOrEqualTo(Float value) {
+            addCriterion("val1 <=", value, "val1");
+            return (Criteria) this;
+        }
+
+        public Criteria andVal1In(List<Float> values) {
+            addCriterion("val1 in", values, "val1");
+            return (Criteria) this;
+        }
+
+        public Criteria andVal1NotIn(List<Float> values) {
+            addCriterion("val1 not in", values, "val1");
+            return (Criteria) this;
+        }
+
+        public Criteria andVal1Between(Float value1, Float value2) {
+            addCriterion("val1 between", value1, value2, "val1");
+            return (Criteria) this;
+        }
+
+        public Criteria andVal1NotBetween(Float value1, Float value2) {
+            addCriterion("val1 not between", value1, value2, "val1");
+            return (Criteria) this;
+        }
+
+        public Criteria andVal2IsNull() {
+            addCriterion("val2 is null");
+            return (Criteria) this;
+        }
+
+        public Criteria andVal2IsNotNull() {
+            addCriterion("val2 is not null");
+            return (Criteria) this;
+        }
+
+        public Criteria andVal2EqualTo(Float value) {
+            addCriterion("val2 =", value, "val2");
+            return (Criteria) this;
+        }
+
+        public Criteria andVal2NotEqualTo(Float value) {
+            addCriterion("val2 <>", value, "val2");
+            return (Criteria) this;
+        }
+
+        public Criteria andVal2GreaterThan(Float value) {
+            addCriterion("val2 >", value, "val2");
+            return (Criteria) this;
+        }
+
+        public Criteria andVal2GreaterThanOrEqualTo(Float value) {
+            addCriterion("val2 >=", value, "val2");
+            return (Criteria) this;
+        }
+
+        public Criteria andVal2LessThan(Float value) {
+            addCriterion("val2 <", value, "val2");
+            return (Criteria) this;
+        }
+
+        public Criteria andVal2LessThanOrEqualTo(Float value) {
+            addCriterion("val2 <=", value, "val2");
+            return (Criteria) this;
+        }
+
+        public Criteria andVal2In(List<Float> values) {
+            addCriterion("val2 in", values, "val2");
+            return (Criteria) this;
+        }
+
+        public Criteria andVal2NotIn(List<Float> values) {
+            addCriterion("val2 not in", values, "val2");
+            return (Criteria) this;
+        }
+
+        public Criteria andVal2Between(Float value1, Float value2) {
+            addCriterion("val2 between", value1, value2, "val2");
+            return (Criteria) this;
+        }
+
+        public Criteria andVal2NotBetween(Float value1, Float value2) {
+            addCriterion("val2 not between", value1, value2, "val2");
+            return (Criteria) this;
+        }
+
+        public Criteria andVal3IsNull() {
+            addCriterion("val3 is null");
+            return (Criteria) this;
+        }
+
+        public Criteria andVal3IsNotNull() {
+            addCriterion("val3 is not null");
+            return (Criteria) this;
+        }
+
+        public Criteria andVal3EqualTo(Float value) {
+            addCriterion("val3 =", value, "val3");
+            return (Criteria) this;
+        }
+
+        public Criteria andVal3NotEqualTo(Float value) {
+            addCriterion("val3 <>", value, "val3");
+            return (Criteria) this;
+        }
+
+        public Criteria andVal3GreaterThan(Float value) {
+            addCriterion("val3 >", value, "val3");
+            return (Criteria) this;
+        }
+
+        public Criteria andVal3GreaterThanOrEqualTo(Float value) {
+            addCriterion("val3 >=", value, "val3");
+            return (Criteria) this;
+        }
+
+        public Criteria andVal3LessThan(Float value) {
+            addCriterion("val3 <", value, "val3");
+            return (Criteria) this;
+        }
+
+        public Criteria andVal3LessThanOrEqualTo(Float value) {
+            addCriterion("val3 <=", value, "val3");
+            return (Criteria) this;
+        }
+
+        public Criteria andVal3In(List<Float> values) {
+            addCriterion("val3 in", values, "val3");
+            return (Criteria) this;
+        }
+
+        public Criteria andVal3NotIn(List<Float> values) {
+            addCriterion("val3 not in", values, "val3");
+            return (Criteria) this;
+        }
+
+        public Criteria andVal3Between(Float value1, Float value2) {
+            addCriterion("val3 between", value1, value2, "val3");
+            return (Criteria) this;
+        }
+
+        public Criteria andVal3NotBetween(Float value1, Float value2) {
+            addCriterion("val3 not between", value1, value2, "val3");
+            return (Criteria) this;
+        }
+
+        public Criteria andVal4IsNull() {
+            addCriterion("val4 is null");
+            return (Criteria) this;
+        }
+
+        public Criteria andVal4IsNotNull() {
+            addCriterion("val4 is not null");
+            return (Criteria) this;
+        }
+
+        public Criteria andVal4EqualTo(Float value) {
+            addCriterion("val4 =", value, "val4");
+            return (Criteria) this;
+        }
+
+        public Criteria andVal4NotEqualTo(Float value) {
+            addCriterion("val4 <>", value, "val4");
+            return (Criteria) this;
+        }
+
+        public Criteria andVal4GreaterThan(Float value) {
+            addCriterion("val4 >", value, "val4");
+            return (Criteria) this;
+        }
+
+        public Criteria andVal4GreaterThanOrEqualTo(Float value) {
+            addCriterion("val4 >=", value, "val4");
+            return (Criteria) this;
+        }
+
+        public Criteria andVal4LessThan(Float value) {
+            addCriterion("val4 <", value, "val4");
+            return (Criteria) this;
+        }
+
+        public Criteria andVal4LessThanOrEqualTo(Float value) {
+            addCriterion("val4 <=", value, "val4");
+            return (Criteria) this;
+        }
+
+        public Criteria andVal4In(List<Float> values) {
+            addCriterion("val4 in", values, "val4");
+            return (Criteria) this;
+        }
+
+        public Criteria andVal4NotIn(List<Float> values) {
+            addCriterion("val4 not in", values, "val4");
+            return (Criteria) this;
+        }
+
+        public Criteria andVal4Between(Float value1, Float value2) {
+            addCriterion("val4 between", value1, value2, "val4");
+            return (Criteria) this;
+        }
+
+        public Criteria andVal4NotBetween(Float value1, Float value2) {
+            addCriterion("val4 not between", value1, value2, "val4");
+            return (Criteria) this;
+        }
+
+        public Criteria andNnameIsNull() {
+            addCriterion("nname is null");
+            return (Criteria) this;
+        }
+
+        public Criteria andNnameIsNotNull() {
+            addCriterion("nname is not null");
+            return (Criteria) this;
+        }
+
+        public Criteria andNnameEqualTo(String value) {
+            addCriterion("nname =", value, "nname");
+            return (Criteria) this;
+        }
+
+        public Criteria andNnameNotEqualTo(String value) {
+            addCriterion("nname <>", value, "nname");
+            return (Criteria) this;
+        }
+
+        public Criteria andNnameGreaterThan(String value) {
+            addCriterion("nname >", value, "nname");
+            return (Criteria) this;
+        }
+
+        public Criteria andNnameGreaterThanOrEqualTo(String value) {
+            addCriterion("nname >=", value, "nname");
+            return (Criteria) this;
+        }
+
+        public Criteria andNnameLessThan(String value) {
+            addCriterion("nname <", value, "nname");
+            return (Criteria) this;
+        }
+
+        public Criteria andNnameLessThanOrEqualTo(String value) {
+            addCriterion("nname <=", value, "nname");
+            return (Criteria) this;
+        }
+
+        public Criteria andNnameLike(String value) {
+            addCriterion("nname like", value, "nname");
+            return (Criteria) this;
+        }
+
+        public Criteria andNnameNotLike(String value) {
+            addCriterion("nname not like", value, "nname");
+            return (Criteria) this;
+        }
+
+        public Criteria andNnameIn(List<String> values) {
+            addCriterion("nname in", values, "nname");
+            return (Criteria) this;
+        }
+
+        public Criteria andNnameNotIn(List<String> values) {
+            addCriterion("nname not in", values, "nname");
+            return (Criteria) this;
+        }
+
+        public Criteria andNnameBetween(String value1, String value2) {
+            addCriterion("nname between", value1, value2, "nname");
+            return (Criteria) this;
+        }
+
+        public Criteria andNnameNotBetween(String value1, String value2) {
+            addCriterion("nname not between", value1, value2, "nname");
+            return (Criteria) this;
+        }
+
+        public Criteria andNtypeIsNull() {
+            addCriterion("ntype is null");
+            return (Criteria) this;
+        }
+
+        public Criteria andNtypeIsNotNull() {
+            addCriterion("ntype is not null");
+            return (Criteria) this;
+        }
+
+        public Criteria andNtypeEqualTo(String value) {
+            addCriterion("ntype =", value, "ntype");
+            return (Criteria) this;
+        }
+
+        public Criteria andNtypeNotEqualTo(String value) {
+            addCriterion("ntype <>", value, "ntype");
+            return (Criteria) this;
+        }
+
+        public Criteria andNtypeGreaterThan(String value) {
+            addCriterion("ntype >", value, "ntype");
+            return (Criteria) this;
+        }
+
+        public Criteria andNtypeGreaterThanOrEqualTo(String value) {
+            addCriterion("ntype >=", value, "ntype");
+            return (Criteria) this;
+        }
+
+        public Criteria andNtypeLessThan(String value) {
+            addCriterion("ntype <", value, "ntype");
+            return (Criteria) this;
+        }
+
+        public Criteria andNtypeLessThanOrEqualTo(String value) {
+            addCriterion("ntype <=", value, "ntype");
+            return (Criteria) this;
+        }
+
+        public Criteria andNtypeLike(String value) {
+            addCriterion("ntype like", value, "ntype");
+            return (Criteria) this;
+        }
+
+        public Criteria andNtypeNotLike(String value) {
+            addCriterion("ntype not like", value, "ntype");
+            return (Criteria) this;
+        }
+
+        public Criteria andNtypeIn(List<String> values) {
+            addCriterion("ntype in", values, "ntype");
+            return (Criteria) this;
+        }
+
+        public Criteria andNtypeNotIn(List<String> values) {
+            addCriterion("ntype not in", values, "ntype");
+            return (Criteria) this;
+        }
+
+        public Criteria andNtypeBetween(String value1, String value2) {
+            addCriterion("ntype between", value1, value2, "ntype");
+            return (Criteria) this;
+        }
+
+        public Criteria andNtypeNotBetween(String value1, String value2) {
+            addCriterion("ntype not between", value1, value2, "ntype");
+            return (Criteria) this;
+        }
+    }
+
+    public static class Criteria extends GeneratedCriteria {
+
+        protected Criteria() {
+            super();
+        }
+    }
+
+    public static class Criterion {
+        private String condition;
+
+        private Object value;
+
+        private Object secondValue;
+
+        private boolean noValue;
+
+        private boolean singleValue;
+
+        private boolean betweenValue;
+
+        private boolean listValue;
+
+        private String typeHandler;
+
+        public String getCondition() {
+            return condition;
+        }
+
+        public Object getValue() {
+            return value;
+        }
+
+        public Object getSecondValue() {
+            return secondValue;
+        }
+
+        public boolean isNoValue() {
+            return noValue;
+        }
+
+        public boolean isSingleValue() {
+            return singleValue;
+        }
+
+        public boolean isBetweenValue() {
+            return betweenValue;
+        }
+
+        public boolean isListValue() {
+            return listValue;
+        }
+
+        public String getTypeHandler() {
+            return typeHandler;
+        }
+
+        protected Criterion(String condition) {
+            super();
+            this.condition = condition;
+            this.typeHandler = null;
+            this.noValue = true;
+        }
+
+        protected Criterion(String condition, Object value, String typeHandler) {
+            super();
+            this.condition = condition;
+            this.value = value;
+            this.typeHandler = typeHandler;
+            if (value instanceof List<?>) {
+                this.listValue = true;
+            } else {
+                this.singleValue = true;
+            }
+        }
+
+        protected Criterion(String condition, Object value) {
+            this(condition, value, null);
+        }
+
+        protected Criterion(String condition, Object value, Object secondValue, String typeHandler) {
+            super();
+            this.condition = condition;
+            this.value = value;
+            this.secondValue = secondValue;
+            this.typeHandler = typeHandler;
+            this.betweenValue = true;
+        }
+
+        protected Criterion(String condition, Object value, Object secondValue) {
+            this(condition, value, secondValue, null);
+        }
+    }
+}

modelsrc/com/miniframe/model/system/dao/DNodeValMapper.java

@@ -0,0 +1,10 @@
+package com.miniframe.model.system.dao;
+
+import com.miniframe.model.system.DNodeVal;
+import com.miniframe.model.system.DNodeValSQLBuilder;
+import com.miniframe.spring.db.MFBaseMapper;
+import com.miniframe.system.MiniserviceBaseDao;
+
+public interface DNodeValMapper extends MiniserviceBaseDao, MFBaseMapper<DNodeVal> {
+    long countByExample(DNodeValSQLBuilder example);
+}

modelsrc/com/miniframe/model/system/xml/DNodeValMapper.xml

@@ -0,0 +1,50 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
+<mapper namespace="com.miniframe.model.system.dao.DNodeValMapper">
+  <sql id="Example_Where_Clause">
+    <!--
+      WARNING - @mbg.generated
+    -->
+    <where>
+      <foreach collection="oredCriteria" item="criteria" separator="or">
+        <if test="criteria.valid">
+          <trim prefix="(" prefixOverrides="and" suffix=")">
+            <foreach collection="criteria.criteria" item="criterion">
+              <choose>
+                <when test="criterion.noValue">
+                  and ${criterion.condition}
+                </when>
+                <when test="criterion.singleValue">
+                  and ${criterion.condition} #{criterion.value}
+                </when>
+                <when test="criterion.betweenValue">
+                  and ${criterion.condition} #{criterion.value} and #{criterion.secondValue}
+                </when>
+                <when test="criterion.listValue">
+                  and ${criterion.condition}
+                  <foreach close=")" collection="criterion.value" item="listItem" open="(" separator=",">
+                    #{listItem}
+                  </foreach>
+                </when>
+              </choose>
+            </foreach>
+          </trim>
+        </if>
+      </foreach>
+    </where>
+  </sql>
+  <select id="countByExample" parameterType="com.miniframe.model.system.DNodeValSQLBuilder" resultType="java.lang.Long">
+    <!--
+      WARNING - @mbg.generated
+    -->
+    select count(*) from d_node_val
+    <if test="_parameter != null">
+      <include refid="Example_Where_Clause" />
+    </if>
+  </select>
+  <cache>
+    <!--
+      WARNING - @mbg.generated
+    -->
+  </cache>
+</mapper>

src/main/java/com/miniframe/dbtransfer/DNodeValDbTransfer.java

@@ -0,0 +1,23 @@
+package com.miniframe.dbtransfer;
+
+import com.miniframe.core.DbTransfer;
+import java.io.Serializable;
+import java.util.List;
+import java.util.Map;
+
+import com.miniframe.model.system.DNodeVal;
+
+/**
+ * 实体列表,“D_NODE_VAL”数据库数据转化逻辑处理（重新生成不覆盖）。
+ */
+public class DNodeValDbTransfer extends DbTransfer implements Serializable {
+	
+	private static final long serialVersionUID = -7051358269847459502L;
+
+	@Override
+	public List transfer(final List l,Map map) throws Exception{
+		List<DNodeVal> list=l;
+		return list;
+	};
+
+}

src/main/java/com/miniframe/template/FireInitVo.java

@@ -10,8 +10,8 @@ import java.util.Map;
 public class FireInitVo {
 
     public List<DNodeVal> nodeVals;
-    public List<DSource>  dSources;
-    public Map<Integer, DSourceVal> dSourceValMap;
+    public List<DSource>  dources;
+    public Map<Integer, DSourceVal> dsourceValMap;
 
     public List<DNodeVal> getNodeVals() {
         return nodeVals;
@@ -21,19 +21,19 @@ public class FireInitVo {
         this.nodeVals = nodeVals;
     }
 
-    public List<DSource> getdSources() {
-        return dSources;
+    public List<DSource> getDources() {
+        return dources;
     }
 
-    public void setdSources(List<DSource> dSources) {
-        this.dSources = dSources;
+    public void setDources(List<DSource> dources) {
+        this.dources = dources;
     }
 
-    public Map<Integer, DSourceVal> getdSourceValMap() {
-        return dSourceValMap;
+    public Map<Integer, DSourceVal> getDsourceValMap() {
+        return dsourceValMap;
     }
 
-    public void setdSourceValMap(Map<Integer, DSourceVal> dSourceValMap) {
-        this.dSourceValMap = dSourceValMap;
+    public void setDsourceValMap(Map<Integer, DSourceVal> dsourceValMap) {
+        this.dsourceValMap = dsourceValMap;
     }
 }