mongodb工具方法，日志部分使用mongo

modules/i3plus-pojo-base/pom.xml

@@ -27,6 +27,10 @@
             <groupId>org.apache.commons</groupId>
             <artifactId>commons-lang3</artifactId>
         </dependency>
+        <dependency>
+            <groupId>com.alibaba</groupId>
+            <artifactId>fastjson</artifactId>
+        </dependency>
 
     </dependencies>
 

modules/i3plus-pojo-base/src/main/java/cn/estsh/i3plus/pojo/base/jpa/dao/BaseMongoRepository.java

@@ -0,0 +1,50 @@
+package cn.estsh.i3plus.pojo.base.jpa.dao;
+
+import cn.estsh.i3plus.pojo.base.common.Pager;
+import org.bson.conversions.Bson;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.data.mongodb.repository.MongoRepository;
+import org.springframework.data.repository.NoRepositoryBean;
+
+import java.io.Serializable;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * @Description : 自定义Repository的方法接口
+ * @Reference : MongoRepository
+ * @Author : alwaysfrin
+ * @CreateDate : 2018-09-13 10:34
+ * @Modify:
+ **/
+@NoRepositoryBean
+public interface BaseMongoRepository<T, ID extends Serializable> extends MongoRepository<T, ID> {
+
+    T getById(long id);
+
+    List<T> findByProperty(String propertyName, Object value);
+
+    List<T> findByProperty(String propertyName, Object value,String orderByParam, int ascOrDesc);
+
+    List<T> findByPropertyLike(String propertyName, Object value);
+
+    List<T> findByPropertyLike(String propertyName, Object value,String orderByParam, int ascOrDesc);
+
+    T getByProperty(String propertyName, Object value);
+
+    List<T> findByBson(Bson bson);
+
+    List<T> findByBson(Bson bson,String orderByParam, int ascOrDesc);
+
+    long findByBsonCount(Bson bson);
+
+    List<T> findByBsonPager(Bson bson,Pager pager);
+
+    List<T> findByBsonPager(Bson bson,Pager pager,String orderByParam, int ascOrDesc);
+
+    long listCount();
+
+    List<T> listPager(Pager pager);
+
+    List<T> listPager(Pager pager,String orderByParam, int ascOrDesc);
+}

modules/i3plus-pojo-base/src/main/java/cn/estsh/i3plus/pojo/base/jpa/daoimpl/BaseMongoRepositoryImpl.java

