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搜索，但有人必须这样做。）

Here's the simpler code.

此版本使用案例类：

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配置会更容易。

如何为Scala应用程序提供基本配置？

5 个答案: