diff --git a/src/main/java/com/supwisdom/dlpay/framework/dao/BusinessparaDao.java b/src/main/java/com/supwisdom/dlpay/framework/dao/BusinessparaDao.java
new file mode 100644
index 0000000..5bf13d9
--- /dev/null
+++ b/src/main/java/com/supwisdom/dlpay/framework/dao/BusinessparaDao.java
@@ -0,0 +1,25 @@
+package com.supwisdom.dlpay.framework.dao;
+
+import com.supwisdom.dlpay.framework.domain.TBusinesspara;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.data.jpa.repository.Lock;
+import org.springframework.data.jpa.repository.Query;
+import org.springframework.data.jpa.repository.QueryHints;
+import org.springframework.stereotype.Repository;
+
+import javax.persistence.LockModeType;
+import javax.persistence.QueryHint;
+
+@Repository
+public interface BusinessparaDao extends JpaRepository<TBusinesspara, String> {
+  TBusinesspara findByParakey(String parakey);
+
+  @Lock(LockModeType.PESSIMISTIC_WRITE)
+  @Query(value = " from TBusinesspara where parakey=?1 ")
+  TBusinesspara findByParakeyForUpdate(String parakey);
+
+  @Lock(LockModeType.PESSIMISTIC_WRITE)
+  @QueryHints({@QueryHint(name = "javax.persistence.lock.timeout", value ="0")})
+  @Query(value = " from TBusinesspara where parakey=?1 ")
+  TBusinesspara findByParakeyForUpdateNowait(String parakey);
+}
diff --git a/src/main/java/com/supwisdom/dlpay/framework/dao/SysparaDao.java b/src/main/java/com/supwisdom/dlpay/framework/dao/SysparaDao.java
new file mode 100644
index 0000000..7e20856
--- /dev/null
+++ b/src/main/java/com/supwisdom/dlpay/framework/dao/SysparaDao.java
@@ -0,0 +1,25 @@
+package com.supwisdom.dlpay.framework.dao;
+
+import com.supwisdom.dlpay.framework.domain.TSyspara;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.data.jpa.repository.Lock;
+import org.springframework.data.jpa.repository.Query;
+import org.springframework.data.jpa.repository.QueryHints;
+import org.springframework.stereotype.Repository;
+
+import javax.persistence.LockModeType;
+import javax.persistence.QueryHint;
+
+@Repository
+public interface SysparaDao extends JpaRepository<TSyspara, Integer> {
+  TSyspara findByParaid(int paraid);
+
+  @Lock(LockModeType.PESSIMISTIC_WRITE)
+  @Query(value = "from TSyspara where paraid=?1 ")
+  TSyspara findByParaidWithLock(int paraid);
+
+  @Lock(LockModeType.PESSIMISTIC_WRITE)
+  @QueryHints({@QueryHint(name = "javax.persistence.lock.timeout", value ="0")})
+  @Query(value = "from TSyspara where paraid=?1 ")
+  TSyspara findByParaidWithLockNowait(int paraid);
+}
diff --git a/src/main/java/com/supwisdom/dlpay/framework/domain/TBusinesspara.java b/src/main/java/com/supwisdom/dlpay/framework/domain/TBusinesspara.java
new file mode 100644
index 0000000..6c6691e
--- /dev/null
+++ b/src/main/java/com/supwisdom/dlpay/framework/domain/TBusinesspara.java
@@ -0,0 +1,41 @@
+package com.supwisdom.dlpay.framework.domain;
+
+import javax.persistence.Column;
+import javax.persistence.Entity;
+import javax.persistence.Id;
+import javax.persistence.Table;
+
+@Entity
+@Table(name = "TB_BUSINESSPARA")
+public class TBusinesspara {
+  @Id
+  @Column(name="PARAKEY", nullable = false, length = 60)
+  private String parakey;
+
+  @Column(name="PARAVAL", length = 1000)
+  private String paraval;
+
+  public TBusinesspara() {
+  }
+
+  public TBusinesspara(String parakey, String paraval) {
+    this.parakey = parakey;
+    this.paraval = paraval;
+  }
+
+  public String getParakey() {
+    return parakey;
+  }
+
+  public void setParakey(String parakey) {
+    this.parakey = parakey;
+  }
+
+  public String getParaval() {
+    return paraval;
+  }
+
+  public void setParaval(String paraval) {
+    this.paraval = paraval;
+  }
+}
diff --git a/src/main/java/com/supwisdom/dlpay/framework/domain/TSyspara.java b/src/main/java/com/supwisdom/dlpay/framework/domain/TSyspara.java
new file mode 100644
index 0000000..50cd0f7
--- /dev/null
+++ b/src/main/java/com/supwisdom/dlpay/framework/domain/TSyspara.java
@@ -0,0 +1,158 @@
+package com.supwisdom.dlpay.framework.domain;
+
+import com.supwisdom.dlpay.framework.util.DateUtil;
+import com.supwisdom.dlpay.framework.util.NumberUtil;
+import com.supwisdom.dlpay.framework.util.StringUtil;
+import com.supwisdom.dlpay.framework.util.SysparaUtil;
+
+import javax.persistence.Column;
+import javax.persistence.Entity;
+import javax.persistence.Id;
+import javax.persistence.Table;
+
+@Entity
+@Table(name = "TB_SYSPARA")
+public class TSyspara {
+  @Id
+  @Column(name = "PARAID", nullable = false, precision = 9)
+  private Integer paraid;
+
+  @Column(name = "PARAVAL", length = 100)
+  private String paraval;
+
+  @Column(name = "PARANAME", length = 90)
+  private String paraname;
+
+  @Column(name = "PARAUNIT", length = 20)
+  private String paraunit;
+
+  @Column(name = "VALUETYPE", length = 10)
+  private String valueType = SysparaUtil.SYSPARA_VALUETYPE_STRING;
+
+  @Column(name = "EDITFLAG", nullable = false, precision = 1)
+  private Integer editflag;
+
+  @Column(name = "DISPLAYFLAG", length = 10)
+  private String displayflag;
+
+  @Column(name = "REMARK", length = 240)
+  private String remark;
+
+  @Column(name = "LASTSAVED", length = 14)
+  private String lastsaved;
+
+  public TSyspara() {
+  }
+
+  public TSyspara(Integer paraid, Integer editflag) {
+    this.paraid = paraid;
+    this.editflag = editflag;
+  }
+
+  public TSyspara(Integer paraid, String paraval, String paraname, String paraunit, String valueType, Integer editflag, String displayflag, String remark, String lastsaved) {
+    this.paraid = paraid;
+    this.paraval = paraval;
+    this.paraname = paraname;
+    this.paraunit = paraunit;
+    this.valueType = valueType;
+    this.editflag = editflag;
+    this.displayflag = displayflag;
+    this.remark = remark;
+    this.lastsaved = lastsaved;
+  }
+
+  public Integer getParaid() {
+    return paraid;
+  }
+
+  public void setParaid(Integer paraid) {
+    this.paraid = paraid;
+  }
+
+  public String getParaval() {
+    return paraval;
+  }
+
+  public void setParaval(String paraval) {
+    this.paraval = paraval;
+  }
+
+  public String getParaname() {
+    return paraname;
+  }
+
+  public void setParaname(String paraname) {
+    this.paraname = paraname;
+  }
+
+  public String getParaunit() {
+    return paraunit;
+  }
+
+  public void setParaunit(String paraunit) {
+    this.paraunit = paraunit;
+  }
+
+  public String getValueType() {
+    return valueType;
+  }
+
+  public void setValueType(String valueType) {
+    this.valueType = valueType;
+  }
+
+  public Integer getEditflag() {
+    return editflag;
+  }
+
+  public void setEditflag(Integer editflag) {
+    this.editflag = editflag;
+  }
+
+  public String getDisplayflag() {
+    return displayflag;
+  }
+
+  public void setDisplayflag(String displayflag) {
+    this.displayflag = displayflag;
+  }
+
+  public String getRemark() {
+    return remark;
+  }
+
+  public void setRemark(String remark) {
+    this.remark = remark;
+  }
+
+  public String getLastsaved() {
+    return lastsaved;
+  }
+
+  public void setLastsaved(String lastsaved) {
+    this.lastsaved = lastsaved;
+  }
+
+  /**
+   * 判断参数是否非法
+   * @return 非法 -> true; 合法 -> false
+   */
+  public boolean checkValueInvalid() {
+    if (!StringUtil.isEmpty(this.paraval)) {
+      if (SysparaUtil.SYSPARA_VALUETYPE_AMOUNT.equals(this.valueType) && !NumberUtil.isAmount(this.paraval)) {
+        return true; //参数值非金额类型
+      } else if (SysparaUtil.SYSPARA_VALUETYPE_DECIMAL.equals(this.valueType) && !NumberUtil.isDecimal(this.paraval)) {
+        return true; //参数值非数值类型
+      } else if (SysparaUtil.SYSPARA_VALUETYPE_NUMBER.equals(this.valueType) && !NumberUtil.isNumber(this.paraval)) {
+        return true; //参数值非整数
+      } else if (SysparaUtil.SYSPARA_VALUETYPE_SWITCH.equals(this.valueType) && !"1".equals(this.paraval) && !"0".equals(this.paraval)) {
+        return true; //参数值非开关量 0/1
+      } else if (SysparaUtil.SYSPARA_VALUETYPE_DATE.equals(this.valueType) && !DateUtil.checkDatetimeValid(this.paraval, "yyyyMMdd")) {
+        return true; //参数值非日期格式
+      } else if (SysparaUtil.SYSPARA_VALUETYPE_DATETIME.equals(this.valueType) && !DateUtil.checkDatetimeValid(this.paraval, "yyyyMMddHHmmss")) {
+        return true; //参数值非日期时间格式
+      }
+    }
+    return false; //默认字符串格式都合法
+  }
+}
diff --git a/src/main/java/com/supwisdom/dlpay/framework/service/SystemUtilService.java b/src/main/java/com/supwisdom/dlpay/framework/service/SystemUtilService.java
index 21d2793..23c7172 100644
--- a/src/main/java/com/supwisdom/dlpay/framework/service/SystemUtilService.java
+++ b/src/main/java/com/supwisdom/dlpay/framework/service/SystemUtilService.java
@@ -1,6 +1,8 @@
 package com.supwisdom.dlpay.framework.service;
 
 import com.supwisdom.dlpay.framework.data.SystemDateTime;
