使用Morphia操作MongoDB

项目环境:SpringBoot + SpringClound + JDK8

1.添加Morphiade的Maven依赖

    <dependency>
      <groupId>org.mongodb.morphiagroupId>
      <artifactId>morphiaartifactId>
      <version>1.1.0version>
    dependency>

2.启动文件bootstrap.profiles中添加mongoDB配置

mongo.uri=mongodb://microschool:microschool@192.168.3.252:27017/micro-school?authSource=micro-school
mongo.dbName=micro-school

3.MongoDB属性读取及配置类

package com.h.mongo;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

@Component
public class MongoProperties {
    @Value("${mongo.uri:}")
    protected String uri;
    @Value("${mongo.dbName:}")
    protected String dbName;

    public String getUri() {
        return uri==null?null:uri.trim();
    }
    public void setUri(String uri) {
        this.uri = uri;
    }
    public String getDbName() {
        return dbName==null?null:dbName.trim();
    }
    public void setDbName(String dbName) {
        this.dbName = dbName;
    }
}

package com.h.mongo;

import com.mongodb.MongoClient;
import com.mongodb.MongoClientOptions;
import com.mongodb.MongoClientURI;
import org.mongodb.morphia.Datastore;
import org.mongodb.morphia.Morphia;
import org.mongodb.morphia.annotations.Entity;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.util.StringUtils;

import javax.annotation.PreDestroy;
import java.net.UnknownHostException;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

@Configuration
public class MongoAutoConfiguration {
    protected Logger log = LoggerFactory.getLogger(getClass());  

    @Autowired
    private MongoProperties mongoProperties;

    @Bean(name = "dsForRW")
    public Datastore dsForRW() throws Exception {
        MongoClient mongoClient = createInstance(mongoProperties);
        Datastore dsForRWMdt = morphia().createDatastore(mongoClient, mongoProperties.getDbName());
        afterCreateDs(dsForRWMdt);
        return dsForRWMdt;
    }

    @PreDestroy
    public void close(){
        log.info("mongoClient is destroy");
    }

    private void afterCreateDs(Datastore dsForRW)  throws UnknownHostException {
        try {
            dsForRW.ensureIndexes();
            dsForRW.ensureCaps();
//          BasicDBObject keys = new BasicDBObject();
//          keys.put("link", 1);
//          keys.put("shortLink", 1);

//          DBCollection dbCollection = ds.getCollection(ShortLink.class);
//          dbCollection.createIndex(keys);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    private MongoClient createInstance(MongoProperties mongoProperties)  throws UnknownHostException {

        MongoClientOptions.Builder builder = MongoClientOptions.builder();
        builder.socketKeepAlive(true);
        builder.connectTimeout(5000);
        builder.socketTimeout(0);
//      builder.maxWaitTime(60000);
        builder.heartbeatFrequency(2000);// 心跳频率

        MongoClientURI clientURI = new MongoClientURI(mongoProperties.getUri(),builder); 
        MongoClient mongoClient = new MongoClient(clientURI);
        if(StringUtils.isEmpty(mongoProperties.getDbName())){
            mongoProperties.setDbName(clientURI.getDatabase());
        }
        return mongoClient;
    }

    private Morphia morphia() {
        //
        Morphia morphia = new Morphia();
        // 手动加载
        if (0 == morphia.getMapper().getMappedClasses().size()) {
//          morphia.map(com.dachen.shorturl.domains.ShortLink.class);
        }
        SetclazzSet = this.getAllEntity("com.dachen");
        if(clazzSet!=null && clazzSet.size()>0){
            morphia.map(clazzSet);
        }
        morphia.getMapper().getConverters().addConverter(BigDecimalConverter.class);
        return morphia;
    }

    @SuppressWarnings("rawtypes")
    private Set getAllEntity(String packageName){
        List> returnClassList = ClassUtil.getClasses(packageName) ;
        if(returnClassList==null || returnClassList.isEmpty()){
            return null;
        }
        SetclazzSet = new HashSet<>();
        for(Class clazz:returnClassList){
            Entity entity = clazz.getAnnotation(Entity.class);
            if(entity!=null){
                log.info("loading mongo entity:{},table:{}",clazz.getName(),entity.value());
                clazzSet.add(clazz);
            }
        }
        return clazzSet;
    }

}

4.Morphia操作MongoDB的工具类

package com.h.mongo;

import com.mongodb.*;
import org.bson.types.ObjectId;
import org.mongodb.morphia.AdvancedDatastore;
import org.mongodb.morphia.mapping.Mapper;
import org.mongodb.morphia.query.Query;
import org.mongodb.morphia.query.UpdateOperations;
import org.mongodb.morphia.query.UpdateResults;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;

import javax.annotation.Resource;
import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.List;
import java.util.Set;
import java.util.regex.Pattern;

@Component
public class MongoCommonDAO {
    private final Logger logger = LoggerFactory.getLogger(getClass());

