restapi作為前后端互動的樞紐：面對大批量的前端請求，需要確保回復的及時性，使用快取是一項有效工具，我們可以把多數前端請求的回復response存入快取，特別是一些需要大量計算才能獲取的回復值，更可以大大提高后端的反應速度，值得慶幸的是akka-http已經提供了對快取的支持，是基于java8 caffein的一套快取操作工具包的，下面就介紹一下akka-http的caching，
akka-http caching 有個依賴：
"com.typesafe.akka" %% "akka-http-caching" % akkaHttpVersion,
先從快取存盤結構開始，看看下面的一段快取結構定義：
import akka.http.scaladsl.util.FastFuture
import akka.http.caching.scaladsl.Cache
import akka.http.caching.scaladsl.CachingSettings
import akka.http.caching.LfuCache
val defaultCachingSettings = CachingSettings(sys)
val lfuCacheSettings = //最少使用排除演算法快取
defaultCachingSettings.lfuCacheSettings
.withInitialCapacity(128) //起始單位
.withMaxCapacity(1024) //最大單位
.withTimeToLive(1.hour) //最長存留時間
.withTimeToIdle(30.minutes) //最長未使用時間
val cachingSettings =
defaultCachingSettings.withLfuCacheSettings(lfuCacheSettings)
//key -> String
val lfuCache: Cache[String, Option[Map[String, Any]]] = LfuCache(cachingSettings)
lfuCache是一種基于使用頻率演算法的快取管理系統，這個我們就不必多說了，最好能拿個例子來示范解釋：剛好手頭有個獲取用戶資訊的http請求樣板：
val route = pathPrefix(pathName) {
pathPrefix("getuserinfo") {
(get & parameter('userid)) { userid => {
val userinfo = posRepo.getUserInfo(userid)
userinfo match {
case Some(ui) => complete(toJson(ui))
case None => complete(toJson(Map[String, Any](("TERMINALID" -> ""))))
}
}
}
}
def getUserInfo(userid: String): Option[UserInfo] = {
val sql = "SELECT CUSTOMERS.SHOPID AS SHOPID, TERMINALID, DEVICEID, IMPSVCURL FROM CUSTOMERS INNER JOIN TERMINALS " +
" ON CUSTOMERS.SHOPID=TERMINALS.SHOPID " +
" WHERE (CUSTOMERS.DISABLED=0 AND TERMINALS.DISABLED=0) " +
" AND (CUSTOMERS.EXPDATE > GETDATE() AND TERMINALS.EXPDATE > GETDATE()) AND TERMINALID='" + userid + "'"
val rows = query[Map[String, Any]]("mpos", sql, rsc.resultSet2Map)
val futUI: Future[Option[Map[String, Any]]] = rows.runWith(Sink.lastOption)
Await.result(futUI, 3 seconds)
}
當收到前端 http://mycom.com/pos/getuserinfo?userid=1234 這樣的請求時需要從資料庫里讀取用戶資訊資料及進行一些轉換處理，這個請求呼叫得頻率較高、資料庫讀取也比較耗時，是個實在的例子，我們來看看如何實作快取管理：
在akka-http里可以用兩種方式來實作快取管理：1、直接用cache工具，2、用akka-http提供的Directive: cache, alwaysCache
我們先看看如何直接使用cache操作，先看看Cache的構建：
abstract class Cache[K, V] extends akka.http.caching.javadsl.Cache[K, V] {
cache =>
/**
* Returns either the cached Future for the given key or evaluates the given value generating
* function producing a `Future[V]`.
*/
def apply(key: K, genValue: () => Future[V]): Future[V]
Cache[K,V]是以K為鍵，一個（）=> Future[V]為值的結構，也就是說我們需要把一個獲取Future值的函式存在快取里：
pathPrefix("getuserinfo") {
(get & parameter('userid)) { userid => {
val userinfo = lfuCache.getOrLoad(userid, _ => posRepo.futureUserInfo(userid))
onComplete(userinfo) {
_ match {
case Success(oui) => oui match {
case Some(ui) => complete(toJson(ui))
case None => complete(toJson(Map[String, Any](("TERMINALID" -> ""))))
}
case Failure(_) => complete(toJson(Map[String, Any](("TERMINALID" -> ""))))
}
}
}
}
def futureUserInfo(userid: String): Future[Option[Map[String, Any]]] = {
val sql = "SELECT CUSTOMERS.SHOPID AS SHOPID, TERMINALID, DEVICEID, IMPSVCURL FROM CUSTOMERS INNER JOIN TERMINALS " +
" ON CUSTOMERS.SHOPID=TERMINALS.SHOPID " +
" WHERE (CUSTOMERS.DISABLED=0 AND TERMINALS.DISABLED=0) " +
" AND (CUSTOMERS.EXPDATE > GETDATE() AND TERMINALS.EXPDATE > GETDATE()) AND TERMINALID='" + userid + "'"
val rows = query[Map[String, Any]]("mpos", sql, rsc.resultSet2Map)
rows.runWith(Sink.lastOption)
}
首先我們需要把getUserInfo修改成futureUserInfo，然后傳入cache.getOrLoad()：
/**
* Returns either the cached Future for the given key, or applies the given value loading
* function on the key, producing a `Future[V]`.
*/
def getOrLoad(key: K, loadValue: K => Future[V]): Future[V]
跟著我們再試試用akka-http的Directive, cache和alwaysCache，這兩個是同一個東西，只是cache多了個是否使用快取這么個控制，是通過request-header Cache-Control來實作的，如：Cache-Control`(`no-cache`)，cache函式是這樣定義的；
def cache[K](cache: Cache[K, RouteResult], keyer: PartialFunction[RequestContext, K]): Directive0
這個函式回傳Directive0, 可以直接對應 { ... complete(...) }，所以cache可以把一個route包嵌在里面如：
cache(myCache, simpleKeyer) {
complete {
i += 1
i.toString
}
}
simpleKeyer是個K對應函式：在我們這個例子里K -> Uri, Cache[Uri,RouteResult]，這里有個現成的構建器：routeCache[Uri]
/**
* Creates an [[LfuCache]] with default settings obtained from the system's configuration.
*/
def routeCache[K](implicit s: ActorSystem): Cache[K, RouteResult] =
LfuCache[K, RouteResult](s)
不過這個LfuCache使用了application.conf里面的cachingSettings. 我們想直接控制lfuCache構建，所以可以用:
val lfuCache = LfuCache[Uri,RouteResult](cachingSettings)
alwaysCache的具體使用和上面的cache.getOrLoad相同：
import akka.http.scaladsl.model.{HttpMethods, StatusCodes, Uri}
import akka.http.scaladsl.util.FastFuture
import akka.http.caching.scaladsl.Cache
import akka.http.caching.scaladsl.CachingSettings
import akka.http.caching.LfuCache
import akka.http.scaladsl.server.RequestContext
import akka.http.scaladsl.server.RouteResult
import akka.http.scaladsl.server.directives.CachingDirectives._
import scala.concurrent.duration._
import scala.util._
val defaultCachingSettings = CachingSettings(sys)
val lfuCacheSettings = //最少使用排除演算法快取
defaultCachingSettings.lfuCacheSettings
.withInitialCapacity(128) //起始單位
.withMaxCapacity(1024) //最大單位
.withTimeToLive(1.hour) //最長存留時間
.withTimeToIdle(30.minutes) //最長未使用時間
val cachingSettings =
defaultCachingSettings.withLfuCacheSettings(lfuCacheSettings)
//Uri->key, RouteResult -> value
val lfuCache = LfuCache[Uri,RouteResult](cachingSettings)
//Example keyer for non-authenticated GET requests
val simpleKeyer: PartialFunction[RequestContext, Uri] = {
val isGet: RequestContext => Boolean = _.request.method == HttpMethods.GET
// val isAuthorized: RequestContext => Boolean =
// _.request.headers.exists(_.is(Authorization.lowercaseName))
val result: PartialFunction[RequestContext, Uri] = {
case r: RequestContext if isGet(r) => r.request.uri
}
result
}
val route = pathPrefix(pathName) {
pathPrefix("getuserinfo") {
(get & parameter('userid)) { userid => {
alwaysCache(lfuCache,simpleKeyer) {
onComplete(posRepo.futureUserInfo(userid)) {
_ match {
case Success(oui) => oui match {
case Some(ui) => complete(toJson(ui))
case None => complete(toJson(Map[String, Any](("TERMINALID" -> ""))))
}
case Failure(_) => complete(toJson(Map[String, Any](("TERMINALID" -> ""))))
}
}
}
}
}
} ~
好了，我覺著可能直接呼叫cache.getOrLoad會更好些，因為akka-http還在不停的變，java8caffein應該不會再調整了吧，
轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/180704.html
標籤：Scala