+import com.supwisdom.dlpay.framework.domain.TBusinesspara;
+import com.supwisdom.dlpay.framework.domain.TSyspara;
 import com.supwisdom.dlpay.framework.domain.TTaskLock;
 import org.springframework.transaction.annotation.Propagation;
 import org.springframework.transaction.annotation.Transactional;
@@ -40,4 +42,38 @@
   String getTranscodeName(int transocde, String defaultValue);
 
 
+  /********************** 获取【系统参数】【业务参数】通用方法 **********************/
+  String getSysparaValue(int paraid);
+
+  String getSysparaValue(int paraid, String defaultValue);
+
+  boolean getSysparaValueAsBoolean(int paraid);
+
+  int getSysparaValueAsInt(int paraid, int defaultValue);
+
+  double getSysparaValueAsDouble(int paraid, double defaultValue);
+
+  TSyspara getSyspara(int paraid);
+
+  @Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class)
+  TSyspara getSysparaValueForUpdate(int paraid);
+
+  @Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class)
+  TSyspara getSysparaValueForUpdateNowait(int paraid);
+
+
+  String getBusinessValue(String parakey);
+
+  String getBusinessValue(String parakey, String defaultValue);
+
+  TBusinesspara getBusiness(String parakey);
+
+  @Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class)
+  TBusinesspara getBusinessValueForUpdate(String parakey);
+
+  @Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class)
+  TBusinesspara getBusinessValueForUpdateNowait(String parakey);
+  /********************** 获取【系统参数】【业务参数】通用方法 **********************/
+
+
 }
diff --git a/src/main/java/com/supwisdom/dlpay/framework/service/impl/SystemUtilServiceImpl.java b/src/main/java/com/supwisdom/dlpay/framework/service/impl/SystemUtilServiceImpl.java
index ec021e9..c1d9971 100644
--- a/src/main/java/com/supwisdom/dlpay/framework/service/impl/SystemUtilServiceImpl.java
+++ b/src/main/java/com/supwisdom/dlpay/framework/service/impl/SystemUtilServiceImpl.java
@@ -1,15 +1,12 @@
 package com.supwisdom.dlpay.framework.service.impl;
 
 import com.supwisdom.dlpay.framework.core.DatabaseConfig;
-import com.supwisdom.dlpay.framework.dao.SettleCtlDao;
-import com.supwisdom.dlpay.framework.dao.TaskLockDao;
-import com.supwisdom.dlpay.framework.dao.TranscodeDao;
+import com.supwisdom.dlpay.framework.dao.*;
 import com.supwisdom.dlpay.framework.data.SystemDateTime;
-import com.supwisdom.dlpay.framework.domain.TSettlectl;
-import com.supwisdom.dlpay.framework.domain.TTaskLock;
-import com.supwisdom.dlpay.framework.domain.TTranscode;
+import com.supwisdom.dlpay.framework.domain.*;
 import com.supwisdom.dlpay.framework.service.SystemUtilService;
 import com.supwisdom.dlpay.framework.util.DateUtil;
+import com.supwisdom.dlpay.framework.util.NumberUtil;
 import com.supwisdom.dlpay.framework.util.StringUtil;
 import org.apache.log4j.Logger;
 import org.springframework.beans.factory.annotation.Autowired;
@@ -30,6 +27,10 @@
   private SettleCtlDao settleCtlDao;
   @Autowired
   private TranscodeDao transcodeDao;
+  @Autowired
+  private SysparaDao sysparaDao;
+  @Autowired
+  private BusinessparaDao businessparaDao;
 
   private static final Logger logger = Logger.getLogger(SystemUtilServiceImpl.class);
 
@@ -149,4 +150,88 @@
     return defaultValue;
   }
 
+  @Override
+  public String getSysparaValue(int paraid) {
+    TSyspara syspara = sysparaDao.findByParaid(paraid);
+    if (null != syspara) return syspara.getParaval();
+    return null;
+  }
+
+  @Override
+  public String getSysparaValue(int paraid, String defaultValue) {
+    String paraval = getSysparaValue(paraid);
+    if (null != paraval) return paraval;
+    return defaultValue;
+  }
+
+  @Override
+  public boolean getSysparaValueAsBoolean(int paraid) {
+    TSyspara syspara = sysparaDao.findByParaid(paraid);
+    if (null != syspara && "1".equals(syspara.getParaval())) return true;
+    return false;
+  }
+
+  @Override
+  public int getSysparaValueAsInt(int paraid, int defaultValue) {
+    TSyspara syspara = sysparaDao.findByParaid(paraid);
+    if (null != syspara && NumberUtil.isNumber(syspara.getParaval())) return Integer.parseInt(syspara.getParaval());
+    return defaultValue;
+  }
+
+  @Override
+  public double getSysparaValueAsDouble(int paraid, double defaultValue) {
+    TSyspara syspara = sysparaDao.findByParaid(paraid);
+    if (null != syspara && NumberUtil.isDecimal(syspara.getParaval())) return Double.parseDouble(syspara.getParaval());
+    return defaultValue;
+  }
+
+  @Override
+  public TSyspara getSyspara(int paraid){
+    return sysparaDao.findByParaid(paraid);
+  }
+
+  @Override
+  public TSyspara getSysparaValueForUpdate(int paraid){
+    return sysparaDao.findByParaidWithLock(paraid);
+  }
+
+  @Override
+  public TSyspara getSysparaValueForUpdateNowait(int paraid){
+    return sysparaDao.findByParaidWithLockNowait(paraid);
+  }
+
+  @Override
+  public String getBusinessValue(String parakey) {
+    if (!StringUtil.isEmpty(parakey)) {
+      TBusinesspara businesspara = businessparaDao.findByParakey(parakey.trim());
+      if (null != businesspara) return businesspara.getParaval();
+    }
+    return null;
+  }
+
+  @Override
+  public String getBusinessValue(String parakey, String defaultValue) {
+    String paraval = getBusinessValue(parakey);
+    if (!StringUtil.isEmpty(paraval)) return paraval;
+    return defaultValue;
+  }
+
+  @Override
+  public TBusinesspara getBusiness(String parakey) {
+    if (!StringUtil.isEmpty(parakey)) return businessparaDao.findByParakey(parakey.trim());
+    return null;
+  }
+
+  @Override
+  public TBusinesspara getBusinessValueForUpdate(String parakey){
+    if (!StringUtil.isEmpty(parakey)) return businessparaDao.findByParakeyForUpdate(parakey.trim());
+    return null;
+  }
+
+  @Override
+  public TBusinesspara getBusinessValueForUpdateNowait(String parakey) {
+    if (!StringUtil.isEmpty(parakey)) return businessparaDao.findByParakeyForUpdateNowait(parakey.trim());
+    return null;
+  }
+
 }
