支持通用查询映射转换

veasion · veasion · commit 8a1ce0e8e8ee · 2021-12-16T10:14:50.000+08:00
diff --git a/src/main/java/cn/veasion/db/criteria/AutoCriteria.java b/src/main/java/cn/veasion/db/criteria/AutoCriteria.java
@@ -0,0 +1,39 @@
+package cn.veasion.db.criteria;
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.Target;
+
+import static java.lang.annotation.ElementType.FIELD;
+import static java.lang.annotation.RetentionPolicy.RUNTIME;
+
+/**
+ * 自动动态查询（约定规则）
+ * <pre>
+ *    注解建议使用在字段类型为 Map 上，key 为字段名称（前端传），value 为值 （前端传）;
+ *    为防止存在SQL注入 key 正则匹配 [_0-9a-zA-Z]+ 才会生效。
+ *    约定规则一：value 数值、字符串等基础类型统一 Operator.EQ 处理
+ *    约定规则二：value 字符串类型前缀为 % 后缀为 % 全模糊，前缀 % 走左模糊，后缀 % 走右模糊
+ *    约定规则三：value 为集合、数组类型走 Operator.IN
+ *    约定规则四：key 以 start_ 开头走 Operator.GTE，如 start_createTime 走 createTime >= value
+ *    约定规则五：key 以 end_ 开头走 Operator.LTE，如 end_createTime 走 createTime <= value
+ *    约定规则六：日期类型自动转 yyyy-MM-dd HH:mm:ss 字符串
+ * </pre>
+ *
+ * @author luozhuowei
+ * @date 2021/12/15
+ */
+@Target(FIELD)
+@Retention(RUNTIME)
+public @interface AutoCriteria {
+
+    /**
+     * 是否跳过空值，如空字符串、空集合、空数组等（默认跳过）
+     */
+    boolean skipEmpty() default true;
+
+    /**
+     * 关联类，触发动态关联（默认当前操作实体类）
+     */
+    Class<?> relation() default Void.class;
+
+}
diff --git a/src/main/java/cn/veasion/db/criteria/QueryCriteriaConvert.java b/src/main/java/cn/veasion/db/criteria/QueryCriteriaConvert.java
@@ -10,14 +10,17 @@
 import cn.veasion.db.utils.FieldUtils;
 
 import java.lang.reflect.Field;
+import java.text.SimpleDateFormat;
 import java.util.Arrays;
 import java.util.Collection;
+import java.util.Date;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.Iterator;
 import java.util.Map;
 import java.util.Objects;
 import java.util.Set;
