From a52581836d3c5f5575cd1b6275496cd27d366f76 Mon Sep 17 00:00:00 2001 From: cym1102 Date: Sun, 8 Sep 2024 14:21:47 +0800 Subject: [PATCH] 1 --- lib/jpaHelper-release.jar | Bin 35898 -> 0 bytes lib/jpaHelper/.gitignore | 1 + lib/jpaHelper/pom.xml | 56 + .../main/java/com/cym/bean/CreateTime.java | 12 + .../src/main/java/com/cym/bean/InitValue.java | 14 + .../src/main/java/com/cym/bean/OrderBy.java | 48 + .../src/main/java/com/cym/bean/Page.java | 99 ++ .../src/main/java/com/cym/bean/Sort.java | 108 ++ .../src/main/java/com/cym/bean/Update.java | 35 + .../main/java/com/cym/bean/UpdateTime.java | 12 + .../com/cym/reflection/ReflectionUtil.java | 65 ++ .../cym/reflection/SerializableFunction.java | 9 + .../main/java/com/cym/utils/BeanExtUtil.java | 58 + .../main/java/com/cym/utils/Condition.java | 53 + .../com/cym/utils/ConditionAndWrapper.java | 351 ++++++ .../com/cym/utils/ConditionOrWrapper.java | 332 ++++++ .../java/com/cym/utils/ConditionWrapper.java | 247 ++++ .../src/main/java/com/cym/utils/InitTool.java | 83 ++ .../src/main/java/com/cym/utils/InitUtil.java | 17 + .../main/java/com/cym/utils/JpaHelper.java | 1018 +++++++++++++++++ .../main/java/com/cym/utils/PackageTools.java | 28 + .../java/com/cym/utils/SnowFlakeUtils.java | 11 + .../src/main/java/com/cym/utils/SqlUtils.java | 61 + lib/sqlHelper/.gitignore | 1 + lib/sqlHelper/pom.xml | 66 ++ .../com/cym/sqlHelper/bean/BaseModel.java | 39 + .../java/com/cym/sqlHelper/bean/Order.java | 25 + .../java/com/cym/sqlHelper/bean/Page.java | 60 + .../java/com/cym/sqlHelper/bean/Sort.java | 83 ++ .../java/com/cym/sqlHelper/bean/Update.java | 27 + .../com/cym/sqlHelper/config/AsyncConfig.java | 24 + .../cym/sqlHelper/config/CompositeIndex.java | 15 + .../sqlHelper/config/DataSourceConfig.java | 59 + .../com/cym/sqlHelper/config/InitValue.java | 14 + .../com/cym/sqlHelper/config/SingleIndex.java | 15 + .../java/com/cym/sqlHelper/config/Table.java | 15 + .../sqlHelper/reflection/ReflectionUtil.java | 65 ++ .../reflection/SerializableFunction.java | 9 + .../com/cym/sqlHelper/utils/Condition.java | 39 + .../sqlHelper/utils/ConditionAndWrapper.java | 339 ++++++ .../sqlHelper/utils/ConditionOrWrapper.java | 321 ++++++ .../cym/sqlHelper/utils/ConditionWrapper.java | 235 ++++ .../cym/sqlHelper/utils/SnowFlakeUtils.java | 11 + .../com/cym/sqlHelper/utils/SqlHelper.java | 944 +++++++++++++++ .../com/cym/sqlHelper/utils/SqlUtils.java | 151 +++ .../com/cym/sqlHelper/utils/TableUtils.java | 107 ++ .../src/test/java/cn/craccd/test/Test.java | 1 + 47 files changed, 5383 insertions(+) delete mode 100644 lib/jpaHelper-release.jar create mode 100644 lib/jpaHelper/.gitignore create mode 100644 lib/jpaHelper/pom.xml create mode 100644 lib/jpaHelper/src/main/java/com/cym/bean/CreateTime.java create mode 100644 lib/jpaHelper/src/main/java/com/cym/bean/InitValue.java create mode 100644 lib/jpaHelper/src/main/java/com/cym/bean/OrderBy.java create mode 100644 lib/jpaHelper/src/main/java/com/cym/bean/Page.java create mode 100644 lib/jpaHelper/src/main/java/com/cym/bean/Sort.java create mode 100644 lib/jpaHelper/src/main/java/com/cym/bean/Update.java create mode 100644 lib/jpaHelper/src/main/java/com/cym/bean/UpdateTime.java create mode 100644 lib/jpaHelper/src/main/java/com/cym/reflection/ReflectionUtil.java create mode 100644 lib/jpaHelper/src/main/java/com/cym/reflection/SerializableFunction.java create mode 100644 lib/jpaHelper/src/main/java/com/cym/utils/BeanExtUtil.java create mode 100644 lib/jpaHelper/src/main/java/com/cym/utils/Condition.java create mode 100644 lib/jpaHelper/src/main/java/com/cym/utils/ConditionAndWrapper.java create mode 100644 lib/jpaHelper/src/main/java/com/cym/utils/ConditionOrWrapper.java create mode 100644 lib/jpaHelper/src/main/java/com/cym/utils/ConditionWrapper.java create mode 100644 lib/jpaHelper/src/main/java/com/cym/utils/InitTool.java create mode 100644 lib/jpaHelper/src/main/java/com/cym/utils/InitUtil.java create mode 100644 lib/jpaHelper/src/main/java/com/cym/utils/JpaHelper.java create mode 100644 lib/jpaHelper/src/main/java/com/cym/utils/PackageTools.java create mode 100644 lib/jpaHelper/src/main/java/com/cym/utils/SnowFlakeUtils.java create mode 100644 lib/jpaHelper/src/main/java/com/cym/utils/SqlUtils.java create mode 100644 lib/sqlHelper/.gitignore create mode 100644 lib/sqlHelper/pom.xml create mode 100644 lib/sqlHelper/src/main/java/com/cym/sqlHelper/bean/BaseModel.java create mode 100644 lib/sqlHelper/src/main/java/com/cym/sqlHelper/bean/Order.java create mode 100644 lib/sqlHelper/src/main/java/com/cym/sqlHelper/bean/Page.java create mode 100644 lib/sqlHelper/src/main/java/com/cym/sqlHelper/bean/Sort.java create mode 100644 lib/sqlHelper/src/main/java/com/cym/sqlHelper/bean/Update.java create mode 100644 lib/sqlHelper/src/main/java/com/cym/sqlHelper/config/AsyncConfig.java create mode 100644 lib/sqlHelper/src/main/java/com/cym/sqlHelper/config/CompositeIndex.java create mode 100644 lib/sqlHelper/src/main/java/com/cym/sqlHelper/config/DataSourceConfig.java create mode 100644 lib/sqlHelper/src/main/java/com/cym/sqlHelper/config/InitValue.java create mode 100644 lib/sqlHelper/src/main/java/com/cym/sqlHelper/config/SingleIndex.java create mode 100644 lib/sqlHelper/src/main/java/com/cym/sqlHelper/config/Table.java create mode 100644 lib/sqlHelper/src/main/java/com/cym/sqlHelper/reflection/ReflectionUtil.java create mode 100644 lib/sqlHelper/src/main/java/com/cym/sqlHelper/reflection/SerializableFunction.java create mode 100644 lib/sqlHelper/src/main/java/com/cym/sqlHelper/utils/Condition.java create mode 100644 lib/sqlHelper/src/main/java/com/cym/sqlHelper/utils/ConditionAndWrapper.java create mode 100644 lib/sqlHelper/src/main/java/com/cym/sqlHelper/utils/ConditionOrWrapper.java create mode 100644 lib/sqlHelper/src/main/java/com/cym/sqlHelper/utils/ConditionWrapper.java create mode 100644 lib/sqlHelper/src/main/java/com/cym/sqlHelper/utils/SnowFlakeUtils.java create mode 100644 lib/sqlHelper/src/main/java/com/cym/sqlHelper/utils/SqlHelper.java create mode 100644 lib/sqlHelper/src/main/java/com/cym/sqlHelper/utils/SqlUtils.java create mode 100644 lib/sqlHelper/src/main/java/com/cym/sqlHelper/utils/TableUtils.java create mode 100644 lib/sqlHelper/src/test/java/cn/craccd/test/Test.java diff --git a/lib/jpaHelper-release.jar b/lib/jpaHelper-release.jar deleted file mode 100644 index 7e0428420d0f3f708e8c3a66a82a075250d21efe..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 35898 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 + 4.0.0 + jpaHelper + jar + release + + + org.springframework.boot + spring-boot-starter-parent + 3.3.3 + + + + + 21 + + + + + cn.hutool + hutool-all + 5.8.25 + + + com.mysql + mysql-connector-j + + + org.springframework.boot + spring-boot-starter-data-jpa + + + + io.swagger.core.v3 + swagger-annotations-jakarta + 2.2.19 + + + + + + + + org.apache.maven.plugins + maven-compiler-plugin + + ${java.version} + ${java.version} + ${project.build.sourceEncoding} + + + + + \ No newline at end of file diff --git a/lib/jpaHelper/src/main/java/com/cym/bean/CreateTime.java b/lib/jpaHelper/src/main/java/com/cym/bean/CreateTime.java new file mode 100644 index 0000000..6b71c20 --- /dev/null +++ b/lib/jpaHelper/src/main/java/com/cym/bean/CreateTime.java @@ -0,0 +1,12 @@ +package com.cym.bean; + +import java.lang.annotation.ElementType; +import java.lang.annotation.Retention; +import java.lang.annotation.RetentionPolicy; +import java.lang.annotation.Target; + +@Retention(RetentionPolicy.RUNTIME) +@Target({ ElementType.FIELD }) +public @interface CreateTime { + +} diff --git a/lib/jpaHelper/src/main/java/com/cym/bean/InitValue.java b/lib/jpaHelper/src/main/java/com/cym/bean/InitValue.java new file mode 100644 index 0000000..0060545 --- /dev/null +++ b/lib/jpaHelper/src/main/java/com/cym/bean/InitValue.java @@ -0,0 +1,14 @@ +package com.cym.bean; + +import java.lang.annotation.ElementType; +import java.lang.annotation.Retention; +import java.lang.annotation.RetentionPolicy; +import java.lang.annotation.Target; + +@Retention(RetentionPolicy.RUNTIME) +@Target({ ElementType.FIELD }) +public @interface InitValue { + + String value(); + +} diff --git a/lib/jpaHelper/src/main/java/com/cym/bean/OrderBy.java b/lib/jpaHelper/src/main/java/com/cym/bean/OrderBy.java new file mode 100644 index 0000000..8ae5d55 --- /dev/null +++ b/lib/jpaHelper/src/main/java/com/cym/bean/OrderBy.java @@ -0,0 +1,48 @@ +package com.cym.bean; + +public class OrderBy { + Direction direction; + String column; + String orderByStr; + + + + public static enum Direction { + ASC, DESC; + } + + public OrderBy(Direction direction, String column) { + this.direction = direction; + this.column = column; + } + + public OrderBy() { + + } + + + public String getOrderByStr() { + return orderByStr; + } + + public void setOrderByStr(String orderByStr) { + this.orderByStr = orderByStr; + } + + public Direction getDirection() { + return direction; + } + + public void setDirection(Direction direction) { + this.direction = direction; + } + + public String getColumn() { + return column; + } + + public void setColumn(String column) { + this.column = column; + } + +} diff --git a/lib/jpaHelper/src/main/java/com/cym/bean/Page.java b/lib/jpaHelper/src/main/java/com/cym/bean/Page.java new file mode 100644 index 0000000..19c873b --- /dev/null +++ b/lib/jpaHelper/src/main/java/com/cym/bean/Page.java @@ -0,0 +1,99 @@ +package com.cym.bean; + +import java.util.ArrayList; +import java.util.List; + +import io.swagger.v3.oas.annotations.media.Schema; + +@Schema(description = " 分页返回类") +public class Page { + @Schema(description = "总记录数") + Long total = 0l; + @Schema(description = "起始页,从1开始") + Integer pageNum = 1; + @Schema(description = "每页记录数,默认为10") + Integer pageSize = 10; + + @Schema(description = "起始编号") + Integer startRow; + @Schema(description = "结束编号") + Integer endRow; + @Schema(description = "总页数") + Integer pages; + + @Schema(description = "内容列表") + List list; + + public Page() { + + } + + public Page(Integer pageNum, Integer pageSize) { + this.setPageNum(pageNum); + this.setPageSize(pageSize); + } + + /** + * 清空List + */ + public void clearList() { + list = new ArrayList<>(); + } + + public Long getTotal() { + return total; + } + + public void setTotal(Long total) { + this.total = total; + } + + public Integer getPageNum() { + return pageNum; + } + + public void setPageNum(Integer pageNum) { + this.pageNum = pageNum; + } + + public Integer getPageSize() { + return pageSize; + } + + public void setPageSize(Integer pageSize) { + this.pageSize = pageSize; + } + + public List getList() { + return list; + } + + public void setList(List list) { + this.list = list; + } + + public Integer getStartRow() { + return startRow; + } + + public void setStartRow(Integer startRow) { + this.startRow = startRow; + } + + public Integer getEndRow() { + return endRow; + } + + public void setEndRow(Integer endRow) { + this.endRow = endRow; + } + + public Integer getPages() { + return pages; + } + + public void setPages(Integer pages) { + this.pages = pages; + } + +} diff --git a/lib/jpaHelper/src/main/java/com/cym/bean/Sort.java b/lib/jpaHelper/src/main/java/com/cym/bean/Sort.java new file mode 100644 index 0000000..1835994 --- /dev/null +++ b/lib/jpaHelper/src/main/java/com/cym/bean/Sort.java @@ -0,0 +1,108 @@ +package com.cym.bean; + +import java.util.ArrayList; +import java.util.List; + +import com.cym.bean.OrderBy.Direction; +import com.cym.reflection.ReflectionUtil; +import com.cym.reflection.SerializableFunction; +import cn.hutool.core.util.StrUtil; + +public class Sort { + List orderList = new ArrayList<>(); + + public Sort() { + + } + + public Sort(String column, Direction direction) { + OrderBy order = new OrderBy(); + order.setColumn(column); + order.setDirection(direction); + + orderList.add(order); + } + + public Sort(List orderList) { + this.orderList.addAll(orderList); + } + + public Sort(String orderByStr) { + OrderBy order = new OrderBy(); + order.setOrderByStr(orderByStr); + + orderList.add(order); + } + + public Sort(SerializableFunction column, Direction direction) { + OrderBy order = new OrderBy(); + order.setColumn(ReflectionUtil.getFieldName(column)); + order.setDirection(direction); + + orderList.add(order); + } + + public Sort add(String column, Direction direction) { + OrderBy order = new OrderBy(); + order.setColumn(column); + order.setDirection(direction); + + orderList.add(order); + + return this; + } + + public Sort add(SerializableFunction column, Direction direction) { + OrderBy order = new OrderBy(); + order.setColumn(ReflectionUtil.getFieldName(column)); + order.setDirection(direction); + + orderList.add(order); + + return this; + } + + public Sort add(String orderByStr) { + OrderBy order = new OrderBy(); + order.setOrderByStr(orderByStr); + + orderList.add(order); + + return this; + } + + public String toString() { + List sqlList = new ArrayList<>(); + for (OrderBy order : orderList) { + if (StrUtil.isEmpty(order.getOrderByStr())) { + String sql = "`" + StrUtil.toUnderlineCase(order.getColumn()) + "`"; + + if (order.getDirection() == Direction.ASC) { + sql += " ASC"; + } + if (order.getDirection() == Direction.DESC) { + sql += " DESC"; + } + + sqlList.add(sql); + } else { + sqlList.add(order.getOrderByStr()); + } + } + if (sqlList.size() > 0) { + return " ORDER BY " + StrUtil.join(",", sqlList); + } else { + return ""; + } + + } + + public List getOrderList() { + return orderList; + } + + public void setOrderList(List orderList) { + this.orderList = orderList; + } + +} diff --git a/lib/jpaHelper/src/main/java/com/cym/bean/Update.java b/lib/jpaHelper/src/main/java/com/cym/bean/Update.java new file mode 100644 index 0000000..d79722b --- /dev/null +++ b/lib/jpaHelper/src/main/java/com/cym/bean/Update.java @@ -0,0 +1,35 @@ +package com.cym.bean; + +import java.util.HashMap; +import java.util.Map; + +import com.cym.reflection.ReflectionUtil; +import com.cym.reflection.SerializableFunction; + +public class Update { + + Map sets; + + public Update() { + sets = new HashMap(); + } + + public Update set(String key, Object value) { + sets.put(key, value); + return this; + } + + public Update set(SerializableFunction property, Object value) { + sets.put(ReflectionUtil.getFieldName(property), value); + return this; + } + + public Map getSets() { + return sets; + } + + public void setSets(Map sets) { + this.sets = sets; + } + +} diff --git a/lib/jpaHelper/src/main/java/com/cym/bean/UpdateTime.java b/lib/jpaHelper/src/main/java/com/cym/bean/UpdateTime.java new file mode 100644 index 0000000..fa243b1 --- /dev/null +++ b/lib/jpaHelper/src/main/java/com/cym/bean/UpdateTime.java @@ -0,0 +1,12 @@ +package com.cym.bean; + +import java.lang.annotation.ElementType; +import java.lang.annotation.Retention; +import java.lang.annotation.RetentionPolicy; +import java.lang.annotation.Target; + +@Retention(RetentionPolicy.RUNTIME) +@Target({ ElementType.FIELD }) +public @interface UpdateTime { + +} diff --git a/lib/jpaHelper/src/main/java/com/cym/reflection/ReflectionUtil.java b/lib/jpaHelper/src/main/java/com/cym/reflection/ReflectionUtil.java new file mode 100644 index 0000000..91d3e80 --- /dev/null +++ b/lib/jpaHelper/src/main/java/com/cym/reflection/ReflectionUtil.java @@ -0,0 +1,65 @@ +package com.cym.reflection; + +import java.beans.Introspector; +import java.lang.invoke.SerializedLambda; +import java.lang.reflect.Field; +import java.lang.reflect.Method; +import java.util.Map; +import java.util.concurrent.ConcurrentHashMap; + +import org.springframework.util.ClassUtils; +import org.springframework.util.ReflectionUtils; + +public class ReflectionUtil { + + private static Map, Field> cache = new ConcurrentHashMap<>(); + + public static String getFieldName(SerializableFunction function) { + Field field = ReflectionUtil.getField(function); + return field.getName(); + } + + public static Field getField(SerializableFunction function) { + return cache.computeIfAbsent(function, ReflectionUtil::findField); + } + + public static Field findField(SerializableFunction function) { + Field field = null; + String fieldName = null; + try { + // 第1步 获取SerializedLambda + Method method = function.getClass().getDeclaredMethod("writeReplace"); + method.setAccessible(Boolean.TRUE); + SerializedLambda serializedLambda = (SerializedLambda) method.invoke(function); + // 第2步 implMethodName 即为Field对应的Getter方法名 + String implMethodName = serializedLambda.getImplMethodName(); + if (implMethodName.startsWith("get") && implMethodName.length() > 3) { + fieldName = Introspector.decapitalize(implMethodName.substring(3)); + + } else if (implMethodName.startsWith("is") && implMethodName.length() > 2) { + fieldName = Introspector.decapitalize(implMethodName.substring(2)); + } else if (implMethodName.startsWith("lambda$")) { + throw new IllegalArgumentException("SerializableFunction不能传递lambda表达式,只能使用方法引用"); + + } else { + throw new IllegalArgumentException(implMethodName + "不是Getter方法引用"); + } + // 第3步 获取的Class是字符串，并且包名是“/”分割，需要替换成“.”，才能获取到对应的Class对象 + String declaredClass = serializedLambda.getImplClass().replace("/", "."); + Class aClass = Class.forName(declaredClass, false, ClassUtils.getDefaultClassLoader()); + + // 第4步 Spring 中的反射工具类获取Class中定义的Field + field = ReflectionUtils.findField(aClass, fieldName); + + } catch (Exception e) { + e.printStackTrace(); + } + // 第5步 如果没有找到对应的字段应该抛出异常 + if (field != null) { + return field; + } + throw new NoSuchFieldError(fieldName); + } + + +} \ No newline at end of file diff --git a/lib/jpaHelper/src/main/java/com/cym/reflection/SerializableFunction.java b/lib/jpaHelper/src/main/java/com/cym/reflection/SerializableFunction.java new file mode 100644 index 0000000..4a3bb6d --- /dev/null +++ b/lib/jpaHelper/src/main/java/com/cym/reflection/SerializableFunction.java @@ -0,0 +1,9 @@ +package com.cym.reflection; + +import java.io.Serializable; +import java.util.function.Function; + +@FunctionalInterface +public interface SerializableFunction extends Function, Serializable { + +} \ No newline at end of file diff --git a/lib/jpaHelper/src/main/java/com/cym/utils/BeanExtUtil.java b/lib/jpaHelper/src/main/java/com/cym/utils/BeanExtUtil.java new file mode 100644 index 0000000..9952ed3 --- /dev/null +++ b/lib/jpaHelper/src/main/java/com/cym/utils/BeanExtUtil.java @@ -0,0 +1,58 @@ +package com.cym.utils; + +import java.util.ArrayList; +import java.util.List; + +import com.cym.bean.Page; +import cn.hutool.core.bean.BeanUtil; + +public class BeanExtUtil { + + /** + * 根据List对象属性批量创建对应的Class List对象 + * + * @param list + * @param clazz + * @return + */ + public static List copyListByProperties(List list, Class clazz) { + if (list == null) { + return null; + } + + List rsList = new ArrayList<>(); + for (Object source : list) { + rsList.add((T) BeanUtil.copyProperties(source, clazz)); + } + + return rsList; + } + + + /** + * 根据PageResp对象属性批量创建对应的Class PageResp对象 + * + * @param pageResp + * @param clazz + * @return + */ + @SuppressWarnings("unchecked") + public static Page copyPageByProperties(Page page, Class clazz) { + Page pageNew = copyBeanByProperties(page, Page.class); + pageNew.setList(copyListByProperties(page.getList(), clazz)); + return pageNew; + } + + /** + * 按照Bean对象属性创建对应的Class对象 + * + */ + public static T copyBeanByProperties(Object source, Class tClass) { + return BeanUtil.copyProperties(source, tClass); + } + + + + + +} diff --git a/lib/jpaHelper/src/main/java/com/cym/utils/Condition.java b/lib/jpaHelper/src/main/java/com/cym/utils/Condition.java new file mode 100644 index 0000000..784a916 --- /dev/null +++ b/lib/jpaHelper/src/main/java/com/cym/utils/Condition.java @@ -0,0 +1,53 @@ +package com.cym.utils; + +public class Condition { + public Condition(String column, String operation, Object value) { + this.column = column; + this.operation = operation; + this.value = value; + } + + public Condition(String condition) { + this.condition = condition; + } + + String column; + String operation; + Object value; + String condition; + + + + public String getCondition() { + return condition; + } + + public void setCondition(String condition) { + this.condition = condition; + } + + public String getColumn() { + return column; + } + + public void setColumn(String column) { + this.column = column; + } + + public String getOperation() { + return operation; + } + + public void setOperation(String operation) { + this.operation = operation; + } + + public Object getValue() { + return value; + } + + public void setValue(Object value) { + this.value = value; + } + +} diff --git a/lib/jpaHelper/src/main/java/com/cym/utils/ConditionAndWrapper.java b/lib/jpaHelper/src/main/java/com/cym/utils/ConditionAndWrapper.java new file mode 100644 index 0000000..cb9942a --- /dev/null +++ b/lib/jpaHelper/src/main/java/com/cym/utils/ConditionAndWrapper.java @@ -0,0 +1,351 @@ +package com.cym.utils; + +import java.util.Arrays; +import java.util.Collection; + +import com.cym.reflection.ReflectionUtil; +import com.cym.reflection.SerializableFunction; + +/** + * 查询语句生成器 AND连接 + * + */ +public class ConditionAndWrapper extends ConditionWrapper { + + public ConditionAndWrapper() { + andLink = true; + } + + public ConditionAndWrapper and(ConditionWrapper conditionWrapper) { + list.add(conditionWrapper); + return this; + } + + /** + * 自由撰写条件 + * + * @param condition 条件 + * @return ConditionWrapper + */ + public ConditionAndWrapper custom(String condition) { + super.custom(condition); + return this; + } + + + /** + * 等于 + * + * @param column 字段 + * @param params 参数 + * @return ConditionWrapper + */ + public ConditionAndWrapper eq(String column, Object params) { + super.eq(column, params); + return this; + } + + /** + * 等于 + * + * @param column 字段 + * @param params 参数 + * @return ConditionWrapper + */ + public ConditionAndWrapper eq(SerializableFunction column, Object params) { + super.eq(ReflectionUtil.getFieldName(column), params); + return this; + } + + /** + * 不等于 + * + * @param column 字段 + * @param params 参数 + * @return ConditionAndWrapper + */ + public ConditionAndWrapper ne(String column, Object params) { + super.ne(column, params); + return this; + } + + /** + * 不等于 + * + * @param column 字段 + * @param params 参数 + * @return ConditionAndWrapper + */ + public ConditionAndWrapper ne(SerializableFunction column, Object params) { + super.ne(ReflectionUtil.getFieldName(column), params); + return this; + } + + /** + * 小于 + * + * @param column 字段 + * @param params 参数 + * @return ConditionAndWrapper + */ + public ConditionAndWrapper lt(String column, Object params) { + super.lt(column, params); + return this; + } + + /** + * 小于 + * + * @param column 字段 + * @param params 参数 + * @return ConditionAndWrapper + */ + public ConditionAndWrapper lt(SerializableFunction column, Object params) { + super.lt(ReflectionUtil.getFieldName(column), params); + return this; + } + + /** + * 小于或等于 + * + * @param column 字段 + * @param params 参数 + * @return ConditionAndWrapper + */ + public ConditionAndWrapper lte(String column, Object params) { + super.lte(column, params); + return this; + } + + /** + * 小于或等于 + * + * @param column 字段 + * @param params 参数 + * @return ConditionAndWrapper + */ + public ConditionAndWrapper lte(SerializableFunction column, Object params) { + super.lte(ReflectionUtil.getFieldName(column), params); + return this; + } + + /** + * 大于 + * + * @param column 字段 + * @param params 参数 + * @return ConditionAndWrapper + */ + public ConditionAndWrapper gt(String column, Object params) { + super.gt(column, params); + return this; + } + + /** + * 大于 + * + * @param column 字段 + * @param params 参数 + * @return ConditionAndWrapper + */ + public ConditionAndWrapper gt(SerializableFunction column, Object params) { + super.gt(ReflectionUtil.getFieldName(column), params); + return this; + } + + /** + * 大于或等于 + * + * @param column 字段 + * @param params 参数 + * @return ConditionAndWrapper + */ + public ConditionAndWrapper gte(String column, Object params) { + super.gte(column, params); + return this; + } + + /** + * 大于或等于 + * + * @param column 字段 + * @param params 参数 + * @return ConditionAndWrapper + */ + public ConditionAndWrapper gte(SerializableFunction column, Object params) { + super.gte(ReflectionUtil.getFieldName(column), params); + return this; + } + + /** + * 相似于 + * + * @param column 字段 + * @param params 参数 + * @return ConditionAndWrapper + */ + public ConditionAndWrapper like(String column, String params) { + super.like(column, params); + return this; + } + + /** + * 相似于 + * + * @param column 字段 + * @param params 参数 + * @return ConditionAndWrapper + */ + public ConditionAndWrapper like(SerializableFunction column, String params) { + super.like(ReflectionUtil.getFieldName(column), params); + return this; + } + + /** + * 在其中 + * + * @param column 字段 + * @param params 参数 + * @return ConditionAndWrapper + */ + public ConditionAndWrapper in(String column, Collection params) { + super.in(column, params); + return this; + } + + /** + * 在其中 + * + * @param column 字段 + * @param params 参数 + * @return ConditionAndWrapper + */ + public ConditionAndWrapper in(SerializableFunction column, Collection params) { + super.in(ReflectionUtil.getFieldName(column), params); + return this; + } + + /** + * 在其中 + * + * @param column 字段 + * @param params 参数 + * @return ConditionAndWrapper + */ + public ConditionAndWrapper in(String column, Object[] params) { + super.in(column, Arrays.asList(params)); + return this; + } + + /** + * 在其中 + * + * @param column 字段 + * @param params 参数 + * @return ConditionAndWrapper + */ + public ConditionAndWrapper in(SerializableFunction column, Object[] params) { + super.in(ReflectionUtil.getFieldName(column), Arrays.asList(params)); + return this; + } + + /** + * 不在其中 + * + * @param column 字段 + * @param params 参数 + * @return ConditionAndWrapper + */ + public ConditionAndWrapper nin(String column, Collection params) { + super.nin(column, params); + return this; + } + + /** + * 不在其中 + * + * @param column 字段 + * @param params 参数 + * @return ConditionAndWrapper + */ + public ConditionAndWrapper nin(SerializableFunction column, Collection params) { + super.nin(ReflectionUtil.getFieldName(column), params); + return this; + } + + /** + * 不在其中 + * + * @param column 字段 + * @param params 参数 + * @return ConditionAndWrapper + */ + public ConditionAndWrapper nin(String column, Object[] params) { + super.nin(column, Arrays.asList(params)); + return this; + } + + /** + * 不在其中 + * + * @param column 字段 + * @param params 参数 + * @return ConditionAndWrapper + */ + public ConditionAndWrapper nin(SerializableFunction column, Object[] params) { + super.nin(ReflectionUtil.getFieldName(column), Arrays.asList(params)); + return this; + } + + /** + * 为空 + * + * @param + * + * @param column 字段 + * @return ConditionAndWrapper + */ + public ConditionAndWrapper isNull(String column) { + super.isNull(column); + return this; + } + + /** + * 为空 + * + * @param + * + * @param column 字段 + * @return ConditionAndWrapper + */ + public ConditionAndWrapper isNull(SerializableFunction column) { + super.isNull(ReflectionUtil.getFieldName(column)); + return this; + } + + /** + * 不为空 + * + * @param + * + * @param column 字段 + * @return ConditionAndWrapper + */ + public ConditionAndWrapper isNotNull(String column) { + super.isNotNull(column); + return this; + } + + /** + * 不为空 + * + * @param + * + * @param column 字段 + * @return ConditionAndWrapper + */ + public ConditionAndWrapper isNotNull(SerializableFunction column) { + super.isNotNull(ReflectionUtil.getFieldName(column)); + return this; + } +} diff --git a/lib/jpaHelper/src/main/java/com/cym/utils/ConditionOrWrapper.java b/lib/jpaHelper/src/main/java/com/cym/utils/ConditionOrWrapper.java new file mode 100644 index 0000000..9a3e887 --- /dev/null +++ b/lib/jpaHelper/src/main/java/com/cym/utils/ConditionOrWrapper.java @@ -0,0 +1,332 @@ +package com.cym.utils; + +import java.util.Arrays; +import java.util.Collection; + +import com.cym.reflection.ReflectionUtil; +import com.cym.reflection.SerializableFunction; + +/** + * 查询语句生成器 OR连接 + * + */ +public class ConditionOrWrapper extends ConditionWrapper { + + public ConditionOrWrapper() { + andLink = false; + } + + public ConditionOrWrapper or(ConditionWrapper conditionWrapper) { + list.add(conditionWrapper); + return this; + } + + /** + * 自由撰写条件 + * + * @param condition 条件 + * @return ConditionWrapper + */ + public ConditionOrWrapper custom(String condition) { + super.custom(condition); + return this; + } + + /** + * 等于 + * + * @param column 字段 + * @param params 参数 + * @return ConditionWrapper + */ + public ConditionOrWrapper eq(String column, Object params) { + super.eq(column, params); + return this; + } + /** + * 等于 + * + * @param column 字段 + * @param params 参数 + * @return ConditionWrapper + */ + public ConditionOrWrapper eq(SerializableFunction column, Object params) { + super.eq(ReflectionUtil.getFieldName(column), params); + return this; + } + /** + * 不等于 + * + * @param column 字段 + * @param params 参数 + * @return ConditionOrWrapper + */ + public ConditionOrWrapper ne(String column, Object params) { + super.ne(column, params); + return this; + } + + /** + * 不等于 + * + * @param column 字段 + * @param params 参数 + * @return ConditionOrWrapper + */ + public ConditionOrWrapper ne(SerializableFunction column, Object params) { + super.ne(ReflectionUtil.getFieldName(column), params); + return this; + } + + /** + * 小于 + * + * @param column 字段 + * @param params 参数 + * @return ConditionOrWrapper + */ + public ConditionOrWrapper lt(String column, Object params) { + super.lt(column, params); + return this; + } + /** + * 小于 + * + * @param column 字段 + * @param params 参数 + * @return ConditionOrWrapper + */ + public ConditionOrWrapper lt(SerializableFunction column, Object params) { + super.lt(ReflectionUtil.getFieldName(column), params); + return this; + } + /** + * 小于或等于 + * + * @param column 字段 + * @param params 参数 + * @return ConditionOrWrapper + */ + public ConditionOrWrapper lte(String column, Object params) { + super.lte(column, params); + return this; + } + /** + * 小于或等于 + * + * @param column 字段 + * @param params 参数 + * @return ConditionOrWrapper + */ + public ConditionOrWrapper lte(SerializableFunction column, Object params) { + super.lte(ReflectionUtil.getFieldName(column), params); + return this; + } + /** + * 大于 + * + * @param column 字段 + * @param params 参数 + * @return ConditionOrWrapper + */ + public ConditionOrWrapper gt(String column, Object params) { + super.gt(column, params); + return this; + } + /** + * 大于 + * + * @param column 字段 + * @param params 参数 + * @return ConditionOrWrapper + */ + public ConditionOrWrapper gt(SerializableFunction column, Object params) { + super.gt(ReflectionUtil.getFieldName(column), params); + return this; + } + /** + * 大于或等于 + * + * @param column 字段 + * @param params 参数 + * @return ConditionOrWrapper + */ + public ConditionOrWrapper gte(String column, Object params) { + super.gte(column, params); + return this; + } + /** + * 大于或等于 + * + * @param column 字段 + * @param params 参数 + * @return ConditionOrWrapper + */ + public ConditionOrWrapper gte(SerializableFunction column, Object params) { + super.gte(ReflectionUtil.getFieldName(column), params); + return this; + } + /** + * 相似于 + * + * @param column 字段 + * @param params 参数 + * @return ConditionOrWrapper + */ + public ConditionOrWrapper like(String column, String params) { + super.like(column, params); + return this; + } + /** + * 相似于 + * + * @param column 字段 + * @param params 参数 + * @return ConditionOrWrapper + */ + public ConditionOrWrapper like(SerializableFunction column, String params) { + super.like(ReflectionUtil.getFieldName(column), params); + return this; + } + /** + * 在其中 + * + * @param column 字段 + * @param params 参数 + * @return ConditionOrWrapper + */ + public ConditionOrWrapper in(String column, Collection params) { + super.in(column, params); + return this; + } + /** + * 在其中 + * + * @param column 字段 + * @param params 参数 + * @return ConditionOrWrapper + */ + public ConditionOrWrapper in(SerializableFunction column, Collection params) { + super.in(ReflectionUtil.getFieldName(column), params); + return this; + } + + /** + * 在其中 + * + * @param column 字段 + * @param params 参数 + * @return ConditionOrWrapper + */ + public ConditionOrWrapper in(String column, Object[] params) { + super.in(column, Arrays.asList(params)); + return this; + } + + /** + * 在其中 + * + * @param column 字段 + * @param params 参数 + * @return ConditionOrWrapper + */ + public ConditionOrWrapper in(SerializableFunction column, Object[] params) { + super.in(ReflectionUtil.getFieldName(column), Arrays.asList(params)); + return this; + } + + /** + * 不在其中 + * + * @param column 字段 + * @param params 参数 + * @return ConditionOrWrapper + */ + public ConditionOrWrapper nin(String column, Collection params) { + super.nin(column, params); + return this; + } + /** + * 不在其中 + * + * @param column 字段 + * @param params 参数 + * @return ConditionOrWrapper + */ + public ConditionOrWrapper nin(SerializableFunction column, Collection params) { + super.nin(ReflectionUtil.getFieldName(column), params); + return this; + } + + /** + * 不在其中 + * + * @param column 字段 + * @param params 参数 + * @return ConditionOrWrapper + */ + public ConditionOrWrapper nin(String column, Object[] params) { + super.nin(column, Arrays.asList(params)); + return this; + } + /** + * 不在其中 + * + * @param column 字段 + * @param params 参数 + * @return ConditionOrWrapper + */ + public ConditionOrWrapper nin(SerializableFunction column, Object[] params) { + super.nin(ReflectionUtil.getFieldName(column), Arrays.asList(params)); + return this; + } + /** + * 为空 + * + * @param + * + * @param column 字段 + * @return ConditionOrWrapper + */ + public ConditionOrWrapper isNull(String column) { + super.isNull(column); + return this; + } + /** + * 为空 + * + * @param + * + * @param column 字段 + * @return ConditionOrWrapper + */ + public ConditionOrWrapper isNull(SerializableFunction column) { + super.isNull(ReflectionUtil.getFieldName(column)); + return this; + } + + /** + * 不为空 + * + * @param + * + * @param column 字段 + * @return ConditionOrWrapper + */ + public ConditionOrWrapper isNotNull(String column) { + super.isNotNull(column); + return this; + } + /** + * 不为空 + * + * @param + * + * @param column 字段 + * @return ConditionOrWrapper + */ + public ConditionOrWrapper isNotNull(SerializableFunction column) { + super.isNotNull(ReflectionUtil.getFieldName(column)); + return this; + } +} diff --git a/lib/jpaHelper/src/main/java/com/cym/utils/ConditionWrapper.java b/lib/jpaHelper/src/main/java/com/cym/utils/ConditionWrapper.java new file mode 100644 index 0000000..6d7ed6c --- /dev/null +++ b/lib/jpaHelper/src/main/java/com/cym/utils/ConditionWrapper.java @@ -0,0 +1,247 @@ +package com.cym.utils; + +import java.util.ArrayList; +import java.util.Collection; +import java.util.List; + +import cn.hutool.core.util.StrUtil; + +/** + * 查询语句生成器 + * + * @author CYM + * + */ +public abstract class ConditionWrapper { + boolean andLink; + + List list = new ArrayList(); + + /** + * 将Wrapper转化为Condition + * + * @param params + * + * @return Condition + */ + public String build(List values) { + String sql = ""; + if (list.size() > 0) { + List blocks = new ArrayList(); + for (Object object : list) { + if (object instanceof Condition) { + Condition condition = (Condition) object; + + if (StrUtil.isNotEmpty(condition.getCondition())) { + blocks.add(condition.getCondition()); + } else { + String block = null; + if (condition.getValue() == null) { + if (condition.getOperation().equals("IS NULL") || condition.getOperation().equals("IS NOT NULL")) { + block = buildColumn(condition.getColumn()) + " " + condition.getOperation(); + } else { + block = buildColumn(condition.getColumn()) + " " + condition.getOperation() + " null"; + } + } else { + if (condition.getValue() instanceof List) { + block = buildColumn(condition.getColumn()) + " " + condition.getOperation() + " " + buildIn(condition.getValue()); + for (Object val : (List) condition.getValue()) { + values.add(val); + } + } else { + block = buildColumn(condition.getColumn()) + " " + condition.getOperation() + " ?"; + if (!condition.getOperation().equals("LIKE")) { + values.add(condition.getValue()); + } else { + values.add("%" + condition.getValue().toString().replace("%", "\\%") + "%"); + } + } + } + blocks.add(block); + } + } + + if (object instanceof ConditionWrapper) { + ConditionWrapper conditionWrapper = (ConditionWrapper) object; + String block = " (" + conditionWrapper.build(values) + ") "; + blocks.add(block); + } + } + + if (andLink) { + sql = StrUtil.join(" AND ", blocks); + } else { + sql = StrUtil.join(" OR ", blocks); + } + + } + return sql; + } + + public String buildColumn(String column) { + return "`" + StrUtil.toUnderlineCase(column) + "`"; + } + + public String buildIn(Object value) { + List ask = new ArrayList(); + for (Object obj : (Collection) value) { + ask.add("?"); + } + + if (ask.size() > 0) { + return " (" + StrUtil.join(",", ask) + ") "; + } else { + return " (null) "; + } + + } + + /** + * 自由撰写条件 + * + * @param condition + */ + public ConditionWrapper custom(String condition) { + list.add(new Condition(condition)); + return this; + } + + /** + * 等于 + * + * @param column 字段 + * @param params 参数 + * @return ConditionWrapper + */ + public ConditionWrapper eq(String column, Object params) { + list.add(new Condition(column, "=", params)); + return this; + } + + /** + * 不等于 + * + * @param column 字段 + * @param params 参数 + * @return ConditionWrapper + */ + public ConditionWrapper ne(String column, Object params) { + list.add(new Condition(column, "<>", params)); + return this; + } + + /** + * 小于 + * + * @param column 字段 + * @param params 参数 + * @return ConditionWrapper + */ + public ConditionWrapper lt(String column, Object params) { + list.add(new Condition(column, "<", params)); + return this; + } + + /** + * 小于或等于 + * + * @param column 字段 + * @param params 参数 + * @return ConditionWrapper + */ + public ConditionWrapper lte(String column, Object params) { + list.add(new Condition(column, "<=", params)); + return this; + } + + /** + * 大于 + * + * @param column 字段 + * @param params 参数 + * @return ConditionWrapper + */ + public ConditionWrapper gt(String column, Object params) { + list.add(new Condition(column, ">", params)); + return this; + } + + /** + * 大于或等于 + * + * @param column 字段 + * @param params 参数 + * @return ConditionWrapper + */ + public ConditionWrapper gte(String column, Object params) { + list.add(new Condition(column, ">=", params)); + return this; + } + + /** + * 相似于 + * + * @param column 字段 + * @param params 参数 + * @return ConditionWrapper + */ + public ConditionWrapper like(String column, String params) { + list.add(new Condition(column, "LIKE", params)); + return this; + } + + /** + * 在其中 + * + * @param column 字段 + * @param params 参数 + * @return ConditionWrapper + */ + public ConditionWrapper in(String column, Collection params) { + list.add(new Condition(column, "IN", params)); + return this; + } + + /** + * 不在其中 + * + * @param column 字段 + * @param params 参数 + * @return ConditionWrapper + */ + public ConditionWrapper nin(String column, Collection params) { + list.add(new Condition(column, "NOT IN", params)); + return this; + } + + /** + * 为空 + * + * @param + * + * @param column 字段 + * @return ConditionWrapper + */ + public ConditionWrapper isNull(String column) { + list.add(new Condition(column, "IS NULL", null)); + return this; + } + + /** + * 不为空 + * + * @param + * + * @param column 字段 + * @return ConditionWrapper + */ + public ConditionWrapper isNotNull(String column) { + list.add(new Condition(column, "IS NOT NULL", null)); + return this; + } + + public boolean notEmpty() { + return list.size() > 0; + } + +} diff --git a/lib/jpaHelper/src/main/java/com/cym/utils/InitTool.java b/lib/jpaHelper/src/main/java/com/cym/utils/InitTool.java new file mode 100644 index 0000000..0c1e5e4 --- /dev/null +++ b/lib/jpaHelper/src/main/java/com/cym/utils/InitTool.java @@ -0,0 +1,83 @@ +package com.cym.utils; + +import java.lang.reflect.Field; +import java.util.Set; + +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.beans.factory.annotation.Value; +import org.springframework.jdbc.core.JdbcTemplate; +import org.springframework.stereotype.Service; + +import com.cym.bean.InitValue; +import com.cym.bean.Update; + +import cn.hutool.core.util.ClassUtil; +import cn.hutool.core.util.ReflectUtil; +import jakarta.persistence.Entity; +import jakarta.transaction.Transactional; + +@Service +public class InitTool { + @Autowired + PackageTools packageTools; + + @Autowired + JpaHelper jpaHelper; + + @Autowired + JdbcTemplate jdbcTemplate; + + @Value("${spring.datasource.url:}") + String url; + + @Transactional + public void init() { + Set> set = ClassUtil.scanPackage(packageTools.getMainPackage()); + // 注入默认值 + for (Class clazz : set) { + Entity entity = clazz.getAnnotation(Entity.class); + if (entity != null) { + Field[] fields = ReflectUtil.getFields(clazz); + for (Field field : fields) { + if (field.isAnnotationPresent(InitValue.class)) { + InitValue defaultValue = field.getAnnotation(InitValue.class); + if (defaultValue.value() != null) { + // 更新默认值 + Long count = jpaHelper.findCountByQuery(new ConditionAndWrapper().isNull(field.getName()), clazz); + if (count > 0) { + String value = defaultValue.value(); + Object obj = null; + // 获取字段类型 + Class type = field.getType(); + if (type.equals(String.class)) { + obj = value; + } + if (type.equals(Short.class)) { + obj = Short.parseShort(value); + } + if (type.equals(Integer.class)) { + obj = Integer.parseInt(value); + } + if (type.equals(Long.class)) { + obj = Long.parseLong(value); + } + if (type.equals(Float.class)) { + obj = Float.parseFloat(value); + } + if (type.equals(Double.class)) { + obj = Double.parseDouble(value); + } + if (type.equals(Boolean.class)) { + obj = Boolean.parseBoolean(value); + } + + jpaHelper.updateByQuery(new ConditionAndWrapper().isNull(field.getName()), new Update().set(field.getName(), obj), clazz); + } + } + } + } + } + } + } + +} diff --git a/lib/jpaHelper/src/main/java/com/cym/utils/InitUtil.java b/lib/jpaHelper/src/main/java/com/cym/utils/InitUtil.java new file mode 100644 index 0000000..664b3d3 --- /dev/null +++ b/lib/jpaHelper/src/main/java/com/cym/utils/InitUtil.java @@ -0,0 +1,17 @@ +package com.cym.utils; + +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.context.annotation.Configuration; + +import jakarta.annotation.PostConstruct; + +@Configuration +public class InitUtil { + @Autowired + InitTool initTool; + + @PostConstruct + public void init() { + initTool.init(); + } +} diff --git a/lib/jpaHelper/src/main/java/com/cym/utils/JpaHelper.java b/lib/jpaHelper/src/main/java/com/cym/utils/JpaHelper.java new file mode 100644 index 0000000..0c7270d --- /dev/null +++ b/lib/jpaHelper/src/main/java/com/cym/utils/JpaHelper.java @@ -0,0 +1,1018 @@ +package com.cym.utils; + +import java.lang.reflect.Field; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Collection; +import java.util.HashSet; +import java.util.List; +import java.util.Map; +import java.util.Map.Entry; +import java.util.Set; + +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.jdbc.core.JdbcTemplate; +import org.springframework.stereotype.Service; + +import com.cym.bean.CreateTime; +import com.cym.bean.InitValue; +import com.cym.bean.Page; +import com.cym.bean.Sort; +import com.cym.bean.Update; +import com.cym.bean.UpdateTime; +import com.cym.reflection.ReflectionUtil; +import com.cym.reflection.SerializableFunction; + +import cn.hutool.core.util.ReflectUtil; +import cn.hutool.core.util.StrUtil; +import jakarta.persistence.Id; + +/** + * sql操作器 + * + */ +@Service +public class JpaHelper { + Logger logger = LoggerFactory.getLogger(this.getClass()); + + @Autowired + JdbcTemplate jdbcTemplate; + + @Value("${spring.datasource.url:}") + String url; + @Autowired + SqlUtils sqlUtils; + + /** + * 获取主键 + * + * @param clazz + * @return + */ + public String getPrimalKey(Class clazz) { + + Field[] fields = ReflectUtil.getFields(clazz); + + for (Field field : fields) { + if (field.isAnnotationPresent(Id.class)) { + return field.getName(); + } + } + + return null; + } + + /** + * 获取主键值 + * + * @param clazz + * @return + */ + public String getPrimalValue(Object object) { + String key = getPrimalKey(object.getClass()); + + if (StrUtil.isNotEmpty(key)) { + Object obj = ReflectUtil.getFieldValue(object, key); + return obj != null ? obj.toString() : null; + } + return null; + } + + /** + * 累加某一个字段的数量,原子操作 + * + * @param object + */ + + public void addCountById(String id, SerializableFunction property, Long count, Class clazz) { + addCountById(id, ReflectionUtil.getFieldName(property), count, clazz); + } + + /** + * 累加某一个字段的数量,原子操作 + * + * @param object + */ + + public void addCountById(String id, String property, Long count, Class clazz) { + String sql = "UPDATE `" + StrUtil.toUnderlineCase(clazz.getSimpleName()) + "` SET `" + StrUtil.toUnderlineCase(property) + "` = `" + StrUtil.toUnderlineCase(property) + + "` + ? WHERE `id` = ?"; + Object[] params = new Object[] { count, id }; + sqlUtils.logQuery(sql, params); + jdbcTemplate.update(buildSql(sql), params); + } + + /** + * 累加某一个字段的数量,原子操作 + * + * @param object + */ + + public void addCountById(String id, SerializableFunction property, Double count, Class clazz) { + addCountById(id, ReflectionUtil.getFieldName(property), count, clazz); + } + + /** + * 累加某一个字段的数量,原子操作 + * + * @param object + */ + + public void addCountById(String id, String property, Double count, Class clazz) { + String sql = "UPDATE `" + StrUtil.toUnderlineCase(clazz.getSimpleName()) + "` SET `" + StrUtil.toUnderlineCase(property) + "` = `" + StrUtil.toUnderlineCase(property) + + "` + ? WHERE `id` = ?"; + Object[] params = new Object[] { count, id }; + sqlUtils.logQuery(sql, params); + jdbcTemplate.update(buildSql(sql), params); + } + + /** + * 插入或更新 + * + * @param object 对象 @throws + */ + + public String insertOrUpdate(Object object) { + Long time = System.currentTimeMillis(); + String id = getPrimalValue(object); + if (StrUtil.isEmpty(id)) { + // 插入 + // 设置插入时间 + setCreateTime(object, time); + // 设置更新时间 + setUpdateTime(object, time); + // 设置默认值 + setDefaultVaule(object); + // 设置id + ReflectUtil.setFieldValue(object, getPrimalKey(object.getClass()), SnowFlakeUtils.nextId()); + + List fieldsPart = new ArrayList(); + List placeHolder = new ArrayList(); + List paramValues = new ArrayList(); + + List fields = getFields(object.getClass()); + for (Field field : fields) { + fieldsPart.add("`" + StrUtil.toUnderlineCase(field.getName()) + "`"); + placeHolder.add("?"); + paramValues.add(ReflectUtil.getFieldValue(object, field)); + } + + String sql = "INSERT INTO `" + StrUtil.toUnderlineCase(object.getClass().getSimpleName()) + "` (" + StrUtil.join(",", fieldsPart) + ") VALUES (" + StrUtil.join(",", placeHolder) + ")"; + sqlUtils.logQuery(sql, paramValues.toArray()); + jdbcTemplate.update(buildSql(sql), paramValues.toArray()); + + } else { + // 更新 + updateById(object); + } + + // 返回id + return getPrimalValue(object); + } + + /** + * 插入 + * + * @param object 对象 + */ + + public String insert(Object object) { + // 去除主键id + ReflectUtil.setFieldValue(object, getPrimalKey(object.getClass()), null); + + // 插入数据库 + insertOrUpdate(object); + + // 返回id + return getPrimalValue(object); + } + + /** + * 插入全部字段 + * + * @param object 对象 + */ + public String insertAllColumn(Object object) { + // 没有id生成id + String id = (String) ReflectUtil.getFieldValue(object, getPrimalKey(object.getClass())); + if (StrUtil.isEmpty(id)) { + id = SnowFlakeUtils.nextId().toString(); + ReflectUtil.setFieldValue(object, getPrimalKey(object.getClass()), id); + } + + String sql = ""; + List fieldsPart = new ArrayList(); + List placeHolder = new ArrayList(); + List paramValues = new ArrayList(); + + List fields = getFields(object.getClass()); + for (Field field : fields) { + fieldsPart.add("`" + StrUtil.toUnderlineCase(field.getName()) + "`"); + placeHolder.add("?"); + paramValues.add(ReflectUtil.getFieldValue(object, field)); + } + + sql = "INSERT INTO `" + StrUtil.toUnderlineCase(object.getClass().getSimpleName()) + "` (" + StrUtil.join(",", fieldsPart) + ") VALUES (" + StrUtil.join(",", placeHolder) + ")"; + sqlUtils.logQuery(sql, paramValues.toArray()); + jdbcTemplate.update(buildSql(sql), paramValues.toArray()); + + // 返回id + return getPrimalValue(object); + } + + /** + * 批量插入 + * + * @param object 对象 + */ + public List insertBatch(List objectList) { + if (objectList == null || objectList.size() == 0) { + return new ArrayList<>(); + } + Long time = System.currentTimeMillis(); + List ids = new ArrayList<>(); + List paramValues = new ArrayList(); + + String sql = null; + for (Object object : objectList) { + // 设置插入时间 + setCreateTime(object, time); + // 设置更新时间 + setUpdateTime(object, time); + // 设置默认值 + setDefaultVaule(object); + + // 没有id生成id + String id = (String) ReflectUtil.getFieldValue(object, getPrimalKey(object.getClass())); + if (StrUtil.isEmpty(id)) { + id = SnowFlakeUtils.nextId().toString(); + ReflectUtil.setFieldValue(object, getPrimalKey(object.getClass()), id); + } + ids.add(id); + + List fieldsPart = new ArrayList(); + List placeHolder = new ArrayList(); + List objs = new ArrayList<>(); + + List fields = getFields(object.getClass()); + for (Field field : fields) { + fieldsPart.add("`" + StrUtil.toUnderlineCase(field.getName()) + "`"); + placeHolder.add("?"); + objs.add(ReflectUtil.getFieldValue(object, field)); + } + paramValues.add(objs.toArray()); + + if (sql == null) { + sql = "INSERT INTO `" + StrUtil.toUnderlineCase(object.getClass().getSimpleName()) + "` (" + StrUtil.join(",", fieldsPart) + ") VALUES (" + StrUtil.join(",", placeHolder) + ")"; + } + + sqlUtils.logQuery(sql, objs.toArray()); + } + + jdbcTemplate.batchUpdate(buildSql(sql), paramValues); + // 返回id + return ids; + } + + /** + * 根据id更新 + * + * @param object 对象 + */ + + public void updateById(Object object) { + if (StrUtil.isEmpty(getPrimalValue(object))) { + return; + } + // 设置更新时间 + setUpdateTime(object, System.currentTimeMillis()); + + List fields = getFields(object.getClass()); + + List fieldsPart = new ArrayList(); + List paramValues = new ArrayList(); + + for (Field field : fields) { + if (!field.getName().equals(getPrimalKey(object.getClass())) && ReflectUtil.getFieldValue(object, field) != null) { + fieldsPart.add("`" + StrUtil.toUnderlineCase(field.getName()) + "`=?"); + paramValues.add(ReflectUtil.getFieldValue(object, field)); + } + } + paramValues.add(getPrimalValue(object)); + if (fieldsPart.size() == 0) { + return; + } + String sql = "UPDATE `" + StrUtil.toUnderlineCase(object.getClass().getSimpleName()) + "` SET " + StrUtil.join(",", fieldsPart) + " WHERE id = ?"; + sqlUtils.logQuery(sql, paramValues.toArray()); + jdbcTemplate.update(buildSql(sql), paramValues.toArray()); + } + + /** + * 根据id更新全部字段 + * + * @param object 对象 + */ + + public void updateAllColumnById(Object object) { + if (StrUtil.isEmpty(getPrimalValue(object))) { + return; + } + + List fields = getFields(object.getClass()); + + List fieldsPart = new ArrayList(); + List paramValues = new ArrayList(); + + for (Field field : fields) { + if (!field.getName().equals(getPrimalKey(object.getClass()))) { + fieldsPart.add("`" + StrUtil.toUnderlineCase(field.getName()) + "`=?"); + paramValues.add(ReflectUtil.getFieldValue(object, field)); + } + } + paramValues.add(getPrimalValue(object)); + + String sql = "UPDATE `" + StrUtil.toUnderlineCase(object.getClass().getSimpleName()) + "` SET " + StrUtil.join(",", fieldsPart) + " WHERE id = ?"; + sqlUtils.logQuery(sql, paramValues.toArray()); + jdbcTemplate.update(buildSql(sql), paramValues.toArray()); + } + + /** + * 条件更新 + * + * @param conditionAndWrapper + * @param update + * @param clazz + */ + + public void updateByQuery(ConditionWrapper conditionWrapper, Update update, Class clazz) { + if (update == null || update.getSets().size() == 0) { + return; + } + + List fieldsPart = new ArrayList(); + List values = new ArrayList(); + for (Entry entry : update.getSets().entrySet()) { + fieldsPart.add("`" + StrUtil.toUnderlineCase(entry.getKey()) + "`=?"); + values.add(entry.getValue()); + } + + String sql = "UPDATE `" + StrUtil.toUnderlineCase(clazz.getSimpleName()) + "` SET " + StrUtil.join(",", fieldsPart); + if (conditionWrapper != null && conditionWrapper.notEmpty()) { + sql += " WHERE " + conditionWrapper.build(values); + } + sqlUtils.logQuery(sql, values.toArray()); + jdbcTemplate.update(buildSql(sql), values.toArray()); + } + + /** + * 根据id删除 + * + * @param id 对象 + * @param clazz 类 + */ + + public void deleteById(String id, Class clazz) { + if (StrUtil.isEmpty(id)) { + return; + } + + deleteByQuery(new ConditionAndWrapper().eq(getPrimalKey(clazz), id), clazz); + } + + /** + * 根据id删除 + * + * @param id 对象 + * @param clazz 类 + */ + + public void deleteByIds(Collection ids, Class clazz) { + if (ids == null || ids.size() == 0) { + return; + } + deleteByQuery(new ConditionAndWrapper().in(getPrimalKey(clazz), ids), clazz); + } + + /** + * 根据id删除 + * + * @param id 对象 + * @param clazz 类 + */ + + public void deleteByIds(String[] ids, Class clazz) { + deleteByQuery(new ConditionAndWrapper().in(getPrimalKey(clazz), ids), clazz); + } + + /** + * 根据条件删除 + * + * @param query 查询 + * @param clazz 类 + */ + + public void deleteByQuery(ConditionWrapper conditionWrapper, Class clazz) { + + List values = new ArrayList(); + String sql = "DELETE FROM `" + StrUtil.toUnderlineCase(clazz.getSimpleName()) + "`"; + if (conditionWrapper != null && conditionWrapper.notEmpty()) { + sql += " WHERE " + conditionWrapper.build(values); + } + sqlUtils.logQuery(sql, values.toArray()); + jdbcTemplate.update(buildSql(sql), values.toArray()); + } + + /** + * 设置默认值 + * + * @param object 对象 + */ + public void setDefaultVaule(Object object) { + List fields = getFields(object.getClass()); + for (Field field : fields) { + // 获取注解 + if (field.isAnnotationPresent(InitValue.class)) { + InitValue defaultValue = field.getAnnotation(InitValue.class); + + String value = defaultValue.value(); + + if (ReflectUtil.getFieldValue(object, field) == null) { + // 获取字段类型 + Class type = field.getType(); + if (type.equals(String.class)) { + ReflectUtil.setFieldValue(object, field, value); + } + if (type.equals(Short.class)) { + ReflectUtil.setFieldValue(object, field, Short.parseShort(value)); + } + if (type.equals(Integer.class)) { + ReflectUtil.setFieldValue(object, field, Integer.parseInt(value)); + } + if (type.equals(Long.class)) { + ReflectUtil.setFieldValue(object, field, Long.parseLong(value)); + } + if (type.equals(Float.class)) { + ReflectUtil.setFieldValue(object, field, Float.parseFloat(value)); + } + if (type.equals(Double.class)) { + ReflectUtil.setFieldValue(object, field, Double.parseDouble(value)); + } + if (type.equals(Boolean.class)) { + ReflectUtil.setFieldValue(object, field, Boolean.parseBoolean(value)); + } + } + } + } + } + + /** + * 设置更新时间 + * + * @param object 对象 + */ + public void setUpdateTime(Object object, Long time) { + List fields = getFields(object.getClass()); + for (Field field : fields) { + // 获取注解 + if (field.isAnnotationPresent(UpdateTime.class) && field.getType().equals(Long.class)) { + ReflectUtil.setFieldValue(object, field, time); + } + } + } + + /** + * 设置创建时间 + * + * @param object 对象 + */ + public void setCreateTime(Object object, Long time) { + List fields = getFields(object.getClass()); + for (Field field : fields) { + // 获取注解 + if (field.isAnnotationPresent(CreateTime.class) && field.getType().equals(Long.class)) { + ReflectUtil.setFieldValue(object, field, time); + } + } + } + + /** + * 按查询条件获取Page + * + * @param query 查询 + * @param page 分页 + * @param clazz 类 + * @return Page 分页 + */ + public Page findPageByQuery(ConditionWrapper conditionWrapper, Sort sort, Page page, Class clazz) { + List values = new ArrayList(); + // 查询出一共的条数 + Long count = findCountByQuery(conditionWrapper, clazz); + + String sql = "SELECT * FROM `" + StrUtil.toUnderlineCase(clazz.getSimpleName()) + "`"; + if (conditionWrapper != null && conditionWrapper.notEmpty()) { + sql += " WHERE " + conditionWrapper.build(values); + } + if (sort != null && sort.getOrderList().size() > 0) { + sql += " " + sort.toString(); + } else { + sql += " ORDER BY " + getPrimalKey(clazz) + " DESC"; + } + + sql += buildLimit(page); + + Page pageResp = new Page<>(); + pageResp.setPageSize(page.getPageSize()); + pageResp.setPageNum(page.getPageNum()); + pageResp.setTotal(count); + + pageResp.setStartRow((page.getPageNum() - 1) * page.getPageNum() + 1); + pageResp.setEndRow(pageResp.getStartRow() + page.getPageSize() - 1); + pageResp.setPages((count.intValue() + page.getPageSize() - 1) / page.getPageSize()); + + sqlUtils.logQuery(sql, values.toArray()); + pageResp.setList(buildObjects(jdbcTemplate.queryForList(buildSql(sql), values.toArray()), clazz)); + + return pageResp; + } + + /** + * 按查询条件获取Page + * + * @param query 查询 + * @param page 分页 + * @param clazz 类 + * @return Page 分页 + */ + public Page findPageByQuery(Sort sort, Page page, Class clazz) { + return findPageByQuery(null, sort, page, clazz); + } + + /** + * 按查询条件获取Page + * + * @param + * + * @param query 查询 + * @param page 分页 + * @param clazz 类 + * @return Page 分页 + */ + public Page findPageByQuery(ConditionWrapper conditionWrapper, Page page, Class clazz) { + return findPageByQuery(conditionWrapper, null, page, clazz); + } + + /** + * 按查询条件获取Page + * + * @param query 查询 + * @param page 分页 + * @param clazz 类 + * @return Page 分页 + */ + public Page findPageByQuery(Page page, Class clazz) { + return findPageByQuery(null, null, page, clazz); + } + + /** + * 根据id查找 + * + * @param id id + * @param clazz 类 + * @return T 对象 + */ + public T findById(String id, Class clazz) { + if (StrUtil.isEmpty(id)) { + return null; + } + + return findOneByQuery(new ConditionAndWrapper().eq(getPrimalKey(clazz), id), clazz); + + } + + /** + * 根据条件查找单个 + * + * @param query 查询 + * @param clazz 类 + * @return T 对象 + */ + public T findOneByQuery(ConditionWrapper conditionWrapper, Sort sort, Class clazz) { + + Page page = new Page(); + page.setPageSize(1); + page.setPageNum(1); + Page pageResp = findPageByQuery(conditionWrapper, sort, page, clazz); + + if (pageResp.getList().size() > 0) { + return pageResp.getList().get(0); + + } + return null; + } + + /** + * 根据条件查找单个 + * + * @param query 查询 + * @param clazz 类 + * @return T 对象 + */ + public T findOneByQuery(Sort sort, Class clazz) { + return findOneByQuery(null, sort, clazz); + } + + /** + * 根据条件查找单个 + * + * @param 类型 + * @param condition + * @param clazz 类 + * @return T 对象 + */ + public T findOneByQuery(ConditionWrapper conditionWrapper, Class clazz) { + return findOneByQuery(conditionWrapper, null, clazz); + + } + + /** + * 根据条件查找List + * + * @param 类型 + * @param query 查询 + * @param clazz 类 + * @return List 列表 + */ + public List findListByQuery(ConditionWrapper conditionWrapper, Sort sort, Class clazz) { + List values = new ArrayList(); + + String sql = "SELECT * FROM `" + StrUtil.toUnderlineCase(clazz.getSimpleName()) + "`"; + if (conditionWrapper != null && conditionWrapper.notEmpty()) { + sql += " WHERE " + conditionWrapper.build(values); + } + if (sort != null) { + sql += " " + sort.toString(); + } else { + sql += " ORDER BY `" + getPrimalKey(clazz) + "` DESC"; + } + sqlUtils.logQuery(sql, values.toArray()); + return buildObjects(jdbcTemplate.queryForList(buildSql(sql), values.toArray()), clazz); + } + + /** + * 根据条件查找List + * + * @param 类型 + * @param condition 查询 + * @param clazz 类 + * @return List 列表 + */ + public List findListByQuery(ConditionWrapper conditionWrapper, Class clazz) { + return (List) findListByQuery(conditionWrapper, null, clazz); + } + + /** + * 根据条件查找List + * + * @param 类型 + * @param condition 查询 + * @param clazz 类 + * @return List 列表 + */ + public List findListByQuery(Sort sort, Class clazz) { + return (List) findListByQuery(null, sort, clazz); + } + + /** + * 根据条件查找某个属性 + * + * @param 类型 + * @param query 查询 + * @param clazz 类 + * @param property 属性 + * @param propertyClass 属性类 + * @return List 列表 + */ + public List findPropertiesByQuery(ConditionWrapper conditionWrapper, Class clazz, String property, Class propertyClass) { + List list = findListByQuery(conditionWrapper, clazz); + List propertyList = extractProperty(list, property, propertyClass); + + return propertyList; + } + + /** + * 根据条件查找某个属性 + * + * @param 类型 + * @param query 查询 + * @param clazz 类 + * @param property 属性 + * @param propertyClass 属性类 + * @return List 列表 + */ + public List findPropertiesByQuery(ConditionWrapper conditionWrapper, Class clazz, SerializableFunction property, Class propertyClass) { + return findPropertiesByQuery(conditionWrapper, clazz, ReflectionUtil.getFieldName(property), propertyClass); + } + + /** + * 根据条件查找某个属性 + * + * @param 类型 + * @param condition 查询 + * @param clazz 类 + * @param property 属性 + * @return List 列表 + */ + public List findPropertiesByQuery(ConditionWrapper conditionWrapper, Class clazz, String property) { + return findPropertiesByQuery(conditionWrapper, clazz, property, String.class); + } + + /** + * 根据条件查找某个属性 + * + * @param 类型 + * @param condition 查询 + * @param clazz 类 + * @param property 属性 + * @return List 列表 + */ + public List findPropertiesByQuery(ConditionWrapper conditionWrapper, Class clazz, SerializableFunction property) { + return findPropertiesByQuery(conditionWrapper, clazz, ReflectionUtil.getFieldName(property), String.class); + } + + /** + * 根据id查找某个属性 + * + * @param 类型 + * @param condition 查询 + * @param clazz 类 + * @param property 属性 + * @return List 列表 + */ + public List findPropertiesByIds(Collection ids, Class clazz, String property) { + if (ids == null || ids.size() == 0) { + return new ArrayList(); + } + + ConditionAndWrapper ConditionAndWrapper = new ConditionAndWrapper(); + ConditionAndWrapper.in(getPrimalKey(clazz), ids); + + return findPropertiesByQuery(ConditionAndWrapper, clazz, property, String.class); + } + + /** + * 根据id查找某个属性 + * + * @param 类型 + * @param condition 查询 + * @param clazz 类 + * @param property 属性 + * @return List 列表 + */ + public List findPropertiesByIds(Collection ids, Class clazz, SerializableFunction property) { + return findPropertiesByIds(ids, clazz, ReflectionUtil.getFieldName(property)); + } + + /** + * 根据id查找某个属性 + * + * @param 类型 + * @param condition 查询 + * @param clazz 类 + * @param property 属性 + * @return List 列表 + */ + public List findPropertiesByIds(String[] ids, Class clazz, String property) { + return findPropertiesByIds(Arrays.asList(ids), clazz, property); + } + + /** + * 根据id查找某个属性 + * + * @param 类型 + * @param condition 查询 + * @param clazz 类 + * @param property 属性 + * @return List 列表 + */ + public List findPropertiesByIds(String[] ids, Class clazz, SerializableFunction property) { + return findPropertiesByIds(Arrays.asList(ids), clazz, ReflectionUtil.getFieldName(property)); + } + + /** + * 根据条件查找id + * + * @param query 查询 + * @param clazz 类 + * @return List 列表 + */ + public List findIdsByQuery(ConditionWrapper conditionWrapper, Class clazz) { + + return findPropertiesByQuery(conditionWrapper, clazz, getPrimalKey(clazz)); + } + + /** + * 根据id集合查找 + * + * @param List ids id集合 + * @param clazz 类 + * @return List 列表 + */ + public List findListByIds(Collection ids, Class clazz) { + return findListByIds(ids, null, clazz); + } + + /** + * 根据id集合查找 + * + * @param List ids id集合 + * @param clazz 类 + * @return List 列表 + */ + public List findListByIds(String[] ids, Class clazz) { + return findListByIds(Arrays.asList(ids), null, clazz); + } + + /** + * 根据id集合查找 + * + * @param List ids id集合 + * @param clazz 类 + * @return List 列表 + */ + public List findListByIds(Collection ids, Sort sort, Class clazz) { + if (ids == null || ids.size() == 0) { + return new ArrayList(); + } + + ConditionAndWrapper ConditionAndWrapper = new ConditionAndWrapper(); + ConditionAndWrapper.in(getPrimalKey(clazz), ids); + + return findListByQuery(ConditionAndWrapper, sort, clazz); + } + + /** + * 根据id集合查找 + * + * @param List ids id集合 + * @param clazz 类 + * @return List 列表 + */ + public List findListByIds(String[] ids, Sort sort, Class clazz) { + return findListByIds(Arrays.asList(ids), sort, clazz); + } + + /** + * 查询全部 + * + * @param 类型 + * @param clazz 类 + * @return List 列表 + */ + public List findAll(Class clazz) { + return findAll(null, clazz); + } + + /** + * 查询全部 + * + * @param 类型 + * @param clazz 类 + * @return List 列表 + */ + public List findAll(Sort sort, Class clazz) { + return findListByQuery(null, sort, clazz); + } + + /** + * 查找全部的id + * + * @param clazz 类 + * @return List 列表 + */ + public List findAllIds(Class clazz) { + return findIdsByQuery(null, clazz); + } + + /** + * 查找数量 + * + * @param condition 查询 + * @param clazz 类 + * @return Long 数量 + */ + public Long findCountByQuery(ConditionWrapper conditionWrapper, Class clazz) { + List values = new ArrayList(); + String sql = "SELECT COUNT(*) FROM `" + StrUtil.toUnderlineCase(clazz.getSimpleName()) + "`"; + if (conditionWrapper != null && conditionWrapper.notEmpty()) { + sql += " WHERE " + conditionWrapper.build(values); + } + sqlUtils.logQuery(sql, values.toArray()); + return jdbcTemplate.queryForObject(buildSql(sql), Long.class, values.toArray()); + } + + /** + * 查找全部数量 + * + * @param clazz 类 + * @return Long 数量 + */ + public Long findAllCount(Class clazz) { + return findCountByQuery(null, clazz); + } + + /** + * 获取list中对象某个属性,组成新的list + * + * @param list 列表 + * @param clazz 类 + * @param property 属性 + * @return List 列表 + */ + public List extractProperty(List list, String property, Class clazz) { + Set rs = new HashSet(); + for (Object object : list) { + Object value = ReflectUtil.getFieldValue(object, property); + if (value != null && value.getClass().equals(clazz)) { + rs.add((T) value); + } + } + + return new ArrayList(rs); + } + + /** + * Map转Bean + * + * @param + * @param queryForList + * @param clazz + * @return + */ + public List buildObjects(List> queryForList, Class clazz) { + List list = new ArrayList(); + try { + Field[] fields = ReflectUtil.getFields(clazz); + + for (Map map : queryForList) { + Object obj = clazz.getDeclaredConstructor().newInstance(); + + for (Map.Entry entry : map.entrySet()) { + String mapKey = entry.getKey(); + Object mapValue = entry.getValue(); + + for (Field field : fields) { + if (StrUtil.toUnderlineCase(field.getName()).equals(mapKey)) { + ReflectUtil.setFieldValue(obj, field.getName(), mapValue); + break; + } + } + + } + + list.add((T) obj); + } + + } catch (Exception e) { + e.printStackTrace(); + } + + return list; + } + + public String buildSql(String sql) { + if (StrUtil.isEmpty(sql)) { + return ""; + } + + if (!url.contains("mysql")) { + sql = sql.replace("`", "\""); + } + + return sql; + } + + public String buildLimit(Page page) { + if (url.contains("mysql") || url.contains("sqlite")) { + return " LIMIT " + (page.getPageNum() - 1) * page.getPageSize() + "," + page.getPageSize(); + } else { + return " LIMIT " + page.getPageSize() + " OFFSET " + (page.getPageNum() - 1) * page.getPageSize(); + } + } + + public List getFields(Class clazz) { + + Field[] fields = ReflectUtil.getFields(clazz); + List list = new ArrayList<>(); + for (Field field : fields) { + if (!field.toString().contains("static") && !field.toString().contains("final")) { + list.add(field); + } + } + + return list; + } + +} diff --git a/lib/jpaHelper/src/main/java/com/cym/utils/PackageTools.java b/lib/jpaHelper/src/main/java/com/cym/utils/PackageTools.java new file mode 100644 index 0000000..3be9dd5 --- /dev/null +++ b/lib/jpaHelper/src/main/java/com/cym/utils/PackageTools.java @@ -0,0 +1,28 @@ +package com.cym.utils; + +import java.util.Map; + +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.boot.autoconfigure.SpringBootApplication; +import org.springframework.context.ApplicationContext; +import org.springframework.stereotype.Component; + +@Component +public class PackageTools { + + @Autowired + ApplicationContext context; + + /** + * 找到主程序包 + * @return + */ + public String getMainPackage() { + Map annotatedBeans = context.getBeansWithAnnotation(SpringBootApplication.class); + String packageName = annotatedBeans.isEmpty() ? null : annotatedBeans.values().toArray()[0].getClass().getPackage().getName(); + + return packageName; + } + + +} diff --git a/lib/jpaHelper/src/main/java/com/cym/utils/SnowFlakeUtils.java b/lib/jpaHelper/src/main/java/com/cym/utils/SnowFlakeUtils.java new file mode 100644 index 0000000..b80b109 --- /dev/null +++ b/lib/jpaHelper/src/main/java/com/cym/utils/SnowFlakeUtils.java @@ -0,0 +1,11 @@ +package com.cym.utils; + +import cn.hutool.core.util.IdUtil; + +public class SnowFlakeUtils { + + public static Long nextId() { + return IdUtil.getSnowflake(0, 0).nextId(); + } + +} \ No newline at end of file diff --git a/lib/jpaHelper/src/main/java/com/cym/utils/SqlUtils.java b/lib/jpaHelper/src/main/java/com/cym/utils/SqlUtils.java new file mode 100644 index 0000000..bf6ba1f --- /dev/null +++ b/lib/jpaHelper/src/main/java/com/cym/utils/SqlUtils.java @@ -0,0 +1,61 @@ +package com.cym.utils; + +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; +import org.springframework.beans.factory.annotation.Value; +import org.springframework.stereotype.Component; + +import cn.hutool.core.util.StrUtil; + +@Component +public class SqlUtils { + Logger logger = LoggerFactory.getLogger(this.getClass()); + + @Value("${spring.datasource.url:}") + String url; + + @Value("${spring.datasource.printsql:true}") + Boolean printsql; + + String separator = System.getProperty("line.separator"); + + public void logQuery(String sql) { + logQuery(sql, null); + } + + public void logQuery(String sql, Object[] params) { + sql = formatSql(sql); + + if (params != null) { + for (Object object : params) { + + if (object instanceof String) { + sql = sql.replaceFirst("\\?", "'" + object.toString().replace("$", "¥").replace("\\%", "\\\\%") + "'"); + } else { + sql = sql.replaceFirst("\\?", String.valueOf(object)); + } + + } + } + if (printsql) { + logger.info(separator + sql + separator); + } + } + + public String formatSql(String sql) { + if (StrUtil.isEmpty(sql)) { + return ""; + } + + if (!url.contains("mysql")) { + sql = sql.replace("`", "\""); + } + + sql = sql.replace("FROM", separator + "FROM")// + .replace("WHERE", separator + "WHERE")// + .replace("ORDER", separator + "ORDER")// + .replace("LIMIT", separator + "LIMIT")// + .replace("VALUES", separator + "VALUES");// + return sql; + } +} diff --git a/lib/sqlHelper/.gitignore b/lib/sqlHelper/.gitignore new file mode 100644 index 0000000..b83d222 --- /dev/null +++ b/lib/sqlHelper/.gitignore @@ -0,0 +1 @@ +/target/ diff --git a/lib/sqlHelper/pom.xml b/lib/sqlHelper/pom.xml new file mode 100644 index 0000000..ae77cc4 --- /dev/null +++ b/lib/sqlHelper/pom.xml @@ -0,0 +1,66 @@ + + 4.0.0 + sqlHelper + jar + release + + org.springframework.boot + spring-boot-starter-parent + 3.3.3 + + + + + 21 + + + + + org.springframework.boot + spring-boot-starter + + + + org.springframework.boot + spring-boot-starter-jdbc + + + + + org.xerial + sqlite-jdbc + + + + cn.hutool + hutool-all + 5.8.25 + + + + + io.swagger.core.v3 + swagger-annotations-jakarta + 2.2.19 + + + + + + + + + + org.apache.maven.plugins + maven-compiler-plugin + + ${java.version} + ${java.version} + ${project.build.sourceEncoding} + + + + + \ No newline at end of file diff --git a/lib/sqlHelper/src/main/java/com/cym/sqlHelper/bean/BaseModel.java b/lib/sqlHelper/src/main/java/com/cym/sqlHelper/bean/BaseModel.java new file mode 100644 index 0000000..f9657db --- /dev/null +++ b/lib/sqlHelper/src/main/java/com/cym/sqlHelper/bean/BaseModel.java @@ -0,0 +1,39 @@ +package com.cym.sqlHelper.bean; + +import java.io.Serializable; + +import io.swagger.v3.oas.annotations.media.Schema; + +public class BaseModel implements Serializable { + @Schema(description = "主键id") + String id; + @Schema(hidden = true) + Long createTime; + @Schema(hidden = true) + Long updateTime; + + public String getId() { + return id; + } + + public void setId(String id) { + this.id = id; + } + + public Long getCreateTime() { + return createTime; + } + + public void setCreateTime(Long createTime) { + this.createTime = createTime; + } + + public Long getUpdateTime() { + return updateTime; + } + + public void setUpdateTime(Long updateTime) { + this.updateTime = updateTime; + } + +} diff --git a/lib/sqlHelper/src/main/java/com/cym/sqlHelper/bean/Order.java b/lib/sqlHelper/src/main/java/com/cym/sqlHelper/bean/Order.java new file mode 100644 index 0000000..72f7fcf --- /dev/null +++ b/lib/sqlHelper/src/main/java/com/cym/sqlHelper/bean/Order.java @@ -0,0 +1,25 @@ +package com.cym.sqlHelper.bean; + +import com.cym.sqlHelper.bean.Sort.Direction; + +public class Order { + Direction direction; + String column; + + public Direction getDirection() { + return direction; + } + + public void setDirection(Direction direction) { + this.direction = direction; + } + + public String getColumn() { + return column; + } + + public void setColumn(String column) { + this.column = column; + } + +} diff --git a/lib/sqlHelper/src/main/java/com/cym/sqlHelper/bean/Page.java b/lib/sqlHelper/src/main/java/com/cym/sqlHelper/bean/Page.java new file mode 100644 index 0000000..ae13838 --- /dev/null +++ b/lib/sqlHelper/src/main/java/com/cym/sqlHelper/bean/Page.java @@ -0,0 +1,60 @@ +package com.cym.sqlHelper.bean; + +import java.util.Collections; +import java.util.List; + +import io.swagger.v3.oas.annotations.media.Schema; + +/** + * 分页类 + * + */ +public class Page { + @Schema(description ="总记录数") + Long count = 0l; + @Schema(description ="起始页(从1开始)") + Integer curr = 1; + + @Schema(description ="每页记录数") + Integer limit = 10; + + @Schema(description ="列表内容") + List records = Collections.emptyList(); + +// public List getRecords(Class clazz) { +// return (List) records; +// } + + public List getRecords() { + return records; + } + + public void setRecords(List records) { + this.records = records; + } + + public Long getCount() { + return count; + } + + public void setCount(Long count) { + this.count = count; + } + + public Integer getCurr() { + return curr; + } + + public void setCurr(Integer curr) { + this.curr = curr; + } + + public Integer getLimit() { + return limit; + } + + public void setLimit(Integer limit) { + this.limit = limit; + } + +} diff --git a/lib/sqlHelper/src/main/java/com/cym/sqlHelper/bean/Sort.java b/lib/sqlHelper/src/main/java/com/cym/sqlHelper/bean/Sort.java new file mode 100644 index 0000000..e8871c4 --- /dev/null +++ b/lib/sqlHelper/src/main/java/com/cym/sqlHelper/bean/Sort.java @@ -0,0 +1,83 @@ +package com.cym.sqlHelper.bean; + +import java.util.ArrayList; +import java.util.List; + +import com.cym.sqlHelper.reflection.ReflectionUtil; +import com.cym.sqlHelper.reflection.SerializableFunction; + +import cn.hutool.core.util.StrUtil; + +public class Sort { + List orderList = new ArrayList<>(); + + public static enum Direction { + ASC, DESC; + } + + public Sort() { + + } + + public Sort(String column, Direction direction) { + Order order = new Order(); + order.setColumn(column); + order.setDirection(direction); + + orderList.add(order); + } + + public Sort(List orderList) { + this.orderList.addAll(orderList); + } + + public Sort(SerializableFunction column, Direction direction) { + Order order = new Order(); + order.setColumn(ReflectionUtil.getFieldName(column)); + order.setDirection(direction); + + orderList.add(order); + } + + public Sort add(String column, Direction direction) { + Order order = new Order(); + order.setColumn(column); + order.setDirection(direction); + + orderList.add(order); + + return this; + } + + public Sort add(SerializableFunction column, Direction direction) { + Order order = new Order(); + order.setColumn(ReflectionUtil.getFieldName(column)); + order.setDirection(direction); + + orderList.add(order); + + return this; + } + + public String toString() { + List sqlList = new ArrayList<>(); + for (Order order : orderList) { + + String sql = StrUtil.toUnderlineCase(order.getColumn()); + + if (order.getDirection() == Direction.ASC) { + sql += " ASC"; + } + if (order.getDirection() == Direction.DESC) { + sql += " DESC"; + } + + sqlList.add(sql); + } + + return " ORDER BY " + StrUtil.join(",", sqlList); + } + + + +} diff --git a/lib/sqlHelper/src/main/java/com/cym/sqlHelper/bean/Update.java b/lib/sqlHelper/src/main/java/com/cym/sqlHelper/bean/Update.java new file mode 100644 index 0000000..74a8bbd --- /dev/null +++ b/lib/sqlHelper/src/main/java/com/cym/sqlHelper/bean/Update.java @@ -0,0 +1,27 @@ +package com.cym.sqlHelper.bean; + +import java.util.HashMap; +import java.util.Map; + +public class Update { + + Map sets; + + public Update() { + sets = new HashMap(); + } + + public Update set(String key, Object value) { + sets.put(key, value); + return this; + } + + public Map getSets() { + return sets; + } + + public void setSets(Map sets) { + this.sets = sets; + } + +} diff --git a/lib/sqlHelper/src/main/java/com/cym/sqlHelper/config/AsyncConfig.java b/lib/sqlHelper/src/main/java/com/cym/sqlHelper/config/AsyncConfig.java new file mode 100644 index 0000000..53f510b --- /dev/null +++ b/lib/sqlHelper/src/main/java/com/cym/sqlHelper/config/AsyncConfig.java @@ -0,0 +1,24 @@ +package com.cym.sqlHelper.config; + +import org.springframework.context.annotation.Bean; +import org.springframework.context.annotation.Configuration; +import org.springframework.core.task.AsyncTaskExecutor; +import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor; + +@Configuration +public class AsyncConfig { + + private static final int MAX_POOL_SIZE = 50; + + private static final int CORE_POOL_SIZE = 20; + + @Bean("sqlThreadPool") + public AsyncTaskExecutor sqlThreadPool() { + ThreadPoolTaskExecutor asyncTaskExecutor = new ThreadPoolTaskExecutor(); + asyncTaskExecutor.setMaxPoolSize(MAX_POOL_SIZE); + asyncTaskExecutor.setCorePoolSize(CORE_POOL_SIZE); + asyncTaskExecutor.setThreadNamePrefix("sql-thread-pool-"); + asyncTaskExecutor.initialize(); + return asyncTaskExecutor; + } +} \ No newline at end of file diff --git a/lib/sqlHelper/src/main/java/com/cym/sqlHelper/config/CompositeIndex.java b/lib/sqlHelper/src/main/java/com/cym/sqlHelper/config/CompositeIndex.java new file mode 100644 index 0000000..7c1f85a --- /dev/null +++ b/lib/sqlHelper/src/main/java/com/cym/sqlHelper/config/CompositeIndex.java @@ -0,0 +1,15 @@ + +package com.cym.sqlHelper.config; + +import java.lang.annotation.ElementType; +import java.lang.annotation.Retention; +import java.lang.annotation.RetentionPolicy; +import java.lang.annotation.Target; + +@Target({ ElementType.TYPE }) +@Retention(RetentionPolicy.RUNTIME) +public @interface CompositeIndex { + + boolean unique() default false; + String[] colums(); +} diff --git a/lib/sqlHelper/src/main/java/com/cym/sqlHelper/config/DataSourceConfig.java b/lib/sqlHelper/src/main/java/com/cym/sqlHelper/config/DataSourceConfig.java new file mode 100644 index 0000000..592ff82 --- /dev/null +++ b/lib/sqlHelper/src/main/java/com/cym/sqlHelper/config/DataSourceConfig.java @@ -0,0 +1,59 @@ +package com.cym.sqlHelper.config; + +import java.io.File; + +import javax.sql.DataSource; + +import org.springframework.beans.factory.annotation.Value; +import org.springframework.context.annotation.Bean; +import org.springframework.context.annotation.Configuration; + +import com.zaxxer.hikari.HikariDataSource; + +import cn.hutool.core.io.FileUtil; +import cn.hutool.core.util.StrUtil; + +@Configuration +public class DataSourceConfig { + @Value("${spring.datasource.url:}") + String url; + @Value("${spring.datasource.username:}") + String username; + @Value("${spring.datasource.password:}") + String password; + @Value("${spring.database.type}") + String database; + + @Value("${spring.database.sqlite-path:}") + String sqlitePath; + + @Bean + public DataSource dataSource() throws Exception { + HikariDataSource dataSource = new HikariDataSource(); + if (database.toLowerCase().equals("mysql")) { + dataSource.setJdbcUrl(url); + dataSource.setUsername(username);// 用户名 + dataSource.setPassword(password);// 密码 + dataSource.setDriverClassName("com.mysql.cj.jdbc.Driver"); + } else if (database.toLowerCase().equals("postgresql")) { + dataSource.setJdbcUrl(url); + dataSource.setUsername(username);// 用户名 + dataSource.setPassword(password);// 密码 + dataSource.setDriverClassName("org.postgresql.Driver"); + } else if (database.toLowerCase().equals("sqlite")) { + if (StrUtil.isEmpty(sqlitePath)) { + sqlitePath = FileUtil.getUserHomePath() + File.separator + "sqlite.db"; + } + + dataSource.setJdbcUrl("jdbc:sqlite:" + sqlitePath); + dataSource.setDriverClassName("org.sqlite.JDBC"); + + // sqlite使用连接池 + dataSource.setMaximumPoolSize(5); + } else { + throw new Exception("数据库类型配置错误"); + } + + return dataSource; + } +} diff --git a/lib/sqlHelper/src/main/java/com/cym/sqlHelper/config/InitValue.java b/lib/sqlHelper/src/main/java/com/cym/sqlHelper/config/InitValue.java new file mode 100644 index 0000000..b48cd67 --- /dev/null +++ b/lib/sqlHelper/src/main/java/com/cym/sqlHelper/config/InitValue.java @@ -0,0 +1,14 @@ +package com.cym.sqlHelper.config; + +import java.lang.annotation.ElementType; +import java.lang.annotation.Retention; +import java.lang.annotation.RetentionPolicy; +import java.lang.annotation.Target; + +@Retention(RetentionPolicy.RUNTIME) +@Target({ ElementType.FIELD }) +public @interface InitValue { + + String value(); + +} diff --git a/lib/sqlHelper/src/main/java/com/cym/sqlHelper/config/SingleIndex.java b/lib/sqlHelper/src/main/java/com/cym/sqlHelper/config/SingleIndex.java new file mode 100644 index 0000000..53f9536 --- /dev/null +++ b/lib/sqlHelper/src/main/java/com/cym/sqlHelper/config/SingleIndex.java @@ -0,0 +1,15 @@ + +package com.cym.sqlHelper.config; + +import java.lang.annotation.ElementType; +import java.lang.annotation.Retention; +import java.lang.annotation.RetentionPolicy; +import java.lang.annotation.Target; + +@Target({ ElementType.FIELD }) +@Retention(RetentionPolicy.RUNTIME) +public @interface SingleIndex { + + boolean unique() default false; + +} diff --git a/lib/sqlHelper/src/main/java/com/cym/sqlHelper/config/Table.java b/lib/sqlHelper/src/main/java/com/cym/sqlHelper/config/Table.java new file mode 100644 index 0000000..cd55e05 --- /dev/null +++ b/lib/sqlHelper/src/main/java/com/cym/sqlHelper/config/Table.java @@ -0,0 +1,15 @@ +package com.cym.sqlHelper.config; + +import java.lang.annotation.Documented; +import java.lang.annotation.ElementType; +import java.lang.annotation.Retention; +import java.lang.annotation.RetentionPolicy; +import java.lang.annotation.Target; + +@Documented +@Retention(RetentionPolicy.RUNTIME) +@Target({ ElementType.TYPE }) +public @interface Table { + + +} diff --git a/lib/sqlHelper/src/main/java/com/cym/sqlHelper/reflection/ReflectionUtil.java b/lib/sqlHelper/src/main/java/com/cym/sqlHelper/reflection/ReflectionUtil.java new file mode 100644 index 0000000..1014a1f --- /dev/null +++ b/lib/sqlHelper/src/main/java/com/cym/sqlHelper/reflection/ReflectionUtil.java @@ -0,0 +1,65 @@ +package com.cym.sqlHelper.reflection; + +import java.beans.Introspector; +import java.lang.invoke.SerializedLambda; +import java.lang.reflect.Field; +import java.lang.reflect.Method; +import java.util.Map; +import java.util.concurrent.ConcurrentHashMap; + +import org.springframework.util.ClassUtils; +import org.springframework.util.ReflectionUtils; + +public class ReflectionUtil { + + private static Map, Field> cache = new ConcurrentHashMap<>(); + + public static String getFieldName(SerializableFunction function) { + Field field = ReflectionUtil.getField(function); + return field.getName(); + } + + public static Field getField(SerializableFunction function) { + return cache.computeIfAbsent(function, ReflectionUtil::findField); + } + + public static Field findField(SerializableFunction function) { + Field field = null; + String fieldName = null; + try { + // 第1步 获取SerializedLambda + Method method = function.getClass().getDeclaredMethod("writeReplace"); + method.setAccessible(Boolean.TRUE); + SerializedLambda serializedLambda = (SerializedLambda) method.invoke(function); + // 第2步 implMethodName 即为Field对应的Getter方法名 + String implMethodName = serializedLambda.getImplMethodName(); + if (implMethodName.startsWith("get") && implMethodName.length() > 3) { + fieldName = Introspector.decapitalize(implMethodName.substring(3)); + + } else if (implMethodName.startsWith("is") && implMethodName.length() > 2) { + fieldName = Introspector.decapitalize(implMethodName.substring(2)); + } else if (implMethodName.startsWith("lambda$")) { + throw new IllegalArgumentException("SerializableFunction不能传递lambda表达式,只能使用方法引用"); + + } else { + throw new IllegalArgumentException(implMethodName + "不是Getter方法引用"); + } + // 第3步 获取的Class是字符串，并且包名是“/”分割，需要替换成“.”，才能获取到对应的Class对象 + String declaredClass = serializedLambda.getImplClass().replace("/", "."); + Class aClass = Class.forName(declaredClass, false, ClassUtils.getDefaultClassLoader()); + + // 第4步 Spring 中的反射工具类获取Class中定义的Field + field = ReflectionUtils.findField(aClass, fieldName); + + } catch (Exception e) { + e.printStackTrace(); + } + // 第5步 如果没有找到对应的字段应该抛出异常 + if (field != null) { + return field; + } + throw new NoSuchFieldError(fieldName); + } + + +} \ No newline at end of file diff --git a/lib/sqlHelper/src/main/java/com/cym/sqlHelper/reflection/SerializableFunction.java b/lib/sqlHelper/src/main/java/com/cym/sqlHelper/reflection/SerializableFunction.java new file mode 100644 index 0000000..69b35d0 --- /dev/null +++ b/lib/sqlHelper/src/main/java/com/cym/sqlHelper/reflection/SerializableFunction.java @@ -0,0 +1,9 @@ +package com.cym.sqlHelper.reflection; + +import java.io.Serializable; +import java.util.function.Function; + +@FunctionalInterface +public interface SerializableFunction extends Function, Serializable { + +} \ No newline at end of file diff --git a/lib/sqlHelper/src/main/java/com/cym/sqlHelper/utils/Condition.java b/lib/sqlHelper/src/main/java/com/cym/sqlHelper/utils/Condition.java new file mode 100644 index 0000000..b852b98 --- /dev/null +++ b/lib/sqlHelper/src/main/java/com/cym/sqlHelper/utils/Condition.java @@ -0,0 +1,39 @@ +package com.cym.sqlHelper.utils; + +public class Condition { + public Condition(String column, String operation, Object value) { + this.column = column; + this.operation = operation; + this.value = value; + } + + String column; + String operation; + Object value; + + + public String getColumn() { + return column; + } + + public void setColumn(String column) { + this.column = column; + } + + public String getOperation() { + return operation; + } + + public void setOperation(String operation) { + this.operation = operation; + } + + public Object getValue() { + return value; + } + + public void setValue(Object value) { + this.value = value; + } + +} diff --git a/lib/sqlHelper/src/main/java/com/cym/sqlHelper/utils/ConditionAndWrapper.java b/lib/sqlHelper/src/main/java/com/cym/sqlHelper/utils/ConditionAndWrapper.java new file mode 100644 index 0000000..c773c3f --- /dev/null +++ b/lib/sqlHelper/src/main/java/com/cym/sqlHelper/utils/ConditionAndWrapper.java @@ -0,0 +1,339 @@ +package com.cym.sqlHelper.utils; + +import java.util.Arrays; +import java.util.Collection; + +import com.cym.sqlHelper.reflection.ReflectionUtil; +import com.cym.sqlHelper.reflection.SerializableFunction; + +/** + * 查询语句生成器 AND连接 + * + */ +public class ConditionAndWrapper extends ConditionWrapper { + + public ConditionAndWrapper() { + andLink = true; + } + + public ConditionAndWrapper and(ConditionWrapper conditionWrapper) { + list.add(conditionWrapper); + return this; + } + + /** + * 等于 + * + * @param column 字段 + * @param params 参数 + * @return ConditionWrapper + */ + public ConditionAndWrapper eq(String column, Object params) { + super.eq(column, params); + return this; + } + + /** + * 等于 + * + * @param column 字段 + * @param params 参数 + * @return ConditionWrapper + */ + public ConditionAndWrapper eq(SerializableFunction column, Object params) { + super.eq(ReflectionUtil.getFieldName(column), params); + return this; + } + + /** + * 不等于 + * + * @param column 字段 + * @param params 参数 + * @return ConditionAndWrapper + */ + public ConditionAndWrapper ne(String column, Object params) { + super.ne(column, params); + return this; + } + + /** + * 不等于 + * + * @param column 字段 + * @param params 参数 + * @return ConditionAndWrapper + */ + public ConditionAndWrapper ne(SerializableFunction column, Object params) { + super.ne(ReflectionUtil.getFieldName(column), params); + return this; + } + + /** + * 小于 + * + * @param column 字段 + * @param params 参数 + * @return ConditionAndWrapper + */ + public ConditionAndWrapper lt(String column, Object params) { + super.lt(column, params); + return this; + } + + /** + * 小于 + * + * @param column 字段 + * @param params 参数 + * @return ConditionAndWrapper + */ + public ConditionAndWrapper lt(SerializableFunction column, Object params) { + super.lt(ReflectionUtil.getFieldName(column), params); + return this; + } + + /** + * 小于或等于 + * + * @param column 字段 + * @param params 参数 + * @return ConditionAndWrapper + */ + public ConditionAndWrapper lte(String column, Object params) { + super.lte(column, params); + return this; + } + + /** + * 小于或等于 + * + * @param column 字段 + * @param params 参数 + * @return ConditionAndWrapper + */ + public ConditionAndWrapper lte(SerializableFunction column, Object params) { + super.lte(ReflectionUtil.getFieldName(column), params); + return this; + } + + /** + * 大于 + * + * @param column 字段 + * @param params 参数 + * @return ConditionAndWrapper + */ + public ConditionAndWrapper gt(String column, Object params) { + super.gt(column, params); + return this; + } + + /** + * 大于 + * + * @param column 字段 + * @param params 参数 + * @return ConditionAndWrapper + */ + public ConditionAndWrapper gt(SerializableFunction column, Object params) { + super.gt(ReflectionUtil.getFieldName(column), params); + return this; + } + + /** + * 大于或等于 + * + * @param column 字段 + * @param params 参数 + * @return ConditionAndWrapper + */ + public ConditionAndWrapper gte(String column, Object params) { + super.gte(column, params); + return this; + } + + /** + * 大于或等于 + * + * @param column 字段 + * @param params 参数 + * @return ConditionAndWrapper + */ + public ConditionAndWrapper gte(SerializableFunction column, Object params) { + super.gte(ReflectionUtil.getFieldName(column), params); + return this; + } + + /** + * 相似于 + * + * @param column 字段 + * @param params 参数 + * @return ConditionAndWrapper + */ + public ConditionAndWrapper like(String column, String params) { + super.like(column, params); + return this; + } + + /** + * 相似于 + * + * @param column 字段 + * @param params 参数 + * @return ConditionAndWrapper + */ + public ConditionAndWrapper like(SerializableFunction column, String params) { + super.like(ReflectionUtil.getFieldName(column), params); + return this; + } + + /** + * 在其中 + * + * @param column 字段 + * @param params 参数 + * @return ConditionAndWrapper + */ + public ConditionAndWrapper in(String column, Collection params) { + super.in(column, params); + return this; + } + + /** + * 在其中 + * + * @param column 字段 + * @param params 参数 + * @return ConditionAndWrapper + */ + public ConditionAndWrapper in(SerializableFunction column, Collection params) { + super.in(ReflectionUtil.getFieldName(column), params); + return this; + } + + /** + * 在其中 + * + * @param column 字段 + * @param params 参数 + * @return ConditionAndWrapper + */ + public ConditionAndWrapper in(String column, Object[] params) { + super.in(column, Arrays.asList(params)); + return this; + } + + /** + * 在其中 + * + * @param column 字段 + * @param params 参数 + * @return ConditionAndWrapper + */ + public ConditionAndWrapper in(SerializableFunction column, Object[] params) { + super.in(ReflectionUtil.getFieldName(column), Arrays.asList(params)); + return this; + } + + /** + * 不在其中 + * + * @param column 字段 + * @param params 参数 + * @return ConditionAndWrapper + */ + public ConditionAndWrapper nin(String column, Collection params) { + super.nin(column, params); + return this; + } + + /** + * 不在其中 + * + * @param column 字段 + * @param params 参数 + * @return ConditionAndWrapper + */ + public ConditionAndWrapper nin(SerializableFunction column, Collection params) { + super.nin(ReflectionUtil.getFieldName(column), params); + return this; + } + + /** + * 不在其中 + * + * @param column 字段 + * @param params 参数 + * @return ConditionAndWrapper + */ + public ConditionAndWrapper nin(String column, Object[] params) { + super.nin(column, Arrays.asList(params)); + return this; + } + + /** + * 不在其中 + * + * @param column 字段 + * @param params 参数 + * @return ConditionAndWrapper + */ + public ConditionAndWrapper nin(SerializableFunction column, Object[] params) { + super.nin(ReflectionUtil.getFieldName(column), Arrays.asList(params)); + return this; + } + + /** + * 为空 + * + * @param + * + * @param column 字段 + * @return ConditionAndWrapper + */ + public ConditionAndWrapper isNull(String column) { + super.isNull(column); + return this; + } + + /** + * 为空 + * + * @param + * + * @param column 字段 + * @return ConditionAndWrapper + */ + public ConditionAndWrapper isNull(SerializableFunction column) { + super.isNull(ReflectionUtil.getFieldName(column)); + return this; + } + + /** + * 不为空 + * + * @param + * + * @param column 字段 + * @return ConditionAndWrapper + */ + public ConditionAndWrapper isNotNull(String column) { + super.isNotNull(column); + return this; + } + + /** + * 不为空 + * + * @param + * + * @param column 字段 + * @return ConditionAndWrapper + */ + public ConditionAndWrapper isNotNull(SerializableFunction column) { + super.isNotNull(ReflectionUtil.getFieldName(column)); + return this; + } +} diff --git a/lib/sqlHelper/src/main/java/com/cym/sqlHelper/utils/ConditionOrWrapper.java b/lib/sqlHelper/src/main/java/com/cym/sqlHelper/utils/ConditionOrWrapper.java new file mode 100644 index 0000000..fd888a8 --- /dev/null +++ b/lib/sqlHelper/src/main/java/com/cym/sqlHelper/utils/ConditionOrWrapper.java @@ -0,0 +1,321 @@ +package com.cym.sqlHelper.utils; + +import java.util.Arrays; +import java.util.Collection; + +import com.cym.sqlHelper.reflection.ReflectionUtil; +import com.cym.sqlHelper.reflection.SerializableFunction; + +/** + * 查询语句生成器 OR连接 + * + */ +public class ConditionOrWrapper extends ConditionWrapper { + + public ConditionOrWrapper() { + andLink = false; + } + + public ConditionOrWrapper or(ConditionWrapper conditionWrapper) { + list.add(conditionWrapper); + return this; + } + + /** + * 等于 + * + * @param column 字段 + * @param params 参数 + * @return ConditionWrapper + */ + public ConditionOrWrapper eq(String column, Object params) { + super.eq(column, params); + return this; + } + /** + * 等于 + * + * @param column 字段 + * @param params 参数 + * @return ConditionWrapper + */ + public ConditionOrWrapper eq(SerializableFunction column, Object params) { + super.eq(ReflectionUtil.getFieldName(column), params); + return this; + } + /** + * 不等于 + * + * @param column 字段 + * @param params 参数 + * @return ConditionOrWrapper + */ + public ConditionOrWrapper ne(String column, Object params) { + super.ne(column, params); + return this; + } + + /** + * 不等于 + * + * @param column 字段 + * @param params 参数 + * @return ConditionOrWrapper + */ + public ConditionOrWrapper ne(SerializableFunction column, Object params) { + super.ne(ReflectionUtil.getFieldName(column), params); + return this; + } + + /** + * 小于 + * + * @param column 字段 + * @param params 参数 + * @return ConditionOrWrapper + */ + public ConditionOrWrapper lt(String column, Object params) { + super.lt(column, params); + return this; + } + /** + * 小于 + * + * @param column 字段 + * @param params 参数 + * @return ConditionOrWrapper + */ + public ConditionOrWrapper lt(SerializableFunction column, Object params) { + super.lt(ReflectionUtil.getFieldName(column), params); + return this; + } + /** + * 小于或等于 + * + * @param column 字段 + * @param params 参数 + * @return ConditionOrWrapper + */ + public ConditionOrWrapper lte(String column, Object params) { + super.lte(column, params); + return this; + } + /** + * 小于或等于 + * + * @param column 字段 + * @param params 参数 + * @return ConditionOrWrapper + */ + public ConditionOrWrapper lte(SerializableFunction column, Object params) { + super.lte(ReflectionUtil.getFieldName(column), params); + return this; + } + /** + * 大于 + * + * @param column 字段 + * @param params 参数 + * @return ConditionOrWrapper + */ + public ConditionOrWrapper gt(String column, Object params) { + super.gt(column, params); + return this; + } + /** + * 大于 + * + * @param column 字段 + * @param params 参数 + * @return ConditionOrWrapper + */ + public ConditionOrWrapper gt(SerializableFunction column, Object params) { + super.gt(ReflectionUtil.getFieldName(column), params); + return this; + } + /** + * 大于或等于 + * + * @param column 字段 + * @param params 参数 + * @return ConditionOrWrapper + */ + public ConditionOrWrapper gte(String column, Object params) { + super.gte(column, params); + return this; + } + /** + * 大于或等于 + * + * @param column 字段 + * @param params 参数 + * @return ConditionOrWrapper + */ + public ConditionOrWrapper gte(SerializableFunction column, Object params) { + super.gte(ReflectionUtil.getFieldName(column), params); + return this; + } + /** + * 相似于 + * + * @param column 字段 + * @param params 参数 + * @return ConditionOrWrapper + */ + public ConditionOrWrapper like(String column, String params) { + super.like(column, params); + return this; + } + /** + * 相似于 + * + * @param column 字段 + * @param params 参数 + * @return ConditionOrWrapper + */ + public ConditionOrWrapper like(SerializableFunction column, String params) { + super.like(ReflectionUtil.getFieldName(column), params); + return this; + } + /** + * 在其中 + * + * @param column 字段 + * @param params 参数 + * @return ConditionOrWrapper + */ + public ConditionOrWrapper in(String column, Collection params) { + super.in(column, params); + return this; + } + /** + * 在其中 + * + * @param column 字段 + * @param params 参数 + * @return ConditionOrWrapper + */ + public ConditionOrWrapper in(SerializableFunction column, Collection params) { + super.in(ReflectionUtil.getFieldName(column), params); + return this; + } + + /** + * 在其中 + * + * @param column 字段 + * @param params 参数 + * @return ConditionOrWrapper + */ + public ConditionOrWrapper in(String column, Object[] params) { + super.in(column, Arrays.asList(params)); + return this; + } + + /** + * 在其中 + * + * @param column 字段 + * @param params 参数 + * @return ConditionOrWrapper + */ + public ConditionOrWrapper in(SerializableFunction column, Object[] params) { + super.in(ReflectionUtil.getFieldName(column), Arrays.asList(params)); + return this; + } + + /** + * 不在其中 + * + * @param column 字段 + * @param params 参数 + * @return ConditionOrWrapper + */ + public ConditionOrWrapper nin(String column, Collection params) { + super.nin(column, params); + return this; + } + /** + * 不在其中 + * + * @param column 字段 + * @param params 参数 + * @return ConditionOrWrapper + */ + public ConditionOrWrapper nin(SerializableFunction column, Collection params) { + super.nin(ReflectionUtil.getFieldName(column), params); + return this; + } + + /** + * 不在其中 + * + * @param column 字段 + * @param params 参数 + * @return ConditionOrWrapper + */ + public ConditionOrWrapper nin(String column, Object[] params) { + super.nin(column, Arrays.asList(params)); + return this; + } + /** + * 不在其中 + * + * @param column 字段 + * @param params 参数 + * @return ConditionOrWrapper + */ + public ConditionOrWrapper nin(SerializableFunction column, Object[] params) { + super.nin(ReflectionUtil.getFieldName(column), Arrays.asList(params)); + return this; + } + /** + * 为空 + * + * @param + * + * @param column 字段 + * @return ConditionOrWrapper + */ + public ConditionOrWrapper isNull(String column) { + super.isNull(column); + return this; + } + /** + * 为空 + * + * @param + * + * @param column 字段 + * @return ConditionOrWrapper + */ + public ConditionOrWrapper isNull(SerializableFunction column) { + super.isNull(ReflectionUtil.getFieldName(column)); + return this; + } + + /** + * 不为空 + * + * @param + * + * @param column 字段 + * @return ConditionOrWrapper + */ + public ConditionOrWrapper isNotNull(String column) { + super.isNotNull(column); + return this; + } + /** + * 不为空 + * + * @param + * + * @param column 字段 + * @return ConditionOrWrapper + */ + public ConditionOrWrapper isNotNull(SerializableFunction column) { + super.isNotNull(ReflectionUtil.getFieldName(column)); + return this; + } +} diff --git a/lib/sqlHelper/src/main/java/com/cym/sqlHelper/utils/ConditionWrapper.java b/lib/sqlHelper/src/main/java/com/cym/sqlHelper/utils/ConditionWrapper.java new file mode 100644 index 0000000..64a01e1 --- /dev/null +++ b/lib/sqlHelper/src/main/java/com/cym/sqlHelper/utils/ConditionWrapper.java @@ -0,0 +1,235 @@ +package com.cym.sqlHelper.utils; + +import java.util.ArrayList; +import java.util.Collection; +import java.util.List; + +import cn.hutool.core.util.StrUtil; + +/** + * 查询语句生成器 + * + * @author CYM + * + */ +public abstract class ConditionWrapper { + boolean andLink; + + List list = new ArrayList(); + + /** + * 将Wrapper转化为Condition + * + * @param params + * + * @return Condition + */ + public String build(List values) { + String sql = ""; + if (list.size() > 0) { + List blocks = new ArrayList(); + for (Object object : list) { + if (object instanceof Condition) { + Condition condition = (Condition) object; + String block = null; + + if (condition.getValue() == null) { + if (condition.getOperation().equals("IS NULL") || condition.getOperation().equals("IS NOT NULL")) { + block = buildColumn(condition.getColumn(), String.class) + " " + condition.getOperation(); + } else { + block = buildColumn(condition.getColumn(), String.class) + " " + condition.getOperation() + " null"; + } + } else { + if (condition.getValue() instanceof List) { + block = buildColumn(condition.getColumn(), condition.getValue().getClass()) + " " + condition.getOperation() + " " + buildIn(condition.getValue()); + for (Object val : (List) condition.getValue()) { + values.add(val); + } + } else { + block = buildColumn(condition.getColumn(), condition.getValue().getClass()) + " " + condition.getOperation() + " ?"; + if (!condition.getOperation().equals("LIKE")) { + values.add(condition.getValue()); + } else { + values.add("%" + condition.getValue().toString().replace("%", "\\%") + "%"); + } + } + } + + blocks.add(block); + } + + if (object instanceof ConditionWrapper) { + ConditionWrapper conditionWrapper = (ConditionWrapper) object; + String block = " (" + conditionWrapper.build(values) + ") "; + blocks.add(block); + } + } + + if (andLink) { + sql = StrUtil.join(" AND ", blocks); + } else { + sql = StrUtil.join(" OR ", blocks); + } + + } + return sql; + } + + public String buildColumn(String column, Class clazz) { + + return "`" + StrUtil.toUnderlineCase(column) + "`"; + } + + public String buildIn(Object value) { + List ask = new ArrayList(); + for (Object obj : (Collection) value) { + ask.add("?"); + } + + if (ask.size() > 0) { + return " (" + StrUtil.join(",", ask) + ") "; + } else { + return " (null) "; + } + + } + + /** + * 等于 + * + * @param column 字段 + * @param params 参数 + * @return ConditionWrapper + */ + public ConditionWrapper eq(String column, Object params) { + list.add(new Condition(column, "=", params)); + return this; + } + + /** + * 不等于 + * + * @param column 字段 + * @param params 参数 + * @return ConditionWrapper + */ + public ConditionWrapper ne(String column, Object params) { + list.add(new Condition(column, "<>", params)); + return this; + } + + /** + * 小于 + * + * @param column 字段 + * @param params 参数 + * @return ConditionWrapper + */ + public ConditionWrapper lt(String column, Object params) { + list.add(new Condition(column, "<", params)); + return this; + } + + /** + * 小于或等于 + * + * @param column 字段 + * @param params 参数 + * @return ConditionWrapper + */ + public ConditionWrapper lte(String column, Object params) { + list.add(new Condition(column, "<=", params)); + return this; + } + + /** + * 大于 + * + * @param column 字段 + * @param params 参数 + * @return ConditionWrapper + */ + public ConditionWrapper gt(String column, Object params) { + list.add(new Condition(column, ">", params)); + return this; + } + + /** + * 大于或等于 + * + * @param column 字段 + * @param params 参数 + * @return ConditionWrapper + */ + public ConditionWrapper gte(String column, Object params) { + list.add(new Condition(column, ">=", params)); + return this; + } + + /** + * 相似于 + * + * @param column 字段 + * @param params 参数 + * @return ConditionWrapper + */ + public ConditionWrapper like(String column, String params) { + list.add(new Condition(column, "LIKE", params )); + return this; + } + + /** + * 在其中 + * + * @param column 字段 + * @param params 参数 + * @return ConditionWrapper + */ + public ConditionWrapper in(String column, Collection params) { + list.add(new Condition(column, "IN", params)); + return this; + } + + /** + * 不在其中 + * + * @param column 字段 + * @param params 参数 + * @return ConditionWrapper + */ + public ConditionWrapper nin(String column, Collection params) { + list.add(new Condition(column, "NOT IN", params)); + return this; + } + + /** + * 为空 + * + * @param + * + * @param column 字段 + * @return ConditionWrapper + */ + public ConditionWrapper isNull(String column) { + list.add(new Condition(column, "IS NULL", null)); + return this; + } + + /** + * 不为空 + * + * @param + * + * @param column 字段 + * @return ConditionWrapper + */ + public ConditionWrapper isNotNull(String column) { + list.add(new Condition(column, "IS NOT NULL", null)); + return this; + } + + public boolean notEmpty() { + return list.size() > 0; + } + +} diff --git a/lib/sqlHelper/src/main/java/com/cym/sqlHelper/utils/SnowFlakeUtils.java b/lib/sqlHelper/src/main/java/com/cym/sqlHelper/utils/SnowFlakeUtils.java new file mode 100644 index 0000000..4e30f48 --- /dev/null +++ b/lib/sqlHelper/src/main/java/com/cym/sqlHelper/utils/SnowFlakeUtils.java @@ -0,0 +1,11 @@ +package com.cym.sqlHelper.utils; + +import cn.hutool.core.util.IdUtil; + +public class SnowFlakeUtils { + + public static Long nextId() { + return IdUtil.getSnowflake(0, 0).nextId(); + } + +} \ No newline at end of file diff --git a/lib/sqlHelper/src/main/java/com/cym/sqlHelper/utils/SqlHelper.java b/lib/sqlHelper/src/main/java/com/cym/sqlHelper/utils/SqlHelper.java new file mode 100644 index 0000000..31f4692 --- /dev/null +++ b/lib/sqlHelper/src/main/java/com/cym/sqlHelper/utils/SqlHelper.java @@ -0,0 +1,944 @@ +package com.cym.sqlHelper.utils; + +import java.lang.reflect.Field; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Collection; +import java.util.HashSet; +import java.util.List; +import java.util.Map; +import java.util.Map.Entry; +import java.util.Set; + +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.jdbc.core.JdbcTemplate; +import org.springframework.stereotype.Service; + +import com.cym.sqlHelper.bean.Page; +import com.cym.sqlHelper.bean.Sort; +import com.cym.sqlHelper.bean.Update; +import com.cym.sqlHelper.config.InitValue; +import com.cym.sqlHelper.reflection.ReflectionUtil; +import com.cym.sqlHelper.reflection.SerializableFunction; + +import cn.hutool.core.util.ClassUtil; +import cn.hutool.core.util.ReflectUtil; +import cn.hutool.core.util.StrUtil; +import jakarta.annotation.PostConstruct; + +/** + * mongodb操作器 + * + */ +@Service +public class SqlHelper extends SqlUtils { + @Value("${spring.database.type}") + String database; + @Value("${spring.database.package}") + String packageName; + @Value("${spring.database.print:false}") + Boolean print; + + @Autowired + JdbcTemplate jdbcTemplate; + + Logger logger = LoggerFactory.getLogger(this.getClass()); + + @Autowired + TableUtils tableUtils; + + @PostConstruct + private void scan() { + if (StrUtil.isEmpty(packageName)) { + return; + } + + Set> set = ClassUtil.scanPackage(packageName); + for (Class clazz : set) { + tableUtils.initTable(clazz); + } + } + + /** + * 插入或更新 + * + * @param object 对象 + */ + public String insertOrUpdate(Object object) { + + Long time = System.currentTimeMillis(); + String id = (String) ReflectUtil.getFieldValue(object, "id"); +// Object objectOrg = StrUtil.isNotEmpty(id) ? findById(id, object.getClass()) : null; + try { + if (StrUtil.isEmpty(id)) { + // 插入 + // 设置插入时间 + if (ReflectUtil.getField(object.getClass(), "createTime") != null) { + ReflectUtil.setFieldValue(object, "createTime", time); + } + if (ReflectUtil.getField(object.getClass(), "updateTime") != null) { + ReflectUtil.setFieldValue(object, "updateTime", time); + } + // 设置默认值 + setDefaultVaule(object); + + // 没有id设置id + if (StrUtil.isEmpty(id)) { + ReflectUtil.setFieldValue(object, "id", SnowFlakeUtils.nextId()); + } + + String sql = ""; + List fieldsPart = new ArrayList(); + List placeHolder = new ArrayList(); + List paramValues = new ArrayList(); + + Field[] fields = ReflectUtil.getFields(object.getClass()); + for (Field field : fields) { + fieldsPart.add("`" + StrUtil.toUnderlineCase(field.getName()) + "`"); + placeHolder.add("?"); + paramValues.add(ReflectUtil.getFieldValue(object, field)); + } + + sql = "INSERT INTO `" + StrUtil.toUnderlineCase(object.getClass().getSimpleName()) + "` (" + StrUtil.join(",", fieldsPart) + ") VALUES (" + StrUtil.join(",", placeHolder) + ")"; + + logQuery(formatSql(sql), paramValues.toArray()); + jdbcTemplate.update(formatSql(sql), paramValues.toArray()); + + } else { + // 更新 + Field[] fields = ReflectUtil.getFields(object.getClass()); + + // 设置更新时间 + if (ReflectUtil.getField(object.getClass(), "updateTime") != null) { + ReflectUtil.setFieldValue(object, "updateTime", time); + } + + List fieldsPart = new ArrayList(); + List paramValues = new ArrayList(); + + for (Field field : fields) { + if (!field.getName().equals("id") && ReflectUtil.getFieldValue(object, field) != null) { + fieldsPart.add("`" + StrUtil.toUnderlineCase(field.getName()) + "`=?"); + paramValues.add(ReflectUtil.getFieldValue(object, field)); + } + } + paramValues.add(id); + + String sql = "UPDATE `" + StrUtil.toUnderlineCase(object.getClass().getSimpleName()) + "` SET " + StrUtil.join(",", fieldsPart) + " WHERE id = ?"; + + logQuery(formatSql(sql), paramValues.toArray()); + jdbcTemplate.update(formatSql(sql), paramValues.toArray()); + } + } catch (Exception e) { + e.printStackTrace(); + throw new RuntimeException(e); + } + + return (String) ReflectUtil.getFieldValue(object, "id"); + } + + /** + * 插入 + * + * @param object 对象 + */ + public String insert(Object object) { +// String id = (String) ReflectUtil.getFieldValue(object, "id"); +// Object objectOrg = StrUtil.isNotEmpty(id) ? findById(id, object.getClass()) : null; +// if (objectOrg != null) { +// // 数据库里已有相同id, 使用新id以便插入 +// ReflectUtil.setFieldValue(object, "id", snowFlake.nextId()); +// } + +// // 没有id生成id +// if (ReflectUtil.getFieldValue(object, "id") == null) { +// ReflectUtil.setFieldValue(object, "id", snowFlake.nextId()); +// } + + // 去除主键id + ReflectUtil.setFieldValue(object, "id", null); + + insertOrUpdate(object); + + return (String) ReflectUtil.getFieldValue(object, "id"); + } + + + /** + * 插入全部字段 + * + * @param object 对象 + */ + public String insertAllColumn(Object object) { + // 没有id生成id + if (ReflectUtil.getFieldValue(object, "id") == null) { + ReflectUtil.setFieldValue(object, "id", SnowFlakeUtils.nextId()); + } + + String sql = ""; + List fieldsPart = new ArrayList(); + List placeHolder = new ArrayList(); + List paramValues = new ArrayList(); + + Field[] fields = ReflectUtil.getFields(object.getClass()); + for (Field field : fields) { + fieldsPart.add("`" + StrUtil.toUnderlineCase(field.getName()) + "`"); + placeHolder.add("?"); + paramValues.add(ReflectUtil.getFieldValue(object, field)); + } + + sql = "INSERT INTO `" + StrUtil.toUnderlineCase(object.getClass().getSimpleName()) + "` (" + StrUtil.join(",", fieldsPart) + ") VALUES (" + StrUtil.join(",", placeHolder) + ")"; + logQuery(formatSql(sql), paramValues.toArray()); + jdbcTemplate.update(formatSql(sql), paramValues.toArray()); + + // 返回id + return (String) ReflectUtil.getFieldValue(object, "id"); + } + + /** + * 批量插入 + * + * @param + * + * @param object 对象 + */ + public void insertBatch(List list) { + Long time = System.currentTimeMillis(); + +// Map idMap = new HashMap(); +// for (Object object : list) { +// if (ReflectUtil.getFieldValue(object, "id") != null) { +// String id = (String) ReflectUtil.getFieldValue(object, "id"); +// Object objectOrg = StrUtil.isNotEmpty(id) ? findById(id, object.getClass()) : null; +// idMap.put((String) ReflectUtil.getFieldValue(object, "id"), objectOrg); +// } +// } + + for (Object object : list) { +// if (ReflectUtil.getFieldValue(object, "id") != null && idMap.get((String) ReflectUtil.getFieldValue(object, "id")) != null) { +// // 数据库里已有相同id, 使用新id以便插入 +// ReflectUtil.setFieldValue(object, "id", snowFlake.nextId()); +// } + + // 没有id生成id + if (ReflectUtil.getFieldValue(object, "id") == null) { + ReflectUtil.setFieldValue(object, "id", SnowFlakeUtils.nextId()); + } + + // 设置插入时间 + if (ReflectUtil.getField(object.getClass(), "createTime") != null) { + ReflectUtil.setFieldValue(object, "createTime", time); + } + if (ReflectUtil.getField(object.getClass(), "updateTime") != null) { + ReflectUtil.setFieldValue(object, "updateTime", time); + } + // 设置默认值 + setDefaultVaule(object); + } + + List paramValues = new ArrayList(); + String sqls = null; + for (Object object : list) { + Field[] fields = ReflectUtil.getFields(object.getClass()); + + List fieldsPart = new ArrayList(); + List placeHolder = new ArrayList(); + + List params = new ArrayList(); + for (Field field : fields) { + fieldsPart.add("`" + StrUtil.toUnderlineCase(field.getName()) + "`"); + placeHolder.add("?"); + params.add(ReflectUtil.getFieldValue(object, field)); + } + + paramValues.add(params.toArray()); + + if (sqls == null) { + sqls = "INSERT INTO `" + StrUtil.toUnderlineCase(object.getClass().getSimpleName()) + "` (" + StrUtil.join(",", fieldsPart) + ") VALUES (" + StrUtil.join(",", placeHolder) + ")"; + } + logQuery(formatSql(sqls), params.toArray()); + } + + //logQueryBatch(formatSql(sqls), paramValues); + jdbcTemplate.batchUpdate(formatSql(sqls), paramValues); + } + + /** + * 根据id更新 + * + * @param object 对象 + */ + public void updateById(Object object) { + if (StrUtil.isEmpty((String) ReflectUtil.getFieldValue(object, "id"))) { + return; + } + insertOrUpdate(object); + } + + /** + * 批量更新 + * + * @param conditionAndWrapper + * @param update + * @param clazz + */ + public void updateMulti(ConditionWrapper conditionWrapper, Update update, Class clazz) { + if (update == null || update.getSets().size() == 0) { + return; + } + List fieldsPart = new ArrayList(); + List paramValues = new ArrayList(); + for (Entry entry : update.getSets().entrySet()) { + if (entry.getKey() != null && entry.getValue() != null) { + fieldsPart.add("`" + StrUtil.toUnderlineCase(entry.getKey()) + "`=?"); + paramValues.add(entry.getValue().toString()); + } + } + + String sql = "UPDATE `" + StrUtil.toUnderlineCase(clazz.getSimpleName()) + "` SET " + StrUtil.join(",", fieldsPart); + if (conditionWrapper != null && conditionWrapper.notEmpty()) { + sql += " WHERE " + conditionWrapper.build(paramValues); + } + + logQuery(formatSql(sql), paramValues.toArray()); + jdbcTemplate.update(formatSql(sql), paramValues.toArray()); + } + + /** + * 累加某一个字段的数量,原子操作 + * + * @param object + */ + public void addCountById(String id, String property, Long count, Class clazz) { + String sql = "UPDATE `" + StrUtil.toUnderlineCase(clazz.getSimpleName()) + "` SET `" + property + "` = CAST(`" + property + "` AS DECIMAL(30,10)) + ? WHERE `id` = ?"; + Object[] params = new Object[] { count, id }; + logQuery(formatSql(sql), params); + jdbcTemplate.update(formatSql(sql), params); + } + + /** + * 累加某一个字段的数量,原子操作 + * + * @param object + */ + public void addCountById(String id, SerializableFunction property, Long count, Class clazz) { + addCountById(id, ReflectionUtil.getFieldName(property), count, clazz); + } + + /** + * 根据id更新 + * + * @param object 对象 + */ + public void updateAllColumnById(Object object) { + if (StrUtil.isEmpty((String) ReflectUtil.getFieldValue(object, "id"))) { + return; + } + + Field[] fields = ReflectUtil.getFields(object.getClass()); + + List fieldsPart = new ArrayList(); + List paramValues = new ArrayList(); + + for (Field field : fields) { + if (!field.getName().equals("id")) { + fieldsPart.add("`" + StrUtil.toUnderlineCase(field.getName()) + "`=?"); + paramValues.add(ReflectUtil.getFieldValue(object, field)); + } + } + paramValues.add((String) ReflectUtil.getFieldValue(object, "id")); + + String sql = "UPDATE `" + StrUtil.toUnderlineCase(object.getClass().getSimpleName()) + "` SET " + StrUtil.join(",", fieldsPart) + " WHERE id = ?"; + + logQuery(formatSql(sql), paramValues.toArray()); + jdbcTemplate.update(formatSql(sql), paramValues.toArray()); + + } + + /** + * 根据id删除 + * + * @param id 对象 + * @param clazz 类 + */ + public void deleteById(String id, Class clazz) { + + if (StrUtil.isEmpty(id)) { + return; + } + deleteByQuery(new ConditionAndWrapper().eq("id", id), clazz); + } + + /** + * 根据id删除 + * + * @param id 对象 + * @param clazz 类 + */ + public void deleteByIds(Collection ids, Class clazz) { + if (ids == null || ids.size() == 0) { + return; + } + + deleteByQuery(new ConditionAndWrapper().in("id", ids), clazz); + } + + /** + * 根据id删除 + * + * @param id 对象 + * @param clazz 类 + */ + public void deleteByIds(String[] ids, Class clazz) { + deleteByIds(Arrays.asList(ids), clazz); + } + + /** + * 根据条件删除 + * + * @param query 查询 + * @param clazz 类 + */ + public void deleteByQuery(ConditionWrapper conditionWrapper, Class clazz) { + List values = new ArrayList(); + String sql = "DELETE FROM `" + StrUtil.toUnderlineCase(clazz.getSimpleName()) + "`"; + if (conditionWrapper != null && conditionWrapper.notEmpty()) { + sql += " WHERE " + conditionWrapper.build(values); + } + logQuery(formatSql(sql), values.toArray()); + jdbcTemplate.update(formatSql(sql), values.toArray()); + } + + /** + * 设置默认值 + * + * @param object 对象 + */ + private void setDefaultVaule(Object object) { + Field[] fields = ReflectUtil.getFields(object.getClass()); + for (Field field : fields) { + // 获取注解 + if (field.isAnnotationPresent(InitValue.class)) { + InitValue defaultValue = field.getAnnotation(InitValue.class); + + String value = defaultValue.value(); + + if (ReflectUtil.getFieldValue(object, field) == null) { + // 获取字段类型 + Class type = field.getType(); + if (type.equals(String.class)) { + ReflectUtil.setFieldValue(object, field, value); + } + if (type.equals(Short.class)) { + ReflectUtil.setFieldValue(object, field, Short.parseShort(value)); + } + if (type.equals(Integer.class)) { + ReflectUtil.setFieldValue(object, field, Integer.parseInt(value)); + } + if (type.equals(Long.class)) { + ReflectUtil.setFieldValue(object, field, Long.parseLong(value)); + } + if (type.equals(Float.class)) { + ReflectUtil.setFieldValue(object, field, Float.parseFloat(value)); + } + if (type.equals(Double.class)) { + ReflectUtil.setFieldValue(object, field, Double.parseDouble(value)); + } + if (type.equals(Boolean.class)) { + ReflectUtil.setFieldValue(object, field, Boolean.parseBoolean(value)); + } + } + } + } + } + + /** + * 按查询条件获取Page + * + * @param query 查询 + * @param page 分页 + * @param clazz 类 + * @return Page 分页 + */ + public Page findPage(ConditionWrapper conditionWrapper, Sort sort, Page page, Class clazz) { + List values = new ArrayList(); + // 查询出一共的条数 + Long count = findCountByQuery(conditionWrapper, clazz); + + String sql = "SELECT * FROM `" + StrUtil.toUnderlineCase(clazz.getSimpleName()) + "`"; + if (conditionWrapper != null && conditionWrapper.notEmpty()) { + sql += " WHERE " + conditionWrapper.build(values); + } + if (sort != null) { + sql += " " + sort.toString(); + } else { + sql += " ORDER BY id DESC"; + } + if (database.equalsIgnoreCase("mysql") || database.equalsIgnoreCase("sqlite")) { + sql += " LIMIT " + (page.getCurr() - 1) * page.getLimit() + "," + page.getLimit(); + } else { + sql += " LIMIT " + page.getLimit() + " OFFSET " + (page.getCurr() - 1) * page.getLimit(); + } + + page.setCount(count); + + logQuery(formatSql(sql), values.toArray()); + page.setRecords(buildObjects(jdbcTemplate.queryForList(formatSql(sql), values.toArray()), clazz)); + + return page; + } + + /** + * 按查询条件获取Page + * + * @param query 查询 + * @param page 分页 + * @param clazz 类 + * @return Page 分页 + */ + public Page findPage(Sort sort, Page page, Class clazz) { + return findPage(null, sort, page, clazz); + } + + /** + * 按查询条件获取Page + * + * @param query 查询 + * @param page 分页 + * @param clazz 类 + * @return Page 分页 + */ + public Page findPage(ConditionWrapper conditionWrapper, Page page, Class clazz) { + return findPage(conditionWrapper, null, page, clazz); + } + + /** + * 按查询条件获取Page + * + * @param query 查询 + * @param page 分页 + * @param clazz 类 + * @return Page 分页 + */ + public Page findPage(Page page, Class clazz) { + return findPage(null, null, page, clazz); + } + + /** + * 根据id查找 + * + * @param id id + * @param clazz 类 + * @return T 对象 + */ + public T findById(String id, Class clazz) { + if (StrUtil.isEmpty(id)) { + return null; + } + + return findOneByQuery(new ConditionAndWrapper().eq("id", id), clazz); + + } + + /** + * 根据条件查找单个 + * + * @param query 查询 + * @param clazz 类 + * @return T 对象 + */ + public T findOneByQuery(ConditionWrapper conditionWrapper, Sort sort, Class clazz) { + List values = new ArrayList(); + List list = new ArrayList(); + String sql = "SELECT * FROM `" + StrUtil.toUnderlineCase(clazz.getSimpleName()) + "`"; + if (conditionWrapper != null && conditionWrapper.notEmpty()) { + sql += " WHERE " + conditionWrapper.build(values); + } + if (sort != null) { + sql += " " + sort.toString(); + } else { + sql += " ORDER BY id DESC"; + } + sql += " limit 1"; + + logQuery(formatSql(sql), values.toArray()); + list = buildObjects(jdbcTemplate.queryForList(formatSql(sql), values.toArray()), clazz); + return list.size() > 0 ? list.get(0) : null; + } + + /** + * 根据条件查找单个 + * + * @param query 查询 + * @param clazz 类 + * @return T 对象 + */ + public T findOneByQuery(Sort sort, Class clazz) { + return findOneByQuery(null, sort, clazz); + } + + /** + * 根据条件查找单个 + * + * @param 类型 + * @param condition + * @param clazz 类 + * @return T 对象 + */ + public T findOneByQuery(ConditionWrapper conditionWrapper, Class clazz) { + return findOneByQuery(conditionWrapper, null, clazz); + + } + + /** + * 根据条件查找List + * + * @param 类型 + * @param query 查询 + * @param clazz 类 + * @return List 列表 + */ + public List findListByQuery(ConditionWrapper conditionWrapper, Sort sort, Class clazz) { + List values = new ArrayList(); + + String sql = "SELECT * FROM `" + StrUtil.toUnderlineCase(clazz.getSimpleName()) + "`"; + if (conditionWrapper != null && conditionWrapper.notEmpty()) { + sql += " WHERE " + conditionWrapper.build(values); + } + if (sort != null) { + sql += " " + sort.toString(); + } else { + sql += " ORDER BY id DESC"; + } + + logQuery(formatSql(sql), values.toArray()); + return buildObjects(jdbcTemplate.queryForList(formatSql(sql), values.toArray()), clazz); + } + + /** + * 根据条件查找List + * + * @param 类型 + * @param condition 查询 + * @param clazz 类 + * @return List 列表 + */ + public List findListByQuery(ConditionWrapper conditionWrapper, Class clazz) { + return (List) findListByQuery(conditionWrapper, null, clazz); + } + + /** + * 根据条件查找List + * + * @param 类型 + * @param condition 查询 + * @param clazz 类 + * @return List 列表 + */ + public List findListByQuery(Sort sort, Class clazz) { + return (List) findListByQuery(null, sort, clazz); + } + + /** + * 根据条件查找某个属性 + * + * @param 类型 + * @param query 查询 + * @param documentClass 类 + * @param property 属性 + * @param propertyClass 属性类 + * @return List 列表 + */ + public List findPropertiesByQuery(ConditionWrapper conditionWrapper, Class documentClass, String property, Class propertyClass) { + List list = findListByQuery(conditionWrapper, documentClass); + List propertyList = extractProperty(list, property, propertyClass); + + return propertyList; + } + + /** + * 根据条件查找某个属性 + * + * @param 类型 + * @param query 查询 + * @param documentClass 类 + * @param property 属性 + * @param propertyClass 属性类 + * @return List 列表 + */ + public List findPropertiesByQuery(ConditionWrapper conditionWrapper, Class documentClass, SerializableFunction property, Class propertyClass) { + return findPropertiesByQuery(conditionWrapper, documentClass, ReflectionUtil.getFieldName(property), propertyClass); + } + + /** + * 根据条件查找某个属性 + * + * @param 类型 + * @param condition 查询 + * @param documentClass 类 + * @param property 属性 + * @return List 列表 + */ + public List findPropertiesByQuery(ConditionWrapper conditionWrapper, Class documentClass, String property) { + return findPropertiesByQuery(conditionWrapper, documentClass, property, String.class); + } + + /** + * 根据条件查找某个属性 + * + * @param 类型 + * @param condition 查询 + * @param documentClass 类 + * @param property 属性 + * @return List 列表 + */ + public List findPropertiesByQuery(ConditionWrapper conditionWrapper, Class documentClass, SerializableFunction property) { + return findPropertiesByQuery(conditionWrapper, documentClass, ReflectionUtil.getFieldName(property), String.class); + } + + /** + * 根据id查找某个属性 + * + * @param 类型 + * @param condition 查询 + * @param documentClass 类 + * @param property 属性 + * @return List 列表 + */ + public List findPropertiesByIds(Collection ids, Class documentClass, String property) { + if (ids == null || ids.size() == 0) { + return new ArrayList(); + } + + ConditionAndWrapper ConditionAndWrapper = new ConditionAndWrapper(); + ConditionAndWrapper.in("id", ids); + + return findPropertiesByQuery(ConditionAndWrapper, documentClass, property, String.class); + } + + /** + * 根据id查找某个属性 + * + * @param 类型 + * @param condition 查询 + * @param documentClass 类 + * @param property 属性 + * @return List 列表 + */ + public List findPropertiesByIds(Collection ids, Class documentClass, SerializableFunction property) { + return findPropertiesByIds(ids, documentClass, ReflectionUtil.getFieldName(property)); + } + + /** + * 根据id查找某个属性 + * + * @param 类型 + * @param condition 查询 + * @param documentClass 类 + * @param property 属性 + * @return List 列表 + */ + public List findPropertiesByIds(String[] ids, Class documentClass, String property) { + return findPropertiesByIds(Arrays.asList(ids), documentClass, property); + } + + /** + * 根据id查找某个属性 + * + * @param 类型 + * @param condition 查询 + * @param documentClass 类 + * @param property 属性 + * @return List 列表 + */ + public List findPropertiesByIds(String[] ids, Class documentClass, SerializableFunction property) { + return findPropertiesByIds(Arrays.asList(ids), documentClass, ReflectionUtil.getFieldName(property)); + } + + /** + * 根据条件查找id + * + * @param query 查询 + * @param clazz 类 + * @return List 列表 + */ + public List findIdsByQuery(ConditionWrapper conditionWrapper, Class clazz) { + + return findPropertiesByQuery(conditionWrapper, clazz, "id"); + } + + /** + * 根据id集合查找 + * + * @param List ids id集合 + * @param clazz 类 + * @return List 列表 + */ + public List findListByIds(Collection ids, Class clazz) { + return findListByIds(ids, null, clazz); + } + + /** + * 根据id集合查找 + * + * @param List ids id集合 + * @param clazz 类 + * @return List 列表 + */ + public List findListByIds(String[] ids, Class clazz) { + return findListByIds(Arrays.asList(ids), null, clazz); + } + + /** + * 根据id集合查找 + * + * @param List ids id集合 + * @param clazz 类 + * @return List 列表 + */ + public List findListByIds(Collection ids, Sort sort, Class clazz) { + if (ids == null || ids.size() == 0) { + return new ArrayList(); + } + + ConditionAndWrapper ConditionAndWrapper = new ConditionAndWrapper(); + ConditionAndWrapper.in("id", ids); + + return findListByQuery(ConditionAndWrapper, sort, clazz); + } + + /** + * 根据id集合查找 + * + * @param List ids id集合 + * @param clazz 类 + * @return List 列表 + */ + public List findListByIds(String[] ids, Sort sort, Class clazz) { + return findListByIds(Arrays.asList(ids), sort, clazz); + } + + /** + * 查询全部 + * + * @param 类型 + * @param clazz 类 + * @return List 列表 + */ + public List findAll(Class clazz) { + return findAll(null, clazz); + } + + /** + * 查询全部 + * + * @param 类型 + * @param clazz 类 + * @return List 列表 + */ + public List findAll(Sort sort, Class clazz) { + return findListByQuery(null, sort, clazz); + } + + /** + * 查找全部的id + * + * @param clazz 类 + * @return List 列表 + */ + public List findAllIds(Class clazz) { + return findIdsByQuery(null, clazz); + } + + /** + * 查找数量 + * + * @param condition 查询 + * @param clazz 类 + * @return Long 数量 + */ + public Long findCountByQuery(ConditionWrapper conditionWrapper, Class clazz) { + List values = new ArrayList(); + String sql = "SELECT COUNT(*) FROM `" + StrUtil.toUnderlineCase(clazz.getSimpleName()) + "`"; + if (conditionWrapper != null && conditionWrapper.notEmpty()) { + sql += " WHERE " + conditionWrapper.build(values); + } + + logQuery(formatSql(sql), values.toArray()); + return jdbcTemplate.queryForObject(formatSql(sql), values.toArray(), Long.class); + } + + /** + * 查找全部数量 + * + * @param clazz 类 + * @return Long 数量 + */ + public Long findAllCount(Class clazz) { + return findCountByQuery(null, clazz); + } + + /** + * 获取list中对象某个属性,组成新的list + * + * @param list 列表 + * @param clazz 类 + * @param property 属性 + * @return List 列表 + */ + private List extractProperty(List list, String property, Class clazz) { + Set rs = new HashSet(); + for (Object object : list) { + Object value = ReflectUtil.getFieldValue(object, property); + if (value != null && value.getClass().equals(clazz)) { + rs.add((T) value); + } + } + + return new ArrayList(rs); + } + + /** + * Map转Bean + * + * @param + * @param queryForList + * @param clazz + * @return + */ + private List buildObjects(List> queryForList, Class clazz) { + List list = new ArrayList(); + try { + + Field[] fields = ReflectUtil.getFields(clazz); + + for (Map map : queryForList) { + Object obj = clazz.getDeclaredConstructor().newInstance(); + + for (Map.Entry entry : map.entrySet()) { + String mapKey = entry.getKey(); + Object mapValue = entry.getValue(); + + for (Field field : fields) { + if (StrUtil.toUnderlineCase(field.getName()).equals(mapKey)) { + ReflectUtil.setFieldValue(obj, field.getName(), mapValue); + break; + } + } + + } + + list.add((T) obj); + } + + } catch (Exception e) { + e.printStackTrace(); + } + + return list; + } + +} diff --git a/lib/sqlHelper/src/main/java/com/cym/sqlHelper/utils/SqlUtils.java b/lib/sqlHelper/src/main/java/com/cym/sqlHelper/utils/SqlUtils.java new file mode 100644 index 0000000..cd719e1 --- /dev/null +++ b/lib/sqlHelper/src/main/java/com/cym/sqlHelper/utils/SqlUtils.java @@ -0,0 +1,151 @@ +package com.cym.sqlHelper.utils; + +import java.util.ArrayList; +import java.util.List; +import java.util.Map; + +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.jdbc.core.JdbcTemplate; +import org.springframework.stereotype.Component; + +import cn.hutool.core.util.StrUtil; + +@Component +public class SqlUtils { + Logger logger = LoggerFactory.getLogger(this.getClass()); + + @Value("${spring.database.type}") + String database; + @Value("${spring.database.package}") + String packageName; + @Value("${spring.database.print:false}") + Boolean print; + @Autowired + JdbcTemplate jdbcTemplate; + + String separator = System.getProperty("line.separator"); + + + public String formatSql(String sql) { + if (StrUtil.isEmpty(sql)) { + return ""; + } + + if (!database.equalsIgnoreCase("mysql")) { + sql = sql.replace("`", "\""); + } + + sql = sql.replace("FROM", separator + "FROM")// + .replace("WHERE", separator + "WHERE")// + .replace("ORDER", separator + "ORDER")// + .replace("LIMIT", separator + "LIMIT")// + .replace("VALUES", separator + "VALUES");// + return sql; + } + + public void checkOrCreateTable(Class clazz) { + String sql = "CREATE TABLE IF NOT EXISTS `" + StrUtil.toUnderlineCase(clazz.getSimpleName()) + "` (id VARCHAR(32) NOT NULL PRIMARY KEY)"; + logQuery(formatSql(sql)); + jdbcTemplate.execute(formatSql(sql)); + + } + + public void logQuery(String sql) { + logQuery(sql, null); + } + + public void logQuery(String sql, Object[] params) { + if (print) { + try { + if (params != null) { + for (Object object : params) { + + if (object instanceof String) { + object = object.toString().replace("$", "RDS_CHAR_DOLLAR"); + sql = sql.replaceFirst("\\?", "'" + object + "'").replace("RDS_CHAR_DOLLAR", "$"); + } else { + sql = sql.replaceFirst("\\?", String.valueOf(object)); + } + + } + } + logger.info(separator + sql); + } catch (Exception e) { + e.printStackTrace(); + } + } + } + + + + + public void checkOrCreateIndex(Class clazz, String name, boolean unique, List> indexs) { + checkOrCreateIndex(clazz, new String[] { name }, unique, indexs); + } + + public void checkOrCreateIndex(Class clazz, String[] colums, boolean unique, List> indexs) { + List columList = new ArrayList(); + for (String colum : colums) { + columList.add(StrUtil.toUnderlineCase(colum)); + } + String name = StrUtil.join("&", columList) + "@" + StrUtil.toUnderlineCase(clazz.getSimpleName()); + + Boolean hasIndex = false; + for (Map map : indexs) { + if (StrUtil.toUnderlineCase(name).equalsIgnoreCase((String) map.get("name")) || StrUtil.toUnderlineCase(name).equalsIgnoreCase((String) map.get("Key_name"))) { + hasIndex = true; + } + } + + if (!hasIndex) { + String type = unique ? "UNIQUE INDEX" : "INDEX"; + String length = ""; + if (database.equals("mysql")) { + length = "(128)"; + } + + columList = new ArrayList(); + for (String colum : colums) { + columList.add(StrUtil.toUnderlineCase("`" + colum + "`" + length)); + } + + String sql = "CREATE " + type + " `" + StrUtil.toUnderlineCase(name) + "` ON `" + StrUtil.toUnderlineCase(clazz.getSimpleName()) + "`(" + StrUtil.join(",", columList) + ")"; + logQuery(formatSql(sql)); + jdbcTemplate.execute(formatSql(sql)); + } + + } + + public void checkOrCreateColumn(Class clazz, String name, List> columns) { + Boolean hasColumn = false; + for (Map map : columns) { + if (StrUtil.toUnderlineCase(name).equalsIgnoreCase((String) map.get("name")) || StrUtil.toUnderlineCase(name).equalsIgnoreCase((String) map.get("Field"))) { + hasColumn = true; + } + } + + if (!hasColumn) { + String sql = "ALTER TABLE `" + StrUtil.toUnderlineCase(clazz.getSimpleName()) + "` ADD COLUMN `" + StrUtil.toUnderlineCase(name) + "` TEXT"; + logQuery(formatSql(sql)); + jdbcTemplate.execute(formatSql(sql)); + } + + } + + + public void updateDefaultValue(Class clazz, String column, String value) { + String sql = "SELECT COUNT(*) FROM " + StrUtil.toUnderlineCase(clazz.getSimpleName()) + " WHERE `" + StrUtil.toUnderlineCase(column) + "` IS NULL"; + logQuery(formatSql(sql)); + Long count = jdbcTemplate.queryForObject(formatSql(sql), Long.class); + if (count > 0) { + sql = "UPDATE " + StrUtil.toUnderlineCase(clazz.getSimpleName()) + " SET `" + StrUtil.toUnderlineCase(column) + "` = ? WHERE `" + StrUtil.toUnderlineCase(column) + "` IS NULL"; + logQuery(formatSql(sql)); + jdbcTemplate.update(formatSql(sql), value); + } + + } + +} diff --git a/lib/sqlHelper/src/main/java/com/cym/sqlHelper/utils/TableUtils.java b/lib/sqlHelper/src/main/java/com/cym/sqlHelper/utils/TableUtils.java new file mode 100644 index 0000000..7471172 --- /dev/null +++ b/lib/sqlHelper/src/main/java/com/cym/sqlHelper/utils/TableUtils.java @@ -0,0 +1,107 @@ +package com.cym.sqlHelper.utils; + +import java.lang.reflect.Field; +import java.util.List; +import java.util.Map; + +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.jdbc.core.JdbcTemplate; +import org.springframework.stereotype.Component; + +import com.cym.sqlHelper.config.CompositeIndex; +import com.cym.sqlHelper.config.InitValue; +import com.cym.sqlHelper.config.SingleIndex; +import com.cym.sqlHelper.config.Table; + +import cn.hutool.core.util.ReflectUtil; +import cn.hutool.core.util.StrUtil; + +@Component +public class TableUtils { + Logger logger = LoggerFactory.getLogger(this.getClass()); + + @Value("${spring.database.type}") + String database; + @Value("${spring.database.package}") + String packageName; + @Autowired + JdbcTemplate jdbcTemplate; + @Autowired + SqlUtils sqlUtils; + + + public void initTable(Class clazz) { + Table table = clazz.getAnnotation(Table.class); + if (table != null) { + // 创建表 + sqlUtils.checkOrCreateTable(clazz); + + // 获取表所有字段 + String sql = ""; + if (database.equals("sqlite")) { + sql = "PRAGMA TABLE_INFO(`" + StrUtil.toUnderlineCase(clazz.getSimpleName()) + "`)"; + } else if (database.equals("mysql")) { + sql = "SHOW COLUMNS FROM `" + StrUtil.toUnderlineCase(clazz.getSimpleName()) + "`"; + } else if (database.equals("postgresql")) { + sql = "SELECT column_name as name FROM information_schema.columns " + // + "WHERE table_schema='public' AND table_name='" + StrUtil.toUnderlineCase(clazz.getSimpleName()) + "'"; + } + sqlUtils.logQuery(sqlUtils.formatSql(sql)); + List> columns = jdbcTemplate.queryForList(sqlUtils.formatSql(sql)); + + // 获取表所有索引 + if (database.equals("sqlite")) { + sql = "PRAGMA INDEX_LIST(`" + StrUtil.toUnderlineCase(clazz.getSimpleName()) + "`)"; + } else if (database.equals("mysql")) { + sql = "SHOW INDEX FROM `" + StrUtil.toUnderlineCase(clazz.getSimpleName()) + "`"; + } else if (database.equals("postgresql")) { + sql = "SELECT " + // + "A.INDEXNAME as name " + // + "FROM PG_AM B " + // + "LEFT JOIN PG_CLASS F ON B.OID = F.RELAM " + // + "LEFT JOIN PG_STAT_ALL_INDEXES E ON F.OID = E.INDEXRELID " + // + "LEFT JOIN PG_INDEX C ON E.INDEXRELID = C.INDEXRELID " + // + "LEFT OUTER JOIN PG_DESCRIPTION D ON C.INDEXRELID = D.OBJOID, " + // + "PG_INDEXES A " + // + "WHERE " + // + "A.SCHEMANAME = E.SCHEMANAME AND A.TABLENAME = E.RELNAME AND A.INDEXNAME = E.INDEXRELNAME " + // + "AND E.SCHEMANAME = 'public' AND E.RELNAME = '" + StrUtil.toUnderlineCase(clazz.getSimpleName()) + "' ";// + } + sqlUtils.logQuery(sqlUtils.formatSql(sql)); + List> indexs = jdbcTemplate.queryForList(sqlUtils.formatSql(sql)); + + // 建立字段 + Field[] fields = ReflectUtil.getFields(clazz); + for (Field field : fields) { + // 创建字段 + if (!field.getName().equals("id")) { + sqlUtils.checkOrCreateColumn(clazz, field.getName(), columns); + } + + // 创建索引 + if (field.isAnnotationPresent(SingleIndex.class)) { + SingleIndex singleIndex = field.getAnnotation(SingleIndex.class); + sqlUtils.checkOrCreateIndex(clazz, field.getName(), singleIndex.unique(), indexs); + } + + // 更新表默认值 + if (field.isAnnotationPresent(InitValue.class)) { + InitValue defaultValue = field.getAnnotation(InitValue.class); + if (defaultValue.value() != null) { + sqlUtils.updateDefaultValue(clazz, field.getName(), defaultValue.value()); + } + } + } + + // 获取组合索引 + if (clazz.isAnnotationPresent(CompositeIndex.class)) { + CompositeIndex compositeIndex = clazz.getAnnotation(CompositeIndex.class); + sqlUtils.checkOrCreateIndex(clazz, compositeIndex.colums(), compositeIndex.unique(), indexs); + } + } + } + +} diff --git a/lib/sqlHelper/src/test/java/cn/craccd/test/Test.java b/lib/sqlHelper/src/test/java/cn/craccd/test/Test.java new file mode 100644 index 0000000..2675041 --- /dev/null +++ b/lib/sqlHelper/src/test/java/cn/craccd/test/Test.java @@ -0,0 +1 @@ +package cn.craccd.test; \ No newline at end of file