diff --git a/src/main/java/com/supwisdom/dlpay/framework/util/NumberUtil.java b/src/main/java/com/supwisdom/dlpay/framework/util/NumberUtil.java
new file mode 100644
index 0000000..a8d4390
--- /dev/null
+++ b/src/main/java/com/supwisdom/dlpay/framework/util/NumberUtil.java
@@ -0,0 +1,65 @@
+package com.supwisdom.dlpay.framework.util;
+
+public class NumberUtil {
+
+  /**
+   * 判断是否是非负整数
+   *
+   * @param str
+   * @return 是 -> true;  否 -> false 如 1 -> true; -1 -> false
+   */
+  public static boolean isDigits(String str) {
+    if (null == str || "".equals(str.trim())) return false;
+    java.util.regex.Pattern pattern = java.util.regex.Pattern.compile("[0-9]*");
+    java.util.regex.Matcher match = pattern.matcher(str.trim());
+    return match.matches();
+  }
+
+  /**
+   * 判断是否是整数（包含正负）
+   *
+   * @param str
+   * @return 是 -> true;  否 -> false  如 -1 -> true; -1.0 -> false
+   */
+  public static boolean isNumber(String str) {
+    if (null == str) return false;
+    try {
+      Integer.valueOf(str);
+      return true;
+    } catch (NumberFormatException ex) {
+      return false;
+    }
+  }
+
+  /**
+   * 判断是否是数字
+   *
+   * @param str
+   * @return 是 -> true;  否 -> false  如 -1 -> true; asd.1sa -> false
+   */
+  public static boolean isDecimal(String str) {
+    if (null == str) return false;
+    try {
+      Double.valueOf(str.trim());
+      return true;
+    } catch (NumberFormatException ex) {
+      return false;
+    }
+  }
+
+  /**
+   * 判断是否是金额(包含正负，最多2位小数)
+   *
+   * @param str
+   * @return 是 -> true;  否 -> false  如 -1.10 -> true; -1.011 -> false
+   */
+  public static boolean isAmount(String str) {
+    if (!isDecimal(str)) return false;
+    if (str.trim().indexOf(".") != -1) {
+      String suffix = str.trim().substring(str.trim().indexOf(".") + 1);
+      if (suffix.length() > 2) return false; //小数位多余2位
+    }
+    return true;
+  }
+
+}
diff --git a/src/main/java/com/supwisdom/dlpay/framework/util/SysparaUtil.java b/src/main/java/com/supwisdom/dlpay/framework/util/SysparaUtil.java
new file mode 100644
index 0000000..d3e9b11
--- /dev/null
+++ b/src/main/java/com/supwisdom/dlpay/framework/util/SysparaUtil.java
@@ -0,0 +1,16 @@
+package com.supwisdom.dlpay.framework.util;
+
+public class SysparaUtil {
+  public static final String SYSPARA_VALUETYPE_AMOUNT = "amount"; //金额类型 Double
+  public static final String SYSPARA_VALUETYPE_SWITCH = "switch"; //开关类型 Boolean 0/1
+  public static final String SYSPARA_VALUETYPE_DATE = "date"; //日期类型 yyyyMMdd
+  public static final String SYSPARA_VALUETYPE_DATETIME = "datetime"; //日期+时间 yyyyMMddHHmmss
+  public static final String SYSPARA_VALUETYPE_DECIMAL = "decimal"; //数值
+  public static final String SYSPARA_VALUETYPE_NUMBER = "number "; //整数，包含正负
+  public static final String SYSPARA_VALUETYPE_STRING = "string"; //字符串
+
+
+  public static final int SYSPARAID_NO1 = 1; //paraid=1
+  public static final int SYSPARAID_NO2 = 2; //paraid=2
+
+}
