java代码操作Mongodb(优化)

上一篇 java代码操作mongodb 我们针对某一个集合操作写了一些代码，但是这个这是针对某一个集合的，通用性不好，现在弄一个工具类出来优化一下。

新建一个工具类 BaseMongoRepository

import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.domain.Sort;
import org.springframework.data.mongodb.core.query.Query;
import org.springframework.data.mongodb.core.query.Update;

import java.io.Serializable;
import java.util.List;

/**
 * Mongodb工具接口
 * @param <T>
 * @param <ID>
 */
public interface BaseMongoRepository<T, ID extends Serializable> {
    T get(ID id);

    T save(T param);

    T save(T param, String collectionName);

    long delete(ID id);

    long deleteAll(List<String> ids);

    <C> List<C> find(Query query, Class<C> c);

    List<T> findAll();

    List<T> findByCondition(Query query);

    public  T findOne(Query query) ;

    T findOne(Query query, String documentName) ;

    List<T> findByCondition(Query query, Sort sort);

    public T findAndModify(Query query, Update update);

    void insertAll(List<T> paramList);

    void insert(T param);

    Page<T> queryByConditionPage(Query query, PageRequest request);

    public Page<T> queryByConditionPage(Query query, PageRequest request, Sort sort);

    <C> Page<C> queryByConditionPage(Query query, PageRequest pageable, Sort sort, Class<C> c);

    <C> Page<C> queryByConditionPage(Query query, PageRequest pageable, Sort sort, Class<C> c, String collectionName);

    void updateFirst(Query query, Update update);


    void update(Query query, Update update);

    T updateById(Object id, Update update);

    void updateFirst(Query query, Update update, String documentName);

    void updateMulti(Query query, Update update, String documentName);

}

实现类，添加了增删改查的基本方法，可以直接调用

import com.mongodb.client.result.DeleteResult;
import com.purcotton.notice.repository.BaseMongoRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageImpl;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.domain.Sort;
import org.springframework.data.mongodb.core.FindAndModifyOptions;
import org.springframework.data.mongodb.core.MongoTemplate;
import org.springframework.data.mongodb.core.mapping.Document;
import org.springframework.data.mongodb.core.query.Criteria;
import org.springframework.data.mongodb.core.query.Query;
import org.springframework.data.mongodb.core.query.Update;

import java.io.Serializable;
import java.lang.reflect.ParameterizedType;
import java.util.List;


/**
 * Mongodb工具接口
 * @param <T>
 * @param <ID>
 */
public class BaseMongoRepositoryImpl<T, ID extends Serializable> implements BaseMongoRepository<T, ID> {

    @Autowired
    protected MongoTemplate mongoTemplate;

    protected Class<T> repositoryClass = this.currentEntityClass();

    protected String collectionName = this.currentEntityCollection();


    private String currentEntityCollection() {
        Class<T> t = this.currentEntityClass();
        Document document = t.getAnnotation(Document.class);
        return document.collection();
    }

    /**
     * 获取泛型的类
     * @return
     */
    private Class currentEntityClass() {
        return (Class) ((ParameterizedType) this.getClass().getGenericSuperclass()).getActualTypeArguments()[0];
    }

    /**
     * insert: 若新增数据的主键已经存在，则会抛 org.springframework.dao.DuplicateKeyException 异常提示主键重复，不保存当前数据。
     * save: 若新增数据的主键已经存在，则会对当前已经存在的数据进行修改操作
     */
    /**
     * 新增集合
     * @param param
     * @return
     */
    @Override
    public T save(T param) {
        mongoTemplate.save(param);
        return param;
    }

    /**
     * 新增集合，id存在时会覆盖
     * @param param
     * @param collectionName
     * @return
     */
    @Override
    public T save(T param, String collectionName) {
        mongoTemplate.save(param, collectionName);
        return param;
    }

