Scala与Mongodb实践3-----运算环境的搭建

目的：使的在IDEA中编辑代码，令代码实现mongodb运算，且转换较为便捷

• 由实验2可知，运算环境的搭建亦需要对数据进行存储和计算，故需要实现类型转换，所以在实验2的基础上搭建环境。

• 由菜鸟教程可得到mongodb命令的具体格式等，如：新建集合

==》可以新建：

              case class  CreateCollection(name:String,options:Options[Any]=None)  //其他的mongodb命令也是照着这样建立的

• 由org.mongodb.scala.model.Filters可知Filters内的相关方法的返回类型都是Bson。例子如下：

 /**
   * Creates a filter that matches all documents where the value of the given field is greater than the specified value.
   *
   * @param fieldName the field name
   * @param value the value
   * @tparam TItem the value type
   * @return the filter
   * @see [[http://docs.mongodb.org/manual/reference/operator/query/gt \$gt]]
   */
  def gt[TItem](fieldName: String, value: TItem): Bson = JFilters.gt(fieldName, value)

  /**
   * Creates a filter that matches all documents where the value of the given field is less than the specified value.
   *
   * @param fieldName the field name
   * @param value the value
   * @tparam TItem the value type
   * @return the filter
   * @see [[http://docs.mongodb.org/manual/reference/operator/query/lt \$lt]]
   */
  def lt[TItem](fieldName: String, value: TItem): Bson = JFilters.lt(fieldName, value)

　　

• 根据相关语法格式，可新建

               case class Count(filter: Option[Bson], options: Option[Any]) 

• 执行相关命令需要引入数据库和集合，新建MGOContext.scala

case class MGOContext(
                       dbName:String,
                       collName:String,
                       action:MGOCommands=null
                     ){ctx=>
  def setDbName(name:String):MGOContext=ctx.copy(dbName=name)

  def setCollName(name:String):MGOContext=ctx.copy(collName=name)

  def setCommand(cmd:MGOCommands):MGOContext=ctx.copy(action=cmd)
}

object MGOContext {
  def apply(db:String,coll:String) = new MGOContext(db,coll)

  def apply(
             db: String,
             coll: String,
             action: MGOCommands = null
           ): MGOContext = new MGOContext(db, coll, action)

}

　

• 分别新建相关的数据库操作，新建MGOCommands.scala和MGOAdmins.scala

//MGOAdmins.scala
import org.bson.conversions.Bson

object MGOAdmins {
  case class DropCollection(collName: String) extends MGOCommands

  case class CreateCollection(collName: String, options: Option[Any] = None) extends MGOCommands

  case class ListCollection(dbName: String) extends MGOCommands

  case class CreateView(viewName: String, viewOn: String, pipeline: Seq[Bson], options: Option[Any] = None) extends MGOCommands

  case class CreateIndex(key: Bson, options: Option[Any] = None) extends MGOCommands

  case class DropIndexByName(indexName: String, options: Option[Any] = None) extends MGOCommands

  case class DropIndexByKey(key: Bson, options: Option[Any] = None) extends MGOCommands

  case class DropAllIndexes(options: Option[Any] = None) extends MGOCommands

}

//MGOCommands.scala
import org.mongodb.scala.{Document, FindObservable}
import org.mongodb.scala.bson.conversions.Bson
import org.mongodb.scala.model.WriteModel

trait MGOCommands

object MGOCommands {
   case class Count(filter: Option[Bson], options: Option[Any]) extends MGOCommands

  case class Distict(fieldName: String, filter: Option[Bson]) extends MGOCommands

  case class Find[M](filter: Option[Bson] = None,
                     andThen: Option[FindObservable[Document] => FindObservable[Document]]= None,
                     converter: Option[Document => M] = None,
                     firstOnly: Boolean = false) extends MGOCommands

  case class Aggregate(pipeLine: Seq[Bson]) extends MGOCommands

  case class MapReduce(mapFunction: String, reduceFunction: String) extends MGOCommands

  case class Insert(newdocs: Seq[Document], options: Option[Any] = None) extends MGOCommands

  case class Delete(filter: Bson, options: Option[Any] = None, onlyOne: Boolean = false) extends MGOCommands