@@ -0,0 +1,286 @@
+package cn.estsh.i3plus.pojo.base.jpa.daoimpl;
+
+import cn.estsh.i3plus.pojo.base.common.Pager;
+import cn.estsh.i3plus.pojo.base.enumutil.CommonEnumUtil;
+import cn.estsh.i3plus.pojo.base.jpa.dao.BaseMongoRepository;
+import cn.estsh.i3plus.pojo.base.tool.SnowflakeIdMaker;
+import com.alibaba.fastjson.JSONObject;
+import com.mongodb.Block;
+import com.mongodb.client.FindIterable;
+import com.mongodb.client.model.Filters;
+import com.mongodb.client.model.Sorts;
+import org.apache.commons.lang3.StringUtils;
+import org.bson.Document;
+import org.bson.conversions.Bson;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.data.mapping.context.MappingContext;
+import org.springframework.data.mongodb.core.MongoOperations;
+import org.springframework.data.mongodb.core.mapping.MongoPersistentEntity;
+import org.springframework.data.mongodb.core.mapping.MongoPersistentProperty;
+import org.springframework.data.mongodb.repository.query.MongoEntityInformation;
+import org.springframework.data.mongodb.repository.support.SimpleMongoRepository;
+
+import javax.persistence.Id;
+import java.io.Serializable;
+import java.lang.reflect.Field;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Optional;
+import java.util.UUID;
+
+/**
+ * @Description : 自定义mongodb持久化接口实现
+ * @Reference :
+ * @Author : alwaysfrin
+ * @CreateDate : 2018-09-13 11:24
+ * @Modify:
+ **/
+public class BaseMongoRepositoryImpl<T, ID extends Serializable> extends SimpleMongoRepository<T, ID>
+                                                            implements BaseMongoRepository<T, ID> {
+    public static final Logger LOGGER = LoggerFactory.getLogger(BaseMongoRepositoryImpl.class);
+
+    /**
+     * 持久化上下文
+     */
+    private final MongoOperations mongoOperations;
+    private final MongoEntityInformation<T, ID> entityInformation;
+    private final MappingContext<? extends MongoPersistentEntity<?>, MongoPersistentProperty> mongoContext;
+    private final Class<T> entityClass;
+
+    public BaseMongoRepositoryImpl(MongoEntityInformation<T, ID> metadata, MongoOperations mongoOperations) {
+        super(metadata, mongoOperations);
+        this.entityInformation = metadata;
+        this.mongoOperations = mongoOperations;
+        this.entityClass = this.entityInformation.getJavaType();
+        mongoContext = mongoOperations.getConverter().getMappingContext();
+    }
+
+    /**
+     * 重写新增方法
+     * @param entity
+     * @param <S>
+     * @return
+     */
+    @Override
+    public <S extends T> S insert(S entity) {
+        innerSave(entity);
+        return entity;
+    }
+
+    /**
+     * 保存对象
+     * @param item 保存对象
+     * @return
+     */
+    private T innerSave(T item) {
+        try {
+            if(item==null)return null;
+            Class<?> clazz = item.getClass();
+
+            //获取主键
+            Field idField = clazz.getField("id");
+            if(idField == null){
+                idField = clazz.getField("primaryKey");
+            }
+            if(idField == null){
+                // 遍历所有属性，以@Id声明确认主键
+                Field[] fields = clazz.getFields();
+                for(Field f : fields){
+                    if(f.getAnnotation(Id.class) != null){
+                        idField = f;
+                        break;
+                    }
+                }
+            }
+
+            if(idField != null){
+                Class<?> type = idField.getType();
+                Object val = idField.get(item);
+                if((type == long.class || type == Long.class) && (val == null || Long.parseLong(val.toString()) == 0)){
+                    // long类型主键，以snowflake为主键
+                    idField.set(item, new SnowflakeIdMaker().nextId());
+                } else if(type == String.class && (val==null || "".equals(val))){
+                    // String类型主键，以UUID为主键
+                    idField.set(item, UUID.randomUUID().toString().replace("-", "").toLowerCase());
+                }
+            }
+
+            this.mongoOperations.insert(item, this.entityInformation.getCollectionName());
+            if(idField!=null){
+                return item;
+            }else {
+                return null;
+            }
+        } catch (Exception e) {
+            e.printStackTrace();
+            throw new RuntimeException(e);
+        }
+    }
+
+    @Override
+    public Optional<T> findById(ID id) {
+        T entity = this.mongoOperations.findById(id, this.entityInformation.getJavaType(), this.entityInformation.getCollectionName());
+
+        if(entity != null) {
+            return Optional.of(entity);
+        }else{
+            return null;
+        }
+    }
+
+    @Override
+    public T getById(long id) {
+        return this.mongoOperations.findById(id, this.entityInformation.getJavaType(), this.entityInformation.getCollectionName());
+    }
+
+    @Override
+    public List<T> findByProperty(String propertyName, Object value) {
+        return findByProperty(propertyName,value,null,0);
+    }
+
+    @Override
+    public List<T> findByProperty(String propertyName, Object value, String orderByParam, int ascOrDesc) {
+        Bson bson = Filters.and(
+                Filters.eq(propertyName, value)
+        );
+
+        return findByBson(bson,orderByParam,ascOrDesc);
+    }
+
+    @Override
+    public List<T> findByPropertyLike(String propertyName, Object value) {
+        return findByPropertyLike(propertyName,value,null,0);
+    }
+
+    @Override
+    public List<T> findByPropertyLike(String propertyName, Object value, String orderByParam, int ascOrDesc) {
+        Bson bson = Filters.and(
+                Filters.regex(propertyName, value.toString())
+        );
+
+        return findByBson(bson,orderByParam,ascOrDesc);
+    }
+
+    @Override
+    public T getByProperty(String propertyName, Object value) {
+        List<T> tList = this.findByProperty(propertyName,value);
+        if(tList.size() > 0){
+            return tList.iterator().next();
+        }else{
+            return null;
+        }
+    }
+
+    /**
+     * 根据bson查询
+     * @param bson
+     * @return
+     */
+    public List<T> findByBson(Bson bson) {
+        return findByBson(bson,null,0);
+    }
+
+    @Override
+    public List<T> findByBson(Bson bson, String orderByParam, int ascOrDesc) {
+        List<Document> dList = new ArrayList<>();
+        Block<Document> saveBlock = new Block<Document>() {
+            @Override
+            public void apply(final Document document) {
+                dList.add(document);
+            }
+        };
+
+        FindIterable findIter = mongoOperations.getCollection(this.entityInformation.getCollectionName()).find(bson);
+        if(StringUtils.isNotBlank(orderByParam) && ascOrDesc != 0){
+            //排序
+            if(ascOrDesc == CommonEnumUtil.ASC_OR_DESC.ASC.getValue()){
+                findIter.sort(Sorts.ascending(orderByParam));
+            }else{
+                findIter.sort(Sorts.descending(orderByParam));
+            }
+        }
+        findIter.forEach(saveBlock);
+
+        return packObjectListFromDocument(dList);
+    }
+
+    @Override
+    public long findByBsonCount(Bson bson) {
+        return mongoOperations.getCollection(this.entityInformation.getCollectionName()).count(bson);
+    }
+
+    private List<T> packObjectListFromDocument(List<Document> dList) {
+        //将获取的document转为对象
+        List<T> resultList = new ArrayList<>();
+        for(Document d : dList){
+            resultList.add(JSONObject.parseObject(d.toJson(), entityClass));
+        }
+
+        return resultList;
+    }
+
+    @Override
+    public List<T> findByBsonPager(Bson bson, Pager pager) {
+        return findByBsonPager(bson,pager,null,0);
+    }
+
+    @Override
+    public List<T> findByBsonPager(Bson bson, Pager pager, String orderByParam, int ascOrDesc) {
+        List<Document> dList = new ArrayList<>();
+        Block<Document> saveBlock = new Block<Document>() {
+            @Override
+            public void apply(final Document document) {
+                dList.add(document);
+            }
+        };
+
+        FindIterable findIter = mongoOperations.getCollection(this.entityInformation.getCollectionName()).find(bson)
+                .skip(pager.getStartRow())
+                .limit(pager.getPageSize());
+        if(StringUtils.isNotBlank(orderByParam) && ascOrDesc != 0){
+            //排序
+            if(ascOrDesc == CommonEnumUtil.ASC_OR_DESC.ASC.getValue()){
+                findIter.sort(Sorts.ascending(orderByParam));
+            }else{
+                findIter.sort(Sorts.descending(orderByParam));
+            }
+        }
+        findIter.forEach(saveBlock);
+        return packObjectListFromDocument(dList);
+    }
+
+    @Override
+    public long listCount() {
+        return mongoOperations.getCollection(this.entityInformation.getCollectionName()).count();
+    }
+
+    @Override
+    public List<T> listPager(Pager pager) {
+        return listPager(pager,null,0);
+    }
+
+    @Override
+    public List<T> listPager(Pager pager, String orderByParam, int ascOrDesc) {
+        List<Document> dList = new ArrayList<>();
+        Block<Document> saveBlock = new Block<Document>() {
+            @Override
+            public void apply(final Document document) {
+                dList.add(document);
+            }
+        };
+        FindIterable findIter = mongoOperations.getCollection(this.entityInformation.getCollectionName()).find()
+                .skip(pager.getStartRow())
+                .limit(pager.getPageSize());
+        if(StringUtils.isNotBlank(orderByParam) && ascOrDesc != 0){
+            //排序
+            if(ascOrDesc == CommonEnumUtil.ASC_OR_DESC.ASC.getValue()){
+                findIter.sort(Sorts.ascending(orderByParam));
+            }else{
+                findIter.sort(Sorts.descending(orderByParam));
+            }
+        }
+        findIter.forEach(saveBlock);
+        return packObjectListFromDocument(dList);
+    }
+}

