Mongodb封装

4dkankan-utils-mongodb/README.md

@@ -0,0 +1,34 @@
+## 使用说明
+
+### 实体继承
+	BaseMongoEntity
+### service
+	继承 extends MongodbBaseService<当前实体>
+### 实现类
+	extends MongodbBaseServiceImpl<当前实体> implements service 
+
+### 方法
+	分页 ，pageQuery
+
+	获取数量 getCount
+
+	保存 save ，insert
+
+	删除 delete ，deleteById
+
+	修改  update
+
+	根据id查找 findById
+
+	查询全部 findAll
+
+	查询 find 根据条件
+
+	等一系列封装的方法
+
+### 配置
+	spring:
+		data:
+			mongodb:
+			uri: mongodb://账户:密码@xxxxxxxxxx:27017/数据库
+

4dkankan-utils-mongodb/pom.xml

@@ -10,13 +10,26 @@
     <modelVersion>4.0.0</modelVersion>
 
     <artifactId>4dkankan-utils-mongodb</artifactId>
-
+    <properties>
+        <fastjson-version>1.2.79</fastjson-version>
+        <hutool-version>5.7.17</hutool-version>
+    </properties>
     <dependencies>
         <dependency>
             <groupId>org.springframework.boot</groupId>
             <artifactId>spring-boot-starter-data-mongodb</artifactId>
             <version>2.3.12.RELEASE</version>
         </dependency>
