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;


public interface baseMongoRepository {
    T get(ID id);

    T save(T param);

    T save(T param, String collectionName);

    long delete(ID id);

    long deleteAll(List ids);

     List find(Query query, Class c);

    List findAll();

    List findByCondition(Query query);

    public  T findOne(Query query) ;

    T findOne(Query query, String documentName) ;

    List findByCondition(Query query, Sort sort);

    public T findAndModify(Query query, Update update);

    void insertAll(List paramList);

    void insert(T param);

    Page queryByConditionPage(Query query, PageRequest request);

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

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

     Page queryByConditionPage(Query query, PageRequest pageable, Sort sort, Class 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;



public class baseMongoRepositoryImpl implements baseMongoRepository {

    @Autowired
    protected MongoTemplate mongoTemplate;

    protected Class repositoryClass = this.currentEntityClass();

    protected String collectionName = this.currentEntityCollection();


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

    
    private Class currentEntityClass() {
        return (Class) ((ParameterizedType) this.getClass().getGenericSuperclass()).getActualTypeArguments()[0];
    }

    
    
    @Override
    public T save(T param) {
        mongoTemplate.save(param);
        return param;
    }

    
    @Override
    public T save(T param, String collectionName) {
        mongoTemplate.save(param, collectionName);
        return param;
    }

    
    @Override
    public void insert(T param) {
        mongoTemplate.insert(param);
    }

    
    @Override
    public void insertAll(List paramList) {
        mongoTemplate.insertAll(paramList);
    }
    
    @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);

    }

    
    @Override
    public long deleteAll(List ids) {
        DeleteResult result = mongoTemplate.remove(new Query(Criteria.where("_id").in(ids)), repositoryClass);
        return result.getDeletedCount();
    }

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

    
    @Override
    public T get(Serializable id) {
        return mongoTemplate.findById(id, repositoryClass);
    }

    
    @Override
    public  List find(Query query, Class c) {
        return mongoTemplate.find(query, c, collectionName);
    }

    
    @Override
    public List findAll() {
        return mongoTemplate.findAll(repositoryClass);
    }

    
    @Override
    public List findByCondition(Query query) {
        return mongoTemplate.find(query, repositoryClass);
    }

    
    @Override
    public List findByCondition(Query query, Sort sort) {
        query.with(sort);
        return mongoTemplate.find(query, repositoryClass);
    }

    
    @Override
    public T findOne(Query query) {
        return mongoTemplate.findOne(query, repositoryClass);
    }

    
    @Override
    public T findOne(Query query, String documentName) {
        return mongoTemplate.findOne(query, repositoryClass, documentName);
    }


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

    
    @Override
    public Page 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 list = mongoTemplate.find(query, repositoryClass);
        return new PageImpl<>(list, PageRequest.of(pageable.getPageNumber() - 1, pageable.getPageSize()), count);
    }

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

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

    @Override
    public  Page queryByConditionPage(Query query, PageRequest pageable, Sort sort, Class 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 list = mongoTemplate.find(query, c, collectionName);

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

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

    
    @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);
    }

    
    @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);
    }

    
    @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;


@Slf4j
@Service
public class UserdocumentServiceImpl extends baseMongoRepositoryImpl {
    @Autowired
    MongoTemplate mongoTemplate;

    public static final String KEY = "user_document_test";

    
    public Userdocument addUser(Userdocument userdocument) {
        userdocument.insertParam("tom");
        // 方式一
//        Userdocument d = mongoTemplate.save(userdocument, KEY);

        // 方式二
        Userdocument d = (Userdocument) super.save(userdocument);
        return d;
    }

    
    public PageResponse 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 list = mongoTemplate.find(query, Userdocument.class, KEY);

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

        PageResponse 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;
    }

    
    public Userdocument findById(String id) {
        Userdocument one = mongoTemplate.findById(id, Userdocument.class, KEY);
        return one;
    }

    
    public List findAllData() {
        // 方式一
//        return mongoTemplate.findAll(Userdocument.class, KEY);
        // 方式二
        return super.findAll();
    }

    
    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;
    }

    
    public List findByCondition(Userdocument userdocument) {
        Query query = conditionQuery(userdocument);
        // 方式一
//        List list = mongoTemplate.find(query, Userdocument.class, KEY);

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

    
    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());
    }

    
    public void deleteById(String id) {
        Query query = new Query(Criteria.where("_id").is(id));
        // 方式一
//        mongoTemplate.remove(query, KEY);

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