modules/i3plus-pojo-base/src/main/java/cn/estsh/i3plus/pojo/base/jpa/daoimpl/BaseRepositoryImpl.java

@@ -21,8 +21,8 @@ import java.util.*;
  * @CreateDate : 2018-09-13 11:24
  * @Modify:
  **/
-public class BaseRepositoryImpl<T, ID extends Serializable> extends SimpleJpaRepository<T, Serializable>
+public class BaseRepositoryImpl<T, ID extends Serializable> extends SimpleJpaRepository<T, ID>
-                                                            implements BaseRepository<T, Serializable> {
+                                                            implements BaseRepository<T, ID> {
     public static final Logger LOGGER = LoggerFactory.getLogger(BaseRepositoryImpl.class);
 
     /**

modules/i3plus-pojo-base/src/main/java/cn/estsh/i3plus/pojo/base/jpa/factory/BaseMongoRepositoryFactoryBean.java

@@ -0,0 +1,63 @@
+package cn.estsh.i3plus.pojo.base.jpa.factory;
+
+import cn.estsh.i3plus.pojo.base.jpa.daoimpl.BaseMongoRepositoryImpl;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.data.mongodb.core.MongoOperations;
+import org.springframework.data.mongodb.repository.MongoRepository;
+import org.springframework.data.mongodb.repository.query.MongoEntityInformation;
+import org.springframework.data.mongodb.repository.support.MongoRepositoryFactory;
+import org.springframework.data.mongodb.repository.support.MongoRepositoryFactoryBean;
+import org.springframework.data.repository.core.RepositoryInformation;
+import org.springframework.data.repository.core.RepositoryMetadata;
+import org.springframework.data.repository.core.support.RepositoryFactorySupport;
+
+import java.io.Serializable;
+
+/**
+ * @Description : 自定义mongodb持久化工厂类
+ * @Reference :
+ * @Author : alwaysfrin
+ * @CreateDate : 2018-09-13 14:55
+ * @Modify:
+ **/
+public class BaseMongoRepositoryFactoryBean<R extends MongoRepository<T, I>, T, I extends Serializable> extends MongoRepositoryFactoryBean<R, T, I> {
+    public static final Logger LOGGER = LoggerFactory.getLogger(BaseMongoRepositoryFactoryBean.class);
+
+    public BaseMongoRepositoryFactoryBean(Class<? extends R> repositoryInterface) {
+        super(repositoryInterface);
+    }
+
+    @Override
+    protected RepositoryFactorySupport getFactoryInstance(MongoOperations operations) {
+        //LOGGER.info("【初始mongo持久仓】");
+        //生成持久mongo仓库实例
+        return new BaseMongoRepositoryFactory(operations);
+    }
+
+    //创建一个内部类，该类不用在外部访问
+    private static class BaseMongoRepositoryFactory<T, I extends Serializable> extends MongoRepositoryFactory {
+
+        private final MongoOperations mongoOperations;
+        //private final MappingContext<? extends MongoPersistentEntity<?>, MongoPersistentProperty> mappingContext;
+
+        public BaseMongoRepositoryFactory(MongoOperations mongoOperations) {
+            super(mongoOperations);
+            this.mongoOperations = mongoOperations;
+            //this.mappingContext = mongoOperations.getConverter().getMappingContext();
+        }
+
+        //设置具体的实现类是BaseRepositoryImpl
+        @Override
+        protected Object getTargetRepository(RepositoryInformation information) {
+            MongoEntityInformation<?, Serializable> entityInformation = getEntityInformation(information.getDomainType());
+            return new BaseMongoRepositoryImpl(entityInformation, mongoOperations);
+        }
+
+        //设置具体的实现类的class
+        @Override
+        protected Class<?> getRepositoryBaseClass(RepositoryMetadata metadata) {
+            return BaseMongoRepositoryImpl.class;
+        }
+    }
+}

modules/i3plus-pojo-base/src/main/java/cn/estsh/i3plus/pojo/base/jpa/factory/BaseRepositoryFactoryBean.java

@@ -1,6 +1,8 @@
 package cn.estsh.i3plus.pojo.base.jpa.factory;
 
 import cn.estsh.i3plus.pojo.base.jpa.daoimpl.BaseRepositoryImpl;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 import org.springframework.data.jpa.repository.JpaRepository;
 import org.springframework.data.jpa.repository.support.JpaRepositoryFactory;
 import org.springframework.data.jpa.repository.support.JpaRepositoryFactoryBean;
@@ -19,6 +21,7 @@ import java.io.Serializable;
  * @Modify:
  **/
 public class BaseRepositoryFactoryBean<R extends JpaRepository<T, I>, T, I extends Serializable> extends JpaRepositoryFactoryBean<R, T, I> {
+    public static final Logger LOGGER = LoggerFactory.getLogger(BaseRepositoryFactoryBean.class);
 
     public BaseRepositoryFactoryBean(Class<? extends R> repositoryInterface) {
         super(repositoryInterface);
@@ -26,6 +29,7 @@ public class BaseRepositoryFactoryBean<R extends JpaRepository<T, I>, T, I exten
 
     @Override
     protected RepositoryFactorySupport createRepositoryFactory(EntityManager em) {
+        //LOGGER.info("【初始JPA持久仓】");
         return new BaseRepositoryFactory(em);
     }
 

modules/i3plus-pojo-base/src/main/java/cn/estsh/i3plus/pojo/base/tool/BsonPackTool.java

@@ -0,0 +1,586 @@
+package cn.estsh.i3plus.pojo.base.tool;
+
+import cn.estsh.i3plus.pojo.base.enumutil.CommonEnumUtil;
+import com.alibaba.fastjson.JSONObject;
+import com.mongodb.Block;
+import com.mongodb.client.MongoCollection;
+import com.mongodb.client.model.Filters;
+import com.mongodb.client.model.Sorts;
+import org.bson.Document;
+import org.bson.conversions.Bson;
+import org.springframework.data.mongodb.core.MongoOperations;
+
+import java.text.SimpleDateFormat;
+import java.util.ArrayList;
+import java.util.Date;
+import java.util.List;
+
+/**
+ * @Description :
+ * @Reference :
+ * @Author : alwaysfrin
+ * @CreateDate : 2018-11-01 16:26
+ * @Modify:
+ *
+ * (>) 大于 - $gt
+ * (<) 小于 - $lt
+ * (>=) 大于等于 - $gte
+ * (<= ) 小于等于 - $lte
+ *  $ne ----------- not equal  !=
+ *   $eq  --------  equal  =
+ *
+ *   查询 title 包含"库"字的文档：
+ *   db.col.find({title:/库/})
+ *
+ *   查询 title 字段以"教"字开头的文档：
+ *   db.col.find({title:/^库/})
+ *
+ *   查询 titl e字段以"教"字结尾的文档：
+ *   db.col.find({title:/库$/})
+ **/
+public class BsonPackTool {
+
+    /**
+     * 防止sql注入
+     * @param data
+     * @return
+     */
+    public static String getSafeParam(Object data){
+        return data.toString().replaceAll(";","")
+                .replaceAll("'","")
+                .replaceAll("\"","")
+                .replaceAll("/","")
+                .replaceAll("\\\\","")
+                .replaceAll("delete","")
+                .replaceAll("update","")
+                .replaceAll("insert","");
+    }
+
+    /**
+     * 单页查询，获取查询document结果集合
+     * @param mongoOperations
+     * @param tableName 查询的表名
+     * @param bson 查询条件
+     * @param skip 忽略的条数
+     * @param limit 查询的条数
+     * @return document结果集合
+     */
+    public static List<Document> query(MongoOperations mongoOperations, String tableName, Bson bson, int skip, int limit) {
+        List<Document> newLins = new ArrayList<>();
+        Block<Document> saveBlock = new Block<Document>() {
+            @Override
+            public void apply(final Document document) {
+                newLins.add(document);
+            }
+        };
+
+        //查询
+        MongoCollection<Document> collection = mongoOperations.getCollection(tableName);
+        collection.find(bson).skip(skip).limit(limit).forEach(saveBlock);
+        collection.count(bson);
+
+        return newLins;
+    }
+
+    /**
+     * 分页查询
+     * @param mongoOperations
+     * @param tableName 表名
+     * @param bson 查询条件
+     * @param pageSize 单页查询条数
+     * @return 查询结果集合
+     */
+    public static List<Document> queryPages(MongoOperations mongoOperations, String tableName, Bson bson, int pageSize) {
+        //分页查询
+        List<Document> list = new ArrayList<>();
+        long count = mongoOperations.getCollection(tableName).count(bson);
+        int loops = (int)((count + pageSize - 1) / pageSize);
+        for(int i = 0; i < loops; i++) {
+            List<Document> newFinds = query(mongoOperations, tableName, bson, i * pageSize, pageSize);
+            list.addAll(newFinds);
+        }
+        return list;
+    }
+
+
+    /**
+     * 封装日期
+     * @param startDate 开始日期
+     * @param endDate 开始日期和结束日期，以逗号分隔（分为开始时间和结束时间）
+     * @param columnName HQL里对应的时间字段
+     * @param bson 封装的bson
+     * @param isShowTime 是否包含时分秒
+     */
+    public static Bson timeBuilder( String startDate,String endDate, String columnName, Bson bson, boolean isShowTime) {
+        startDate = getSafeParam(startDate);
+        endDate = getSafeParam(endDate);
+
+        if (startDate == null || startDate.trim().length() == 0) {
+            startDate = "1900-01-01";
+        } else {
+            startDate = startDate.trim();
+        }
+        if (isShowTime && startDate.trim().length()<=11) {
+            startDate+= " 00:00:00";
+        }
+        if (endDate == null || endDate.trim().length() == 0) {
+            endDate = "2100-01-01";
+        } else {
+            endDate = endDate.trim();
+        }
+        if (isShowTime&& endDate.trim().length()<=11) {
+            endDate+= " 23:59:59";
+        }
+        bson = Filters.and(
+                bson,
+                Filters.gte(columnName,startDate),  //大于等于开始日期
+                Filters.lte(columnName,endDate)     //小于等于结束日期
+                );
+
+        return bson;
+    }
+
+    /**
+     * 封装日期
+     * @param date 开始日期和结束日期，以逗号分隔（分为开始时间和结束时间）
+     * @param columnName HQL里对应的时间字段
+     * @param bson 封装的bson
+     * @param showTaday 如果没有开始时间和结束时间，是否查询当天时间，还是查询所有时间。true:查询当天时间，false:查询所有
+     * @param isShowTime 是否包含时分秒
+     */
+    public static Bson timeBuilder( String date, String columnName, Bson bson, Boolean showTaday,boolean isShowTime) {
+        date = getSafeParam(date);
+
+        String today = (new SimpleDateFormat("yyyy-MM-dd")).format(new Date());
+        if(date != null && date.trim().length() > 0 && (date.length() == 1 || ",".equals(date))){
+            //只有一个逗号
+            date = "";
+        }
+        if(date != null && date.trim().length() > 0){
+            String[] time = date.split(",");
+            if(time.length == 1){
+                //只有开始日期，没有结束日期
+                bson = Filters.and(
+                        bson,
+                        //Filters.eq(columnName,time[0])
+                        Filters.regex(columnName, "^"+time[0]) //like 日期%^
+                );
+            }else if (time.length == 2 && ((time[0] != null && time[0].trim().length() > 0) || (time[1] != null & time[1].trim().length() > 0))) {
+                if (time[0] == null || time[0].trim().length() == 0) {
+                    time[0] = "1900-01-01";
+                } else {
+                    time[0] = time[0].trim();
+                }
+                if (isShowTime && time[0].trim().length()<=11) {
+                    time[0]+= " 00:00:00";
+                }
+                if (time[1] == null || time[1].trim().length() == 0) {
+                    time[1] = "2100-01-01";
+                } else {
+                    time[1] = time[1].trim();
+                }
+                if (isShowTime&& time[1].trim().length()<=11) {
+                    time[1]+= " 23:59:59";
+                }
+                bson = Filters.and(
+                        bson,
+                        Filters.gte(columnName,time[0]),  //大于等于开始日期
+                        Filters.lte(columnName,time[1])     //小于等于结束日期
+                );
+            } else {
+                if (showTaday) {
+                    if (isShowTime) {
+
+                        bson = Filters.and(
+                                bson,
+                                Filters.gte(columnName,time[0] + " 00:00:00"),  //大于等于开始日期
+                                Filters.lte(columnName,time[1] + " 23:59:59")     //小于等于结束日期
+                        );
+                    }else{
+                        bson = Filters.and(
+                                bson,
+                                Filters.gte(columnName,time[0]),  //大于等于开始日期
+                                Filters.lte(columnName,time[1])     //小于等于结束日期
+                        );
+                    }
+                }
+            }
+        }
+        return bson;
+    }
+
+    /**
+     * 封装String对象成like语句
+     * @param str 对象值
+     * @param columnName 列名
+     * @param bson
+     */
+    public static Bson getStringLikerPack(String str,String columnName, Bson bson) {
+        if (str != null && str.trim().length() > 0) {
+            str = getSafeParam(str);
+
+            bson = Filters.and(
+                    bson,
+                    Filters.regex(columnName, str) //like
+            );
+        }
+
+        return bson;
+    }
+
+    /**
+     * 封装String对象成like语句
+     * @param str 对象值
+     * @param columnName 列名
+     * @param bson
+     */
+    public static Bson getStringLikerPackOr(String str,String columnName, Bson bson) {
+        if (str != null && str.trim().length() > 0) {
+            str = getSafeParam(str);
+
+            bson = Filters.and(
+                    bson,
+                    Filters.or(
+                        Filters.regex(columnName, str) //like
+                    )
+            );
+        }
+        return bson;
+    }
+
+    /**
+     * 封装String对象成like语句(右侧模糊)
+     * @param str 对象值
+     * @param columnName 列名
+     * @param bson
+     */
+    public static Bson getStringRightLikerPack(String str,String columnName, Bson bson) {
+        if (str != null && str.trim().length() > 0) {
+            str = getSafeParam(str);
+            bson = Filters.and(
+                    bson,
+                    Filters.regex(columnName, str + "^") //like
+            );
+        }
+        return bson;
+    }
+
+    /**
+     * 封装String对象成like语句(左侧模糊)
+     * @param str 对象值
+     * @param columnName 列名
+     * @param bson
+     */
+    public static Bson getStringLeftLikerPack(String str,String columnName, Bson bson) {
+        if (str != null && str.trim().length() > 0) {
+            str = getSafeParam(str);
+            bson = Filters.and(
+                    bson,
+                    Filters.regex(columnName, "^" + str) //like
+            );
+        }
+        return bson;
+    }
+
+    /**
+     * 封装String对象成equal语句
+     * @param columnName 列名
+     * @param bson
+     */
+    public static Bson getStringEqualPack(String data,String columnName, Bson bson) {
+        if(data != null && data.trim().length() > 0){
+            data = getSafeParam(data);
+            bson = Filters.and(
+                    bson,
+                    Filters.eq(columnName, data)
+            );
+        }
+        return bson;
+    }
+
+    /**
+     * 封装long或者int的整数对象成equal语句
+     * @param columnName 列名
+     * @param bson
+     */
+    public static Bson getNumEqualPack(Object data,String columnName, Bson bson) {
+        if(data!=null&&Long.parseLong(data.toString()) > 0){
+            data = getSafeParam(data);
+            bson = Filters.and(
+                    bson,
+                    Filters.eq(columnName, data)
+            );
+        }
+        return bson;
+    }
+
+    /**
+     * 封装long或者int的整数对象成equal语句
+     * @param columnName 列名
+     * @param bson
+     */
+    public static Bson getNumEqualPackForZero(Object data,String columnName, Bson bson) {
+        if(data!=null&&Long.parseLong(data.toString()) >= 0){
+            data = getSafeParam(data);
+            bson = Filters.and(
+                    bson,
+                    Filters.eq(columnName, data)
+            );
+        }
+        return bson;
+    }
+
+    /**
+     * 封装long或者int的整数对象成equal语句
+     * @param columnName 列名
+     * @param bson
+     */
+    public static Bson getNumWithZeroEqualPack(Object data,String columnName, Bson bson) {
+        if(data!=null&&Long.parseLong(data.toString()) >= 0){
+            data = getSafeParam(data);
+            bson = Filters.and(
+                    bson,
+                    Filters.eq(columnName, data)
+            );
+        }
+        return bson;
+    }
+
+    /**
+     * 封装long或者int的整数对象成大于语句
+     * @param columnName 列名
+     * @param bson
+     */
+    public static Bson getNumBiggerPack(Object data,String columnName, Bson bson) {
+        if(data!=null&&Long.parseLong(data.toString()) > 0){
+            data = getSafeParam(data);
+            bson = Filters.and(
+                    bson,
+                    Filters.gt(columnName, data)
+            );
+        }
+        return bson;
+    }
+
+    /**
+     * 封装long或者int的整数对象成小于语句
+     * @param columnName 列名
+     * @param bson
+     */
+    public static Bson getNumSmallerPack(Object data,String columnName, Bson bson) {
+        if(data!=null&&Long.parseLong(data.toString()) > 0){
+            data = getSafeParam(data);
+            bson = Filters.and(
+                    bson,
+                    Filters.lt(columnName, data)
+            );
+        }
+        return bson;
+    }
+
+    /**
+     * 封装double对象成大于语句
+     * @param columnName 列名
+     * @param bson
+     */
+    public static Bson getDoubleBiggerPack(Object data,String columnName, Bson bson) {
+        if(data!=null&&Double.parseDouble(data.toString()) > 0){
+            data = getSafeParam(data);
+            bson = Filters.and(
+                    bson,
+                    Filters.gt(columnName, data)
+            );
+        }
+        return bson;
+    }
+
+    /**
+     * 封装double对象成小于语句
+     * @param columnName 列名
+     * @param bson
+     */
+    public static Bson getDoubleSmallerPack(Object data,String columnName, Bson bson) {
+        if(data!=null&&Double.parseDouble(data.toString()) > 0){
+            data = getSafeParam(data);
+            bson = Filters.and(
+                    bson,
+                    Filters.lt(columnName, data)
+            );
+        }
+        return bson;
+    }
+
+    /**
+     * 封装long或者int的整数对象成equal语句
+     * @param columnName 列名
+     * @param bson
+     */
+    public static Bson getNumEqualPack(Object data,String columnName, Bson bson,Integer expvalue) {
+        if(data!=null&&Long.parseLong(data.toString()) > (long)expvalue){
+            data = getSafeParam(data);
+            bson = Filters.and(
+                    bson,
+                    Filters.eq(columnName, data)
+            );
+        }
+        return bson;
+    }
+
+    /**
+     * 封装double对象成equal语句
+     * @param columnName 列名
+     * @param bson
+     */
+    public static Bson getNumEqualPackDouble(Object data,String columnName, Bson bson) {
+        if(data!=null&&Double.parseDouble(data.toString()) > 0){
+            data = getSafeParam(data);
+            bson = Filters.and(
+                    bson,
+                    Filters.eq(columnName, data)
+            );
+        }
+        return bson;
+    }
+
+    /**
+     * 封装long或者int的整数对象成equal语句
+     * @param columnName 列名
+     * @param bson
+     */
+    public static Bson getNumEqualPackDouble(Object data,String columnName, Bson bson,Integer expvalue) {
+        if(data!=null&&Double.parseDouble(data.toString()) > (double)expvalue){
+            data = getSafeParam(data);
+            bson = Filters.and(
+                    bson,
+                    Filters.eq(columnName, data)
+            );
+        }
+        return bson;
+    }
+
+    /**
+     * 封装long或者int的整数对象成equal语句(不等于)
+     * @param columnName 列名
+     * @param bson
+     */
+    public static Bson getNumNOEqualPack(Object data,String columnName, Bson bson) {
+        if(data!=null){
+            data = getSafeParam(data);
+            bson = Filters.and(
+                    bson,
+                    Filters.ne(columnName, data)
+            );
+        }
+        return bson;
+    }
+
+    /**
+     * 封装in查询语句
+     * @param data
+     * @param columnName
+     * @param bson
+     */
+    public static Bson getInPack(String data,String columnName, Bson bson){
+        if (data!=null&&data.trim().length()>0) {
+            data = getSafeParam(data);
+            bson = Filters.and(
+                    bson,
+                    Filters.in(columnName, data)
+            );
+        }
+        return bson;
+    }
+
+    /**
+     * 封装in String查询语句
+     * @param data
+     * @param columnName
+     * @param bson
+     */
+    public static Bson getInPackString(String data,String columnName, Bson bson){
+        if (data != null && data.trim().length()>0) {
+            data = getSafeParam(data);
+            //判断最后一位是不是逗号
+            if(data.lastIndexOf(",") != (data.length()-1)){
+                data += ",";
+            }
+            String[] dataArray = data.substring(0, data.length()-1).split(",");
+            data = "";
+            for (int i = 0 ; i < dataArray.length ;i++) {
+                if(i ==  dataArray.length -1){
+                    data += "'" + dataArray[i] + "'";
+                }else{
+                    data += "'" + dataArray[i] + "',";
+                }
+            }
+            bson = Filters.and(
+                    bson,
+                    Filters.in(columnName, data)
+            );
+        }
+        return bson;
+    }
+
+    /**
+     * 封装in String查询语句
+     * @param data
+     * @param columnName
+     * @param bson
+     */
+    public static Bson getNotInPackString(String data,String columnName, Bson bson){
+        if (data != null && data.trim().length()>0) {
+            data = getSafeParam(data);
+            //判断最后一位是不是逗号
+            if(data.lastIndexOf(",") != (data.length()-1)){
+                data += ",";
+            }
+            String[] dataArray = data.substring(0, data.length()-1).split(",");
+            data = "";
+            for (int i = 0 ; i < dataArray.length ;i++) {
+                if(i ==  dataArray.length -1){
+                    data += "'" + dataArray[i] + "'";
+                }else{
+                    data += "'" + dataArray[i] + "',";
+                }
+            }
+            bson = Filters.and(
+                    bson,
+                    Filters.nin(columnName, data)
+            );
+        }
+        return bson;
+    }
+
+    /**
+     * 封装not in查询语句
+     * @param data
+     * @param columnName
+     * @param bson
+     */
+    public static Bson getNotInPack(String data,String columnName, Bson bson){
+        if (data!=null&&data.trim().length()>0) {
+            data = getSafeParam(data);
+            bson = Filters.and(
+                    bson,
+                    Filters.nin(columnName, data)
+            );
+        }
+        return bson;
+    }
+
+    /**
+     * 将MONGODB的BSON转成对象
+     * @param dList
+     * @param entityClass
+     * @return
+     */
+    public List<?> packDocumentToObjectList(List<Document> dList,Class entityClass){
+        //将获取的document转为对象
+        List resultList = new ArrayList();
+        for(Document d : dList){
+            resultList.add(JSONObject.parseObject(d.toJson(), entityClass));
+        }
+
+        return resultList;
+    }
+}

modules/i3plus-pojo-base/src/main/java/cn/estsh/i3plus/pojo/base/tool/HqlPack.java

@@ -16,6 +16,8 @@ public class HqlPack {
 		return data.toString().replaceAll(";","")
 					.replaceAll("'","")
 					.replaceAll("\"","")
+					.replaceAll("/","")
+					.replaceAll("\\\\","")
 					.replaceAll("delete","")
 					.replaceAll("update","")
 					.replaceAll("insert","");

modules/i3plus-pojo-platform/src/main/java/cn/estsh/i3plus/pojo/platform/bean/LogOperate.java

@@ -27,7 +27,6 @@ import java.text.DecimalFormat;
 @Api(value="操作日志表",description = "操作日志表")
 public class LogOperate extends BaseBean {
 
- 
     @Column(name="OPERATE_MODULE_ID")
     @ApiParam(value ="操作模块（枚举）" , example = "-1")
     private Integer operateModuleId;

modules/i3plus-pojo-platform/src/main/java/cn/estsh/i3plus/pojo/platform/repository/LogOperateRepository.java

@@ -1,5 +1,6 @@
 package cn.estsh.i3plus.pojo.platform.repository;
 
+import cn.estsh.i3plus.pojo.base.jpa.dao.BaseMongoRepository;
 import cn.estsh.i3plus.pojo.base.jpa.dao.BaseRepository;
 import cn.estsh.i3plus.pojo.platform.bean.LogOperate;
 import org.springframework.data.mongodb.repository.MongoRepository;
@@ -11,5 +12,5 @@ import org.springframework.data.mongodb.repository.MongoRepository;
  * @Date        : 2018-10-22 12:03:00.118
  * @Modify      :
  **/
-public interface LogOperateRepository extends MongoRepository<LogOperate, Long> {
+public interface LogOperateRepository extends BaseMongoRepository<LogOperate, Long> {
 }

pom.xml

@@ -115,6 +115,13 @@
                 <artifactId>shiro-core</artifactId>
                 <version>1.4.0</version>
             </dependency>
+
+
+            <dependency>
+                <groupId>com.alibaba</groupId>
+                <artifactId>fastjson</artifactId>
+                <version>1.2.49</version>
+            </dependency>
         </dependencies>
     </dependencyManagement>