Question

我做的很好（至少它看起来确实如此），但我不相信这是最好的方法...... 基本上，我想将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()
  }
}

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

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"

这真的有意义吗？在我看来，它有点复杂＆＃34;来写。是否有更简单的方法可以用更少的代码/类来完成相同的逻辑？

谢谢，

的Yoann

Play 2.4 + i18n：使用数据库而不是属性文件进行国际化

0 个答案: