Mongodb Scala DAO

這篇文章將說說，我使用 MongoDB & Cashbah 的一些心得，這程式的主架構是我從 simplistic 學來的。

The Abstract DAO

底下是一個很簡單的 CRUD 的 MongoDB DAO. 在這邊，我們建立一個 DAO 時，我們會把這個 DAO 用的儲存空間 MongoCollection 傳進來，另外要注意的一點是，這個 MongoCollection 的 WriteConcert 必需是 Strict 的。

/**
 *  Base class for all DAO classes.
 */
abstract class AbstractDAO[T, ID <: Serializable](protected[locadz] val mongoCol: MongoCollection) {

  /** builder to turn mongodb object into model object */
  implicit protected val builder: DBObject => Either[DataAccessException, T]

  /** builder to turn model object into mongodb object */
  implicit protected val extractor: T => DBObject

  /** this dao expects the underlying mongoCol would throw exception when error occurs. */
  require(mongoCol.getWriteConcern != null)
  require(mongoCol.getWriteConcern.getW >= 1, "Write must be >= 1, was %d".format(mongoCol.getWriteConcern.getW))

  /** insert object into the underly*/
  def insert(obj: T): Either[DataAccessException, ID] = {
    try {
      val dbObj: DBObject = extractor(obj)
      val res: WriteResult = mongoCol.insert(dbObj)
      Right(dbObj.getAs[ID]("_id").get)
    } catch {
      case e: MongoException      => Left(new DataAccessException(e))
      case e: DataAccessException => Left(e)
    }
  }

  def save(obj: T): Option[DataAccessException] = {
    try {
      val res = mongoCol.save[T](obj)
      None
    } catch {
      case e: MongoException      => Some(new DataAccessException(e))
      case e: DataAccessException => Some(e)
    }
  }

  def findById(id: ID): Either[DataAccessException, Option[T]] = {
    try {
      mongoCol.findOneByID(id) match {
        case None        => Right(None)
        case Some(dbObj) => builder.apply(dbObj).right.map(Option(_))
      }
    } catch {
      case e: DataAccessException => Left(e)
    }
  }

  def delete(id: ID): Option[DataAccessException] = {
    try {
      mongoCol.remove(MongoDBObject("_id" -> id))
      None
    } catch {
      case e: MongoException => Some(new DataAccessException(e))
    }
  }

  def find[T](dbObj: DBObject)(implicit builder: (DBObject) => Either[DataAccessException, T]): Either[DataAccessException, Iterable[T]] = {

    try {
      Right(mongoCol.find(dbObj)
        .flatMap(found => {
          builder.apply(found).fold(
            e => throw e,
            r => Some(r))
        }).toStream)

    } catch {
      case e: DataAccessException => Left(e)
    }
  }
}

這邊有兩個需要被實作的東西

val builder: DBObject => Either[DataAccessException, T]
val extractor: T => DBObject

而怎麼建立這兩個東西，就是全文的重點了。

How to use AbstractDAO

先來看一個範例；實作上，在 UserDAO object 上，我們先把欄位的名稱及資料型態，一個個的定好

