如何為Scala應用程序提供基本配置？

Question

我正在研究用Scala編寫的小型GUI應用程序。 用戶將在GUI中設置一些設置，我希望它們在程序執行之間保持不變。 基本上我想要一個scala.collections.mutable.Map，它會在修改后自動保存到文件中。

這似乎是一個常見的問題，但我一直無法找到輕量級的解決方案。 這個問題通常如何解決？

Answer 1

我做了很多這個，我使用.properties文件（它在Java-land中是慣用的）。 不過，我的設計非常直觀。 如果您有嵌套的配置構造，您可能需要不同的格式，如YAML（如果人類是主要作者）或JSON或XML（如果機器是作者）。

下面是一些加載道具的示例代碼，操作為Scala Map，然后再次保存為.properties：

import java.io._
import java.util._
import scala.collection.JavaConverters._

val f = new File("test.properties")
// test.properties:
//   foo=bar
//   baz=123

val props = new Properties

// Note: in real code make sure all these streams are 
// closed carefully in try/finally
val fis = new InputStreamReader(new FileInputStream(f), "UTF-8")
props.load(fis)
fis.close()

println(props) // {baz=123, foo=bar}

val map = props.asScala // Get to Scala Map via JavaConverters
map("foo") = "42"
map("quux") = "newvalue"

println(map)   // Map(baz -> 123, quux -> newvalue, foo -> 42)
println(props) // {baz=123, quux=newvalue, foo=42}

val fos = new OutputStreamWriter(new FileOutputStream(f), "UTF-8")
props.store(fos, "")
fos.close()

Answer 2

這是使用XML和案例類來讀取配置的示例。 真正的類可以比地圖更好。 （您也可以執行sbt和至少一個項目的操作，將配置作為Scala源並將其編譯進去;保存它不太自動。或者作為repl腳本。我沒有用Google搜索，但有人必須這樣做。 ）

這是更簡單的代碼。

此版本使用案例類：

case class PluginDescription(name: String, classname: String) {
  def toXML: Node = {
    <plugin>
      <name>{name}</name>
      <classname>{classname}</classname>
    </plugin>
  }
}
object PluginDescription {

  def fromXML(xml: Node): PluginDescription = {
    // extract one field
    def getField(field: String): Option[String] = {
      val text = (xml \\ field).text.trim
      if (text == "") None else Some(text)
    }
    def extracted = {
      val name = "name"
      val claas = "classname"
      val vs = Map(name -> getField(name), claas -> getField(claas))
      if (vs.values exists (_.isEmpty)) fail()
      else PluginDescription(name = vs(name).get, classname = vs(claas).get)
    }
    def fail() = throw new RuntimeException("Bad plugin descriptor.")
    // check the top-level tag
    xml match {
      case <plugin>{_*}</plugin>  => extracted
      case _                      => fail()
    }
  }
}

此代碼反射性地調用case類的應用。 用例是默認args可以提供config中缺少的字段。 這里沒有類型轉換。 例如， case class Config(foo: String = "bar") 。

// isn't it easier to write a quick loop to reflect the field names?
import scala.reflect.runtime.{currentMirror => cm, universe => ru}
import ru._

def fromXML(xml: Node): Option[PluginDescription] = {
  def extract[A]()(implicit tt: TypeTag[A]): Option[A] = {
    // extract one field
    def getField(field: String): Option[String] = {
      val text = (xml \\ field).text.trim
      if (text == "") None else Some(text)
    } 

    val apply = ru.newTermName("apply")
    val module = ru.typeOf[A].typeSymbol.companionSymbol.asModule
    val ts = module.moduleClass.typeSignature
    val m = (ts member apply).asMethod
    val im = cm reflect (cm reflectModule module).instance
    val mm = im reflectMethod m

    def getDefault(i: Int): Option[Any] = {
      val n = ru.newTermName("apply$default$" + (i+1))
      val m = ts member n
      if (m == NoSymbol) None
      else Some((im reflectMethod m.asMethod)())
    } 
    def extractArgs(pss: List[List[Symbol]]): List[Option[Any]] =
      pss.flatten.zipWithIndex map (p => getField(p._1.name.encoded) orElse getDefault(p._2))
    val args = extractArgs(m.paramss)
    if (args exists (!_.isDefined)) None
    else Some(mm(args.flatten: _*).asInstanceOf[A])
  } 
  // check the top-level tag
  xml match {
    case <plugin>{_*}</plugin>  => extract[PluginDescription]()
    case _                      => None
  } 
} 

XML有loadFile並且save ，它太糟糕了，似乎沒有Properties的單行。

$ scala
Welcome to Scala version 2.10.0-RC5 (Java HotSpot(TM) 64-Bit Server VM, Java 1.7.0_06).
Type in expressions to have them evaluated.
Type :help for more information.

scala> import reflect.io._
import reflect.io._

scala> import java.util._
import java.util._

scala> import java.io.{StringReader, File=>JFile}
import java.io.{StringReader, File=>JFile}

scala> import scala.collection.JavaConverters._
import scala.collection.JavaConverters._

scala> val p = new Properties
p: java.util.Properties = {}

scala> p load new StringReader(
     | (new File(new JFile("t.properties"))).slurp)

scala> p.asScala
res2: scala.collection.mutable.Map[String,String] = Map(foo -> bar)

Answer 3

因為這一切歸結為將地圖/對象序列化為文件，您的選擇是：

• 經典序列化到字節碼
• 序列化為XML
• 序列化為JSON（易於使用Jackson或Lift-JSON）
• 使用屬性文件（丑陋，沒有utf-8支持）
• 序列化為專有格式（丑陋，為什么重新發明輪子）

Answer 4

我建議將Map轉換為Properties，反之亦然。 “* .properties”文件是在Java世界中存儲配置的標准文件，為什么不將它用於Scala？

Answer 5

常見的方法是*。 屬性，* .xml，因為scala本身支持xml，所以在java中使用xml配置會更容易。