3

我所做的工作正常（至少看起来确实如此），但我不相信这是最好的方法......基本上，我想将我的 i18n 翻译放在数据库中而不是属性文件中，以便用户可以轻松编辑这些翻译，并且缓存可以在短时间内将它们提供给其他用户 - 我使用 Akka Actor 从数据库中读取并创建 messageApi 使用的缓存（之前我总是需要重新部署属性文件）。

基本上，我所做的完全是错误的吗？

TranslationActor.scala：

class TranslationActor extends Actor {
  def receive = {
    case _ => {
      Logger.info("Starting to cache the translations")
      TranslationActor.tempCache = ListMap.empty
      var translations: ListMap[String, String] = ListMap.empty
      for (acceptedLanguage <- TranslationActor.acceptedLanguages) {
        val translationLanguageId: Long = TranslationLanguage.findByCode(acceptedLanguage).get.id
        val languageTranslations: Seq[Translation] = Translation.findAllByLanguageId(translationLanguageId)
        translations = new ListMap[String, String]
        for (languageTranslation <- languageTranslations) {
          val tag = EnglishTranslation.findById(languageTranslation.englishTranslationId).get.tag
          var returnedTranslation: String = languageTranslation.translation
          if (returnedTranslation.isEmpty) {
            returnedTranslation = tag
          }
          translations += tag -> new CacheValue(new Locale(acceptedLanguage), returnedTranslation).stringVar
        }
        TranslationActor.tempCache += acceptedLanguage -> translations
      }
      TranslationActor.cache = TranslationActor.tempCache
      Logger.info("Finished to cache the translations")
    }
  }
}

object TranslationActor {
  var acceptedLanguages: Seq[String] = Seq("fr", "en")
  var cache: ListMap[String, ListMap[String, String]] = ListMap.empty
  var tempCache: ListMap[String, ListMap[String, String]] = ListMap.empty
}

class CacheValue(locale: Locale, string: String) {
  val created: Long = System.currentTimeMillis
  var messageFormat: MessageFormat = null
  var localeVar: Locale = locale
  var stringVar: String = string

  def isOlderThan(period: Long): Boolean = {
    (System.currentTimeMillis - created) > (period * 1000)
  }

  def getMessageFormat: MessageFormat = {
    if (messageFormat == null) {
      if (stringVar != null) {
        messageFormat = new MessageFormat(stringVar, localeVar)
      } else {
        messageFormat = new MessageFormat("", localeVar)
      }
    }
    messageFormat
  }
}

ManageTranslationDaemon.scala ：

@Singleton
class ManageTranslationDaemon @Inject() (actorSystem: ActorSystem, applicationLifecycle: ApplicationLifecycle) {
  Logger.info("Scheduling the translation daemon")
  val translationActor = actorSystem.actorOf(Props(new TranslationActor()))
  actorSystem.scheduler.schedule(1 seconds, 30 minutes, translationActor, "translationDaemon")

  applicationLifecycle.addStopHook { () =>
    Logger.info("Shutting down translation daemon")
    Future.successful(actorSystem.shutdown())
  }
}

TranslationGuiceConfiguration.scala ：（来自 com.google.inject.AbstractModule）

class TranslationGuiceConfiguration extends AbstractModule {
  def configure() : Unit = {
    bind(classOf[ManageTranslationDaemon]).asEagerSingleton()
  }
}

然后我在 MessagesPersoApi.scala 中扩展了 DefaultMessagesApi 的一部分（通过查看 MessagesApi 的代码） ：

class MessagesPersoApi @Inject() (environment: Environment, configuration: Configuration, langs: Langs) extends DefaultMessagesApi(environment: Environment, configuration: Configuration, langs: Langs) {

  private def joinPaths(first: Option[String], second: String) = first match {
    case Some(parent) => new java.io.File(parent, second).getPath
    case None => second
  }

  override protected def loadMessages(langCode: String): Map[String, String] = {
    TranslationActor.cache.getOrElse(langCode, loadMessagesFromFile("messages." + langCode))
  }

  protected def loadMessagesFromFile(langCode: String): Map[String, String] = {
    import scala.collection.JavaConverters._
    environment.classLoader.getResources(joinPaths(messagesPrefix, langCode)).asScala.toList
      .filterNot(url => Resources.isDirectory(environment.classLoader, url)).reverse
      .map { messageFile =>
        Messages.parse(Messages.UrlMessageSource(messageFile), messageFile.toString).fold(e => throw e, identity)
      }.foldLeft(Map.empty[String, String]) {_ ++ _}
  }

  override protected def loadAllMessages: Map[String, Map[String, String]] = {
    langs.availables.map(_.code).map { lang =>
      (lang, loadMessages(lang))
    }.toMap
      .+("default" -> loadMessagesFromFile("messages"))
      .+("default.play" -> loadMessagesFromFile("messages.default"))
  }
}

最后创建了一个模块 (play.api.inject.Module) MessagesPersoModule.scala ：

class MessagesPersoModule extends Module {
  def bindings(environment: Environment, configuration: Configuration) = {
    Seq(
      bind[Langs].to[DefaultLangs],
      bind[MessagesApi].to[MessagesPersoApi]
    )
  }
}

最后，在我的application.conf 中使用它：

play.modules.disabled += "play.api.i18n.I18nModule"
play.modules.enabled += "modules.MessagesPersoModule"
play.modules.enabled += "modules.TranslationGuiceConfiguration"

这真的有意义吗？在我看来，写起来有点“复杂”。有没有更简单的方法可以用更少的代码/类来做同样的逻辑？

谢谢，

约安

4

0 回答 0