    @Resource(name = "dsForRW")
    protected AdvancedDatastore dsForRW;


    public  T getByObjectId(final Class clazz,ObjectId id){
        @SuppressWarnings("unchecked")
        Query query = (Query) dsForRW.createQuery(clazz);
        query.filter(Mapper.ID_KEY,id);
        return query.get();
    }

    public  T getByPK(final Class clazz,String pk){
        Query  query = this.createQuery(clazz, pk);
        return query.get();
    }

    public  T findAndModifyByPK(final Class clazz,String pk,DBObject update){
        Query  query = this.createQuery(clazz, pk);
        UpdateOperations ops = this.createUpdateOperations(clazz, update);
        return dsForRW.findAndModify(query, ops);
    }

    public  T findAndModify(final Class clazz,DBObject filter,DBObject update){
        Query query = this.createQuery(clazz, filter);
        UpdateOperations ops = this.createUpdateOperations(clazz,update);
        return dsForRW.findAndModify(query, ops);
    }

    public  T findAndModifyOrCreate(final Class clazz,DBObject filter,DBObject update){
        Query query = this.createQuery(clazz, filter);
        UpdateOperations ops = this.createUpdateOperations(clazz,update);
        return dsForRW.findAndModify(query, ops,false, true);
    }

    public  UpdateResults update(final Class clazz,DBObject filter,DBObject update)
    {
        Query query = this.createQuery(clazz, filter);
        UpdateOperations ops = this.createUpdateOperations(clazz, update);
        return dsForRW.update(query, ops);
    }

    @SuppressWarnings("unchecked")
    public  UpdateResults addToArray(final Class clazz,DBObject filter,String fieldExpr, List values, boolean addDups)
    {
        Query query = this.createQuery(clazz, filter);
        UpdateOperations ops = (UpdateOperations) dsForRW.createUpdateOperations(clazz);
        ops.addAll(fieldExpr, values,addDups);
        return dsForRW.update(query, ops);
    }

    @SuppressWarnings("unchecked")
    public  UpdateResults removeFromArray(final Class clazz,DBObject filter,String fieldExpr, Object value)
    {
        Query query = this.createQuery(clazz, filter);
        UpdateOperations ops = (UpdateOperations) dsForRW.createUpdateOperations(clazz);
        ops.removeAll(fieldExpr, value);
        return dsForRW.update(query, ops);
    }

    @SuppressWarnings("unchecked")
    public  UpdateResults removeAllFromArray(final Class clazz,DBObject filter,String fieldExpr, List values){
        Query query = this.createQuery(clazz, filter);
        UpdateOperations ops = (UpdateOperations) dsForRW.createUpdateOperations(clazz);
        ops.removeAll(fieldExpr, values);
        return dsForRW.update(query, ops);
    }


    public T insertOrUpdate(T entity)
    {
        if (entity == null) {
            return null;
        }
        if (entity instanceof AbstractBaseInfo) {
            AbstractBaseInfo obj = (AbstractBaseInfo) entity;
            if (obj.getId() == null) {
                obj.setId(MongodbUtil.genMongoId());
                dsForRW.insert(obj);
                return entity;
            }
        }
        dsForRW.save(entity);
        return entity;
    }
//  public T insert(T entity) {
//      if (entity == null) {
//          return null;
//      }
//      Key key = dsForRW.insert(entity);
//      return entity;
//  }
    public void batchInsert(List objList) {
        Object[]arrays = new Object[objList.size()];
        int i=0;
        for(Object obj :objList){
            if(obj instanceof AbstractBaseInfo){
                AbstractBaseInfo entity = (AbstractBaseInfo)obj;
                if(entity.getId()==null)
                {
                    entity.setId(MongodbUtil.genMongoId());
                }
                arrays[i++]=entity;
            }else{
                arrays[i++]=obj;
            }
        }
        dsForRW.insert(arrays);
    }