+        <dependency>
+            <groupId>cn.hutool</groupId>
+            <artifactId>hutool-all</artifactId>
+            <version>${hutool-version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.projectlombok</groupId>
+            <artifactId>lombok</artifactId>
+            <version>1.18.20</version>
+        </dependency>
 
         <dependency>
             <groupId>org.apache.commons</groupId>
@@ -26,6 +39,16 @@
             <groupId>org.apache.commons</groupId>
             <artifactId>commons-pool2</artifactId>
         </dependency>
+        <dependency>
+            <groupId>com.fasterxml.jackson.core</groupId>
+            <artifactId>jackson-annotations</artifactId>
+            <version>2.11.1</version>
+            <scope>compile</scope>
+        </dependency>
+        <dependency>
+            <groupId>com.alibaba</groupId>
+            <artifactId>fastjson</artifactId>
+        </dependency>
     </dependencies>
 
 </project>

4dkankan-utils-mongodb/src/main/java/com/fdkankan/mongodb/base/BaseMongoEntity.java

@@ -0,0 +1,33 @@
+package com.fdkankan.mongodb.base;
+
+import com.alibaba.fastjson.annotation.JSONField;
+import com.fasterxml.jackson.annotation.JsonFormat;
+import com.fasterxml.jackson.annotation.JsonIgnore;
+import lombok.Data;
+
+import java.util.Date;
+
+/**
+ * @author Xiewj
+ * @date 2021/11/15
+ */
+@Data
+public class BaseMongoEntity {
+
+   private String id;
+
+   @JsonFormat(timezone = "GMT+8", pattern = "yyyy-MM-dd HH:mm:ss")
+   private Date createTime;
+
+   @JsonFormat(timezone = "GMT+8", pattern = "yyyy-MM-dd HH:mm:ss")
+   private Date updateTime;
+
+   /**
+    * 用来批量操作的
+    * 0代表未删除 ， 1代表已经删除，默认写0
+    * 需要使用对象类型
+    */
+   @JsonIgnore
+   @JSONField(serialize = false)
+   private Integer deleted = 0;
+}

4dkankan-utils-mongodb/src/main/java/com/fdkankan/mongodb/base/BaseRequestMongo.java

@@ -0,0 +1,36 @@
+package com.fdkankan.mongodb.base;
+
+import lombok.Data;
+
+import java.io.Serializable;
+
+@Data
+public class BaseRequestMongo implements Serializable {
+
+    /**
+    * 当前页,默认 1
+    * */
+    private int pageNum=1;
+
+    /**
+     * 每页显示条数，默认 20
+     * */
+    private int pageSize=20;
+
+    /**
+     * 排序字段
+     * */
+    private String orderBy="id";
+    /**
+     * 是否查询全部 true false
+     * */
+    private Boolean isALL=false;
+    /**
+     * 查询排序方式，默认 DESC
+     * */
+    private String sortBy="DESC";
+    /**
+     * lastId 条件分页参数, 区别于skip-limit，采用find(_id>lastId).limit分页.
+     * */
+    private String lastId="";
+}

4dkankan-utils-mongodb/src/main/java/com/fdkankan/mongodb/base/MongoPageResult.java

@@ -0,0 +1,47 @@
+package com.fdkankan.mongodb.base;
+
+
+
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+import java.util.List;
+
+/**
+ * 分页结果.
+ * @author Xiewj
+ * @date 2021/11/30
+ */
+@Data
+@AllArgsConstructor
+@NoArgsConstructor
+public class MongoPageResult<T> {
+
+   /**
+    * 页码，从1开始
+    */
+   private Integer pageNum;
+
+   /**
+    * 页面大小
+    */
+   private Integer pageSize;
+
+
+   /**
+    * 总数
+    */
+   private Long total;
+
+   /**
+    * 总页数
+    */
+   private Integer pages;
+
+   /**
+    * 数据
+    */
+   private List<T> list;
+
+}

4dkankan-utils-mongodb/src/main/java/com/fdkankan/mongodb/service/MongodbBaseService.java

@@ -0,0 +1,60 @@
+package com.fdkankan.mongodb.service;
+
+import com.fdkankan.mongodb.base.MongoPageResult;
+import com.fdkankan.mongodb.base.BaseRequestMongo;
+import com.mongodb.client.result.DeleteResult;
+import org.springframework.data.geo.GeoResults;
+import org.springframework.data.mongodb.core.query.NearQuery;
+import org.springframework.data.mongodb.core.query.Query;
+import org.springframework.data.util.Pair;
+
+import java.util.List;
+
+/**
+ * @author Xiewj
+ * @date 2021/11/15
+ * Mongodb工具类
+ */
+ public interface MongodbBaseService<T>  {
+     MongoPageResult<T> pageQuery(BaseRequestMongo page, Query query);
+
+    long getCount(Query query);
+
+    T save(T t);
+
+    T insert(T t);
+
+
+     DeleteResult delete(T t);
+
+     DeleteResult deleteById(Object id);
+
+     DeleteResult delete(Query query);
+
+    T update(T t);
+
+     T findById(Object id);
+
+     List<T> findAll();
+
+     List<T> find(Query query);
+
+    GeoResults<T> geoNear(NearQuery query);
+
+    T findOne(Query query);
+
+     boolean exists(Query query);
+
+     boolean exists(T t);
+
+     boolean exitsById(Object id);
+
+     long count(Query query);
+
+     Class<T> getTClass();
+
+     Pair<String, Object> extractIdPropertyAndValue(Object object);
+
+     Query getIdQueryFor(Object object);
+
+}

4dkankan-utils-mongodb/src/main/java/com/fdkankan/mongodb/service/impl/MongodbBaseServiceImpl.java

@@ -0,0 +1,227 @@
+package com.fdkankan.mongodb.service.impl;
+
+import cn.hutool.core.util.ObjectUtil;
+import com.fdkankan.mongodb.base.BaseRequestMongo;
+import com.fdkankan.mongodb.base.MongoPageResult;
+import com.fdkankan.mongodb.service.MongodbBaseService;
+import com.mongodb.client.result.DeleteResult;
+import org.apache.commons.lang3.StringUtils;
+import org.bson.Document;
+import org.bson.types.ObjectId;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.domain.Sort;
+import org.springframework.data.geo.GeoResults;
+import org.springframework.data.mapping.MappingException;
+import org.springframework.data.mongodb.core.MongoTemplate;
+import org.springframework.data.mongodb.core.mapping.MongoPersistentEntity;
+import org.springframework.data.mongodb.core.mapping.MongoPersistentProperty;
+import org.springframework.data.mongodb.core.query.Criteria;
+import org.springframework.data.mongodb.core.query.NearQuery;
+import org.springframework.data.mongodb.core.query.Query;
+import org.springframework.data.util.Pair;
+import org.springframework.stereotype.Component;
+import org.springframework.util.Assert;
+
+import javax.annotation.PostConstruct;
+import java.lang.reflect.ParameterizedType;
+import java.util.Collections;
+import java.util.List;
+import java.util.Locale;
+import java.util.stream.Collectors;
+
+/**
+ * @author Xiewj
+ * @date 2021/11/15
+ * Mongodb工具类
+ */
+@Component
+public class MongodbBaseServiceImpl<T> implements MongodbBaseService<T> {
+
+    public static MongodbBaseServiceImpl mongodbBaseService;
+
+
+    @PostConstruct
+    public void init() {
+        mongodbBaseService = this;
+        mongodbBaseService.mongoTemplate = this.mongoTemplate;
+    }
+
+
+    @Autowired
+    private MongoTemplate mongoTemplate;
+
+
+    private static final int FIRST_PAGE_NUM = 1;
+    private static final String ID = "_id";
+
+
+
+
+    /**
+     * 分页查询.
+     *
+     * @param query Mongo Query对象，构造你自己的查询条件.
+     * @param page#mapper 映射器，你从db查出来的list的元素类型是entityClass, 如果你想要转换成另一个对象，比如去掉敏感字段等，可以使用mapper来决定如何转换.
+     * @param page#pageSize 分页的大小.
+     * @param page#pageNum 当前页.
+     * @param page#lastId 条件分页参数, 区别于skip-limit，采用find(_id>lastId).limit分页.
+     * 如果不跳页，像朋友圈，微博这样下拉刷新的分页需求，需要传递上一页的最后一条记录的ObjectId。 如果是null，则返回pageNum那一页.
+     * @return PageResult，一个封装page信息的对象.
+     */
+    @Override
+    public MongoPageResult<T> pageQuery(BaseRequestMongo page, Query query) {
+        //分页逻辑
+        long total = mongoTemplate.count(query, getTClass());
+        final Integer pages = (int) Math.ceil(total / (double) page.getPageSize());
+        if (page.getPageNum() <= 0 || page.getPageNum() > pages) {
+            page.setPageNum(FIRST_PAGE_NUM);
+        }
+        final Criteria criteria = new Criteria();
+        if (StringUtils.isNotBlank(page.getLastId())) {
+            if (page.getPageNum() != FIRST_PAGE_NUM) {
+                criteria.and(ID).gt(new ObjectId(page.getLastId()));
+            }
+            query.limit(page.getPageSize());
+        } else {
+            int skip = page.getPageSize() * (page.getPageNum() - 1);
+            query.skip(skip).limit(page.getPageSize());
+        }
+        List<T> entityList=null;
+        if (page.getSortBy().toUpperCase(Locale.ROOT).equals(Sort.Direction.DESC.name())){
+            entityList =mongoTemplate
+                    .find(query.addCriteria(criteria)
+                                    .with( Sort.by(Collections.singletonList(new Sort.Order(Sort.Direction.DESC, page.getOrderBy())))),
+                            getTClass());
+        }else {
+            entityList=mongoTemplate
+                    .find(query.addCriteria(criteria)
+                                    .with( Sort.by(Collections.singletonList(new Sort.Order(Sort.Direction.ASC,  page.getOrderBy())))),
+                            getTClass());
+        }
+
+
+
+        MongoPageResult<T> mongoPageResult = new MongoPageResult<>();
+        mongoPageResult.setTotal(total);
+        mongoPageResult.setPages(pages);
+        mongoPageResult.setPageSize(page.getPageSize());
+        mongoPageResult.setPageNum(page.getPageNum());
+        mongoPageResult.setList(entityList.stream().collect(Collectors.toList()));
+        return mongoPageResult;
+    }
+
+    @Override
+    public long getCount(Query query) {
+       return mongoTemplate.count(query, getTClass());
+    }
+
+    @Override
+    public T save(T t) {
+        return mongoTemplate.save(t);
+    }
+
+    @Override
+    public T insert(T t) {
+        return  mongoTemplate.insert(t);
+    }
+
+    @Override
+    public DeleteResult delete(T t) {
+        return mongoTemplate.remove(t);
+    }
+
+    @Override
+    public DeleteResult deleteById(Object id) {
+        T t = mongoTemplate.findById(id, getTClass());
+        if (ObjectUtil.isNotNull(t)){
+            return delete(t);
+        }
+        return null;
+    }
+
+    @Override
+    public DeleteResult delete(Query query) {
+        return mongoTemplate.remove(query, getTClass());
+    }
+
+    @Override
+    public T update(T t) {
+       return mongoTemplate.save(t);
+    }
+
+    @Override
+    public T findById(Object id) {
+        return mongoTemplate.findById(id, getTClass());
+    }
+
+    @Override
+    public List<T> findAll() {
+        return mongoTemplate.findAll(getTClass());
+    }
+
+    @Override
+    public List<T> find(Query query) {
+        return mongoTemplate.find(query, getTClass());
+    }
+
+    @Override
+    public GeoResults<T> geoNear(NearQuery query) {
+        GeoResults<T> geoResults = mongoTemplate.geoNear(query, getTClass());
+        return geoResults;
+    }
+
+    @Override
+    public T findOne(Query query) {
+        return mongoTemplate.findOne(query,getTClass());
+    }
+
+    @Override
+    public boolean exists(Query query) {
+        return mongoTemplate.exists(query, getTClass());
+    }
+
+    @Override
+    public boolean exists(T t) {
+        return exists(getIdQueryFor(t));
+    }
+
+    @Override
+    public boolean exitsById(Object id) {
+        return exists(findById(id));
+    }
+
+    @Override
+    public long count(Query query) {
+        return mongoTemplate.count(query, getTClass());
+    }
+
+    @Override
+    public Class<T> getTClass() {
+        Class<T> tClass = (Class<T>) ((ParameterizedType) getClass().getGenericSuperclass()).getActualTypeArguments()[0];
+        return tClass;
+    }
+
+    @Override
+    public Pair<String, Object> extractIdPropertyAndValue(Object object) {
+        Assert.notNull(object, "Id cannot be extracted from 'null'.");
+        Class<?> objectType = object.getClass();
+        if (object instanceof Document) {
+            return Pair.of("_id", ((Document) object).get("_id"));
+        } else {
+            MongoPersistentEntity<?> entity = (MongoPersistentEntity) mongoTemplate.getConverter().getMappingContext().getPersistentEntity(objectType);
+            if (entity != null && entity.hasIdProperty()) {
+                MongoPersistentProperty idProperty = (MongoPersistentProperty) entity.getIdProperty();
+                return Pair.of(idProperty.getFieldName(), entity.getPropertyAccessor(object).getProperty(idProperty));
+            } else {
+                throw new MappingException("No id property found for object of type " + objectType);
+            }
+        }
+    }
+
+    @Override
+    public Query getIdQueryFor(Object object) {
+        Pair<String, Object> id = this.extractIdPropertyAndValue(object);
+        return new Query(Criteria.where((String) id.getFirst()).is(id.getSecond()));
+    }
+
+}