小编igx*_*igx的帖子

我正在努力更好地理解正确的用法apply和unapply方法.

考虑到我们想要序列化和反序列化的对象,这是正确的使用(即Scala方式)使用apply 和unapply？

case class Foo
object Foo {
    apply(json: JValue): Foo = json.extract[Foo]
    unapply(f: Foo): JValue = //process to json
}

有人可以帮我理解这段代码

case "Foo" Foo(data) -> _ => { /*.. implementation */}

我看到了Foo.unapply(数据)的用法,但我不明白这部分是什么

- > _

如何以及何时使用它

是什么区别HashSet和Set什么时候应该每个人使用？这是Mapvs HashMap:

val hashSet = HashSet("Tomatoes", "Chilies")
val set = Set("Tomatoes", "Chilies")
set == hashSet // res: Boolean = true

看看Scala中的编程(控件抽象)我看到这两个具有相同效果的例子:

1.高阶函数

def withPrintWriter(file: File, op: PrintWriter => Unit) {
  val writer = new PrintWriter(file)
  try {
    op(writer)
  } finally {
    writer.close()
  }
}

2.卷曲功能

def withPrintWriter(file: File)(op: PrintWriter => Unit) {
  val writer = new PrintWriter(file)
  try {
    op(writer)
  } finally {
    writer.close()
  }
}

他们之间有什么区别？我们能否始终以两种方式获得相同的结果？

我在用

scala 1.12.10
akka 2.6.3
addSbtPlugin("io.spray" % "sbt-revolver" % "0.9.1")
addSbtPlugin("com.eed3si9n" % "sbt-assembly" % "1.1.0")

但是，在执行时sbt assembly我得到：

java.lang.UnsupportedOperationException: The Security Manager is deprecated and will be removed in a future release
    at java.base/java.lang.System.setSecurityManager(System.java:416)
    at sbt.TrapExit$.installManager(TrapExit.scala:53)
    at sbt.StandardMain$.runManaged(Main.scala:109)
    at sbt.xMain.run(Main.scala:76)
    at xsbt.boot.Launch$$anonfun$run$1.apply(Launch.scala:111)
    at xsbt.boot.Launch$.withContextLoader(Launch.scala:131)
    at xsbt.boot.Launch$.run(Launch.scala:111)
    at xsbt.boot.Launch$$anonfun$apply$1.apply(Launch.scala:37)
    at xsbt.boot.Launch$.launch(Launch.scala:120)
    at xsbt.boot.Launch$.apply(Launch.scala:20)
    at xsbt.boot.Boot$.runImpl(Boot.scala:56)
    at xsbt.boot.Boot$.main(Boot.scala:18)
    at xsbt.boot.Boot.main(Boot.scala)
[error] [launcher] error during sbt launcher: java.lang.UnsupportedOperationException: The Security Manager is deprecated and will be removed in a future release

运行java …

我试图使用MySql跟随slick2示例.但是当我尝试连接到数据库时,我得到了结束异常

import scala.slick.driver.MySQLDriver.simple._
import slickTest.DB.SuppliersEntity

object slickTestDB {

  def main(args: Array[String]) {
    println("CreateDb!")
    val schemaName = "slickTest"
    val conn_str = "jdbc:mysql://localhost:3306/" + schemaName
    val database = Database.forURL(conn_str,user="",password="",driver="com.mysql.jdbc.Driver")
  }
}

得到这个例外

Exception in thread "main" java.lang.ClassNotFoundException: com.mysql.jdbc.Driver
    at java.net.URLClassLoader$1.run(URLClassLoader.java:366)
    at java.net.URLClassLoader$1.run(URLClassLoader.java:355)
    at java.security.AccessController.doPrivileged(Native Method)
    at java.net.URLClassLoader.findClass(URLClassLoader.java:354)
    at java.lang.ClassLoader.loadClass(ClassLoader.java:425)
    at sun.misc.Launcher$AppClassLoader.loadClass(Launcher.java:308)
    at java.lang.ClassLoader.loadClass(ClassLoader.java:358)
    at java.lang.Class.forName0(Native Method)
    at java.lang.Class.forName(Class.java:190)
    at scala.slick.jdbc.JdbcBackend$DatabaseFactoryDef$$anon$4.<init>(JdbcBackend.scala:62)
    at scala.slick.jdbc.JdbcBackend$DatabaseFactoryDef$class.forURL(JdbcBackend.scala:61)
    at scala.slick.jdbc.JdbcBackend$$anon$2.forURL(JdbcBackend.scala:23)
    at slickTest.slickTestDB$.main(slickTestDB.scala:18)
    at slickTest.slickTestDB.main(slickTestDB.scala)

Looking for a good example of polymorphic serialization deserialization using jackson with scala

got an exception :

Exception in thread "main" Blockquote org.codehaus.jackson.map.exc.UnrecognizedPropertyException: Unrecognized field "animals" (Class Zoo), not marked as ignorable

after trying the following code :

    import org.codehaus.jackson.annotate.{ JsonTypeInfo, JsonSubTypes }
    import org.codehaus.jackson.annotate.JsonSubTypes.Type

    @JsonTypeInfo(
      use = JsonTypeInfo.Id.NAME,
      include= JsonTypeInfo.As.PROPERTY,
      property = "type"
    )
    @JsonSubTypes(Array(
      new Type(value= classOf[Cat] , name = "cat"),
      new Type(value= classOf[Dog] , name = "dog")
    )
    )
    abstract class Animal {
      val name:String  = "NoName" …

akka 文档清楚地表明在这样的actor中创建一个actor很危险:

class ActorA extends Actor {
  def receive = ???
}

final class ActorB extends Actor {
  def receive = {
  case _ =>
  val act = context.actorOf(Props(new ActorA))
}}

据我所知,Actor的apply方法是接受this创建actor的引用.但我无法理解(也找不到任何例子)为什么这有害以及它可能导致什么问题？

我有以下列表:

case class myPair(ids:Int,vals:Int)

val someTable = List((20,30), (89,90), (40,65), (45,75), (35,45))

val someList:List[myPair] =
  someTable.map(elem => myPair(elem._1, elem._2)).toList

我想过滤所有"ids"> 45.我试过类似这篇文章的过滤器使用模式匹配):

someList.filter{ case(myPair) => ids >= 45 }

但没有成功.感谢您的帮助

我试图在使用约束注释反序列化时验证json,但它似乎不起作用.例如

import com.fasterxml.jackson.annotation.JsonProperty;
import javax.validation.constraints.Min;
import javax.validation.constraints.NotNull;

public class SimpleFooRequest {

    @NotNull
    @JsonProperty(value = "count")
    @Min(value = 100,message = "must be min 10")
    private  Integer count;

    @NotNull
    private String name;
    public String getName() {return name; }
    public void setName(String name) { this.name = name; }
    public Integer getCount() {return count;}
    public void setCount(Integer count) {this.count = count;}
}

当试图解散json时

@Test
public void testFooRequest() throws Exception
{
  String fooJson = {"count":-10}
  ObjectMapper mapper = new ObjectMapper()
  SimpleFooRequest request = mapper.readValue(fooJson,SimpleFooRequest.class);
  assert …