Scala与Mongodb实践2-----图片、日期的存储读取

目的：在IDEA中实现图片、日期等相关的类型在mongodb存储读取

• 主要是Scala和mongodb里面的类型的转换。Scala里面的数据编码类型和mongodb里面的存储的数据类型各个不同。存在类型转换。
• 而图片和日期的转换如下图所示。

1、日期的存取

• 简单借助java.until.Calendar即可。

val ca=Calendar.getInstance()
ca.set()
ca.getTime

• 有多种具体的格式等，再直接应用mgoDateTime等方法

 //显示各种格式
type MGODate = java.util.Date
  def mgoDate(yyyy: Int, mm: Int, dd: Int): MGODate = {
    val ca = Calendar.getInstance()
    ca.set(yyyy,mm,dd)
    ca.getTime()
  }
  def mgoDateTime(yyyy: Int, mm: Int, dd: Int, hr: Int, min: Int, sec: Int): MGODate = {
    val ca = Calendar.getInstance()
    ca.set(yyyy,mm,dd,hr,min,sec)
    ca.getTime()
  }
  def mgoDateTimeNow: MGODate = {
    val ca = Calendar.getInstance()
    ca.getTime
  }
  def mgoDateToString(dt: MGODate, formatString: String): String = {
    val fmt= new SimpleDateFormat(formatString)
    fmt.format(dt)
  }

　　

2、图片的存取（看图片大小，一般都是如下，大于16M的图片即采用GridFS，分别将图片的属性存储）

借助Akka的FileStream

将File（图片）===》Array[Byte]代码格式，图片在mongodb中显示形式binary

具体代码如下：

FileStreaming.scala

package com.company.files

import java.nio.file.Paths
import java.nio._
import java.io._
import akka.stream.{Materializer}
import akka.stream.scaladsl.{FileIO, StreamConverters}

import scala.concurrent.{Await}
import akka.util._
import scala.concurrent.duration._

object FileStreaming {
  def FileToByteBuffer(fileName: String, timeOut: FiniteDuration)(
    implicit mat: Materializer):ByteBuffer = {
    val fut = FileIO.fromPath(Paths.get(fileName)).runFold(ByteString()) { case (hd, bs) =>
      hd ++ bs
    }
    (Await.result(fut, timeOut)).toByteBuffer
  }

  def FileToByteArray(fileName: String, timeOut: FiniteDuration)(
    implicit mat: Materializer): Array[Byte] = {
    val fut = FileIO.fromPath(Paths.get(fileName)).runFold(ByteString()) { case (hd, bs) =>
      hd ++ bs
    }
    (Await.result(fut, timeOut)).toArray
  }

  def FileToInputStream(fileName: String, timeOut: FiniteDuration)(
    implicit mat: Materializer): InputStream = {
    val fut = FileIO.fromPath(Paths.get(fileName)).runFold(ByteString()) { case (hd, bs) =>
      hd ++ bs
    }
    val buf = (Await.result(fut, timeOut)).toArray
    new ByteArrayInputStream(buf)
  }

  def ByteBufferToFile(byteBuf: ByteBuffer, fileName: String)(
    implicit mat: Materializer) = {
    val ba = new Array[Byte](byteBuf.remaining())
    byteBuf.get(ba,0,ba.length)
    val baInput = new ByteArrayInputStream(ba)
    val source = StreamConverters.fromInputStream(() => baInput)  //ByteBufferInputStream(bytes))
    source.runWith(FileIO.toPath(Paths.get(fileName)))
  }

  def ByteArrayToFile(bytes: Array[Byte], fileName: String)(
    implicit mat: Materializer) = {
    val bb = ByteBuffer.wrap(bytes)
    val baInput = new ByteArrayInputStream(bytes)
    val source = StreamConverters.fromInputStream(() => baInput) //ByteBufferInputStream(bytes))
    source.runWith(FileIO.toPath(Paths.get(fileName)))
  }

  def InputStreamToFile(is: InputStream, fileName: String)(
    implicit mat: Materializer) = {
    val source = StreamConverters.fromInputStream(() => is)
    source.runWith(FileIO.toPath(Paths.get(fileName)))
  }
}

• Helpers.scala　　

package com.company.lib

import java.util.concurrent.TimeUnit

import scala.concurrent.Await
import scala.concurrent.duration.Duration
import java.text.SimpleDateFormat
import java.util.Calendar
import org.mongodb.scala._

object Helpers {

  implicit class DocumentObservable[C](val observable: Observable[Document]) extends ImplicitObservable[Document] {
    override val converter: (Document) => String = (doc) => doc.toJson
  }

  implicit class GenericObservable[C](val observable: Observable[C]) extends ImplicitObservable[C] {
    override val converter: (C) => String = (doc) => doc.toString
  }

  trait ImplicitObservable[C] {
    val observable: Observable[C]
    val converter: (C) => String

    def results(): Seq[C] = Await.result(observable.toFuture(), Duration(10, TimeUnit.SECONDS))
    def headResult() = Await.result(observable.head(), Duration(10, TimeUnit.SECONDS))
    def printResults(initial: String = ""): Unit = {
      if (initial.length > 0) print(initial)
      results().foreach(res => println(converter(res)))
    }
    def printHeadResult(initial: String = ""): Unit = println(s"${initial}${converter(headResult())}")
  }

  type MGODate = java.util.Date
  def mgoDate(yyyy: Int, mm: Int, dd: Int): MGODate = {
    val ca = Calendar.getInstance()
    ca.set(yyyy,mm,dd)
    ca.getTime()
  }
  def mgoDateTime(yyyy: Int, mm: Int, dd: Int, hr: Int, min: Int, sec: Int): MGODate = {
    val ca = Calendar.getInstance()
    ca.set(yyyy,mm,dd,hr,min,sec)
    ca.getTime()
  }
  def mgoDateTimeNow: MGODate = {
    val ca = Calendar.getInstance()
    ca.getTime
  }

