Skip to content

Y
yzg-util
Commit d738a26b authored by yanzg's avatar yanzg
Browse files
Options

颜佐光工具类

parent 89a50d84
Show whitespace changes
Inline Side-by-side
Showing with 394 additions and 512 deletions
yzg-util-base/src/main/java/com/yanzuoguang/util/vo/InitDao.java 0 → 100644
View file @ d738a26b
package com.yanzuoguang.util.vo;
/**
* 初始化Dao数据
*/
public interface InitDao {
/**
* 初始化数据，去掉空值
*/
void init();
}
yzg-util-db/src/main/java/com/yanzuoguang/db/db/dao/BaseDao.java
View file @ d738a26b
...@@ -49,13 +49,4 @@ public interface BaseDao { ...@@ -49,13 +49,4 @@ public interface BaseDao {
* @return 需要返回的数据 * @return 需要返回的数据
*/ */
<T extends Object> T load(Object model, Class<T> cls); <T extends Object> T load(Object model, Class<T> cls);
/**
* 写入当前表的日志
*
* @param logType 日志类型，参照LogModel中的常量
* @param id 操作的当前表的主键编号
* @param data 需要处理的数据
*/
void writeLog(int logType, String id, Object data);
} }
yzg-util-db/src/main/java/com/yanzuoguang/db/db/dao/Impl/DaoConst.java → yzg-util-db/src/main/java/com/yanzuoguang/db/db/dao/DaoConst.java
View file @ d738a26b
package com.yanzuoguang.db.db.dao.Impl; package com.yanzuoguang.db.db.dao;
/** /**
* created by yanzu on 2017/5/30. * created by yanzu on 2017/5/30.
*/ */
public class DaoConst { public class DaoConst {
public static final int OperatorTypeCreate = 0;
public static final int OperatorTypeUpdate = 1;
public static final int OperatorTypeRemove = 2;
public static final int OperatorTypeLoad = 3;
/** /**
* 创建 * 创建
......
yzg-util-db/src/main/java/com/yanzuoguang/db/db/dao/Impl/BaseDaoImpl.java
View file @ d738a26b
//package com.yanzuoguang.db.db.dao.Impl; package com.yanzuoguang.db.db.dao.Impl;
//
//import com.tourbida.sys.core.ILogin; import com.yanzuoguang.db.db.dao.BaseDao;
//import com.tourbida.sys.core.LoginCenter; import com.yanzuoguang.db.db.dao.DaoConst;
//import com.tourbida.sys.core.dao.log.Impl.LogFilterImpl; import com.yanzuoguang.util.exception.CodeException;
//import com.tourbida.sys.core.dao.log.LogDao; import com.yanzuoguang.util.helper.StringHelper;
//import com.tourbida.sys.core.plan.PlanCenterFrom; import com.yanzuoguang.util.obj.ObjectHelper;
//import com.tourbida.sys.core.pojo.ICreateDeveiceVO; import com.yanzuoguang.util.vo.InitDao;
//import com.tourbida.sys.core.pojo.ICreateProjectVO;
//import com.tourbida.sys.core.pojo.ICreateVO; import java.util.HashMap;
//import com.tourbida.sys.core.pojo.IInitVO; import java.util.Map;
//import com.tourbida.sys.core.pojo.log.LogVO;
//import com.tourbida.sys.core.util.ObjectHelper; /**
//import com.tourbida.sys.core.util.StringHelper; * 数据库操作的基本工具类
//import com.tourbida.sys.exception.CodeException; * created by yanzu on 2017/5/30.
//import com.yanzuoguang.db.db.dao.BaseDao; */
//import org.springframework.beans.factory.annotation.Autowired; public abstract class BaseDaoImpl extends BaseDaoSql implements BaseDao {
//
//import javax.annotation.Resource; /**
//import java.util.HashMap; * 获取当前主键
//import java.util.Map; *
// * @return
///** */
// * 数据库操作的基本工具类 private String getIdentity() {
// * created by yanzu on 2017/5/30. return StringHelper.toString(this.db.queryCell("SELECT @@IDENTITY"));
// */ }
//public abstract class BaseDaoImpl extends BaseDaoSql implements BaseDao {
// /**
// public static final int OperatorTypeCreate = 0; * 获取主键名称
// public static final int OperatorTypeUpdate = 1; *
// public static final int OperatorTypeRemove = 2; * @return 获取主键名称
// public static final int OperatorTypeLoad = 3; */
// protected String getKey() {
// /** if (this.Table == null) {
// * 数据库执行类 throw new CodeException("类" + this.getClass().getName() + "未发现表结构");
// */ }
// @Autowired return this.Table.Table.getKeyName();
// protected PlanCenterFrom planCenterFrom; }
//
// /** /**
// * 登录中心 * 获取主键值
// */ *
// @Autowired * @param model 需要获取主键的实体
// protected LoginCenter loginCenter; * @return
// */
// /** protected String getKeyString(Object model) {
// * 日志操作类 String keyField = this.getKey();
// */ Object key = ObjectHelper.get(model, keyField);
// @Resource if (StringHelper.isEmpty(key)) {
// private LogDao logDao; return "";
// }
// @Autowired String keyString = key.toString();
// private LogFilterImpl logFilterImpl; if ("0".equals(keyString)) {
// keyString = "";
// /** }
// * 写入到数据操作类 return keyString;
// * }
// * @param logType 日志类型
// * @param id 操作编号 /**
// * @param data 数据 * 设置主键值
// */ *
// public void writeLog(int logType, String id, Object data) { * @param model 需要设置的实体
// String tableName = this.Table.Table.getName(); * @param key 需要设置的主键值
// if (StringHelper.IsEmpty(id)) { */
// return; protected void setKeyString(Object model, String key) {
// } String keyField = this.getKey();
// // 判断是否需要过滤 ObjectHelper.set(model, keyField, key);
// if (logFilterImpl.isFilter(tableName, LogFilterImpl.TypeLog, logType, data)) { }
// return;
// } /**
// ILogin login = loginCenter.getCurrent(false); * 根据输入参数来获取主键
// LogVO log = new LogVO(); *
// log.LogTable = tableName; * @param from 可以为实体或字符串。为实体时必须包含 主键 字段 或者 id 字段。
// log.LogType = logType; * @return
// log.LogKey = id; */
// log.LogDate = StringHelper.GetNow(); protected String getInputKey(Object from) {
// if (login != null) { String key;
// log.RequestID = login.get("RequestID"); if (from != null && from.getClass() == String.class) {
// log.SessionID = login.get("SessionID"); key = StringHelper.toString(from);
// } } else {
// logDao.create(log); key = this.getKeyString(from);
// } }
// if (StringHelper.isEmpty(key)) {
// private String getIdentity() { key = StringHelper.toString(ObjectHelper.get(from, "id"));
// return StringHelper.GetString(this.db.queryCell("SELECT @@IDENTITY")); }
// } if (StringHelper.isEmpty(key)) {
// key = "";
// /** }
// * 获取主键名称 return key;
// * }
// * @return 获取主键名称
// */ /**
// protected String getKey() { * 创建数据,当不传入了主键时，则会自动生成主键，传入时不会生成。
// if (this.Table == null) { *
// throw new CodeException("类" + this.getClass().getName() + "未发现表结构"); * @param model 需要创建的数据
// } * @return 创建的主键编号, 创建成功，返回主键，否则为空
// return this.Table.Table.getKeyName(); */
// } public String create(Object model) {
// // 判断主键是字符串和需要生成主键
// /** boolean isKeyString = this.Table.Table.getKeyType() == String.class;
// * 获取主键值 String keyString = this.getKeyString(model);
// *
// * @param model 需要获取主键的实体 // 生成主键
// * @return if (StringHelper.isEmpty(keyString) && isKeyString) {
// */ keyString = StringHelper.getNewID();
// protected String getKeyString(Object model) { this.setKeyString(model, keyString);
// String keyField = this.getKey(); }
// Object key = ObjectHelper.GetValue(model, keyField);
// if (StringHelper.IsEmpty(key)) { // 检测数据合法性
// return ""; this.check(DaoConst.OperatorTypeCreate, keyString, model);
// }
// String keyString = key.toString(); // 执行创建的SQL语句
// if ("0".equals(keyString)) { int ret = updateSql(DaoConst.Create, model);
// keyString = ""; // 判断是否需要获取自增编号(主键为整形)
// } if (StringHelper.isEmpty(keyString) && !isKeyString) {
// return keyString; keyString = this.getIdentity();
// } this.setKeyString(model, keyString);
// }
// /**
// * 设置主键值 // 最终处理
// * this.created(model);
// * @param model 需要设置的实体
// * @param key 需要设置的主键值 // 返回执行结果
// */ String retVal = ret > 0 ? keyString : "";
// protected void setKeyString(Object model, String key) { return retVal;
// String keyField = this.getKey(); }
// ObjectHelper.Set(model, keyField, key);
// }
// /**
// /** * 修改数据
// * 根据输入参数来获取主键 *
// * * @param model 需要修改的数据
// * @param from 可以为实体或字符串。为实体时必须包含 主键 字段 或者 id 字段。 * @return 删除的主键编号
// * @return */
// */ public String update(Object model) {
// protected String getInputKey(Object from) { String keyString = this.getKeyString(model);
// String key; if (StringHelper.isEmpty(keyString)) {
// if (from != null && from.getClass() == String.class) { throw new CodeException("表" + this.Table.Table.getName() + "主键值为空时不能更新");
// key = StringHelper.GetString(from); }
// } else { this.check(DaoConst.OperatorTypeUpdate, keyString, model);
// key = this.getKeyString(from); SqlData sqlData = this.getSql(DaoConst.Update);
// } int ret = updateSql(sqlData, model);
// if (StringHelper.IsEmpty(key)) { String retVal = ret > 0 ? keyString : "";
// key = StringHelper.GetString(ObjectHelper.GetValue(from, "id")); return retVal;
// } }
// if (StringHelper.IsEmpty(key)) {
// key = ""; /**
// } * 检测数据
// return key; *
// } * @param operatorType 操作方法类型
// * @param keyString 主键
// /** * @param model 需要检测的数据
// * 创建数据,当不传入了主键时，则会自动生成主键，传入时不会生成。 */
// * protected void check(int operatorType, String keyString, Object model) {
// * @param model 需要创建的数据 if (model instanceof InitDao) {
// * @return 创建的主键编号, 创建成功，返回主键，否则为空 InitDao to = (InitDao) model;
// */ to.init();
// public String create(Object model) { }
// // 判断主键是字符串和需要生成主键 }
// boolean isKeyString = this.Table.Table.getKeyType() == String.class;
// String keyString = this.getKeyString(model); /**
// * 保存数据
// // 生成主键 *
// if (StringHelper.IsEmpty(keyString) && isKeyString) { * @param model 需要保存的数据
// keyString = StringHelper.GetNewID(); * @return 保存的主键编号
// this.setKeyString(model, keyString); */
// } public String save(Object model) {
// String id = this.getKeyString(model);
// // 检测数据合法性 if (StringHelper.isEmpty(id)) {
// this.check(model, OperatorTypeCreate, keyString); return create(model);
// this.initData(model); } else {
// return update(model);
// // 执行创建的SQL语句 }
// int ret = updateSql(DaoConst.Create, model); }
//
// // 判断是否需要获取自增编号(主键为整形) /**
// if (StringHelper.IsEmpty(keyString) && !isKeyString) { * 删除数据
// keyString = this.getIdentity(); *
// this.setKeyString(model, keyString); * @param model 需要删除的数据
// } * @return 删除的主键编号
// */
// // 写入日志，写入到 Log_TablePlanFrom表用作计划任务 public String remove(Object model) {
// if (!StringHelper.IsEmpty(keyString)) { Object from = model;
// writeLog(LogVO.CREATE, keyString, model); // 获取来源主键
// if (ret > 0) { String keyString = getInputKey(from);
// planCenterFrom.WriteFrom(this.Table.Table.getName(), keyString);
// } if (StringHelper.isEmpty(keyString)) {
// } MapRow to = new MapRow();
// ObjectHelper.writeWithFrom(to, model);
// // 最终处理 from = this.queryFirst(MapRow.class, DaoConst.Load, from);
// this.created(model); if (from == null) {
// return "";
// // 返回执行结果 }
// String retVal = ret > 0 ? keyString : ""; keyString = this.getKeyString(from);
// return retVal; }
// }
// // 当主键存在时，只通过主键加载
// if (!StringHelper.isEmpty(keyString)) {
// /** from = new HashMap<String, Object>();
// * 修改数据 this.setKeyString(from, keyString);
// * }
// * @param model 需要修改的数据
// * @return 删除的主键编号 this.check(DaoConst.OperatorTypeRemove, keyString, from);
// */
// public String update(Object model) { SqlData sqlData = this.getSql(DaoConst.Remove);
// String keyString = this.getKeyString(model); int ret = updateSql(sqlData, from);
// if (StringHelper.IsEmpty(keyString)) { String retVal = ret > 0 ? keyString : "";
// throw new CodeException("表" + this.Table.Table.getName() + "主键值为空时不能更新"); return retVal;
// } }
// this.initData(model);
// this.check(model, OperatorTypeUpdate, keyString); /**
// writeLog(LogVO.UPDATE, keyString, model); * 加载数据
// SqlData sqlData = this.getSql(DaoConst.Update); *
// int ret = updateSql(sqlData, model); * @param model 加载数据的请求参数
// String retVal = ret > 0 ? keyString : ""; * @param cls 需要加载的数据的类型
// return retVal; * @param <T> 返回数据的类型
// } * @return 需要返回的数据
// */
// /** public <T extends Object> T load(Object model, Class<T> cls) {
// * 初始化数据 // 获取来源主键
// * Object from = model;
// * @param model String key = this.getInputKey(from);
// */
// protected void initData(Object model) { // 当主键存在时，只通过主键加载
// if (model instanceof IInitVO) { if (!StringHelper.isEmpty(key)) {
// IInitVO to = (IInitVO) model; from = new HashMap<String, Object>();
// to.init(); this.setKeyString(from, key);
// } }
// }
// // 通过传入数据进行加载
// /** T to = this.queryFirst(cls, DaoConst.Load, from);
// * 检测数据 if (to == null) {
// * return to;
// * @param model 需要检测的数据 }
// * @param operatorType 操作方法类型
// * @param keyString 主键 // 判断来源主键是否存在，不存在则获取加载后的主键
// */ if (StringHelper.isEmpty(key)) {
// protected void check(Object model, int operatorType, String keyString) { key = this.getKeyString(to);
// this.check(model, operatorType, keyString, false); }
// }
// check(DaoConst.OperatorTypeLoad, key, to);
// /**
// * 检测数据 return to;
// * }
// * @param model 需要检测的数据
// * @param operatorType 操作方法类型 /**
// * @param isCheckLogin 检测是否已经登录 * 添加统计数据
// */ *
// protected void check(Object model, int operatorType, String keyString, boolean isCheckLogin) { * @param cls 类型
// if (operatorType == OperatorTypeCreate) { * @param model 实体
// ILogin login = loginCenter.getCurrent(isCheckLogin); * @param <T> 泛型类型
// String userID = ""; * @return 增加统计的数据编号
// String deveiceID = ""; */
// String sessionID = ""; public <T extends Object> String addGroup(Class<T> cls, T model) {
// String projectID = ""; // 判断前台实体
// if (login != null) { if (model == null) {
// userID = login.get("UserID"); return "";
// deveiceID = login.get("DeveiceID"); }
// sessionID = login.get("SessionID");
// projectID = login.get("ProjectID"); // 获取前台分组的MD5标识
// } String md5 = this.getMd5(DaoConst.GroupQuery, model);
// if (!StringHelper.isEmpty(this.Table.Table.getMD5KeyName())) {
// if (model instanceof ICreateVO) { ObjectHelper.set(model, this.Table.Table.getMD5KeyName(), md5);
// ICreateVO to = (ICreateVO) model; }
// to.setCreateUserID(userID);
// to.setCreateDate(StringHelper.GetNow()); // 获取标识的实体
// } T from;
// if (this.Table.Table.getKeyType() == String.class) {
// if (model instanceof ICreateDeveiceVO) { from = model;
// ICreateDeveiceVO to = (ICreateDeveiceVO) model; this.setKeyString(model, md5);
// to.setCreateDeveiceID(deveiceID); } else if (!StringHelper.isEmpty(this.Table.Table.getMD5KeyName())) {
// to.setCreateSessionID(sessionID); Map<String, Object> map = new HashMap<String, Object>();
// } map.put(this.Table.Table.getMD5KeyName(), md5);
// from = this.load(map, cls);
// if (model instanceof ICreateProjectVO) { } else {
// ICreateProjectVO to = (ICreateProjectVO) model; from = this.queryFirst(cls, DaoConst.GroupQuery, model);
// to.setCreateProjectID(projectID); }
// }
// } // 当没有存在，则创建，否则 UpdateAdd
// } if (from == null) {
// return this.create(model);
// /** } else {
// * 保存数据 // 获取后台的编号，并写入到前台传入的数据上面
// * String keyField = this.getKey();
// * @param model 需要保存的数据 Object key = ObjectHelper.get(from, keyField);
// * @return 保存的主键编号 ObjectHelper.set(model, keyField, key);
// */
// public String save(Object model) { // 执行更新SQL语句
// String id = this.getKeyString(model); SqlData sqlData = this.getSql(DaoConst.GroupAdd);
// if (StringHelper.IsEmpty(id)) { int ret = this.updateSql(sqlData, model);
// return create(model); if (ret < 1) {
// } else { return this.create(model);
// return update(model); } else {
// } return key.toString();
// } }
// }
// /** }
// * 删除数据
// * /**
// * @param model 需要删除的数据 * 根据SQL语句名称和实体获取MD5值
// * @return 删除的主键编号 *
// */ * @param sqlName SQL语句名称
// public String remove(Object model) { * @param model 获取加密之后的实体
// Object from = model; * @param <T> 获取的类型
// // 获取来源主键 * @return 获取加密之后的值
// String keyString = getInputKey(from); */
// protected <T extends Object> String getMd5(String sqlName, T model) {
// if (StringHelper.IsEmpty(keyString)) { SqlData sql = this.getSql(sqlName);
// MapRow to = new MapRow(); StringBuilder sb = new StringBuilder();
// ObjectHelper.WriteWithFromClass(to, model); for (SqlDataField field : sql.sqlDataFields) {
// from = this.queryFirst(MapRow.class, DaoConst.Load, from); if (sb.length() > 0) {
// if (from == null) { sb.append(":");
// return ""; }
// } Object item = ObjectHelper.get(model, field.paraName);
// keyString = this.getKeyString(from); sb.append(item);
// } }
// return StringHelper.md5(sb.toString());
// // 当主键存在时，只通过主键加载 }
// if (!StringHelper.IsEmpty(keyString)) {
// from = new HashMap<String, Object>(); /**
// this.setKeyString(from, keyString); * 添加统计数据列表
// } *
// * @param sqlName 需要执行的SQL语句名称
// this.initData(from); * @param model 需要执行的SQL语句的实体
// this.check(from, OperatorTypeRemove, keyString); * @return
// */
// writeLog(LogVO.REMOVE, keyString, from); protected int addGroupList(String sqlName, Object model) {
// SqlData sqlData = this.getSql(DaoConst.Remove); this.updateSql(sqlName + "_GroupInit", model);
// int ret = updateSql(sqlData, from); return this.updateSql(sqlName + "_GroupAdd", model);
// String retVal = ret > 0 ? keyString : ""; }
// return retVal;
// } /***
// * 查询数据是否存在，当存在时修改，否则增加
// /** * @param cls 需要创建的实体的类型
// * 加载数据 * @param sqlName 执行的SQL语句
// * * @param request 前台参数，不能包含主键以及其他不需要修改的字段
// * @param model 加载数据的请求参数 * @return 保存成功，返回保存的ID，保存失败，返回空值
// * @param cls 需要加载的数据的类型 */
// * @param <T> 返回数据的类型 public <T extends Object> String saveWith(Class<T> cls, String sqlName, Object request) {
// * @return 需要返回的数据 T from = this.queryFirst(cls, sqlName, request);
// */ if (from == null) {
// public <T extends Object> T load(Object model, Class<T> cls) { try {
// // 获取来源主键 from = cls.newInstance();
// Object from = model; } catch (Exception ex) {
// String key = this.getInputKey(from); throw new CodeException("创建对象" + cls.getName() + "出错", ex);
// }
// // 当主键存在时，只通过主键加载 ObjectHelper.writeWithFrom(from, request);
// if (!StringHelper.IsEmpty(key)) { return this.create(from);
// from = new HashMap<String, Object>(); } else {
// this.setKeyString(from, key); ObjectHelper.writeWithFrom(from, request);
// } return this.update(from);
// }
// // 通过传入数据进行加载 }
// T to = this.queryFirst(cls, DaoConst.Load, from);
// if (to == null) { /**
// return to; * 创建成功后的处理
// } *
// * @param model 创建的实体数据
// // 判断来源主键是否存在，不存在则获取加载后的主键 */
// if (StringHelper.IsEmpty(key)) { protected void created(Object model) {
// key = this.getKeyString(to);
// } }
//
// check(to, OperatorTypeLoad, key); /**
// * 执行是否存在的SQL语句
// // 写入到日志 *
// writeLog(LogVO.LOAD, key, to); * @param sqlName SQL语句名称
// return to; * @param model 实体
// } * @param msg 消息
// */
// /** protected void checkExist(String sqlName, Object model, String msg) {
// * 添加统计数据 MapRow row = this.queryFirst(sqlName, model);
// * if (row != null) {
// * @param cls 类型 throw new CodeException(msg);
// * @param model 实体 }
// * @param <T> 泛型类型 }
// * @return 增加统计的数据编号 }
// */
// public <T extends Object> String addGroup(Class<T> cls, T model) {
// // 判断前台实体
// if (model == null) {
// return "";
// }
//
// // 获取前台分组的MD5标识
// String md5 = this.getMd5(DaoConst.GroupQuery, model);
// if (!StringHelper.IsEmpty(this.Table.Table.getMD5KeyName())) {
// ObjectHelper.Set(model, this.Table.Table.getMD5KeyName(), md5);
// }
//
// // 获取标识的实体
// T from;
// if (this.Table.Table.getKeyType() == String.class) {
// from = model;
// this.setKeyString(model, md5);
// } else if (!StringHelper.IsEmpty(this.Table.Table.getMD5KeyName())) {
// Map<String, Object> map = new HashMap<String, Object>();
// map.put(this.Table.Table.getMD5KeyName(), md5);
// from = this.load(map, cls);
// } else {
// from = this.queryFirst(cls, DaoConst.GroupQuery, model);
// }
//
// // 当没有存在，则创建，否则 UpdateAdd
// if (from == null) {
// return this.create(model);
// } else {
// // 获取后台的编号，并写入到前台传入的数据上面
// String keyField = this.getKey();
// Object key = ObjectHelper.GetValue(from, keyField);
// ObjectHelper.Set(model, keyField, key);
//
// // 执行更新SQL语句
// SqlData sqlData = this.getSql(DaoConst.GroupAdd);
// int ret = this.updateSql(sqlData, model);
// if (ret < 1) {
// return this.create(model);
// } else {
// return key.toString();
// }
// }
// }
//
// /**
// * 根据SQL语句名称和实体获取MD5值
// *
// * @param model
// * @param sqlName
// * @param <T>
// * @return
// */
// protected <T extends Object> String getMd5(String sqlName, T model) {
// SqlData sql = this.getSql(sqlName);
// StringBuilder sb = new StringBuilder();
// for (SqlDataField field : sql.sqlDataFields) {
// if (sb.length() > 0) {
// sb.append(":");
// }
// Object item = ObjectHelper.GetValue(model, field.paraName);
// sb.append(item);
// }
// return StringHelper.GetMD5(sb.toString());
// }
//
// /**
// * 添加统计数据列表
// *
// * @param sqlName 需要执行的SQL语句名称
// * @param model 需要执行的SQL语句的实体
// * @return
// */
// protected int addGroupList(String sqlName, Object model) {
// this.updateSql(sqlName + "_GroupInit", model);
// return this.updateSql(sqlName + "_GroupAdd", model);
// }
//
// /***
// * 查询数据是否存在，当存在时修改，否则增加
// * @param cls 需要创建的实体的类型
// * @param sqlName 执行的SQL语句
// * @param request 前台参数，不能包含主键以及其他不需要修改的字段
// * @return 保存成功，返回保存的ID，保存失败，返回空值
// */
// public <T extends Object> String saveWith(Class<T> cls, String sqlName, Object request) {
// T from = this.queryFirst(cls, sqlName, request);
// if (from == null) {
// try {
// from = cls.newInstance();
// } catch (Exception ex) {
// throw new CodeException("创建对象" + cls.getName() + "出错", ex);
// }
// ObjectHelper.WriteWithFromClass(from, request);
// return this.create(from);
// } else {
// ObjectHelper.WriteWithFromClass(from, request);
// return this.update(from);
// }
// }
//
// /**
// * 创建成功后的处理
// *
// * @param model
// */
// protected void created(Object model) {
//
// }
//
// /**
// * 执行是否存在的SQL语句
// *
// * @param sqlName
// * @param model
// * @param msg
// */
// protected void checkExist(String sqlName, Object model, String msg) {
// MapRow row = this.queryFirst(sqlName, model);
// if (row != null) {
// throw new CodeException(msg);
// }
// }
//}
yzg-util-db/src/main/java/com/yanzuoguang/db/db/dao/Impl/TableStruct.java
View file @ d738a26b
package com.yanzuoguang.db.db.dao.Impl; package com.yanzuoguang.db.db.dao.Impl;
import com.yanzuoguang.db.db.dao.DaoConst;
import com.yanzuoguang.db.db.dao.TableAnnotation; import com.yanzuoguang.db.db.dao.TableAnnotation;
import com.yanzuoguang.util.helper.StringHelper; import com.yanzuoguang.util.helper.StringHelper;
import com.yanzuoguang.util.obj.MethodField; import com.yanzuoguang.util.obj.MethodField;
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment