Imagine you needed to build a caching system in front of a slow backend system with the following requirements:<\/p>\n
Here’s a possible solution taking advantage of Akka actors and Scala’s support for functions as first class objects. \u00a0 The first piece of the puzzle is a The The Here is an example of the The The caching implementation of Using Here’s the code for the CacheSystem<\/code> which creates and queries EhCache caches:<\/p>\nclass CacheSystem(name: String, updateIntervalMin: Int, cacheManager: CacheManager) {\r\n var caches = List.empty[Cache]\r\n val actorSystem = ActorSystem(\"cache_\" + name)\r\n\r\n val DEFAULT_TTL_SEC = 86400 \/\/ 1 day\r\n\r\n def addCache(name: String, size: Int, ttlSeconds: Int = DEFAULT_TTL_SEC): Cache = {\r\n val config = new CacheConfiguration(name, size)\r\n config.setTimeToIdleSeconds(ttlSeconds)\r\n val cache = new Cache(config)\r\n cacheManager.addCache(cache)\r\n caches = cache :: caches\r\n cache\r\n }\r\n\r\n def createCacheActor(cacheName: String, cacheSize: Int, scheduleDelay: Duration, \r\n actorCreator: (Cache, CacheSystem) => Actor, \r\n ttlSeconds: Int = DEFAULT_TTL_SEC): ActorRef = {\r\n\r\n val cache = addCache(cacheName, cacheSize, ttlSeconds)\r\n val actor = actorSystem.actorOf(Props(actorCreator(cache, this)), \r\n name = cacheName + \"CacheActor\")\r\n\r\n actorSystem.scheduler.schedule(scheduleDelay, updateIntervalMin minutes, \r\n actor, UpdateCacheForNow) \r\n if (!DateUtil.isNowInActiveBusinessDay) {\r\n actorSystem.scheduler.scheduleOnce(scheduleDelay, actor, \r\n UpdateCacheForPreviousBusinessDay)\r\n }\r\n\r\n actor\r\n }\r\n\r\n def findCachedObject[T](key: String, cache: Cache, finder: () => T): Option[T] = {\r\n val element = cache.get(key)\r\n\r\n if (element == null) {\r\n findObjectForCache(key, cache, finder)\r\n } else {\r\n Some(element.getObjectValue.asInstanceOf[T])\r\n }\r\n }\r\n\r\n def findObjectForCache[T](key: String, cache: Cache, finder: () => T): Option[T] = {\r\n val domainObj = finder()\r\n if (domainObj != null) {\r\n val element = new Element(key, domainObj)\r\n cache.put(element)\r\n Some(domainObj)\r\n } else {\r\n None\r\n }\r\n }\r\n\r\n def clearAllCaches() {\r\n caches.foreach(_.removeAll())\r\n }\r\n}<\/pre>\ncreateCacheActor<\/code> method creates a cache and an actor, and schedules tasks to periodically update the cache. I decided to use actors for this because the actor system’s thread pool is a good way to meet the throttling requirement. In addition using the Akka API it is easy to have scheduled tasks send messages to actors. \u00a0createCacheActor<\/code> takes a function of \u00a0(Cache, CacheSystem) => Actor<\/code> to create the actor. \u00a0 It then fills in those parameters to create the actor using the Akka actorOf<\/code> method.<\/p>\nfindCachedObject<\/code> and findObjectForCache<\/code> methods take a finder<\/code> function of () => T<\/code> that handles the lookup of objects from the backend system.<\/p>\nCacheSystem<\/code> being used by the business logic layer:<\/p>\nclass CachingBusinessService(bizService: BusinessService) extends BusinessService {\r\n implicit val timeout = Timeout(60 seconds)\r\n\r\n val service1CacheActor = \r\n cacheSystem.createCacheActor(\"service1\", DATE_CACHE_SIZE, 0 seconds, \r\n new Service1CacheActor(_, _, bizService))\r\n \/\/ ... more actors created here\r\n\r\n def service1(date: Date, useFoo: Boolean): JList[Service1Result] = {\r\n val future = \r\n service1CacheActor ? FindValue(new Service1Params(date, useFoo))\r\n Await.result(future, timeout.duration).asInstanceOf[JList[Service1Result]]\r\n }\r\n\r\n \/\/ ... more service methods\r\n}<\/pre>\nCachingBusinessService<\/code> is a caching implementation of the BusinessService<\/code> interface. It creates CacheActor<\/code>s to service the requests. \u00a0 To create the Service1CacheActor<\/code> it passes a curried constructor to createCacheActor<\/code>.<\/p>\nservice1<\/code> sends a FindValue<\/code> message to the service1CacheActor<\/code>, using the ?<\/code> (ask<\/code>) method which returns an Akka Future<\/code>. \u00a0Then it waits for the result of the future and returns it to the caller.<\/p>\nAwait.result<\/code> should raise a red flag. You don’t want to block if you don’t have to (epsecially inside of an actor). However in this case the BusinessService<\/code> is being called as part of a REST API served by a non-async HTTP server. Before the caching layer was introduced it would block waiting for the back end to to respond.<\/p>\nFindValue<\/code> message and the Params<\/code> that it contains. \u00a0Params<\/code> are the parameters for the backend query. Each unique Params<\/code> object corresponds to a cache entry so each Params<\/code> subclass is responsible for generating the appropriate cache key.<\/p>\nobject CacheActor {\r\n case class FindValue(params: Params)\r\n\r\n trait Params {\r\n def cacheKey: String\r\n }\r\n}<\/pre>\n