    /**
     * 新增集合，id存在时会抛异常
     * @param param
     */
    @Override
    public void insert(T param) {
        mongoTemplate.insert(param);
    }

    /**
     * 批量插入集合，id存在时会抛异常
     * @param paramList
     */
    @Override
    public void insertAll(List<T> paramList) {
        mongoTemplate.insertAll(paramList);
    }
    /**
     * 查找并更新集合
     * @param query
     * @param update
     * @return
     */
    @Override
    public T findAndModify(Query query, Update update) {
        FindAndModifyOptions options = new FindAndModifyOptions();
        options.upsert(true);
        options.returnNew(true);
        return mongoTemplate.findAndModify(query, update, options, repositoryClass);

    }

    /**
     * 根据id批量删除集合
     * @param ids
     * @return
     */
    @Override
    public long deleteAll(List<String> ids) {
        DeleteResult result = mongoTemplate.remove(new Query(Criteria.where("_id").in(ids)), repositoryClass);
        return result.getDeletedCount();
    }

    /**
     * 根据id删除
     * @param id
     * @return
     */
    @Override
    public long delete(Serializable id) {
        DeleteResult result = mongoTemplate.remove(new Query(Criteria.where("_id").is(id)), repositoryClass);
        return result.getDeletedCount();
    }

    /**
     * 根据id查询集合
     * @param id
     * @return
     */
    @Override
    public T get(Serializable id) {
        return mongoTemplate.findById(id, repositoryClass);
    }

    /**
     * 根据实体查询集合
     * @param query
     * @param c
     * @param <C>
     * @return
     */
    @Override
    public <C> List<C> find(Query query, Class<C> c) {
        return mongoTemplate.find(query, c, collectionName);
    }

    /**
     * 查询所有的集合数据
     * @return
     */
    @Override
    public List<T> findAll() {
        return mongoTemplate.findAll(repositoryClass);
    }

    /**
     * 根据条件查询集合
     * @param query
     * @return
     */
    @Override
    public List<T> findByCondition(Query query) {
        return mongoTemplate.find(query, repositoryClass);
    }

    /**
     *  根据条件查询并排序
     * @param query
     * @param sort
     * @return
     */
    @Override
    public List<T> findByCondition(Query query, Sort sort) {
        query.with(sort);
        return mongoTemplate.find(query, repositoryClass);
    }

    /**
     * 根据条件查询第一个查到的集合
     * @param query
     * @return
     */
    @Override
    public T findOne(Query query) {
        return mongoTemplate.findOne(query, repositoryClass);
    }

    /**
     * 根据条件查询第一个查到的集合
     * @param query
     * @param documentName
     * @return
     */
    @Override
    public T findOne(Query query, String documentName) {
        return mongoTemplate.findOne(query, repositoryClass, documentName);
    }


    /**
     * 集合分页查询
     * @param query
     * @param pageable
     * @return
     */
    @Override
    public Page<T> queryByConditionPage(Query query, PageRequest pageable) {
        long count = mongoTemplate.count(query, repositoryClass);
        query.limit(pageable.getPageSize());
        query.skip((long) (pageable.getPageNumber() - 1) * pageable.getPageSize());
        List<T> list = mongoTemplate.find(query, repositoryClass);
        return new PageImpl<>(list, PageRequest.of(pageable.getPageNumber() - 1, pageable.getPageSize()), count);
    }

    /**
     * 集合分页查询，带排序
     * @param query
     * @param pageable
     * @param sort
     * @return
     */
    @Override
    public Page<T> queryByConditionPage(Query query, PageRequest pageable, Sort sort) {
        long count = mongoTemplate.count(query, repositoryClass);
        query.limit(pageable.getPageSize());
        query.skip((long) (pageable.getPageNumber() - 1) * pageable.getPageSize());
        query.with(sort);
        List<T> list = mongoTemplate.find(query, repositoryClass);
        return new PageImpl<>(list, PageRequest.of(pageable.getPageNumber() - 1, pageable.getPageSize()), count);
    }

    @Override
    public <C> Page<C> queryByConditionPage(Query query, PageRequest pageable, Sort sort, Class<C> c) {
        long count = mongoTemplate.count(query, repositoryClass);
        query.limit(pageable.getPageSize());
        query.skip((long) (pageable.getPageNumber() - 1) * pageable.getPageSize());
        query.with(sort);
        List<C> list = mongoTemplate.find(query, c, collectionName);

        return new PageImpl<>(list, PageRequest.of(pageable.getPageNumber() - 1, pageable.getPageSize()), count);
    }

    @Override
    public <C> Page<C> queryByConditionPage(Query query, PageRequest pageable, Sort sort, Class<C> c, String collectionName) {
        long count = mongoTemplate.count(query, collectionName);
        query.limit(pageable.getPageSize());
        query.skip((long) (pageable.getPageNumber() - 1) * pageable.getPageSize());
        query.with(sort);
        List<C> list = mongoTemplate.find(query, c, collectionName);

        return new PageImpl<>(list, PageRequest.of(pageable.getPageNumber() - 1, pageable.getPageSize()), count);
    }

    /**
     * 更新集合，更新第一个
     * @param query :
     * @param update :
     */
    @Override
    public void updateFirst(Query query, Update update) {
        mongoTemplate.updateFirst(query, update, repositoryClass);
    }

    /**
     * 根据条件更新集合
     * @param query :
     * @param update :
     */
    @Override
    public void update(Query query, Update update) {
        mongoTemplate.updateMulti(query, update, repositoryClass);
    }

    @Override
    public void updateFirst(Query query, Update update, String documentName) {
        mongoTemplate.upsert(query, update, documentName);
    }

    /**
     * 根据id更新集合
     * @param id :
     * @param update :
     * @return
     */
    @Override
    public T updateById(Object id, Update update) {
        Query query = new Query();
        query.addCriteria(Criteria.where("_id").is(id));
        mongoTemplate.updateFirst(query, update, repositoryClass);
        return mongoTemplate.findById(id, repositoryClass);
    }

    /**
     * 批量更新集合
     * @param query :
     * @param update :
     * @param documentName
     */
    @Override
    public void updateMulti(Query query, Update update, String documentName) {
        mongoTemplate.updateMulti(query, update, documentName);
    }
}

修改之前的UserDocumentServiceImpl的调用方式

import com.purcotton.notice.document.UserDocument;
import com.purcotton.notice.repository.impl.BaseMongoRepositoryImpl;
import com.purcotton.obj.response.PageResponse;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.mongodb.core.MongoTemplate;
import org.springframework.data.mongodb.core.query.Criteria;
import org.springframework.data.mongodb.core.query.Query;
import org.springframework.data.mongodb.core.query.Update;
import org.springframework.stereotype.Service;

import java.util.List;

/**
 * @description:
 * @Author : zouxiliang
 * @Date : 2021/10/27
 */
@Slf4j
@Service
public class UserDocumentServiceImpl extends BaseMongoRepositoryImpl<UserDocument, String> {
    @Autowired
    MongoTemplate mongoTemplate;

    public static final String KEY = "user_document_test";

    /**
     * 增加
     * @param userDocument
     * @return
     */
    public UserDocument addUser(UserDocument userDocument) {
        userDocument.insertParam("tom");
        // 方式一
//        UserDocument d = mongoTemplate.save(userDocument, KEY);

        // 方式二
        UserDocument d = (UserDocument) super.save(userDocument);
        return d;
    }