+import java.util.regex.Pattern;
 
 /**
  * QueryCriteriaConvert
@@ -27,6 +30,8 @@
  */
 public class QueryCriteriaConvert {
 
+    public static final Pattern FIELD_PATTERN = Pattern.compile("[_0-9a-zA-Z]+");
+
     private Object object;
     private EntityQuery query;
     private JoinCriteria[] array;
@@ -69,6 +74,7 @@ public Map<Class<?>, EntityQuery> getJoinClassMap() {
         return joinClassMap;
     }
 
+    @SuppressWarnings("unchecked")
     private void handleFilters() {
         JoinCriteriaMulti joinCriteriaMulti = object.getClass().getAnnotation(JoinCriteriaMulti.class);
         if (joinCriteriaMulti != null) {
@@ -77,53 +83,100 @@ private void handleFilters() {
         initJoinClassMap();
         Map<String, Field> fields = FieldUtils.fields(object.getClass());
         for (Field field : fields.values()) {
-            QueryCriteria annotation = field.getAnnotation(QueryCriteria.class);
-            if (annotation == null) {
+            QueryCriteria queryCriteria = field.getAnnotation(QueryCriteria.class);
+            AutoCriteria autoCriteria = field.getAnnotation(AutoCriteria.class);
+            if (queryCriteria == null && autoCriteria == null) {
                 continue;
             }
             Object value = FieldUtils.getValue(object, field.getName(), true);
             if (value == null) {
                 continue;
             }
-            boolean skipEmpty = annotation.skipEmpty();
-            if (skipEmpty) {
-                if (value instanceof String && "".equals(value)) {
-                    continue;
-                } else if (value instanceof Collection && ((Collection<?>) value).isEmpty()) {
-                    continue;
-                } else if (value instanceof Object[] && ((Object[]) value).length == 0) {
-                    continue;
-                }
+            if (queryCriteria != null) {
+                handleQueryCriteria(field, queryCriteria, value);
+            } else if (value instanceof Map) {
+                handleAutoCriteria(autoCriteria, (Map<String, Object>) value);
+            } else {
+                handleAutoCriteria(autoCriteria, new HashMap<String, Object>() {{
+                    put(field.getName(), value);
+                }});
             }
-            String fieldName = "".equals(annotation.field()) ? field.getName() : annotation.field();
-            Operator operator = annotation.value();
-            Class<?> relationClass = annotation.relation();
+        }
+    }
 
+    private void handleAutoCriteria(AutoCriteria annotation, Map<String, Object> filters) {
+        Class<?> relationClass = annotation.relation();
+        for (Map.Entry<String, Object> entry : filters.entrySet()) {
+            String key = entry.getKey();
+            Object value = entry.getValue();
+            if (value == null) {
+                continue;
+            }
+            if (annotation.skipEmpty() && isEmpty(value)) {
+                return;
+            }
+            if (!FIELD_PATTERN.matcher(key).matches()) {
+                throw new FilterException("非法字段：" + key);
+            }
             if (relationClass != Void.class) {
                 checkJoin(relationClass);
             }
+            Operator operator = Operator.EQ;
+            if (value instanceof Collection || value instanceof Object[]) {
+                operator = Operator.IN;
+            } else if (key.startsWith("start_")) {
+                key = key.substring(6);
+                operator = Operator.GTE;
+            } else if (key.startsWith("end_")) {
+                key = key.substring(4);
+                operator = Operator.LTE;
+            } else if (value instanceof String &&
+                    (String.valueOf(value).startsWith("%") || String.valueOf(value).endsWith("%"))) {
+                operator = Operator.LIKE;
+            }
+            if (value instanceof Date) {
+                value = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format((Date) value);
+            }
+            Filter filter = getFilter(key, operator, value);
+            if (relationClass != Void.class) {
+                filter.fieldAs(joinClassMap.get(relationClass).getTableAs());
+            }
+            query.addFilter(filter);
+        }
+    }
 
-            String[] orFields = annotation.orFields();
-            if (orFields.length > 0) {
-                query.addFilter(Filter.leftBracket());
-                for (int i = 0; i < orFields.length; i++) {
-                    Filter filter = getFilter(orFields[i], operator, value);
-                    if (relationClass != Void.class) {
-                        filter.fieldAs(joinClassMap.get(relationClass).getTableAs());
-                    }
-                    query.addFilter(filter);
-                    if (i < orFields.length - 1) {
-                        query.addFilter(Filter.or());
-                    }
-                }
-                query.addFilter(Filter.rightBracket());
-            } else {
-                Filter filter = getFilter(fieldName, operator, value);
+    private void handleQueryCriteria(Field field, QueryCriteria annotation, Object value) {
+        if (annotation.skipEmpty() && isEmpty(value)) {
+            return;
+        }
+        String fieldName = "".equals(annotation.field()) ? field.getName() : annotation.field();
+        Operator operator = annotation.value();
+        Class<?> relationClass = annotation.relation();
+
+        if (relationClass != Void.class) {
+            checkJoin(relationClass);
+        }
+
+        String[] orFields = annotation.orFields();
+        if (orFields.length > 0) {
+            query.addFilter(Filter.leftBracket());
+            for (int i = 0; i < orFields.length; i++) {
+                Filter filter = getFilter(orFields[i], operator, value);
                 if (relationClass != Void.class) {
                     filter.fieldAs(joinClassMap.get(relationClass).getTableAs());
                 }
                 query.addFilter(filter);
+                if (i < orFields.length - 1) {
+                    query.addFilter(Filter.or());
+                }
             }
+            query.addFilter(Filter.rightBracket());
+        } else {
+            Filter filter = getFilter(fieldName, operator, value);
+            if (relationClass != Void.class) {
+                filter.fieldAs(joinClassMap.get(relationClass).getTableAs());
+            }
+            query.addFilter(filter);
         }
     }
 
@@ -170,6 +223,20 @@ private void checkJoin(Class<?> joinClass) {
         } while (joinClass != Void.class && !joined.contains(joinClass));
     }
 
+    private boolean isEmpty(Object value) {
+        if (value == null) {
+            return true;
+        }
+        if (value instanceof String && "".equals(value)) {
+            return true;
+        } else if (value instanceof Collection && ((Collection<?>) value).isEmpty()) {
+            return true;
+        } else if (value instanceof Object[] && ((Object[]) value).length == 0) {
+            return true;
+        }
+        return false;
+    }
+
     public static Filter getFilter(String field, Operator operator, Object value) {
         if (Operator.EQ.equals(operator)) {
             return Filter.eq(field, value);
@@ -200,6 +267,16 @@ public static Filter getFilter(String field, Operator operator, Object value) {
                 throw new FilterException(field + " 字段 Operator.IN 类型必须是集合或者数组");
             }
         } else if (Operator.LIKE.equals(operator)) {
+            if (value instanceof String) {
+                String str = (String) value;
+                if (str.startsWith("%") && str.endsWith("%")) {
+                    return Filter.like(field, str.substring(1, str.length() - 1));
+                } else if (str.startsWith("%")) {
+                    return Filter.likeLeft(field, str.substring(1));
+                } else if (str.endsWith("%")) {
+                    return Filter.likeRight(field, str.substring(0, str.length() - 1));
+                }
+            }
             return Filter.like(field, value);
         } else if (Operator.BETWEEN.equals(operator)) {
             if (value instanceof Collection) {
diff --git a/src/test/java/cn/veasion/db/criteria/QueryCriteriaTest.java b/src/test/java/cn/veasion/db/criteria/QueryCriteriaTest.java
@@ -7,6 +7,7 @@
 import cn.veasion.db.query.EntityQuery;
 
 import java.util.Arrays;
+import java.util.HashMap;
 
 /**
  * QueryCriteriaTest
@@ -49,6 +50,29 @@ public static void main(String[] args) {
         student.setSnoOrName("熊");
         queryList(student);
 
+        // 根据班级id区间查询
+        student = new StudentInVO();
+        student.setFilters(new HashMap<String, Object>() {{
+            put("start_classId", 1);
+            put("end_classId", 10);
+        }});
+        queryList(student);
+
+        // 根据班级id区间查询（关联班级）
+        student = new StudentInVO();
+        student.setClassFilters(new HashMap<String, Object>() {{
+            put("start_id", 1);
+            put("end_id", 10);
+        }});
+        queryList(student);
+
+        // 根据老师名称模糊查询（关联班级）
+        student = new StudentInVO();
+        student.setTeacherFilters(new HashMap<String, Object>() {{
+            put("name", "罗%");
+        }});
+        queryList(student);
+
     }
 
     private static void queryList(StudentInVO student) {
diff --git a/src/test/java/cn/veasion/db/criteria/StudentInVO.java b/src/test/java/cn/veasion/db/criteria/StudentInVO.java
@@ -5,6 +5,7 @@
 import cn.veasion.db.model.po.TeacherPO;
 
 import java.util.List;
+import java.util.Map;
 
 /**
  * StudentInVO
@@ -18,6 +19,7 @@
 })
 public class StudentInVO {
 
+    // 简单字段查询映射
     @QueryCriteria
     private String sno;
     @QueryCriteria(value = Operator.IN, field = "id")
@@ -35,6 +37,14 @@ public class StudentInVO {
     @QueryCriteria(value = Operator.LIKE, field = "name", relation = TeacherPO.class)
     private String teacherName;
 
+    // 通用查询映射
+    @AutoCriteria
+    private Map<String, Object> filters;
+    @AutoCriteria(relation = ClassesPO.class)
+    private Map<String, Object> classFilters;
+    @AutoCriteria(relation = TeacherPO.class)
+    private Map<String, Object> teacherFilters;
+
     public String getSno() {
         return sno;
     }
@@ -98,5 +108,29 @@ public String getTeacherName() {
     public void setTeacherName(String teacherName) {
         this.teacherName = teacherName;
     }
+
+    public Map<String, Object> getFilters() {
+        return filters;
+    }
+
+    public void setFilters(Map<String, Object> filters) {
+        this.filters = filters;
+    }
+
+    public Map<String, Object> getClassFilters() {
+        return classFilters;
+    }
+
+    public void setClassFilters(Map<String, Object> classFilters) {
+        this.classFilters = classFilters;
+    }
+
+    public Map<String, Object> getTeacherFilters() {
+        return teacherFilters;
+    }
+
+    public void setTeacherFilters(Map<String, Object> teacherFilters) {
+        this.teacherFilters = teacherFilters;
+    }
 }
 