  def mgoDateToString(dt: MGODate, formatString: String): String = {
    val fmt= new SimpleDateFormat(formatString)
    fmt.format(dt)
  }

}

• 　Model.scala

模型中包含了两个具体的模型Person和Address，二者是包含关系，具体模型内含存取方法

package com.company.demo

import org.mongodb.scala._
import bson._
import java.util.Calendar
import com.company.files._

import akka.stream.ActorMaterializer

object Models {
//Model可存在在不同的模型，下面存在一个拥有代表性的模型Person

  case class Address(
                    //Scala中的字段类型，且String的默认参数是“”
                    city: String ="",
                    zipcode: String = ""
                    ) {
    def toDocument: Document =
      bson.Document(
 //bson.Document是bson包里面的Document，其他包内有不同的Document
        "city" -> city,
        "zipcode" -> zipcode
      )
    def fromDocument(doc: Document): Address =
      this.copy(
        city = doc.getString("city"),
        zipcode = doc.getString("zipcode")
      )
  }
    //这是日期的设置
  val ca = Calendar.getInstance()
  ca.set(2001,10,23)
  val defaultDate = ca.getTime
  case class Person (
                    lastName: String = "Doe",
                    firstName: String = "John",
                    age: Int = 1,
                    phones: List[String] = Nil,
                    address: List[Address] = Nil,
                    birthDate: java.util.Date = defaultDate,
                    picture: Array[Byte] = Array()
                    ) { ctx =>
    def toDocument: Document = {
      var doc = bson.Document(
        "lastName" -> ctx.lastName,
        "firstName" -> ctx.firstName,
        "age" -> ctx.age,
        "birthDate" -> ctx.birthDate
      )
      if (ctx.phones != Nil)
        doc = doc + ("phones" -> ctx.phones)
      if (ctx.address != Nil)
        doc = doc + ("address" -> ctx.address.map(addr => addr.toDocument))
      if (!ctx.picture.isEmpty)
        doc = doc + ("picture" -> ctx.picture)

      doc

    }
    import scala.collection.JavaConverters._
    def fromDocument(doc: Document): Person = {
        //keySet
      val ks = doc.keySet
      ctx.copy(
        lastName = doc.getString("lastName"),
        firstName = doc.getString("firstName"),
        age = doc.getInteger("age"),
        phones = {
            doc.get("phones").asInstanceOf[Option[BsonArray]] match {
            case Some(barr) => barr.getValues.asScala.toList.map(_.toString)
            case None => Nil
          }
        },
        address = {
          if (ks.contains("address")) {
            doc.get("address").asInstanceOf[Option[BsonArray]] match {
              case Some(barr) => barr.getValues.asScala.toList.map (
                ad => Address().fromDocument(ad.asDocument())
              )
              case None => Nil
            }
          }
          else Nil
        },
        picture = {
          if (ks.contains("picture")) {
            doc.get("picture").asInstanceOf[Option[BsonBinary]] match {
              case Some(ba) => ba.getData
              case None => Array()
            }
          }
          else Array()
        }
      )
    }
     //在控制台显示的格式。
    def toSink()(implicit mat: ActorMaterializer) = {
      println(s"LastName: ${ctx.lastName}")
      println(s"firstName: ${ctx.firstName}")
      println(s"age: ${ctx.age}")
      println(s"phones: ${ctx.phones}")
      println(s"address ${ctx.address}")
      if(!ctx.picture.isEmpty) {
        val path = s"/img/${ctx.firstName}.jpg"
        FileStreaming.ByteArrayToFile(ctx.picture,path)
        println(s"picture saved to: ${path}")
      }
    }

  }

}

　　

• PersonCRUD.scala简单测试

package com.company.demo

import org.mongodb.scala._
import bson._
import java.util.Calendar
import scala.collection.JavaConverters._
import com.company.lib.Helpers._
import com.company.files.FileStreaming._
import akka.actor._
import akka.stream._
import scala.concurrent.duration._
import scala.util._

object PersonCRUD extends  App {
  import Models._

    implicit val system = ActorSystem()
    implicit val ec = system.dispatcher
    implicit val mat = ActorMaterializer()

    // or provide custom MongoClientSettings
    val settings: MongoClientSettings = MongoClientSettings.builder()
      .applyToClusterSettings(b => b.hosts(List(new ServerAddress("localhost")).asJava))
      .build()
    val client: MongoClient = MongoClient(settings)
    val mydb = client.getDatabase("mydb")
    val mytable = mydb.getCollection("personal")

    val susan = Person(
      lastName = "Wang",
      firstName = "Susan",
      age = 18,
      phones = List("137110998","189343661"),
      address = List(
        Address("Sz","101992"),
        Address(city = "gz", zipcode="231445")
      ),
      birthDate = mgoDate(2001,5,8),
      picture = FileToByteArray("/img/sc.jpg",3 seconds)
    )
/*
    val futResult = mytable.insertOne(susan.toDocument).toFuture()

    futResult.onComplete {
      case Success(value) => println(s"OK! ${value}")
      case Failure(err) => println(s"Boom!!! ${err.getMessage}")
    }

    scala.io.StdIn.readLine() */
  mytable.find().toFuture().andThen {
    case Success(ps) => ps.foreach(Person().fromDocument(_).toSink())
    case Failure(err) => println(s"ERROR: ${err.getMessage}")
  }
  scala.io.StdIn.readLine()
  system.terminate()
  }