    /**
     * 分页查询
     * @param userDocument
     * @return
     */
    public PageResponse<UserDocument> findUserPage(UserDocument userDocument) {
        Query query = conditionQuery(userDocument);

        // 方式一
//        long count = mongoTemplate.count(query, KEY);
//        query.limit(userDocument.getPageSize());
//        query.skip((long) (userDocument.getPageNum() - 1) * userDocument.getPageSize());
//        List<UserDocument> list = mongoTemplate.find(query, UserDocument.class, KEY);

//        PageImpl<UserDocument> page = new PageImpl<>(list, PageRequest.of(userDocument.getPageNum() - 1, userDocument.getPageSize()), count);
        
        // 方式二
        Page page = super.queryByConditionPage(query, PageRequest.of(userDocument.getPageNum(), userDocument.getPageSize()));

        PageResponse<UserDocument> data = new PageResponse<>();
        data.setPageNum(Long.parseLong(userDocument.getPageNum() + 1 + ""));
        data.setPageSize(Long.parseLong(userDocument.getPageSize() + ""));
        data.setList(page.toList());
        data.setTotal(page.getTotalElements());

        return data;
    }

    /**
     * 根据ID查询
     * @param id
     * @return
     */
    public UserDocument findById(String id) {
        UserDocument one = mongoTemplate.findById(id, UserDocument.class, KEY);
        return one;
    }

    /**
     * 查询所有的
     * @return
     */
    public List<UserDocument> findAllData() {
        // 方式一
//        return mongoTemplate.findAll(UserDocument.class, KEY);
        // 方式二
        return super.findAll();
    }

    /**
     * 拼接查询条件
     * @param userDocument
     * @return
     */
    private Query conditionQuery(UserDocument userDocument) {
        Criteria c = new Criteria();
        if (StringUtils.isNotEmpty(userDocument.getUserName())) {
            // 模糊查询
            c.and("userName").regex(".*" + userDocument.getUserName() + ".*");
        }
        if (userDocument.getStatus() != null) {
            c.and("status").is(userDocument.getStatus());
        }
        if (userDocument.getAge() != null) {
            // 大于等于小于等于查询
            c.and("age").lte(userDocument.getAge()).gte(userDocument.getAge());
        }
        if (StringUtils.isNotEmpty(userDocument.getAddress())) {
            c.and("address").regex("*." + userDocument.getAddress() + ".*");
        }
        if (StringUtils.isNotEmpty(userDocument.getPhone())) {
            c.and("phone").is(userDocument.getPhone());
        }
        if (StringUtils.isNotEmpty(userDocument.getCreateTime())) {
            c.and("createTime").gte(userDocument.getCreateTime());
        }
        Query query = new Query(c);
        return query;
    }

    /**
     * 根据条件查询
     * @param userDocument
     * @return
     */
    public List<UserDocument> findByCondition(UserDocument userDocument) {
        Query query = conditionQuery(userDocument);
        // 方式一
//        List<UserDocument> list = mongoTemplate.find(query, UserDocument.class, KEY);

        // 方式二
        List<UserDocument> list = super.find(query, UserDocument.class);
        return list;
    }

    /**
     * 根据ID更新
     * @param userDocument
     * @return
     */
    public UserDocument update(UserDocument userDocument) {
        if (StringUtils.isEmpty(userDocument.getId())) {
            return null;
        }
        Query query = new Query(Criteria.where("_id").is(userDocument.getId()));
        Update update = new Update();
        update.set("userName",userDocument.getUserName());
        update.set("age",userDocument.getAge());
        update.set("status",userDocument.getStatus());
        update.set("address",userDocument.getAddress());
        update.set("sex",userDocument.getSex());
        update.set("phone",userDocument.getPhone());
        update.set("email",userDocument.getEmail());
        userDocument.updateParam("tom");
        // 方式一
//        mongoTemplate.updateFirst(query, update, KEY);

        // 方式二
        super.updateFirst(query, update);

        return findById(userDocument.getId());
    }

    /**
     * 根据ID删除集合数据
     * @param id
     */
    public void deleteById(String id) {
        Query query = new Query(Criteria.where("_id").is(id));
        // 方式一
//        mongoTemplate.remove(query, KEY);

        // 方式二
        super.delete(id);
    }
}