  case class Replace(filter: Bson, replacement: Document, options: Option[Any] = None) extends MGOCommands

  case class Update(filter: Bson, update: Bson, options: Option[Any] = None, onlyOne: Boolean = false) extends MGOCommands

  case class BulkWrite(commands: List[WriteModel[Document]], options: Option[Any] = None) extends MGOCommands

}

• 综上所述，具体实现相关的操作

import org.mongodb.scala.{Document, MongoClient}
import org.mongodb.scala.model.{BulkWriteOptions, CountOptions, CreateCollectionOptions, CreateViewOptions, DeleteOptions, DropIndexOptions, IndexOptions, InsertManyOptions, InsertOneOptions, UpdateOptions}

import scala.concurrent.Future

object MGOEngine{

  import MGOAdmins._
  import MGOCommands._

  def DAO[T](ctx: MGOContext)(implicit client: MongoClient): Future[T] = {
    val db = client.getDatabase(ctx.dbName)
    val coll = db.getCollection(ctx.collName)
    ctx.action match {
      case Count(Some(filter), Some(opt)) =>
        coll.count(filter, opt.asInstanceOf[CountOptions])
          .toFuture().asInstanceOf[Future[T]]
      case Count(Some(filter), None) =>
        coll.count(filter).toFuture()
          .asInstanceOf[Future[T]]
      case Count(None, None) =>
        coll.count().toFuture()
          .asInstanceOf[Future[T]]
      /* distinct */
      case Distict(field, Some(filter)) =>
        coll.distinct(field, filter).toFuture()
          .asInstanceOf[Future[T]]
      case Distict(field, None) =>
        coll.distinct((field)).toFuture()
          .asInstanceOf[Future[T]]
      /* find */
      case Find(None, None, optConv, false) =>
        if (optConv == None) coll.find().toFuture().asInstanceOf[Future[T]]
        else coll.find().map(optConv.get).toFuture().asInstanceOf[Future[T]]
      case Find(None, None, optConv, true) =>
        if (optConv == None) coll.find().first().head().asInstanceOf[Future[T]]
        else coll.find().first().map(optConv.get).head().asInstanceOf[Future[T]]
      case Find(Some(filter), None, optConv, false) =>
        if (optConv == None) coll.find(filter).toFuture().asInstanceOf[Future[T]]
        else coll.find(filter).map(optConv.get).toFuture().asInstanceOf[Future[T]]
      case Find(Some(filter), None, optConv, true) =>
        if (optConv == None) coll.find(filter).first().head().asInstanceOf[Future[T]]
        else coll.find(filter).first().map(optConv.get).head().asInstanceOf[Future[T]]
      case Find(None, Some(next), optConv, _) =>
        if (optConv == None) next(coll.find[Document]()).toFuture().asInstanceOf[Future[T]]
        else next(coll.find[Document]()).map(optConv.get).toFuture().asInstanceOf[Future[T]]
      case Find(Some(filter), Some(next), optConv, _) =>
        if (optConv == None) next(coll.find[Document](filter)).toFuture().asInstanceOf[Future[T]]
        else next(coll.find[Document](filter)).map(optConv.get).toFuture().asInstanceOf[Future[T]]
      /* aggregate */
      case Aggregate(pline) => coll.aggregate(pline).toFuture().asInstanceOf[Future[T]]
      /* mapReduce */
      case MapReduce(mf, rf) => coll.mapReduce(mf, rf).toFuture().asInstanceOf[Future[T]]
      /* insert */
      case Insert(docs, Some(opt)) =>
        if (docs.size > 1) coll.insertMany(docs, opt.asInstanceOf[InsertManyOptions]).toFuture()
          .asInstanceOf[Future[T]]
        else coll.insertOne(docs.head, opt.asInstanceOf[InsertOneOptions]).toFuture()
          .asInstanceOf[Future[T]]
      case Insert(docs, None) =>
        if (docs.size > 1) coll.insertMany(docs).toFuture().asInstanceOf[Future[T]]
        else coll.insertOne(docs.head).toFuture().asInstanceOf[Future[T]]
      /* delete */
      case Delete(filter, None, onlyOne) =>
        if (onlyOne) coll.deleteOne(filter).toFuture().asInstanceOf[Future[T]]
        else coll.deleteMany(filter).toFuture().asInstanceOf[Future[T]]
      case Delete(filter, Some(opt), onlyOne) =>
        if (onlyOne) coll.deleteOne(filter, opt.asInstanceOf[DeleteOptions]).toFuture().asInstanceOf[Future[T]]
        else coll.deleteMany(filter, opt.asInstanceOf[DeleteOptions]).toFuture().asInstanceOf[Future[T]]
      /* replace */
      case Replace(filter, replacement, None) =>
        coll.replaceOne(filter, replacement).toFuture().asInstanceOf[Future[T]]
      case Replace(filter, replacement, Some(opt)) =>
        coll.replaceOne(filter, replacement, opt.asInstanceOf[UpdateOptions]).toFuture().asInstanceOf[Future[T]]
      /* update */
      case Update(filter, update, None, onlyOne) =>
        if (onlyOne) coll.updateOne(filter, update).toFuture().asInstanceOf[Future[T]]
        else coll.updateMany(filter, update).toFuture().asInstanceOf[Future[T]]
      case Update(filter, update, Some(opt), onlyOne) =>
        if (onlyOne) coll.updateOne(filter, update, opt.asInstanceOf[UpdateOptions]).toFuture().asInstanceOf[Future[T]]
        else coll.updateMany(filter, update, opt.asInstanceOf[UpdateOptions]).toFuture().asInstanceOf[Future[T]]
      /* bulkWrite */
      case BulkWrite(commands, None) =>
        coll.bulkWrite(commands).toFuture().asInstanceOf[Future[T]]
      case BulkWrite(commands, Some(opt)) =>
        coll.bulkWrite(commands, opt.asInstanceOf[BulkWriteOptions]).toFuture().asInstanceOf[Future[T]]

      /* drop collection */
      case DropCollection(collName) =>
        val coll = db.getCollection(collName)
        coll.drop().toFuture().asInstanceOf[Future[T]]
      /* create collection */
      case CreateCollection(collName, None) =>
        db.createCollection(collName).toFuture().asInstanceOf[Future[T]]
      case CreateCollection(collName, Some(opt)) =>
        db.createCollection(collName, opt.asInstanceOf[CreateCollectionOptions]).toFuture().asInstanceOf[Future[T]]
      /* list collection */
      case ListCollection(dbName) =>
        client.getDatabase(dbName).listCollections().toFuture().asInstanceOf[Future[T]]
      /* create view */
      case CreateView(viewName, viewOn, pline, None) =>
        db.createView(viewName, viewOn, pline).toFuture().asInstanceOf[Future[T]]
      case CreateView(viewName, viewOn, pline, Some(opt)) =>
        db.createView(viewName, viewOn, pline, opt.asInstanceOf[CreateViewOptions]).toFuture().asInstanceOf[Future[T]]
      /* create index */
      case CreateIndex(key, None) =>
        coll.createIndex(key).toFuture().asInstanceOf[Future[T]]
      case CreateIndex(key, Some(opt)) =>
        coll.createIndex(key, opt.asInstanceOf[IndexOptions]).toFuture().asInstanceOf[Future[T]]
      /* drop index */
      case DropIndexByName(indexName, None) =>
        coll.dropIndex(indexName).toFuture().asInstanceOf[Future[T]]
      case DropIndexByName(indexName, Some(opt)) =>
        coll.dropIndex(indexName, opt.asInstanceOf[DropIndexOptions]).toFuture().asInstanceOf[Future[T]]
      case DropIndexByKey(key, None) =>
        coll.dropIndex(key).toFuture().asInstanceOf[Future[T]]
      case DropIndexByKey(key, Some(opt)) =>
        coll.dropIndex(key, opt.asInstanceOf[DropIndexOptions]).toFuture().asInstanceOf[Future[T]]
      case DropAllIndexes(None) =>
        coll.dropIndexes().toFuture().asInstanceOf[Future[T]]
      case DropAllIndexes(Some(opt)) =>
        coll.dropIndexes(opt.asInstanceOf[DropIndexOptions]).toFuture().asInstanceOf[Future[T]]
    }

  }}