Skip to content

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

Merge remote-tracking branch 'origin/master'

parents bed37658 2a6fb6bd
Hide whitespace changes
Inline Side-by-side
Showing with 1241 additions and 479 deletions
yzg-util-base/src/main/java/com/yanzuoguang/util/SetSetpictureVo.java 0 → 100644
View file @ b23101e3
//package com.yanzuoguang.util;
//
//import com.yanzuoguang.util.base.MethodField;
//import com.yanzuoguang.util.base.ObjectHelper;
//import com.yanzuoguang.util.helper.JsonHelper;
//import com.yanzuoguang.util.helper.StringHelper;
//import com.yanzuoguang.util.vo.BaseVo;
//import com.yanzuoguang.util.vo.InitDao;
//
//import java.util.HashMap;
//
///**
// * 座次图关联表
// *
// * @author 朱磊
// */
//public class SetSetpictureVo extends BaseVo implements InitDao {
//
// /**
// * 座次图关联ID
// */
// private String setPictureId = "setPictureId";
// /**
// * 座次图ID
// */
// private String pictureId = "pictureId";
//
// @Override
// public void init() {
// this.setPictureId = StringHelper.getFirst(this.setPictureId, StringHelper.EMPTY);
// this.pictureId = StringHelper.getFirst(this.pictureId, StringHelper.EMPTY);
// }
//
// public String getSetPictureId() {
// return setPictureId;
// }
//
// public void setSetPictureId(String setPictureId) {
// this.setPictureId = setPictureId;
// }
//
// public String getPictureId() {
// return pictureId;
// }
//
// public void setPictureId(String pictureId) {
// this.pictureId = pictureId;
// }
//
// public static void main(String[] args) {
// SetSetpictureVo set = new SetSetpictureVo();
// System.out.println(ObjectHelper.get(set, "setPictureId"));
// System.out.println(ObjectHelper.get(set, "pictureId"));
//
// HashMap<String, MethodField> initTypeField = ObjectHelper.getTypeField(SetSetpictureVo.class);
// System.out.println(JsonHelper.serialize(initTypeField));
// }
//}
yzg-util-base/src/main/java/com/yanzuoguang/util/base/MethodField.java
View file @ b23101e3
......@@ -12,21 +12,62 @@ public class MethodField {
/**
* 名称
*/
public String name;
private String name;
/**
* 缩写名称
*/
public String nameSimple;
private String nameSimple;
/**
* 对应的字段
*/
public Field field;
private Field field;
/**
* 对应的获取方法
*/
public Method getMethod;
private Method getMethod;
/**
* 对应的设置方法
*/
public Method setMethod;
private Method setMethod;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getNameSimple() {
return nameSimple;
}
public void setNameSimple(String nameSimple) {
this.nameSimple = nameSimple;
}
public Field getField() {
return field;
}
public void setField(Field field) {
this.field = field;
}
public Method getGetMethod() {
return getMethod;
}
public void setGetMethod(Method getMethod) {
this.getMethod = getMethod;
}
public Method getSetMethod() {
return setMethod;
}
public void setSetMethod(Method setMethod) {
this.setMethod = setMethod;
}
}
yzg-util-base/src/main/java/com/yanzuoguang/util/base/ObjectHelper.java
View file @ b23101e3
......@@ -5,10 +5,7 @@ import com.yanzuoguang.util.exception.CodeException;
import com.yanzuoguang.util.exception.ExceptionHelper;
import com.yanzuoguang.util.helper.StringHelper;
import java.lang.reflect.Array;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.lang.reflect.*;
import java.util.*;
/**
......@@ -156,10 +153,10 @@ public class ObjectHelper {
return null;
}
try {
if (item.field != null && Modifier.isPublic(item.field.getModifiers())) {
return item.field.get(target);
} else if (item.getMethod != null && Modifier.isPublic(item.getMethod.getModifiers())) {
return item.getMethod.invoke(target);
if (item.getField() != null && Modifier.isPublic(item.getField().getModifiers())) {
return item.getField().get(target);
} else if (item.getGetMethod() != null && Modifier.isPublic(item.getGetMethod().getModifiers())) {
return item.getGetMethod().invoke(target);
}
} catch (Exception ex) {
ExceptionHelper.handleException(ObjectHelper.class, ex, field);
......@@ -206,17 +203,21 @@ public class ObjectHelper {
return;
}
try {
if (item.field != null && Modifier.isPublic(item.field.getModifiers())) {
Class toType = item.field.getType();
Object toValue = StringHelper.to(toType, value);
item.field.set(target, toValue);
} else if (item.setMethod != null && Modifier.isPublic(item.setMethod.getModifiers())) {
Class toType = item.setMethod.getParameterTypes()[0];
Object toValue = StringHelper.to(toType, value);
item.setMethod.invoke(target, toValue);
}
setByType(target, item, value);
} catch (Exception ex) {
ExceptionHelper.handleException(ObjectHelper.class, ex, field);
ExceptionHelper.handleException(ObjectHelper.class, ex, item.getName());
}
}
public static void setByType(Object target, MethodField item, Object value) throws IllegalAccessException, InvocationTargetException {
if (item.getField() != null && Modifier.isPublic(item.getField().getModifiers())) {
Class toType = item.getField().getType();
Object toValue = StringHelper.to(toType, value);
item.getField().set(target, toValue);
} else if (item.getSetMethod() != null && Modifier.isPublic(item.getSetMethod().getModifiers())) {
Class toType = item.getSetMethod().getParameterTypes()[0];
Object toValue = StringHelper.to(toType, value);
item.getSetMethod().invoke(target, toValue);
}
}
......@@ -247,15 +248,15 @@ public class ObjectHelper {
* 获取缓存中的字段
* @param typeCache 类型
* @param fromName 来源名称
* @param toName 目标名称
* @return
*/
private static MethodField getField(HashMap<String, MethodField> typeCache, String fromName) {
String toName = getSimpleName(fromName);
private static MethodField getField(HashMap<String, MethodField> typeCache, String fromName, String toName) {
if (!typeCache.containsKey(toName)) {
MethodField newObj = new MethodField();
typeCache.put(toName, newObj);
newObj.name = fromName;
newObj.nameSimple = toName;
newObj.setName(fromName);
newObj.setNameSimple(toName);
}
return typeCache.get(toName);
}
......@@ -267,7 +268,7 @@ public class ObjectHelper {
* @return
*/
private static String getSimpleName(String fromName) {
String toName = fromName.toLowerCase().replace("_", "");
String toName = getSimpleFieldName(fromName);
if (toName.startsWith(METHOD_IS)) {
toName = toName.substring(METHOD_IS.length());
} else if (toName.startsWith(METHOD_GET)) {
......@@ -277,7 +278,18 @@ public class ObjectHelper {
} else {
return toName;
}
return getSimpleName(toName);
return toName;
}
/**
* 获取字段处理名称
*
* @param fromName 字段名称
* @return 属性名称
*/
private static String getSimpleFieldName(String fromName) {
String toName = fromName.toLowerCase().replace("_", "");
return toName;
}
/**
......@@ -303,12 +315,13 @@ public class ObjectHelper {
// 忽略大小写、忽略下划线 _
for (Field field : fields) {
MethodField obj = getField(typeCache, field.getName());
if (Modifier.isStatic(field.getModifiers())) {
continue;
}
if (obj.field == null) {
obj.field = field;
String toName = getSimpleFieldName(field.getName());
MethodField obj = getField(typeCache, field.getName(), toName);
if (obj.getField() == null) {
obj.setField(field);
}
}
for (Method method : methods) {
......@@ -317,31 +330,32 @@ public class ObjectHelper {
}
String methodNameSource = method.getName();
String methodNameSimple = methodNameSource.toLowerCase();
String toName = getSimpleName(methodNameSource);
if ("getClass".equals(methodNameSource)) {
continue;
} else if (methodNameSimple.startsWith("set")) {
if (method.getParameterTypes().length != 1) {
continue;
}
MethodField obj = getField(typeCache, methodNameSource);
if (obj.setMethod == null) {
obj.setMethod = method;
MethodField obj = getField(typeCache, methodNameSource,toName);
if (obj.getSetMethod() == null) {
obj.setSetMethod(method);
}
} else if (methodNameSimple.startsWith("get")) {
if (method.getReturnType() == null) {
continue;
}
MethodField obj = getField(typeCache, methodNameSource);
if (obj.getMethod == null) {
obj.getMethod = method;
MethodField obj = getField(typeCache, methodNameSource,toName);
if (obj.getGetMethod() == null) {
obj.setGetMethod(method);
}
} else if (methodNameSimple.startsWith("is")) {
if (method.getReturnType() == null) {
continue;
}
MethodField obj = getField(typeCache, methodNameSource);
if (obj.getMethod == null) {
obj.getMethod = method;
MethodField obj = getField(typeCache, methodNameSource,toName);
if (obj.getGetMethod() == null) {
obj.setGetMethod(method);
}
}
}
......@@ -374,7 +388,7 @@ public class ObjectHelper {
*/
private static MethodField getMethodField(Class<?> type, String name) {
HashMap<String, MethodField> typeCache = getTypeField(type);
name = getSimpleName(name);
name = getSimpleFieldName(name);
return typeCache.containsKey(name) ? typeCache.get(name) : null;
}
......@@ -538,7 +552,7 @@ public class ObjectHelper {
return to;
}
for (Map.Entry<String, MethodField> field : mapField.entrySet()) {
String name = field.getValue().name;
String name = field.getValue().getName();
Object fromValue = ObjectHelper.get(from, name);
if (StringHelper.isEmpty(fromValue)) {
continue;
......
yzg-util-base/src/main/java/com/yanzuoguang/util/cache/MemoryCacheCenter.java
View file @ b23101e3
......@@ -16,7 +16,7 @@ public class MemoryCacheCenter {
/**
* 缓存的对象
*/
public static List<MemoryCache> CLEAR_LIST = new Vector<MemoryCache>();
public final static List<MemoryCache> CLEAR_LIST = new Vector<MemoryCache>();
static {
init();
......
yzg-util-base/src/main/java/com/yanzuoguang/util/exception/CodeException.java
View file @ b23101e3
......@@ -2,6 +2,7 @@ package com.yanzuoguang.util.exception;
/**
* 途比达异常信息
*
* @author 颜佐光
*/
public class CodeException extends RuntimeException {
......@@ -57,6 +58,15 @@ public class CodeException extends RuntimeException {
this.code = code;
}
/**
* 构造函数
* throw new CodeException("01","该订单已过期",order);
* throw new CodeException("02","该订单未到使用时间",order);
*
* @param code 　错误码
* @param message 　错误消息
* @param target 　错误数据源，如订单数据
*/
public CodeException(String code, String message, Object target) {
super(message);
this.code = code;
......
yzg-util-base/src/main/java/com/yanzuoguang/util/helper/ByteHelper.java
View file @ b23101e3
......@@ -29,6 +29,8 @@ public class ByteHelper {
*/
public static final int BCD_MAX_FLAG = 100;
private ByteHelper(){}
// --------------------------------------- toLH -------------------------------------
/**
......@@ -554,6 +556,7 @@ public class ByteHelper {
* @return 转换之后的值
*/
public static int fromBCD(byte from) {
return (from / BYTE_HEX_UNIT) * BYTE_TEN_UNIT + from % BYTE_HEX_UNIT;
return (from / BYTE_HEX_UNIT) * BYTE_TEN_UNIT + from %
BYTE_HEX_UNIT;
}
}
yzg-util-base/src/main/java/com/yanzuoguang/util/helper/CheckerHelper.java
View file @ b23101e3
......@@ -11,12 +11,13 @@ import java.util.regex.Pattern;
/**
* 参数业务逻辑校验
*
* @author 颜佐光
*/
public final class CheckerHelper {
public static final String PARAM_NOT_NULL_TIPS = "param [%s] is null";
public static final String PARAM_NOT_EMPTY_TIPS = "param [%s] is empty";
public static final String PARAM_NOT_NUMBER = "param [%s] must be number";
public static final String PARAM_NOT_NUMBER = "param [%s] value [%s] must be number";
public static final String PARAM_OVER_MAX_LENGTH = "param [%s] maxlength is ";
public static final String PARAM_NOT_DATE_MONTH = "param [%s] must be yyyyMM";
......@@ -176,9 +177,6 @@ public final class CheckerHelper {
String eL = "";
String msg = "";
if (StringHelper.isEmpty(paramVal)) {
msg = PARAM_NOT_NULL_TIPS;
this.checkResult = String.format(msg, paramName, paramVal);
this.setValid(false);
return this;
}
if (DATE_CHECK_TYPE_DAY.equals(queryType)) {
......@@ -272,7 +270,7 @@ public final class CheckerHelper {
SimpleDateFormat format = new SimpleDateFormat(formatStr);
format.parse(paramVal);
} else {
DateAutoHelper.getAutoDate(formatStr);
DateAutoHelper.getAutoDate(paramVal);
}
} catch (ParseException e) {
this.checkResult = String.format(PARAM_NOT_DATE, paramName, formatStr);
......@@ -328,7 +326,7 @@ public final class CheckerHelper {
return this;
}
if (paramVal < min) {
this.checkResult = String.format(PARAM_NOT_MIN, min, paramName);
this.checkResult = String.format(PARAM_NOT_MIN, paramName, min);
this.setValid(false);
}
return this;
......@@ -347,7 +345,7 @@ public final class CheckerHelper {
return this;
}
if (paramVal > max) {
this.checkResult = String.format(PARAM_NOT_MAX, max, paramName);
this.checkResult = String.format(PARAM_NOT_MAX, paramName, max);
this.setValid(false);
}
return this;
......@@ -367,7 +365,7 @@ public final class CheckerHelper {
return this;
}
if (paramVal > max || paramVal < min) {
this.checkResult = String.format(PARAM_NOT_RANGE, min, max, paramName);
this.checkResult = String.format(PARAM_NOT_RANGE, paramName, min, max);
this.setValid(false);
}
return this;
......
yzg-util-base/src/main/java/com/yanzuoguang/util/helper/FileHelper.java
View file @ b23101e3
......@@ -87,18 +87,24 @@ public class FileHelper {
try {
// 删除文件
if (file.exists()) {
file.delete();
if (!file.delete()) {
throw new CodeException("文件删除失败");
}
}
if (file.exists()) {
throw new CodeException("文件删除失败");
}
// 创建文件夹
File parentFile = file.getParentFile();
if (parentFile != null && !parentFile.exists()) {
parentFile.mkdirs();
}
if (!parentFile.exists()) {
throw new CodeException("创建文件夹失败");
if (parentFile != null) {
if (!parentFile.exists()) {
if (!parentFile.mkdirs()) {
throw new CodeException("创建文件夹失败");
}
}
if (!parentFile.exists()) {
throw new CodeException("创建文件夹失败");
}
}
file.createNewFile();
// 写入文件
......
yzg-util-base/src/main/java/com/yanzuoguang/util/helper/HttpHelper.java
View file @ b23101e3
......@@ -86,7 +86,7 @@ public class HttpHelper {
*/
public static String post(HttpURLConnection httpConn, String jsonString) throws IOException {
// 返回的结果
String result = "";
StringBuilder result = new StringBuilder();
// 读取响应输入流
BufferedReader in = null;
PrintWriter out = null;
......@@ -107,7 +107,7 @@ public class HttpHelper {
String line;
// 读取返回的内容
while ((line = in.readLine()) != null) {
result += line;
result.append(line);
}
} finally {
if (out != null) {
......@@ -117,7 +117,7 @@ public class HttpHelper {
in.close();
}
}
return result;
return result.toString();
}
/**
......
yzg-util-base/src/main/java/com/yanzuoguang/util/helper/RandomHelper.java
View file @ b23101e3
......@@ -2,10 +2,12 @@ package com.yanzuoguang.util.helper;
import com.yanzuoguang.util.contants.SystemContants;
import java.util.Random;
import java.util.UUID;
/**
* 随机码生成工具
*
* @author 颜佐光
*/
public final class RandomHelper {
......@@ -75,7 +77,7 @@ public final class RandomHelper {
* 随机生成指定字符集、指定长度的的随机码
*
* @param charset 基础字符集
* @param len 生成随机码长度
* @param len 生成随机码长度
* @return
*/
public static String generateRandomCode(String charset, int len) {
......@@ -102,12 +104,12 @@ public final class RandomHelper {
* @return
*/
private static String generateRandomCodeOne(String charset, int len) {
int index = (int) (Math.random() * len);
int index = new Random().nextInt(len);
return String.valueOf(charset.charAt(index));
}
private static String replace(String str, String olds, String news) {
if(null == str) {
if (null == str) {
return "";
}
while (str.indexOf(olds) > -1) {
......
yzg-util-base/src/main/java/com/yanzuoguang/util/helper/RunHelper.java
View file @ b23101e3
......@@ -13,7 +13,7 @@ public class RunHelper {
/**
* 执行次数
*/
public static int REQ_SIZE = 3;
public final static int REQ_SIZE = 3;
/**
* 执行次数，并且获取最后一次的异常
......
yzg-util-base/src/main/java/com/yanzuoguang/util/helper/StringHelper.java
View file @ b23101e3
......@@ -5,6 +5,7 @@ import com.yanzuoguang.util.exception.CodeException;
import com.yanzuoguang.util.exception.ExceptionHelper;
import java.io.UnsupportedEncodingException;
import java.nio.charset.Charset;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.Arrays;
......@@ -329,31 +330,34 @@ public class StringHelper {
* @return 返回获取的值
*/
public static <T> T to(Class<T> cls, Object from) {
if (from == null) {
return null;
}
String vName = cls.getName();
Object to = null;
if (cls.isEnum()) {
String strValue = toString(from);
to = EnumHelper.toEnum(cls, strValue);
} else if (isType(cls, String.class)) {
if (isType(cls, String.class)) {
to = toString(from);
} else if (TYPE_BOOL.equals(vName) || isType(cls, Boolean.class)) {
} else if (TYPE_BOOL.equals(vName)
|| (isType(cls, Boolean.class) && from != null)) {
String strValue = toString(from);
to = toBoolean(strValue);
} else if (TYPE_INT.equals(vName) || isType(cls, Integer.class)) {
} else if (TYPE_INT.equals(vName)
|| (isType(cls, Integer.class) && from != null)) {
to = toInt(from);
} else if (TYPE_DOUBLE.equals(vName) || isType(cls, Double.class)) {
} else if (TYPE_DOUBLE.equals(vName) ||
(isType(cls, Double.class) && from != null)) {
to = toDouble(from);
} else if (TYPE_FLOAT.equals(vName) || isType(cls, Float.class)) {
} else if (TYPE_FLOAT.equals(vName)
|| (isType(cls, Float.class) && from != null)) {
to = toDouble(from);
} else if (isType(cls, Double.class)) {
to = toDecimal(from);
} else if (isType(cls, Date.class)) {
to = DateHelper.getDateTime(from);
} else if (cls.isEnum()) {
String strValue = toString(from);
if (strValue != null) {
to = EnumHelper.toEnum(cls, strValue);
}
}
if (to != null) {
if (to == null && from == null) {
return null;
} else if (to != null) {
return (T) to;
} else {
if (ObjectHelper.isSub(cls, from.getClass())) {
......@@ -572,7 +576,7 @@ public class StringHelper {
try {
buff = from.getBytes(charset);
// 将字节流转换为字符串
from = new String(buff);
from = new String(buff, charset);
from = from.replace("\0", "").replace("\n", "");
} catch (UnsupportedEncodingException e) {
ExceptionHelper.handleException(StringHelper.class, e, from);
......@@ -822,7 +826,7 @@ public class StringHelper {
// 生成实现指定摘要算法的 MessageDigest 对象。
MessageDigest md = MessageDigest.getInstance("MD5");
// 使用指定的字节数组更新摘要。
md.update(from.getBytes());
md.update(from.getBytes(Charset.forName("utf-8")));
// 通过执行诸如填充之类的最终操作完成哈希计算。
byte[] b = md.digest();
// 生成具体的md5密码到buf数组
......
yzg-util-base/src/main/java/com/yanzuoguang/util/table/TableHeadItem.java
View file @ b23101e3
......@@ -2,7 +2,7 @@ package com.yanzuoguang.util.table;
/**
* 列头
* 列头，A.B , A.C
* @author 颜佐光
*/
public class TableHeadItem {
......
yzg-util-base/src/main/java/com/yanzuoguang/util/thread/AbstractThreadList.java
View file @ b23101e3
......@@ -16,7 +16,7 @@ public abstract class AbstractThreadList<T extends Object> implements ThreadWait
/**
* 线程等待间隔
*/
public static int PrintTimeout = 1000 * 2;
public final static int PrintTimeout = 1000 * 2;
/**
* 线程数量
......@@ -283,7 +283,7 @@ public abstract class AbstractThreadList<T extends Object> implements ThreadWait
}
ThreadListData<T> data = cacheThread.get(Thread.currentThread());
data.setDate(new Date());
data.setDate(System.currentTimeMillis());
data.setData(item);
try {
this.run(item);
......
yzg-util-base/src/main/java/com/yanzuoguang/util/thread/RunPlan.java
View file @ b23101e3
......@@ -10,6 +10,7 @@ import java.util.List;
/**
* 自动执行任务
*
* @author 颜佐光
*/
public class RunPlan {
......@@ -82,7 +83,7 @@ public class RunPlan {
*/
public final void run(boolean isRemove, int maxError) {
for (int i = list.size() - 1; i >= 0; i--) {
Date now = new Date();
long now = System.currentTimeMillis();
RunPlanData item;
synchronized (this.lock) {
item = list.size() > i ? list.get(i) : null;
......@@ -96,10 +97,10 @@ public class RunPlan {
// 在Window CE中时间相减可能会出错
try {
// 处理非法改动时间
if (item.getDate().compareTo(now) > 0) {
if (item.getDate() > now) {
item.setDate(now);
}
millSeconds = (now.getTime() - item.getDate().getTime());
millSeconds = (now - item.getDate());
} catch (Exception ex) {
ExceptionHelper.handleException(ThreadHelper.class, ex);
}
......
yzg-util-base/src/main/java/com/yanzuoguang/util/thread/RunPlanData.java
View file @ b23101e3
......@@ -10,7 +10,7 @@ public class RunPlanData {
/**
* 任务开始时间
*/
private Date date;
private long date;
/**
* 执行标记
*/
......@@ -39,11 +39,11 @@ public class RunPlanData {
this.initDate();
}
public Date getDate() {
public long getDate() {
return date;
}
public void setDate(Date date) {
public void setDate(long date) {
this.date = date;
}
......@@ -106,6 +106,6 @@ public class RunPlanData {
* 重置时间
*/
public void initDate() {
this.date = new Date();
this.date = System.currentTimeMillis();
}
}
yzg-util-base/src/main/java/com/yanzuoguang/util/thread/RunnableListAuto.java
View file @ b23101e3
......@@ -17,7 +17,7 @@ public final class RunnableListAuto {
/**
* 是否打印线程日志
*/
public static boolean IsLog = false;
public final static boolean IsLog = false;
/**
* 缓存的执行对象的数据大小
......
yzg-util-base/src/main/java/com/yanzuoguang/util/thread/ThreadListData.java
View file @ b23101e3
......@@ -13,18 +13,18 @@ public class ThreadListData<T> {
/**
* 执行时间
*/
private Date date;
private long date;
/**
* 执行的数据
*/
private T data;
public Date getDate() {
public long getDate() {
return date;
}
public void setDate(Date date) {
public void setDate(long date) {
this.date = date;
}
......
yzg-util-base/src/main/java/com/yanzuoguang/util/vo/Ref.java
View file @ b23101e3
......@@ -3,11 +3,15 @@ package com.yanzuoguang.util.vo;
/**
* 引用值，方便修改
*
int func(Ref<Interger> int1,Ref<Integer> int2){
int1.value =1 ;
}
* @param <T>
* @author 颜佐光
*/
public class Ref<T> {
public T value;
public Ref(T value) {
this.value = value;
}
......
yzg-util-cloud/src/main/java/com/yanzuoguang/cloud/aop/WebAspect.java
View file @ b23101e3
......@@ -2,7 +2,6 @@ package com.yanzuoguang.cloud.aop;
import com.yanzuoguang.cloud.CloudContans;
import com.yanzuoguang.cloud.service.TokenServiceCall;
import com.yanzuoguang.util.base.ObjectHelper;
import com.yanzuoguang.util.contants.ResultConstants;
import com.yanzuoguang.util.exception.ExceptionHelper;
import com.yanzuoguang.util.helper.JsonHelper;
......@@ -20,6 +19,7 @@ import org.aspectj.lang.reflect.MethodSignature;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
import javax.servlet.ServletRequest;
......@@ -42,6 +42,9 @@ public class WebAspect extends BaseRequestAspect {
@Autowired
private TokenServiceCall tokenServiceCall;
@Value("${yzg.reqUrl:order,check,use}")
private String reqUrl;
/**
* exec aop point aspect
*/
......@@ -116,30 +119,55 @@ public class WebAspect extends BaseRequestAspect {
* @throws NoSuchMethodException
*/
private Type getReturnType(ProceedingJoinPoint joinPoint) {
Method m = getMethod(joinPoint);
Type t = m.getAnnotatedReturnType().getType();
return t;
}
/**
* 获取返回的至类型
*
* @param joinPoint
* @return
* @throws NoSuchMethodException
*/
private Method getMethod(ProceedingJoinPoint joinPoint) {
//获取返回值类型
Signature s = joinPoint.getSignature();
MethodSignature ms = (MethodSignature) s;
Method m = ms.getMethod();
Type t = m.getAnnotatedReturnType().getType();
return t;
return m;
}
/**
* 执行方法
*
* @param joinPoint 需要执行的方法
* @param name 方法名称
* @return 返回结果
* @throws Throwable
*/
private Object executeMethod(ProceedingJoinPoint joinPoint, String name) throws Throwable {
boolean dataArgs = joinPoint.getArgs().length != 1
|| joinPoint.getArgs().length == 1 &&
(joinPoint.getArgs()[0] instanceof ServletResponse || joinPoint.getArgs()[0] instanceof ServletRequest);
if (dataArgs) {
Method method = getMethod(joinPoint);
boolean isUrl = false;
if (!StringHelper.isEmpty(reqUrl)) {
String[] urls = reqUrl.split(",");
for (String url : urls) {
if (method.getName().matches(url)) {
isUrl = true;
break;
}
}
}
if (dataArgs || !isUrl) {
return joinPoint.proceed();
} else {
// 获取请求编号
Object firstArgs = joinPoint.getArgs().length > 0 ? joinPoint.getArgs()[0] : null;
String reqId = ObjectHelper.getString(firstArgs, "reqId");
if (StringHelper.isEmpty(reqId)) {
reqId = StringHelper.md5(JsonHelper.serialize(firstArgs));
} else {
// 请求编号和公司编号挂钩
reqId = StringHelper.getId(ObjectHelper.getString(firstArgs, "companyId"), reqId);
}
String reqId = StringHelper.md5(JsonHelper.serialize(firstArgs));
String reqFull = StringHelper.getId(reqId, HttpAspectUtil.getHttpRequestUrl());
RequestCacheResult req = cacheResult.get(reqFull, new RequestCacheResult(reqFull));
// 缓存的键值对
......
yzg-util-cloud/src/main/java/com/yanzuoguang/cloud/aop/WebConfig.java 0 → 100755
View file @ b23101e3
package com.yanzuoguang.cloud.aop;
import com.yanzuoguang.util.log.Log;
import org.springframework.boot.web.servlet.filter.OrderedHiddenHttpMethodFilter;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.filter.HiddenHttpMethodFilter;
import org.springframework.web.servlet.config.annotation.CorsRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;
import javax.servlet.FilterChain;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
/**
* 跨域的支持
*
* @author 颜佐光
*/
@Configuration
public class WebConfig extends WebMvcConfigurerAdapter {
public WebConfig() {
Log.info(WebConfig.class, "跨域已开启支持");
}
@Bean
public HiddenHttpMethodFilter hiddenHttpMethodFilter() {
return new OrderedHiddenHttpMethodFilter() {
@Override
protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain)
throws ServletException, IOException {
filterChain.doFilter(request, response);
}
};
}
@Override
public void addCorsMappings(CorsRegistry registry) {
registry.addMapping("/**")
.allowedOrigins("*")
.allowCredentials(true)
.allowedMethods("GET", "POST", "DELETE", "PUT")
.maxAge(3600);
}
}
yzg-util-db/src/main/java/com/yanzuoguang/code/CodePwdImpl.java
View file @ b23101e3
......@@ -10,6 +10,7 @@ import java.util.Random;
/**
* 加密算法0版实现
*
* @author 颜佐光
*/
public class CodePwdImpl implements CodePwd {
......@@ -38,25 +39,26 @@ public class CodePwdImpl implements CodePwd {
*/
@Override
public String getCode(String rand, String day, String index, String pwd) {
String ret = "";
StringBuilder ret = new StringBuilder();
// 1. 将随即数和天数进行组合生成字符串
String randDay = "";
StringBuilder sb = new StringBuilder();
{
int randSize = rand.length();
int daySize = day.length();
int maxLen = Math.max(rand.length(), day.length());
for (int i = 0; i < maxLen; i++) {
if (i < daySize) {
randDay += day.charAt(i);
sb.append(day.charAt(i));
}
if (i < randSize) {
randDay += rand.charAt(i);
sb.append(rand.charAt(i));
}
}
}
// 2. 将组合后的数字进行交换
String randDay = sb.toString();
int randDaySize = randDay.length();
char[] dayChars = new char[randDaySize];
{
......@@ -71,7 +73,7 @@ public class CodePwdImpl implements CodePwd {
}
}
for (int i = 0; i < randDaySize; i++) {
ret += dayChars[i];
ret.append(dayChars[i]);
}
}
......@@ -121,10 +123,10 @@ public class CodePwdImpl implements CodePwd {
for (int i = 0; i < newSize; i++) {
newValue[i] = (newValue[i] % 10 + 10) % 10;
ret += newValue[i];
ret.append(newValue[i]);
}
return ret;
return ret.toString();
}
public static void test(String[] args) {
......
yzg-util-db/src/main/java/com/yanzuoguang/dao/BaseDao.java
View file @ b23101e3
package com.yanzuoguang.dao;
import com.yanzuoguang.util.vo.PageSizeData;
import com.yanzuoguang.util.vo.PageSizeReqVo;
import java.util.List;
/**
* 数据基本操作接口
*
* @author 颜佐光
*/
public interface BaseDao {
......@@ -35,31 +39,41 @@ public interface BaseDao {
String save(Object model);
/**
* 删除数据
*
* @param model 需要删除的数据
* 删除数据，可以用于父子表删除，如通过订单删除游客信息 visitorDao.remove({orderId:1});
* int field;
* @param model 需要删除的数据,可以是主键字符串（Int），或者是包含主键的实体，或者是包含其他非主键的实体完全匹配.
* @return 删除的记录数量
*/
int remove(Object model);
/**
* 加载数据
* 加载数据，可以用于父子表删除，如通过订单删除游客信息 visitorDao.load({orderId:1});
*
* @param model 加载数据的请求参数
* @param cls 需要加载的数据的类型
* @param model 加载数据的请求参数,可以是主键字符串（Int），或者是包含主键的实体，或者是包含其他非主键的实体完全匹配.
* @param resultClass 需要加载的数据的类型
* @param <T> 返回数据的类型
* @return 需要返回的数据
*/
<T extends Object> T load(Object model, Class<T> cls);
<T extends Object> T load(Object model, Class<T> resultClass);
/**
* 加载列表数据
* 加载列表数据，可以用于父子表删除，如通过订单删除游客信息 visitorDao.loadList({orderId:1});
*
* @param model 加载数据的请求参数,可以是主键字符串（Int），或者是包含主键的实体，或者是包含其他非主键的实体完全匹配.
* @param resultClass 需要加载的数据的类型
* @param <T> 返回数据的类型
* @return 需要返回的数据
*/
<T extends Object> List<T> loadList(Object model, Class<T> resultClass);
/**
* 加载分页数据
*
* @param model 加载数据的请求参数
* @param cls 需要加载的数据的类型
* @param model 加载数据的请求参数,可以是主键字符串（Int），或者是包含主键的实体，或者是包含其他非主键的实体完全匹配.
* @param resultClass 需要加载的数据的类型
* @param <T> 返回数据的类型
* @return 需要返回的数据
*/
<T extends Object> List<T> loadList(Object model, Class<T> cls);
<T extends Object> PageSizeData<T> loadPage(PageSizeReqVo model, Class<T> resultClass);
}
yzg-util-db/src/main/java/com/yanzuoguang/dao/DaoConst.java
View file @ b23101e3
......@@ -53,6 +53,11 @@ public class DaoConst {
*/
public static final String GROUP_QUERY = "GroupQuery";
/**
* 根据某个字段保存
*/
public static final String SAVE_WITH = "SaveWith";
/**
* 驼峰式命名
*/
......@@ -69,51 +74,119 @@ public class DaoConst {
* 单位地址
*/
public static final int CODE_UNIT = 2;
/**
* 插入SQL语句模板
*/
public static final String SQL_INSERT = "INSERT INTO {TABLE}({FIELD}) VALUES({VALUES})";
/**
* 更新SQL语句模板
*/
public static final String SQL_UPDATE = "UPDATE {TABLE} AS a {INNER} SET {FIELD} WHERE 1=1 {WHERE}";
/**
* 删除SQL语句模板
*/
public static final String SQL_REMOVE = "DELETE a FROM {TABLE} AS a {INNER} WHERE 1=1 {WHERE}";
/**
* 加载SQL语句模板
*/
public static final String SQL_LOAD = "SELECT a.*{FIELD} FROM {TABLE} AS a {INNER} WHERE 1=1 {WHERE}";
/**
* 表名代码片段
*/
public static final String TABLE_CODE = "{TABLE}";
public static final String CODE_TABLE = "{TABLE}";
/**
* 字段代码片段
*/
public static final String FIELD_CODE = "{FIELD}";
public static final String CODE_FIELD = "{FIELD}";
/**
* 值代码片段
*/
public static final String VALUES_CODE = "{VALUES}";
public static final String CODE_VALUES = "{VALUES}";
/**
* WHERE条件代码片段
*/
public static final String WHERE_CODE = "{WHERE}";
public static final String CODE_WHERE = "{WHERE}";
/**
* 插入SQL语句模板
* 更新字段模板
*/
public static final String INSERT_MODEL = "INSERT INTO {TABLE}({FIELD}) VALUES({VALUES})";
public static final String CODE_UPDATE_FIELD = "a.%s=%s";
/**
* 更新SQL语句模板
* 更新字段模板主键
*/
public static final String UPDATE_MODEL = "UPDATE {TABLE} SET {FIELD} WHERE 1=1 {WHERE}";
public static final String CODE_UPDATE_PRIMARY = "a.%s=a.%s";
/**
* 删除SQL语句模板
* 更新字段模板参数
*/
public static final String REMOVE_MODEL = "DELETE FROM {TABLE} WHERE 1=1 {WHERE}";
public static final String CODE_UPDATE_FIELD_PARA = ",a.%s=?";
/**
* 加载SQL语句模板
* 更新字段模板参数
*/
public static final String CODE_UPDATE_FIELD_REMOVE = "a.%s=1";
/**
* 等于条件
*/
public static final String LOAD_MODEL = "SELECT a.*{FIELD} FROM {TABLE} AS a {INNER} WHERE 1=1 {WHERE}";
public static final String CODE_WHERE_EQUALS = "AND %s%s=%s";
/**
* 等于条件参数
*/
public static final String CODE_WHERE_EQUALS_PARA = "AND a.%s=?";
/**
* 未删除条件
*/
public static final String CODE_WHERE_EQUALS_NOT_REMOVE = "AND a.%s=0";
/**
* 版本好字段
*/
public static final String CODE_UPDATE_VERSION_FIELD = ",a.%s=1+a.%s";
/**
* 不等于条件
*/
public static final String CODE_WHERE_NOT_EQUALS = "AND %s%s<>%s";
/**
* 不等于条件
*/
public static final String CODE_WHERE_NOT_EQUALS_PARA = "AND a.%s<>?";
/**
* 默认表标记
*/
public static final String CODE_TAG = "a.";
/**
* 参数标记
*/
public static final String CODE_PARA = "?";
/**
* 增加修改语句的分割符号
*/
public static final String CODE_SPLIT = ",";
/**
* 统计语句增加字段模板
*/
public static final String CODE_GROUP_ADD = "a.{FIELD}=a.{FIELD}+?";
/**
* 版本号字段名称
*/
public static final String VERSON = "verson";
public static final String VERSION_FLAG = "version";
/**
* 删除字段名称
*/
public static final String ISREMOVE = "isremove";
public static final String REMOVE_FLAG = "remove";
/**
* 创建字段名称
*/
public static final String CREATE_FLAG = "create";
/**
* 更新字段名称
*/
public static final String UPDATE_FLAG = "update";
/**
* MD5标记字段
*/
public static final String MD5_KEY_FLAG = "md5key";
/**
* 删除字符串长度变量
*/
public static final String ISREMOVE_CONTANS = "contans____isremove";
public static final String REMOVE_FLAG_INPUT = "remove_input";
/**
* ID字段
*/
......@@ -122,4 +195,85 @@ public class DaoConst {
* 集合初始化大小
*/
public static final int COLLECTION_INIT_SIZE = 15;
/**
* 查询条件默认代码片段
*/
public static final String[] LAST_AUTO_ADD = new String[]{"{WHERE}", "{GROUP}", "{HAVING}", "{ORDER}", "{LIMIT}"};
/**
* 普通字段
*/
public static final int FIELD_NONE = -1;
/**
* 普通字段
*/
public static final int FIELD_COMMON = 0;
/**
* 删除标记
*/
public static final int FIELD_REMOVE = 1;
/**
* 版本号字段
*/
public static final int FIELD_VERSION = 2;
/**
* 主键字段
*/
public static final int FIELD_PRIMARY = 3;
/**
* MD5标记字段，用于统计字段
*/
public static final int FIELD_MD5 = 4;
/**
* 删除时记录操作状态的字段
*/
public static final int FIELD_REMOVE_UPDATE = 5;
/**
* 删除时记录操作状态的字段
*/
public static final int FIELD_CREATE = 6;
/**
* 根据字段保存
*/
public static final int FIELD_SAVE_WITH = 7;
/**
* 根据字段添加统计
*/
public static final int FIELD_ADD_GROUP = 8;
/**
* SQL语句类型-普通语句
*/
public static final int SQL_TYPE_COMMON = 0;
/**
* SQL语句类型-创建语句
*/
public static final int SQL_TYPE_CREATE = 1;
/**
* SQL语句类型-更新语句
*/
public static final int SQL_TYPE_UPDATE = 2;
/**
* SQL语句类型-删除语句
*/
public static final int SQL_TYPE_REMOVE = 3;
/**
* SQL语句类型-加载语句
*/
public static final int SQL_TYPE_LOAD = 4;
/**
* SQL语句类型-是否存在
*/
public static final int SQL_TYPE_EXISTS = 5;
/**
* SQL语句类型-根据字段保存
*/
public static final int SQL_TYPE_SAVE_WITH = 6;
/**
* SQL语句类型-添加统计
*/
public static final int SQL_TYPE_ADD_GROUP = 7;
}
yzg-util-db/src/main/java/com/yanzuoguang/dao/TableAnnotation.java
View file @ b23101e3
package com.yanzuoguang.dao;
import com.yanzuoguang.util.helper.StringHelper;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
......@@ -18,5 +20,11 @@ public @interface TableAnnotation {
*
* @return
*/
String value();
String value() default StringHelper.EMPTY;
/**
* 字段类型
* @return
*/
int type() default DaoConst.FIELD_NONE;
}
yzg-util-db/src/main/java/com/yanzuoguang/dao/impl/BaseDaoImpl.java
View file @ b23101e3
......@@ -2,18 +2,21 @@ package com.yanzuoguang.dao.impl;
import com.yanzuoguang.dao.BaseDao;
import com.yanzuoguang.dao.DaoConst;
import com.yanzuoguang.db.impl.AllBeanRowMapper;
import com.yanzuoguang.util.base.ObjectHelper;
import com.yanzuoguang.util.exception.CodeException;
import com.yanzuoguang.util.helper.DateHelper;
import com.yanzuoguang.util.helper.StringHelper;
import com.yanzuoguang.util.vo.InitDao;
import com.yanzuoguang.util.vo.MapRow;
import com.yanzuoguang.util.vo.*;
import java.util.*;
/**
* 数据库操作的基本工具类
* 1. 实现了基本的增删该查
* 2. 实现了统计的增肌和修改
* 3. 实现了一定功能的基本验证，验证数据是否存在
* 4. 数据主键的获取等功能。
* 5. 获取自增等功能
*
* @author 颜佐光
*/
......@@ -145,6 +148,9 @@ public abstract class BaseDaoImpl extends BaseDaoSql implements BaseDao {
this.check(DaoConst.OPERATOR_TYPE_UPDATE, keyString, model);
SqlData sqlData = this.getSql(DaoConst.UPDATE);
int ret = updateSql(sqlData, model);
if (ret == 0) {
throw new CodeException("修改失败，请确认是否被其他人修改,版本号传入是否正确");
}
String retVal = ret > 0 ? keyString : "";
return retVal;
}
......@@ -161,6 +167,14 @@ public abstract class BaseDaoImpl extends BaseDaoSql implements BaseDao {
InitDao to = (InitDao) model;
to.init();
}
if (operatorType == DaoConst.OPERATOR_TYPE_CREATE || operatorType == DaoConst.OPERATOR_TYPE_UPDATE) {
List<SqlData> sqlArray = this.table.getSqlType(DaoConst.SQL_TYPE_SAVE_WITH);
if (sqlArray != null) {
for (SqlData sql : sqlArray) {
this.checkExist(sql.getName(), model, String.format("%s已经存在", sql.getName()));
}
}
}
}
/**
......@@ -197,16 +211,12 @@ public abstract class BaseDaoImpl extends BaseDaoSql implements BaseDao {
this.setKeyString(from, keyString);
// 调用删除日志
this.check(DaoConst.OPERATOR_TYPE_REMOVE, keyString, from);
} else {
List<MapRow> rows = this.query(MapRow.class, DaoConst.LOAD, from);
for (MapRow row : rows) {
keyString = this.getKeyString(from);
if (StringHelper.isEmpty(keyString)) {
keyString = StringHelper.toString(AllBeanRowMapper.getLoweRowField(row, this.getKey()));
}
// 调用删除日志
this.check(DaoConst.OPERATOR_TYPE_REMOVE, keyString, row);
}
}
// 处理来源值
for (TableFieldVo fieldVo : this.table.getTable().getRemoveUpdate()) {
Object fromValue = ObjectHelper.get(model, fieldVo.inputName);
ObjectHelper.set(from, fieldVo.inputName, fromValue);
}
// 调用删除语句
......@@ -217,13 +227,13 @@ public abstract class BaseDaoImpl extends BaseDaoSql implements BaseDao {
/**
* 加载数据
*
* @param model 加载数据的请求参数
* @param cls 需要加载的数据的类型
* @param <T> 返回数据的类型
* @param model 加载数据的请求参数
* @param resultClass 需要加载的数据的类型
* @param <T> 返回数据的类型
* @return 需要返回的数据
*/
@Override
public <T extends Object> T load(Object model, Class<T> cls) {
public <T extends Object> T load(Object model, Class<T> resultClass) {
// 获取来源主键
Object from = model;
String key = this.getInputKey(from);
......@@ -235,7 +245,7 @@ public abstract class BaseDaoImpl extends BaseDaoSql implements BaseDao {
}
// 通过传入数据进行加载
T to = this.queryFirst(cls, DaoConst.LOAD, from);
T to = this.queryFirst(resultClass, DaoConst.LOAD, from);
if (to == null) {
return to;
}
......@@ -254,13 +264,13 @@ public abstract class BaseDaoImpl extends BaseDaoSql implements BaseDao {
/**
* 加载数据
*
* @param model 加载数据的请求参数
* @param cls 需要加载的数据的类型
* @param <T> 返回数据的类型
* @param model 加载数据的请求参数
* @param resultClass 需要加载的数据的类型
* @param <T> 返回数据的类型
* @return 需要返回的数据
*/
@Override
public <T extends Object> List<T> loadList(Object model, Class<T> cls) {
public <T extends Object> List<T> loadList(Object model, Class<T> resultClass) {
// 获取来源主键
Object from = model;
String key = this.getInputKey(from);
......@@ -272,7 +282,7 @@ public abstract class BaseDaoImpl extends BaseDaoSql implements BaseDao {
}
// 通过传入数据进行加载
List<T> to = this.query(cls, DaoConst.LOAD, from);
List<T> to = this.query(resultClass, DaoConst.LOAD, from);
if (to == null || to.size() == 0) {
return new ArrayList<>();
}
......@@ -290,6 +300,46 @@ public abstract class BaseDaoImpl extends BaseDaoSql implements BaseDao {
return to;
}
/**
* 加载分页数据
*
* @param model 加载数据的请求参数
* @param resultClass 需要加载的数据的类型
* @param <T> 返回数据的类型
* @return 需要返回的数据
*/
@Override
public <T extends Object> PageSizeData<T> loadPage(PageSizeReqVo model, Class<T> resultClass) {
// 获取来源主键
Object from = model;
String key = this.getInputKey(from);
// 当主键存在时，只通过主键加载
if (!StringHelper.isEmpty(key)) {
from = new HashMap<String, Object>(DaoConst.COLLECTION_INIT_SIZE);
this.setKeyString(from, key);
}
// 通过传入数据进行加载
PageSizeData<T> to = this.queryPage(resultClass, model, DaoConst.LOAD, from);
if (to == null || to.getPageTotal() == 0) {
return to;
}
// 判断来源主键是否存在，不存在则获取加载后的主键
if (StringHelper.isEmpty(key)) {
check(DaoConst.OPERATOR_TYPE_LOAD, key, to);
} else {
for (Object item : to.getList()) {
key = this.getKeyString(item);
check(DaoConst.OPERATOR_TYPE_LOAD, key, to);
}
}
return to;
}
/**
* 添加统计数据
*
......
yzg-util-db/src/main/java/com/yanzuoguang/dao/impl/BaseDaoSql.java
View file @ b23101e3
......@@ -19,7 +19,7 @@ import java.util.regex.Matcher;
import java.util.regex.Pattern;
/**
* SQL语句基本操作类
* SQL语句基本操作类,包括SQL语句的解析，参数的组装，查询缓存的处理
*
* @author 颜佐光
*/
......@@ -44,7 +44,7 @@ public abstract class BaseDaoSql {
/**
* 缓存的表结构和SQL语句
*/
protected static MemoryCache<TableSqlCache> cache = new MemoryCache<>();
protected final static MemoryCache<TableSqlCache> cache = new MemoryCache<>();
/**
* 获取数据库执行类
......@@ -131,7 +131,7 @@ public abstract class BaseDaoSql {
if (this.table == null) {
throw new CodeException("类" + this.getClass().getName() + "未发现表结构");
}
SqlData sql = this.table.getSqls().get(name);
SqlData sql = this.table.getNameCache().get(name);
if (isThrow && sql == null) {
throw new CodeException("类" + this.getClass().getName() + "未发现SQL语句" + name);
}
......@@ -186,7 +186,7 @@ public abstract class BaseDaoSql {
protected Object queryCell(SqlData sqlData, Object model) {
List<Object> paras = new ArrayList<>();
String sql = this.getQueryPara(paras, sqlData, model);
Object cell = this.queryCellWithCache(sql, sqlData.getName(), paras.toArray());
Object cell = this.queryCellWithCache(sqlData.getName(), sql, paras.toArray());
return cell;
}
......@@ -412,20 +412,19 @@ public abstract class BaseDaoSql {
* @return SQL条件
*/
protected String getQueryPara(List<Object> paras, SqlData sqlData, Object model) {
// 定义可替换片段
String[] lastCode = new String[]{"{WHERE}", "{GROUP}", "{HAVING}", "{ORDER}", "{LIMIT}"};
// 将SQL语句进行代码片段追加
String sql = sqlData.getSql();
for (String code : lastCode) {
if (sql.indexOf(code) == -1) {
sql += code;
StringBuilder sb = new StringBuilder(sqlData.getSql());
for (String code : DaoConst.LAST_AUTO_ADD) {
if (sb.indexOf(code) == -1) {
sb.append(code);
}
}
// 代码片段缓存
Map<String, List<String>> codeMap = new HashMap<>(DaoConst.COLLECTION_INIT_SIZE);
// 处理字段以及代码片段
String sql = sb.toString();
sql = handleCodeRelease(sql, sqlData, model, codeMap);
sql = handleCodeReplace(sql, codeMap);
......@@ -548,7 +547,7 @@ public abstract class BaseDaoSql {
*/
private Object getParaValue(Object val) {
if (val instanceof Boolean) {
val = 0;
val = (Boolean)val ? 1 : 0;
}
val = StringHelper.toString(val);
return val;
......@@ -682,7 +681,7 @@ public abstract class BaseDaoSql {
}
// 将对象转换为 Map 对象
Map to = new HashMap<String, Object>(DaoConst.COLLECTION_INIT_SIZE);
Map<String, Object> to = new HashMap<>(DaoConst.COLLECTION_INIT_SIZE);
if (from instanceof Map) {
to = (Map) from;
} else {
......@@ -694,16 +693,16 @@ public abstract class BaseDaoSql {
sb.append(" SELECT ");
// 处理列
for (Object oItemKey : to.keySet()) {
for (Map.Entry<String, Object> oItemKey : to.entrySet()) {
if (column > 0) {
sb.append(",");
}
String itemKey = StringHelper.toString(oItemKey);
String itemKey = oItemKey.getKey();
sb.append("? AS " + itemKey);
// 处理参数
Object itemValue = to.get(oItemKey);
Object itemValue = oItemKey.getValue();
itemValue = this.getParaValue(itemValue);
paras.add(itemValue);
column++;
......
yzg-util-db/src/main/java/com/yanzuoguang/dao/impl/SqlData.java
View file @ b23101e3
......@@ -12,9 +12,9 @@ import java.util.List;
public class SqlData {
/**
* 对应的参数顺序
* SQL语句类型
*/
private List<SqlDataField> sqlDataFields = new ArrayList<SqlDataField>();
private int sqlType = DaoConst.SQL_TYPE_COMMON;
/**
* SQL语句的名称
......@@ -26,6 +26,11 @@ public class SqlData {
*/
private String sql;
/**
* 对应的参数顺序
*/
private List<SqlDataField> sqlDataFields = new ArrayList<SqlDataField>();
/**
* 构造函数
*/
......@@ -33,6 +38,22 @@ public class SqlData {
this("", "");
}
/**
* Sql语句类型
* @return Sql语句类型
*/
public int getSqlType() {
return sqlType;
}
/**
* Sql语句类型
* @param sqlType Sql语句类型
*/
public void setSqlType(int sqlType) {
this.sqlType = sqlType;
}
public List<SqlDataField> getSqlDataFields() {
return sqlDataFields;
}
......@@ -231,7 +252,7 @@ public class SqlData {
* @return
*/
public SqlData removeFieldRemove() {
this.removeField(DaoConst.ISREMOVE_CONTANS);
this.removeField(DaoConst.REMOVE_FLAG_INPUT);
return this;
}
......
yzg-util-db/src/main/java/com/yanzuoguang/dao/impl/SqlDataField.java
View file @ b23101e3
package com.yanzuoguang.dao.impl;
import com.yanzuoguang.util.helper.StringHelper;
import java.util.ArrayList;
import java.util.List;
......@@ -12,9 +14,11 @@ public class SqlDataField {
/**
* 前台参数名称,当没有前台参数时，则把当前字段当常量代码片段处理
*/
public String paraName = "";
public String paraName = StringHelper.EMPTY;
/**
* 是否根据前台参数自动添加，false时保持永久添加模式
* 是否根据前台参数自动添加，false时保持永久添加模式,
* 1. true为条件模式，即前台不输入参数时，则不增加相关代码片段
* 2. false为敞亮模式，不管前台是否输入，该参数和片段必然会增加到后台执行语句中
*/
public boolean auto = true;
/**
......
yzg-util-db/src/main/java/com/yanzuoguang/dao/impl/TableFieldVo.java
View file @ b23101e3
......@@ -28,14 +28,28 @@ public class TableFieldVo {
this.type = type;
}
/**
* 表字段的原名称
*/
public String name;
/**
* 表子弹的名称小写
*/
public String lName;
/**
* 前台输入参数的名称
*/
public String inputName;
/**
* 前台输入的参数的小写
*/
public String inputLName;
/**
* 实体的参数的类型
*/
public Class<?> type = String.class;
;
}
yzg-util-db/src/main/java/com/yanzuoguang/dao/impl/TableSqlCache.java
View file @ b23101e3
......@@ -14,6 +14,7 @@ import java.util.regex.Pattern;
/**
* 缓存的SQL语句信息
*
* @author 颜佐光
*/
public class TableSqlCache {
......@@ -24,14 +25,19 @@ public class TableSqlCache {
public static final String PAGE_SIZE_TAG = "_PageSize";
/**
* 表信息
* 表结构信息
*/
private TableStruct table;
/**
* 缓存的SQL信息
* 缓存的SQL信息，按照名称进行缓存
*/
private MemoryCache<SqlData> sqls = new MemoryCache<SqlData>();
private MemoryCache<SqlData> nameCache = new MemoryCache<SqlData>();
/**
* 根据Sql语句类型进行缓存，按照类型进行缓存
*/
private MemoryCache<List<SqlData>> typeCache = new MemoryCache<>();
/**
* 构造函数
......@@ -58,11 +64,25 @@ public class TableSqlCache {
*/
public SqlData add(SqlData sql) {
if (sql != null) {
this.sqls.put(sql.getName(), sql);
this.nameCache.put(sql.getName(), sql);
String keyType = String.valueOf(sql.getSqlType());
this.typeCache.get(keyType, new ArrayList<>()).add(sql);
}
return sql;
}
/**
* 获取所有的Sql语句执行类型
*
* @param sqlType Sql语句执行类型
* @return Sql语句列表
*/
public List<SqlData> getSqlType(int sqlType) {
String keyType = String.valueOf(sqlType);
return typeCache.get(keyType);
}
/**
* 添加SQL
*
......@@ -278,8 +298,8 @@ public class TableSqlCache {
}
private String replaceString(Map<String, StringBuilder> map, String sql) {
for (String key : map.keySet()) {
sql = sql.replace(key, map.get(key).toString());
for (Map.Entry<String, StringBuilder> key : map.entrySet()) {
sql = sql.replace(key.getKey(), key.getValue().toString());
}
return sql;
}
......@@ -292,11 +312,11 @@ public class TableSqlCache {
this.table = table;
}
public MemoryCache<SqlData> getSqls() {
return sqls;
public MemoryCache<SqlData> getNameCache() {
return nameCache;
}
public void setSqls(MemoryCache<SqlData> sqls) {
this.sqls = sqls;
public void setNameCache(MemoryCache<SqlData> nameCache) {
this.nameCache = nameCache;
}
}
yzg-util-db/src/main/java/com/yanzuoguang/dao/impl/TableStruct.java
View file @ b23101e3
......@@ -19,121 +19,326 @@ import java.util.Map;
public class TableStruct {
/**
* 表名称
* 数据库中的表名称
*/
private String name;
/**
* 主键名称
* 缓存的字段，根据字段的类型进行缓存，同一个字段可能会属于多个类型。
*/
private Map<Integer, List<TableFieldVo>> typeFieldCache = new HashMap<>();
/**
* 构造函数
*/
public TableStruct() {
this.name = "";
}
/**
* 通过实体的字段来创建表结构信息
*
* @param name 表名称
* @param cls 关联的实体，主键放在第一位，其他字段放到后面；需要注意的是必需和表结构对应起来，会有隐性BUG，比如说在实体中增加了字段，会导致增加修改失败
*/
public TableStruct(String name, Class<?> cls) {
this.name = name;
// 获取实体中的所有字段信息，包含get、set、field
HashMap<String, MethodField> fields = ObjectHelper.getTypeField(cls);
// 遍历字段
for (Map.Entry<String, MethodField> entry : fields.entrySet()) {
// 字段信息获取
MethodField field = entry.getValue();
if (field.getField() == null && field.getGetMethod() == null) {
continue;
}
addMethodField(field);
}
}
/**
* 添加字段
*
* @param field 添加字段
*/
private void addMethodField(MethodField field) {
int fieldAction = DaoConst.FIELD_NONE;
// 默认后台数据库字段和前台参数字段为字段名，字段类型为class
String fieldName = field.getName();
String fieldInputName = field.getName();
Class<?> fieldType = String.class;
// 获取注解以及返回类型
TableAnnotation annotation = null;
if (field.getField() != null) {
annotation = field.getField().getAnnotation(TableAnnotation.class);
fieldType = field.getField().getType();
} else if (field.getGetMethod() != null) {
annotation = field.getGetMethod().getAnnotation(TableAnnotation.class);
fieldType = field.getGetMethod().getReturnType();
}
// 注解不为空，则修改后台数据库映射字段、字段类型
if (annotation != null) {
if (!StringHelper.isEmpty(annotation.value())) {
fieldName = annotation.value();
}
fieldAction = annotation.type();
}
// 将字段组合成输入字段
TableFieldVo vo = new TableFieldVo(fieldName, fieldInputName, fieldType);
// 根据字段名称规则来获取名称默认类型
int stringAction = getStringAction(vo);
// 获取普通类型字段列表
List<TableFieldVo> commonActionList = this.getFieldActionList(DaoConst.FIELD_COMMON);
// 判断是否属于主键
int resultActionType = getActionType(fieldAction, stringAction);
if (resultActionType == DaoConst.FIELD_PRIMARY) {
// 将历史主键添加到普通列，并且移除历史主键
List<TableFieldVo> primaryActionList = this.getFieldActionList(DaoConst.FIELD_PRIMARY);
commonActionList.addAll(primaryActionList);
primaryActionList.clear();
// 将现有列添加到主键
primaryActionList.add(vo);
} else {
// 将所有非主键列添加到普通列
commonActionList.add(vo);
boolean isTypeMany = resultActionType != DaoConst.FIELD_MD5
&& resultActionType != DaoConst.FIELD_REMOVE
&& resultActionType != DaoConst.FIELD_VERSION
&& resultActionType != DaoConst.FIELD_COMMON;
if (resultActionType != DaoConst.FIELD_COMMON) {
List<TableFieldVo> actionList = this.getFieldActionList(resultActionType);
// 处理其他特殊列
if (isTypeMany) {
actionList.add(vo);
} else if (resultActionType == fieldAction) {
// fieldAction 优先级高于 stringAction
// 假如特殊列已经存在，则将已经存在的特殊列删除，并且添加新的特殊列
actionList.clear();
actionList.add(vo);
} else if (actionList.isEmpty()) {
// stringAction
// 假如是默认的，并且特殊列已经存在，则不进行任何处理
actionList.add(vo);
}
}
}
}
/**
* 获取字段类型
*
* @param fieldAction 字段类型
* @param stringAction 字符串字段类型
* @return 最终类型
*/
private int getActionType(int fieldAction, int stringAction) {
if (fieldAction != DaoConst.FIELD_NONE) {
return fieldAction;
} else {
return stringAction;
}
}
/**
* 获取字符串动作类型
*
* @param vo 输入子弹
* @return 获取到的自动类型
*/
private TableFieldVo key;
private int getStringAction(TableFieldVo vo) {
if (getKey() == null) {
return DaoConst.FIELD_PRIMARY;
} else if (DaoConst.REMOVE_FLAG.equals(vo.inputLName)) {
return DaoConst.FIELD_REMOVE;
} else if (DaoConst.VERSION_FLAG.equals(vo.inputLName)) {
return DaoConst.FIELD_VERSION;
}
// 判断是否属于统计字段
else if (DaoConst.MD5_KEY_FLAG.equals(vo.inputLName)) {
return DaoConst.FIELD_MD5;
} else if (vo.inputLName.startsWith(DaoConst.UPDATE_FLAG)) {
return DaoConst.FIELD_REMOVE_UPDATE;
} else if (vo.inputLName.startsWith(DaoConst.CREATE_FLAG)) {
return DaoConst.FIELD_CREATE;
} else {
return DaoConst.FIELD_COMMON;
}
}
/**
* MD5KEY
* 获取某个类型的所有字段
*
* @param type 某个类型，需要排除的类型
* @param exceptType 需要排除的字段的类型
* @return 字段列表
*/
private TableFieldVo md5Key;
private List<TableFieldVo> getFieldActionList(int type, int... exceptType) {
if (!typeFieldCache.containsKey(type)) {
typeFieldCache.put(type, new ArrayList<>());
}
List<TableFieldVo> from = typeFieldCache.get(type);
if (exceptType == null || exceptType.length == 0) {
return from;
} else {
// 缓存需要排除的子弹
Map<String, Boolean> exceptCache = new HashMap<>(10);
for (int except : exceptType) {
if (!typeFieldCache.containsKey(except)) {
continue;
}
List<TableFieldVo> exceptList = typeFieldCache.get(except);
for (TableFieldVo exceptField : exceptList) {
exceptCache.put(exceptField.name, true);
}
}
// 剩下的字段
List<TableFieldVo> to = new ArrayList<>();
for (TableFieldVo fromItem : from) {
if (exceptCache.containsKey(fromItem.name)) {
continue;
}
to.add(fromItem);
}
return to;
}
}
/**
* 其他字段
* 获取某个类型的第一个字段
*
* @param type 类型
* @return 获取到的子弹
*/
private List<TableFieldVo> fields = new ArrayList<TableFieldVo>();
private TableFieldVo getFieldAction(int type) {
List<TableFieldVo> list = getFieldActionList(type);
return !list.isEmpty() ? list.get(0) : null;
}
/**
* 获取所有普通子弹
*
* @return 所有的普通股字段
*/
public List<TableFieldVo> getFields() {
return fields;
return getFieldActionList(DaoConst.FIELD_COMMON);
}
/**
* 获取表名
*
* @return 获取到的名称
*/
public String getName() {
return name;
}
/**
* 设置表名
*
* @param name 设置的表名
*/
public void setName(String name) {
this.name = name;
}
/**
* 主键
*
* @return 获取到的键值
*/
public TableFieldVo getKey() {
return key;
}
public TableFieldVo getMd5Key() {
return md5Key;
return getFieldAction(DaoConst.FIELD_PRIMARY);
}
/**
* 主键名称
*
* @return 主键名称
*/
public String getKeyName() {
return this.key.inputName;
}
public String getMD5KeyName() {
return md5Key != null ? md5Key.inputName : null;
return this.getKey().inputName;
}
/**
* 主键数据类型
*
* @return 主键类型
*/
public Class<?> getKeyType() {
return this.key.type;
return this.getKey().type;
}
/**
* 构造函数
* ＭＤ５缓存字段
*
* @return md5字段
*/
public TableStruct() {
this.name = "";
this.key = new TableFieldVo(DaoConst.ID_FIELD);
public TableFieldVo getMd5Key() {
return getFieldAction(DaoConst.FIELD_MD5);
}
/**
* 通过实体的字段来创建表结构信息
* ＭＤ５缓存键值
*
* @param name 表名称
* @param cls 关联的实体，主键放在第一位，其他字段放到后面；需要注意的是必需和表结构对应起来，会有隐性BUG，比如说在实体中增加了字段，会导致增加修改失败
* @return MD5名称
*/
public TableStruct(String name, Class<?> cls) {
this.name = name;
// 获取实体中的所有字段信息，包含get、set、field
HashMap<String, MethodField> fields = ObjectHelper.getTypeField(cls);
// 遍历字段
for (Map.Entry<String, MethodField> entry : fields.entrySet()) {
public String getMD5KeyName() {
TableFieldVo md5Key = this.getMd5Key();
return md5Key != null ? md5Key.inputName : null;
}
// 字段信息获取
MethodField field = entry.getValue();
if (field.field == null && field.getMethod == null) {
continue;
}
/**
* 判断是否包含版本号字段
*
* @return 版本号字段
*/
public TableFieldVo getVersion() {
return getFieldAction(DaoConst.FIELD_VERSION);
}
String fieldName = field.name;
String fieldInputName = field.name;
Class<?> fieldType = String.class;
TableAnnotation annotation = null;
if (field.field != null) {
annotation = field.field.getAnnotation(TableAnnotation.class);
fieldType = field.field.getType();
} else if (field.getMethod != null) {
annotation = field.getMethod.getAnnotation(TableAnnotation.class);
fieldType = field.getMethod.getReturnType();
}
if (annotation != null) {
fieldName = annotation.value();
}
/**
* 判断是否包含remove字段
*
* @return 删除字段
*/
public TableFieldVo getRemove() {
return getFieldAction(DaoConst.FIELD_REMOVE);
}
TableFieldVo vo = new TableFieldVo(fieldName, fieldInputName, fieldType);
// 判断是否属于统计字段
if ("md5key".equals(vo.inputLName)) {
this.md5Key = vo;
}
// 判断是否是主键，获取主键数据类型
if (this.key == null) {
this.key = vo;
} else {
this.fields.add(vo);
}
}
/**
* 获取删除时更新子弹
*
* @return 删除时更新字段
*/
public List<TableFieldVo> getRemoveUpdate() {
return getFieldActionList(DaoConst.FIELD_REMOVE_UPDATE);
}
/**
* 获取某一列
*
* @param name 列名
* @return 获取到的字段
*/
public TableFieldVo getField(String name) {
if (StringHelper.isEmpty(name)) {
return null;
}
for (TableFieldVo fieldVo : this.fields) {
for (TableFieldVo fieldVo : this.getFields()) {
if (fieldVo.lName.equals(name.toLowerCase()) || fieldVo.inputLName.equals(name.toLowerCase())) {
return fieldVo;
}
......@@ -142,52 +347,71 @@ public class TableStruct {
}
/**
* 判断是否包含版本号字段
* 通过表结构自动生成SQL语句
*
* @return
* @return 初始化的表SQL语句
*/
public TableFieldVo getVersion() {
return this.getField(DaoConst.VERSON);
public void init(TableSqlCache table) {
table.setTable(this);
if (!StringHelper.isEmpty(this.name)) {
table.add(releaseSqlCreate(), releaseSqlUpdate(), releaseSqlRemove(), releaseSqlLoad());
}
initSaveWith(table);
initAddGroup(table);
}
/**
* 判断是否包含remove字段
* 初始化SaveWith
*
* @return
* @return 初始化的表SQL语句
*/
private TableFieldVo getRemove() {
return this.getField(DaoConst.ISREMOVE);
private void initSaveWith(TableSqlCache table) {
List<TableFieldVo> saveWithField = getFieldActionList(DaoConst.FIELD_SAVE_WITH);
if (saveWithField == null || saveWithField.isEmpty()) {
return;
}
this.addSaveWithSql(table, DaoConst.SAVE_WITH, saveWithField);
}
/**
* 通过表结构自动生成SQL语句
* 初始化添加统计SQL语句
*
* @return
* @return 初始化的表SQL语句
*/
public void init(TableSqlCache table) {
table.setTable(this);
if (!StringHelper.isEmpty(this.name)) {
table.add(releaseSqlCreate(), releaseSqlUpdate(), releaseSqlRemove(), releaseSqlLoad());
private void initAddGroup(TableSqlCache table) {
List<TableFieldVo> addGroupField = getFieldActionList(DaoConst.FIELD_ADD_GROUP);
if (addGroupField == null || addGroupField.isEmpty()) {
return;
}
List<TableFieldVo> commonField = getFieldActionList(DaoConst.FIELD_COMMON,
DaoConst.FIELD_ADD_GROUP, DaoConst.FIELD_MD5,
DaoConst.FIELD_REMOVE, DaoConst.FIELD_REMOVE_UPDATE, DaoConst.FIELD_CREATE);
this.addGroupSql(table, commonField, addGroupField);
}
/**
* 生成创建的SQL语句
*
* @return
* @return 生成的语句
*/
private SqlData releaseSqlCreate() {
// 生成添加的SQL语句
String text = DaoConst.INSERT_MODEL.replace(DaoConst.TABLE_CODE, this.name);
String text = DaoConst.SQL_INSERT.replace(DaoConst.CODE_TABLE, this.name);
SqlData sql = new SqlData(DaoConst.CREATE, text);
String flag = "";
sql.setSqlType(DaoConst.SQL_TYPE_CREATE);
// 第一个增加的字段，不需要增加 ","
String flag = StringHelper.EMPTY;
if (this.getKeyType() == String.class) {
sql.addParaConst(this.key.inputName, DaoConst.FIELD_CODE, this.key.name, DaoConst.VALUES_CODE, "?");
flag = ",";
sql.addParaConst(this.getKey().inputName, DaoConst.CODE_FIELD, this.getKey().name,
DaoConst.CODE_VALUES, DaoConst.CODE_PARA
);
flag = DaoConst.CODE_SPLIT;
}
for (TableFieldVo field : this.fields) {
sql.addParaConst(field.inputName, DaoConst.FIELD_CODE, flag + field.name, DaoConst.VALUES_CODE, flag + "?");
flag = ",";
for (TableFieldVo field : this.getFields()) {
sql.addParaConst(field.inputName, DaoConst.CODE_FIELD, flag + field.name,
DaoConst.CODE_VALUES, flag + DaoConst.CODE_PARA
);
flag = DaoConst.CODE_SPLIT;
}
return sql;
}
......@@ -195,30 +419,32 @@ public class TableStruct {
/**
* 生成修改的SQL语句
*
* @return
* @return 生成的语句
*/
private SqlData releaseSqlUpdate() {
// 生成添加的SQL语句
String text = DaoConst.UPDATE_MODEL.replace(DaoConst.TABLE_CODE, this.name);
String text = DaoConst.SQL_UPDATE.replace(DaoConst.CODE_TABLE, this.name);
SqlData sql = new SqlData(DaoConst.UPDATE, text);
TableFieldVo removeField = this.getRemove();
TableFieldVo versionField = this.getVersion();
sql.addParaConst(this.key.inputName,
DaoConst.FIELD_CODE, "" + this.key.name + "=" + this.key.name,
DaoConst.WHERE_CODE, " AND " + this.key.name + "=?");
for (TableFieldVo field : this.fields) {
if (field == removeField || field == versionField) {
continue;
}
sql.addParaConst(field.inputName, DaoConst.FIELD_CODE, "," + field.name + "=?");
sql.setSqlType(DaoConst.SQL_TYPE_UPDATE);
// 主键字段操作
sql.addCode(DaoConst.CODE_FIELD, String.format(DaoConst.CODE_UPDATE_PRIMARY, this.getKey().name, this.getKey().name));
sql.addConst(this.getKey().inputName, String.format(DaoConst.CODE_WHERE_EQUALS_PARA, this.getKey().name));
// 增加普通代码片段字段
List<TableFieldVo> updateList = getFieldActionList(DaoConst.FIELD_COMMON,
DaoConst.FIELD_CREATE, DaoConst.FIELD_REMOVE, DaoConst.FIELD_VERSION);
for (TableFieldVo field : updateList) {
sql.addParaConst(field.inputName,
DaoConst.CODE_FIELD, String.format(DaoConst.CODE_UPDATE_FIELD_PARA, field.name)
);
}
if (removeField != null) {
sql.addParaConst(removeField.inputName, DaoConst.WHERE_CODE, " AND " + removeField.name + "=0");
}
if (versionField != null) {
sql.addParaConst(versionField.inputName,
DaoConst.FIELD_CODE, "," + versionField.name + "=1+" + versionField.name,
DaoConst.WHERE_CODE, " AND " + versionField.name + "=?");
// 添加删除字段
addWhereRemove(sql);
addUpdateVersion(sql);
// 添加版本号条件
if (getVersion() != null) {
sql.addConst(getVersion().inputName, String.format(DaoConst.CODE_WHERE_EQUALS_PARA, getVersion().name));
}
return sql;
}
......@@ -226,25 +452,34 @@ public class TableStruct {
/**
* 生成删除的SQL语句
*
* @return
* @return 生成的语句
*/
private SqlData releaseSqlRemove() {
TableFieldVo removeField = this.getRemove();
TableFieldVo versionField = this.getVersion();
if (removeField != null) {
if (this.getRemove() != null) {
// 生成添加的SQL语句
String text = DaoConst.UPDATE_MODEL.replace(DaoConst.TABLE_CODE, this.name);
String text = DaoConst.SQL_UPDATE.replace(DaoConst.CODE_TABLE, this.name);
SqlData sql = new SqlData(DaoConst.REMOVE, text);
sql.addCode(DaoConst.FIELD_CODE, removeField.name + "=1");
if (versionField != null) {
sql.addCode(DaoConst.FIELD_CODE, "," + versionField.name + "=1+" + versionField.name);
sql.setSqlType(DaoConst.SQL_TYPE_REMOVE);
// 设置删除字段标记
sql.addCode(DaoConst.CODE_FIELD, String.format(DaoConst.CODE_UPDATE_FIELD_REMOVE, this.getRemove().name));
// 设置删除时需要修改的字段的值
for (TableFieldVo field : this.getFieldActionList(DaoConst.FIELD_REMOVE_UPDATE)) {
sql.addParaConst(field.inputName,
DaoConst.CODE_FIELD, String.format(DaoConst.CODE_UPDATE_FIELD_PARA, field.name)
);
}
addWhereField(sql, "");
// 增加版本号字段的值
addUpdateVersion(sql);
// 生成逻辑删除WHERE条件
addWhereField(sql, DaoConst.CODE_TAG, true);
return sql;
} else {
String text = DaoConst.REMOVE_MODEL.replace(DaoConst.TABLE_CODE, this.name);
String text = DaoConst.SQL_REMOVE.replace(DaoConst.CODE_TABLE, this.name);
SqlData sql = new SqlData(DaoConst.REMOVE, text);
addWhereField(sql, "");
// 生成删除语句Where条件
addWhereField(sql, DaoConst.CODE_TAG, true);
return sql;
}
}
......@@ -252,125 +487,191 @@ public class TableStruct {
/**
* 生成加载的SQL语句
*
* @return
* @return 生成的语句
*/
private SqlData releaseSqlLoad() {
// 生成添加的SQL语句
String text = DaoConst.LOAD_MODEL.replace(DaoConst.TABLE_CODE, this.name);
String text = DaoConst.SQL_LOAD.replace(DaoConst.CODE_TABLE, this.name);
SqlData sql = new SqlData(DaoConst.LOAD, text);
addWhereField(sql, "a.");
sql.setSqlType(DaoConst.SQL_TYPE_LOAD);
// 生成加载语句的WHERE条件
addWhereField(sql, DaoConst.CODE_TAG, false);
return sql;
}
/**
* 当前当前表所有字段的等于SQL语句
*
* @param sql
* @param sql SDL语句
* @param tag 标记
* @param isRemove 是否生成删除相关字段
* @return 生成的语句
*/
private void addWhereField(SqlData sql, String tag) {
TableFieldVo removeField = this.getRemove();
sql.add(this.key.inputName, " AND " + tag + this.key.name + "=?");
for (TableFieldVo field : this.fields) {
sql.add(field.inputName, " AND " + tag + field.name + "=?");
private void addWhereField(SqlData sql, String tag, boolean isRemove) {
sql.add(this.getKey().inputName,
String.format(DaoConst.CODE_WHERE_EQUALS, tag, this.getKey().name, DaoConst.CODE_PARA)
);
// Where条件包含的字段
List<TableFieldVo> fields;
if (!isRemove) {
// 所有字段
fields = this.getFields();
} else {
// 非删除时需要更新的字段
fields = this.getFieldActionList(DaoConst.FIELD_COMMON, DaoConst.FIELD_REMOVE_UPDATE);
}
if (removeField != null) {
sql.addConst(DaoConst.ISREMOVE_CONTANS, " AND " + tag + removeField.name + "=0");
// 添加普通的Where条件
for (TableFieldVo field : fields) {
sql.add(field.inputName,
String.format(DaoConst.CODE_WHERE_EQUALS, tag, field.name, DaoConst.CODE_PARA)
);
}
// 查询时，不能查询到非删除的字段
addWhereRemove(sql);
}
/**
* 生成统计的SQL语句
* 添加删除WHERE条件字段
*
* @param sqlTableData 需要生成的实体
* @param whereFields WHERE字段
* @param updateFields 需要增加的值的字段
* @param sql SQL语句实体
*/
public void addGroupSql(TableSqlCache sqlTableData, TableFieldString whereFields, TableFieldString updateFields) {
sqlTableData.add(this.releaseSqlWhere(DaoConst.GROUP_QUERY, DaoConst.LOAD_MODEL, whereFields));
sqlTableData.add(this.releaseSql(DaoConst.GROUP_ADD, DaoConst.UPDATE_MODEL, "{FIELD}={FIELD}+?", updateFields, new TableFieldString(this.key.name)));
private void addWhereRemove(SqlData sql) {
if (getRemove() != null) {
sql.addParaConst(DaoConst.REMOVE_FLAG_INPUT,
DaoConst.CODE_WHERE,
String.format(DaoConst.CODE_WHERE_EQUALS_NOT_REMOVE, this.getRemove().name)
);
}
}
/**
* 生成SQL语句
* 版本号进行累加
*
* @param name
* @param model
* @param whereFields
* @return
* @param sql 需要处理的SQL语句
*/
public SqlData releaseSqlWhere(String name, String model, TableFieldString whereFields) {
return this.releaseSql(name, model, "", new TableFieldString(), whereFields);
private void addUpdateVersion(SqlData sql) {
// 添加版本字段
if (getVersion() != null) {
sql.addCode(DaoConst.CODE_FIELD, String.format(DaoConst.CODE_UPDATE_VERSION_FIELD, getVersion().name, getVersion().name));
}
}
/**
* 生成SQL语句
*
* @param sqlType SQL语句类型
* @param name SQL语句名称
* @param model SQL语句模板
* @param valueModel 值字段模板
* @param valueFields 值字段
* @param whereFields WHERE字段
* @return
* @return 生成的SQL语句
*/
public SqlData releaseSql(String name, String model, String valueModel, TableFieldString valueFields, TableFieldString whereFields) {
private SqlData releaseSql(int sqlType, String name, String model, String valueModel, List<TableFieldVo> valueFields, List<TableFieldVo> whereFields) {
// 参数字段
List<String> paraFields = new ArrayList<String>();
// 生成修改的SQL语句
SqlData sql = new SqlData(name, model.replace(DaoConst.CODE_TABLE, this.name));
sql.setSqlType(sqlType);
// 生成添加的SQL语句
StringBuilder sbField = new StringBuilder();
for (String field : valueFields.getFields()) {
if (sbField.length() > 0) {
sbField.append(",");
}
sbField.append(valueModel.replace(DaoConst.FIELD_CODE, field));
paraFields.add(field);
String flag = StringHelper.EMPTY;
for (TableFieldVo field : valueFields) {
sql.addParaConst(field.inputName, DaoConst.CODE_FIELD, flag + valueModel.replace(DaoConst.CODE_FIELD, field.name));
flag = DaoConst.CODE_SPLIT;
}
StringBuilder sbWhere = new StringBuilder();
for (String field : whereFields.getFields()) {
sbWhere.append(" AND ");
sbWhere.append(field);
sbWhere.append("=?");
paraFields.add(field);
for (TableFieldVo field : whereFields) {
sql.addParaConst(field.inputName, DaoConst.CODE_WHERE, String.format(DaoConst.CODE_WHERE_EQUALS_PARA, field.name));
}
String[] fields = new String[paraFields.size()];
fields = paraFields.toArray(fields);
// 生成修改的SQL语句
String sql = model.replace(DaoConst.TABLE_CODE, this.name).replace(DaoConst.FIELD_CODE, sbField.toString()).replace(DaoConst.WHERE_CODE, sbWhere.toString());
SqlData ret = new SqlData(name, sql, fields);
return ret;
return sql;
}
/**
* 根据来源字符串获取结束字符串
*
* @param fieldFrom 来源字符串
* @return 返回字符串
*/
private List<TableFieldVo> getFieldString(TableFieldString fieldFrom) {
List<TableFieldVo> list = new ArrayList<>();
for (String fieldName : fieldFrom.getFields()) {
list.add(this.getField(fieldName));
}
return list;
}
/**
* 生成根据某些字段不存在则保存的SQL语句
*
* @param tableStruct
* @param sqlName
* @param whereFields
* @param tableStruct 表结构
* @param sqlName SQL语句
* @param whereFields WHERE条件
*/
public void addSaveWithSql(TableSqlCache tableStruct, String sqlName, TableFieldString whereFields) {
tableStruct.add(this.releaseSqlWhere(sqlName, DaoConst.LOAD_MODEL, whereFields));
addSaveWithSql(tableStruct, sqlName, getFieldString(whereFields));
}
/**
* 生成根据某些字段不存在则保存的SQL语句
*
* @param tableStruct 表结构
* @param sqlName SQL语句
* @param whereFields WHERE条件
*/
private void addSaveWithSql(TableSqlCache tableStruct, String sqlName, List<TableFieldVo> whereFields) {
SqlData sqlData = this.releaseSql(DaoConst.SQL_TYPE_SAVE_WITH, sqlName, DaoConst.SQL_LOAD, StringHelper.EMPTY, new ArrayList<>(), whereFields);
tableStruct.add(sqlData);
}
/**
* 生成统计的SQL语句
*
* @param sqlTableData 需要生成的实体
* @param whereFields WHERE字段
* @param updateFields 需要增加的值的字段
*/
public void addGroupSql(TableSqlCache sqlTableData, TableFieldString whereFields, TableFieldString updateFields) {
addGroupSql(sqlTableData, getFieldString(whereFields), getFieldString(updateFields));
}
/**
* 生成统计的SQL语句
*
* @param sqlTableData 需要生成的实体
* @param whereFields WHERE字段
* @param updateFields 需要增加的值的字段
*/
private void addGroupSql(TableSqlCache sqlTableData, List<TableFieldVo> whereFields, List<TableFieldVo> updateFields) {
sqlTableData.add(this.releaseSql(DaoConst.SQL_TYPE_ADD_GROUP, DaoConst.GROUP_QUERY, DaoConst.SQL_LOAD,
StringHelper.EMPTY, new ArrayList<>(), whereFields));
sqlTableData.add(this.releaseSql(DaoConst.SQL_TYPE_ADD_GROUP, DaoConst.GROUP_ADD, DaoConst.SQL_UPDATE,
DaoConst.CODE_GROUP_ADD, updateFields, this.getFieldActionList(DaoConst.FIELD_PRIMARY)));
}
/**
* 生成判断数据是否存在的SQL语句
*
* @param sqlTableData
* @param sqlName
* @param fields
* @param sqlTableData 表结构
* @param sqlName SQL语句的名称
* @param fields 需要判断的字段
*/
public void addExist(TableSqlCache sqlTableData, String sqlName, String[] fields) {
String text = DaoConst.LOAD_MODEL.replace(DaoConst.TABLE_CODE, this.name);
String text = DaoConst.SQL_LOAD.replace(DaoConst.CODE_TABLE, this.name);
SqlData sql = new SqlData(sqlName, text);
sql.addPara(this.key.inputName, DaoConst.WHERE_CODE, " AND a." + this.key.name + "<>?");
for (String field : fields) {
sql.addParaConst(field, DaoConst.WHERE_CODE, " AND a." + field + "=?");
}
if (getRemove() != null) {
sql.addParaConst(DaoConst.ISREMOVE_CONTANS, DaoConst.WHERE_CODE, " AND a." + DaoConst.ISREMOVE + "=0");
sql.setSqlType(DaoConst.SQL_TYPE_SAVE_WITH);
sql.addConst(this.getKey().inputName,
String.format(DaoConst.CODE_WHERE_NOT_EQUALS_PARA, this.getKey().name)
);
for (String fieldName : fields) {
TableFieldVo field = this.getField(fieldName);
sql.addConst(field.inputName,
String.format(DaoConst.CODE_WHERE_EQUALS_PARA, field.name)
);
}
addWhereRemove(sql);
sqlTableData.add(sql);
}
}
yzg-util-db/src/main/java/com/yanzuoguang/db/impl/AllBeanRowMapper.java
View file @ b23101e3
package com.yanzuoguang.db.impl;
import com.yanzuoguang.dao.DaoConst;
import com.yanzuoguang.dao.TableAnnotation;
import com.yanzuoguang.extend.ConfigDb;
import com.yanzuoguang.util.base.MethodField;
import com.yanzuoguang.util.base.ObjectHelper;
import com.yanzuoguang.util.helper.StringHelper;
import com.yanzuoguang.util.log.Log;
......@@ -13,9 +15,6 @@ import org.springframework.jdbc.support.JdbcUtils;
import org.springframework.util.Assert;
import org.springframework.util.StringUtils;
import java.beans.PropertyDescriptor;
import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
......@@ -25,6 +24,7 @@ import java.util.Map;
/**
* 将数据映射为结果
*
* @author 颜佐光
*/
public class AllBeanRowMapper<T> implements RowMapper<T> {
......@@ -35,24 +35,14 @@ public class AllBeanRowMapper<T> implements RowMapper<T> {
private Class<T> mappedClass;
/**
* Mappings是否属于字段s
*/
private Map<String, Boolean> mappedIsFields;
/**
* 需要映射的字段
*/
private Map<String, Field> mappedFields;
/**
* 需要映射的属性
* 是否属于映射方式
*/
private Map<String, PropertyDescriptor> mappedPropertys;
private boolean isMapping = false;
/**
* 是否属于映射方式
* 获取字段映射关系
*/
private boolean isMapping = false;
private Map<String, MethodField> typeField;
/**
* 配置信息
......@@ -76,32 +66,29 @@ public class AllBeanRowMapper<T> implements RowMapper<T> {
*/
protected void initialize(Class<T> mappedClass) {
this.mappedClass = mappedClass;
this.mappedFields = new HashMap<>(DaoConst.COLLECTION_INIT_SIZE);
this.mappedPropertys = new HashMap<>(DaoConst.COLLECTION_INIT_SIZE);
this.mappedIsFields = new HashMap<>(DaoConst.COLLECTION_INIT_SIZE);
if (ObjectHelper.isSub(MapRow.class, mappedClass) || ObjectHelper.isSub(Map.class, mappedClass)) {
isMapping = true;
} else {
Field[] fields = mappedClass.getFields();
for (Field item : fields) {
if (Modifier.isStatic(item.getModifiers())) {
continue;
Map<String, MethodField> temp = ObjectHelper.getTypeField(mappedClass);
typeField = new HashMap<>(temp.size());
for (Map.Entry<String, MethodField> item : temp.entrySet()) {
String name = item.getKey();
// 获取字段值
MethodField field = item.getValue();
// 获取名称
TableAnnotation annotation = null;
if (field.getField() != null) {
annotation = field.getField().getAnnotation(TableAnnotation.class);
} else if (field.getGetMethod() != null) {
annotation = field.getGetMethod().getAnnotation(TableAnnotation.class);
}
String name = item.getName();
String underscoredName = underscoreName(name);
this.mappedFields.put(underscoredName, item);
this.mappedIsFields.put(underscoredName, true);
}
PropertyDescriptor[] pds = BeanUtils.getPropertyDescriptors(mappedClass);
for (PropertyDescriptor item : pds) {
if (item.getWriteMethod() != null) {
String name = item.getName();
String underscoredName = underscoreName(name);
this.mappedPropertys.put(underscoredName, item);
this.mappedIsFields.put(underscoredName, false);
if (annotation != null && !StringHelper.isEmpty(annotation.value())) {
name = annotation.value();
}
String underscoredName = underscoreName(name);
this.typeField.put(underscoredName, item.getValue());
}
}
}
......@@ -138,8 +125,8 @@ public class AllBeanRowMapper<T> implements RowMapper<T> {
*/
public static MapRow toLoweRow(MapRow from) {
MapRow to = new MapRow();
for (String key : from.keySet()) {
to.put(underscoreNameBase(key), from.get(key));
for (Map.Entry<String, Object> key : from.entrySet()) {
to.put(underscoreNameBase(key.getKey()), key.getValue());
}
return to;
}
......@@ -152,9 +139,9 @@ public class AllBeanRowMapper<T> implements RowMapper<T> {
*/
public static Object getLoweRowField(MapRow from, String field) {
field = underscoreNameBase(field);
for (String key : from.keySet()) {
if (underscoreNameBase(key).equals(field)) {
return from.get(key);
for (Map.Entry<String, Object> key : from.entrySet()) {
if (underscoreNameBase(key.getKey()).equals(field)) {
return key.getValue();
}
}
return null;
......@@ -170,8 +157,6 @@ public class AllBeanRowMapper<T> implements RowMapper<T> {
public T mapRow(ResultSet rs, int rowNumber) throws SQLException, TypeMismatchException {
Assert.state(this.mappedClass != null, "Mapped class was not specified");
T mappedObject = BeanUtils.instantiate(this.mappedClass);
BeanWrapper bw = PropertyAccessorFactory.forBeanPropertyAccess(mappedObject);
initBeanWrapper(bw);
ResultSetMetaData rsmd = rs.getMetaData();
int columnCount = rsmd.getColumnCount();
......@@ -185,53 +170,36 @@ public class AllBeanRowMapper<T> implements RowMapper<T> {
value = JdbcUtils.getResultSetValue(rs, index, String.class);
}
((Map) mappedObject).put(getCamelCase(column), value);
} else if (!this.mappedIsFields.containsKey(underscoredName)) {
} else if (!this.typeField.containsKey(underscoredName)) {
continue;
} else if (!this.mappedIsFields.get(underscoredName)) {
PropertyDescriptor pd = this.mappedPropertys.get(underscoredName);
Class<?> type = pd.getPropertyType();
try {
Object value = JdbcUtils.getResultSetValue(rs, index, type);
if (configDb.isPrintMapper() && rowNumber == 0) {
Log.info(AllBeanRowMapper.class, "Mapping column '%s' to property '%s' of type %s", column, pd.getName(), type);
}
try {
bw.setPropertyValue(pd.getName(), value);
} catch (TypeMismatchException e) {
if (value == null) {
Log.info(AllBeanRowMapper.class,
"Intercepted TypeMismatchException for row %d and column '%s' with " +
"value %s when setting property '%s' of type %s on object: %s",
rowNumber, column, value, pd.getName(), type, mappedObject);
} else {
throw e;
}
}
} catch (NotWritablePropertyException ex) {
throw new DataRetrievalFailureException("Unable to map column " + column + " to property " + pd.getName(), ex);
}
} else {
Field pd = this.mappedFields.get(underscoredName);
Class<?> type = pd.getType();
MethodField pd = this.typeField.get(underscoredName);
Class<?> type;
if (pd.getField() != null) {
type = pd.getField().getType();
} else {
type = pd.getGetMethod().getReturnType();
}
Object value = null;
try {
Object value = JdbcUtils.getResultSetValue(rs, index, type);
value = JdbcUtils.getResultSetValue(rs, index, type);
if (configDb.isPrintMapper() && rowNumber == 0) {
Log.info(AllBeanRowMapper.class, "Mapping column '%s' to property '%s' of type %s", column, pd.getName(), type);
}
try {
pd.set(mappedObject, value);
} catch (IllegalAccessException e) {
if (value == null) {
Log.info(AllBeanRowMapper.class,
"Intercepted TypeMismatchException for row %d and column '%s' with " +
"value %s when setting property '%s' of type %s on object: %s",
rowNumber, column, value, pd.getName(), type, mappedObject);
} else {
throw e;
}
ObjectHelper.setByType(mappedObject, pd, value);
} catch (TypeMismatchException e) {
if (value == null) {
Log.info(AllBeanRowMapper.class,
"Intercepted TypeMismatchException for row %d and column '%s' with " +
"value %s when setting property '%s' of type %s on object: %s",
rowNumber, column, StringHelper.EMPTY, pd.getName(), type, mappedObject);
} else {
throw e;
}
} catch (IllegalAccessException ex) {
throw new DataRetrievalFailureException("Unable to map column " + column + " to field " + pd.getName(), ex);
} catch (Exception ex) {
throw new DataRetrievalFailureException("Unable to map column " + column + " to property " + pd.getName(), ex);
}
}
}
......@@ -257,17 +225,6 @@ public class AllBeanRowMapper<T> implements RowMapper<T> {
return column;
}
/**
* Initialize the given BeanWrapper to be used for row mapping.
* To be called for each row.
* <p>The default implementation is empty. Can be overridden in subclasses.
*
* @param bw the BeanWrapper to initialize
*/
protected void initBeanWrapper(BeanWrapper bw) {
}
/**
* 缓存的处理类
*/
......
yzg-util-db/src/main/java/com/yanzuoguang/excel/ExcelConsole.java
View file @ b23101e3
......@@ -336,7 +336,10 @@ public class ExcelConsole<T extends Object> implements DbRow<T> {
workbook = null;
}
File file = new File(this.getFileName());
if (file.exists() && file.delete()) {
if (file.exists()) {
if (!file.delete()) {
throw new CodeException("文件删除失败");
}
}
return this;
}
......
yzg-util-db/src/main/java/com/yanzuoguang/service/impl/BaseServiceImpl.java
View file @ b23101e3
......@@ -49,7 +49,7 @@ public abstract class BaseServiceImpl<T> implements BaseService<T> {
*/
@Override
public List<String> create(T... models) {
List<String> ids = new ArrayList<String>();
List<String> ids = new ArrayList<>();
for (T t : models) {
String id = createItem(t);
ids.add(id);
......@@ -76,7 +76,7 @@ public abstract class BaseServiceImpl<T> implements BaseService<T> {
*/
@Override
public List<String> update(T... models) {
List<String> ids = new ArrayList<String>();
List<String> ids = new ArrayList<>();
for (T t : models) {
String id = updateItem(t);
ids.add(id);
......@@ -103,7 +103,7 @@ public abstract class BaseServiceImpl<T> implements BaseService<T> {
*/
@Override
public List<String> save(T... models) {
List<String> ids = new ArrayList<String>();
List<String> ids = new ArrayList<>();
for (T item : models) {
String id = saveItem(item);
ids.add(id);
......@@ -157,7 +157,7 @@ public abstract class BaseServiceImpl<T> implements BaseService<T> {
*/
@Override
public List<T> load(T... models) {
List<T> tos = new ArrayList<T>();
List<T> tos = new ArrayList<>();
for (T item : models) {
T to = loadItem(item);
tos.add(to);
......
yzg-util-db/src/main/java/com/yanzuoguang/token/TokenHelper.java
View file @ b23101e3
......@@ -40,7 +40,7 @@ public class TokenHelper {
/**
* 内存缓存
*/
protected static MemoryCache<TokenData> cache = new MemoryCache<>();
protected final static MemoryCache<TokenData> cache = new MemoryCache<>();
/**
......
yzg-util-db/src/main/java/com/yanzuoguang/token/TokenLoad.java
View file @ b23101e3
package com.yanzuoguang.token;
import com.yanzuoguang.util.vo.MapRow;
/**
* 动态加载Token
*
......
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