    public  T get(final Class clazz,String field,Object value)
    {
        Query query = this.createQuery(clazz, new BasicDBObject(field,value));
        return query.get();
    }

    public  T get(final Class clazz,DBObject filter)
    {
        Query query = this.createQuery(clazz, filter);
        return query.get();
    }

    public  List getList(final Class clazz,String field,Object value){
        return this.getList(clazz, new BasicDBObject(field,value));
    }

    public  List getList(final Class clazz,DBObject filter)
    {
        Query query = this.createQuery(clazz, filter);
        return query.asList();
    }

    public  List getList(final Class clazz,DBObject filter,String sort)
    {
        Query query = this.createQuery(clazz, filter);
        if(StringUtils.isNotEmpty(sort)){
            query.order(sort);
        }
        return query.asList();
    }

    public  List getList(final Class clazz,DBObject filter,String sort,int limit)
    {
        Query query = this.createQuery(clazz, filter);
        if(StringUtils.isNotEmpty(sort)){
            query.order(sort);
        }
        if(limit>0){
            query.offset(0).limit(limit);
        }
        return query.asList();
    }
//  /**
//   * 
//   * @param clazz
//   * @param filter 过滤条件
//   * @param sort 排序条件 
{@code order("age,-date")} (age ascending, date descending)
//   * @param pageSize  每页大小
//   * @param pageIndex 第几页，从0开始
//   * @return
//   */
//  public  PageVO getPageData(final Class clazz,DBObject filter,String sort,int pageSize,int pageIndex){
//      if(pageSize<=0){
//          pageSize = 20;
//      }
//      Query query = this.createQuery(clazz, filter);
//      long totalCount = query.countAll();
//      if(StringUtils.isNotEmpty(sort)){
//          query.order(sort);
//      }
//      query.offset(pageIndex * pageSize).limit(pageSize);
//      List list= query.asList();
//      PageVO result = new PageVO<>(list,totalCount,pageSize);
//      return result;
//  }

    public boolean exists(final Class clazz,DBObject query){
        return dsForRW.getCollection(clazz).getCount(query)>0;
    }

    public  void remove(final Class clazz,DBObject filter){
        if(filter==null){
            throw new ServiceException("删除条件为空");
        }
        Setkey = filter.keySet();
        if(key==null || key.isEmpty()){
            throw new ServiceException("删除条件为空");
        }
        Query query = this.createQuery(clazz, filter);
        dsForRW.delete(query);
    }

    @SuppressWarnings("unchecked")
    public  void cleanTable(final Class clazz){
        Query query = (Query) dsForRW.createQuery(clazz);
        dsForRW.delete(query);
    }
    /**
     * field支持多级嵌套 ，比如：order.patient.id
     */
    public List stringFieldList(final Class clazz,DBObject filter,String field){

        DBObject projection = new BasicDBObject();
        projection.put(field, 1);//1表示返回的数据 只包含这个字段，0表示排除

        DBCursor cursor =  dsForRW.getCollection(clazz).find(filter, projection);
        List fieldValueList = new ArrayList();
        while (cursor.hasNext()) {
            DBObject obj = cursor.next();
            fieldValueList.add(getFieldValue(obj,field.split("\\.")));
        }
        return fieldValueList;
    }

    private String getFieldValue(DBObject dbObj,String[]fields){
         int length = fields.length;
         if(length>1){
             Object obj = dbObj.get(fields[0]);
             if(obj instanceof DBObject){
                String[]subFields = new String[length-1];
                System.arraycopy(fields, 1, subFields, 0, length-1);
                return getFieldValue((DBObject)obj,subFields);
             }
         }else if(length==1){
             return MongodbUtil.getString(dbObj, fields[0]);
         }
         return null;
    }


    @SuppressWarnings("unchecked")
    private  UpdateOperations createUpdateOperations(final Class clazz,DBObject update){
        UpdateOperations ops = (UpdateOperations) dsForRW.createUpdateOperations(clazz);
        for( String field:update.keySet()){
            ops.set(field, update.get(field));
        }
        return ops;
    }