‘val Name = attribute("name", Conversion.String)`
‘val Email = attribute("email", Conversion.String)’
‘val CreateDate = attribute("ctime", Conversion.JodaDate)’

而這個 attribute method 做的是，把資料名稱存起來，然後當這個 Attribute instance

收到一個 DBObject 時，把對應的欄位取出來，並將值給轉成定義的格式
收到一個 property value 時，把他轉成 (name -> value) pair

第一個用法的這個方式，用在從 builder 上面，一個個的把值從 DBObject 抓出來再來建立物件，第二個用法用在，把物件轉成 DBObject 時，及用在建立 query 時。

UserDAO 實作

class UserDAO(mongoCol: MongoCollection) extends AbstractDAO[User, String](mongoCol) {

  import UserDAO._

  implicit protected val builder: (DBObject) => Either[DataAccessException, User] = UserDAO.dbObjectToUser _

  implicit protected val extractor: (User) => DBObject = UserDAO.userToDBObject _

  def this(dbCol: DBCollection) = this(dbCol.asScala)

}

object UserDAO {

  import Attributes._

  val Name = attribute("name", Conversion.String)

  val Email = attribute("email", Conversion.String)

  val CreateDate = attribute("ctime", Conversion.JodaDate)

  def dbObjectToUser(dbObj: DBObject): Either[DataAccessException, User] = {

    try {
      val id = dbObj.getAs[String]("_id").get

      Right(
        new User(id,
          Name(dbObj),
          Email(dbObj),
          CreateDate(dbObj)
        )
      )
    } catch {
      case e: DataAccessException => Left(e)
    }
  }

  implicit def userToDBObject(user: User): DBObject = {

    val ret = MongoDBObject("_id" -> user.id)
    ret += Name(user.externalId)
    ret += Email(user.verifiedId)
    ret += CreateDate(user.createDate)
    return ret
  }
}

Attribute & Conversion 部份實作

trait Attribute[A, B <: Any] {
  val name: String
  val conversion: Conversion[A, B]

  protected implicit val manifestA: Manifest[A]
  protected implicit val manifestB: Manifest[B]
}

trait RequiredAttribute[A, B <: Any] extends Attribute[A, B] {

  def apply(value: A): Tuple2[String, B] = {
    name -> conversion.apply(value)
  }

  def apply(value: DBObject): A = {
    value.getAs[B](name).map(b => conversion.unapply(b)).getOrElse(throw new MissingRequiredAttributeException(name))
  }
}

def attribute[A, B <: Any](name: String, dataType: Conversion[A, B])(implicit manifestA: Manifest[A], manifestB: Manifest[B]) = {
  new SingleValueRequiredAttribute[A, B](name, dataType)
}


trait Conversion[A, B] {
  def apply(source: A): B
  def unapply(value: B): A
}

object Conversion {
  case object String extends Conversion[String, String] {
    override def apply(source: String) = source
    override def unapply(value: String) = value
  }

  /**
   * Conversion for DateTime to DateTime.
   */
  object JodaDate extends Conversion[DateTime, DateTime] {

    RegisterJodaTimeConversionHelpers()

    override def apply(source: DateTime): DateTime = source
    override def unapply(value: DateTime): DateTime = value
  }
}

How to Use Attributes to Build Query

前面的 Attribute(s) 不只是用來產做 builder 及 extractor 用的，他們最好用的地方在於建立 query 時，如下

def findByDateRange(start: DateTime, end: DateTime): Either[DataAccessException, User] = {
  return find(CreateDate.name $gth CreateDate(start)._2  $lt CreateDate(range)._2)
}

這邊，我們可以看到用 Conversion 來描述資料型態的好處是，當你儲存的資料型態有變時，你不用去更改你的 MongoDB query ，欄位的名稱、資料型別的轉換，都被封裝起來，使用者在寫 Query 時，不用去記欄位的名稱，也不用去記這個欄位的型態是什麼， MongoDB 支不支援這個型態。

第二個好處是， Casbah 本來只支援 java primitive type & java.util.Date ，透過 Conversion ，我們可以支援任意的資料型態於 query 中，只要透過新的 Conversion 類別，我們就可以增加 MongoDB 可以支援的資料型態。

例如，如果我們想增加對 java.net.URL 的支援，只要訂義以下的 Conversion 即可

case object Url extends Conversion[URL, String] {

  override def apply(source: URL) = source.toExternalForm

  override def unapply(value: String) = new URL(value)
}

Appendix:

Attribute.scala

package com.locadz.model.mongodb

import com.mongodb.DBObject
import com.mongodb.casbah._
import com.locadz.model.exception.MissingRequiredAttributeException

/**
 * Date: 2/20/12
 */
object Attributes {

  trait Attribute[A, B <: Any] {
    val name: String
    val conversion: Conversion[A, B]

    protected implicit val manifestA: Manifest[A]

    protected implicit val manifestB: Manifest[B]

  }

  trait OptionalAttribute[A, B <: Any] extends Attribute[A, B] {

    def apply(value: Option[A]): Tuple2[String, Any] = {
      val v = value.map(conversion.apply(_)).getOrElse(null)
      name -> v
    }

    def apply(value: DBObject): Option[A] = value.getAs[B](name).map(b => conversion.unapply(b))

  }

  trait RequiredAttribute[A, B <: Any] extends Attribute[A, B] {

    def apply(value: A): Tuple2[String, B] = {
      name -> conversion.apply(value)
    }

    def apply(value: DBObject): A = {
      value.getAs[B](name).map(b => conversion.unapply(b)).getOrElse(throw new MissingRequiredAttributeException(name))
    }
  }

  case class SingleValueRequiredAttribute[A, B <: Any](name: String, conversion: Conversion[A, B])(implicit val manifestA: Manifest[A], implicit val manifestB: Manifest[B]) extends RequiredAttribute[A, B]

  case class SingleValueOptionalAttribute[A, B <: Any](name: String, conversion: Conversion[A, B])(implicit val manifestA: Manifest[A], implicit val manifestB: Manifest[B])
    extends OptionalAttribute[A, B]

  def attribute[A, B <: Any](name: String, dataType: Conversion[A, B])(implicit manifestA: Manifest[A], manifestB: Manifest[B]) = {
    new SingleValueRequiredAttribute[A, B](name, dataType)
  }

  def optionalAttribute[A, B <: Any](name: String, dataType: Conversion[A, B])(implicit manifestA: Manifest[A], manifestB: Manifest[B]) = {
    new SingleValueOptionalAttribute[A, B](name, dataType)
  }

}

最近访客更多访客>>

博主相关

文章分类

社区版块

存档分类

最新评论