    @SuppressWarnings("unchecked")
    private  Query createQuery(final Class clazz,DBObject filter) {
        Query query = (Query) dsForRW.createQuery(clazz);
        if(filter!=null){
            for(String condition:filter.keySet()){
                query.filter(condition, filter.get(condition));
            }
        }
        return query;
    }


    @SuppressWarnings("unchecked")
    private  Query createQuery(final Class clazz,String id) {
        Query query = (Query) dsForRW.createQuery(clazz);
        query.filter(Mapper.ID_KEY,id);
        return query;
    }
    /**
     * @see org.mongodb.morphia.query.FieldEndImpl
     * 模糊查询 :左右模糊   TODO
     * 
     *   DBObject query = new BasicDBObject();
         query.put("name", like(userName));
     */
    private BasicDBObject like(String content) {
         Pattern pattern = Pattern.compile("^.*" + content + ".*$", Pattern.CASE_INSENSITIVE);
         return new BasicDBObject("$regex", pattern);
    }

    /*
     * 模糊查询: TODO
        DBObject query = new BasicDBObject();
        query.put("filename", endWith(“.pdf”));
     */
    private BasicDBObject endWith(String content) {
        Pattern pattern = Pattern.compile(content + "$", Pattern.MULTILINE);
        return new BasicDBObject("$regex", pattern);
    }

    public  DBCollection getCollection(Class clazz) {
        return dsForRW.getCollection(clazz);
    }
    /**
     * 排除某些属性
     */
    public  T getInfoExcludeField(Class clazz, DBObject filter, String... ignoringFields) {
        Query query = this.createQuery(clazz, filter);
        if(ignoringFields!=null && ignoringFields.length>0){
            query.retrievedFields(false, ignoringFields);
        }
        return query.get();
    }

    public  T getInfoIncludeField(Class clazz, DBObject filter,String... includeFields) {
        Query query = this.createQuery(clazz, filter);
        if(includeFields!=null && includeFields.length>0){
            query.retrievedFields(true, includeFields);
        }
        return query.get();
    }

    public  List getListExcludeField(Class clazz, DBObject filter,String sort, String... ignoringFields) {
        Query query = this.createQuery(clazz, filter);
        if(ignoringFields!=null && ignoringFields.length>0){
            query.retrievedFields(false, ignoringFields);
        }
        if(StringUtils.isNotEmpty(sort)){
            query.order(sort);
        }
        return query.asList();
    }

    public  List getListIncludeField(Class clazz, DBObject filter,String sort, String... includeFields) {
        Query query = this.createQuery(clazz, filter);
        if(StringUtils.isNotEmpty(sort)){
            query.order(sort);
        }
        if(includeFields!=null && includeFields.length>0){
            query.retrievedFields(true, includeFields);
        }
        return query.asList();
    }

    /**
     * {
        key: { userId: 1 },
        cond: { appId:  "10001" },
        reduce: function( curr, result ) {
                    result.total += curr.money;
                },
        initial: { total : 0 }
       }
       ==
       select userId,sum(money) as total from tablename where appId="10001"
     * 
描述：
     * @param clazz
     * @param key
     * @param cond
     * @param initial
     * @param reduce
     */
    @SuppressWarnings("unchecked")
    public List group(final Class clazz,final DBObject key, final DBObject cond, final DBObject initial, final String reduce){
        return (List) dsForRW.getCollection(clazz).group(key, cond, initial, reduce);
    }

    /**
     * select userId,sum(money) as total from tablename where appId="10001"
     * 条件(pipeline0)   :{$match:{"appId":"10001"}}
     * 分组统计(pipeline1):{$group:{"_id":"$userId","total":{$sum:"$money"}}}
     *  group支持操作：$sum,$avg,$first,$last,$max,$min,$push,$addToSet,$stdDevPop,$stdDevSamp
     * 
描述：
     * @param clazz
     * @param pipeline
     * @return
     */
//  private Iterable aggregate(final Class clazz,final List pipeline){
//      AggregationOutput out = dsForRW.getCollection(clazz).aggregate(pipeline);
//      if(out!=null){
//          return out.results();
//      }
////        dsForRW.getCollection(clazz).aggregate(pipeline, options)
//      return null;
//  }

    @SuppressWarnings("unchecked")
    public List