import org.json4s.DefaultFormats import org.json4s.native.Serialization.{read, write} implicit lazy val formats: DefaultFormats.type = DefaultFormats val source = env.addSource(new SourceFunc_UserInfo()) val dataStream = source // map .map(data => write(data)) // 转 json .map(json => read[UserInfo](json)) // 转 case class

你使用哪款产品呢？提供下相关截图。

不好意思，我去那篇文章下面留言

像是编译器安排了一个类级位图int字段，将多个延迟字段标记为初始化(或未初始化)，并在同步块中初始化目标字段(如果位图的相关xor表明必要的话)。 使用： class Something { lazy val foo = getFoo def getFoo = "foo!" } 生成示例字节码： 0 aload_0 [this] 1 getfield blevins.example.Something.bitmap$0 : int [15] 4 iconst_1 5 iand 6 iconst_0 7 if_icmpne 48 10 aload_0 [this] 11 dup 12 astore_1 13 monitorenter 14 aload_0 [this] 15 getfield blevins.example.Something.bitmap$0 : int [15] 18 iconst_1 19 iand 20 iconst_0 21 if_icmpne 42 24 aload_0 [this] 25 aload_0 [this] 26 invokevirtual blevins.example.Something.getFoo() : java.lang.String [18] 29 putfield blevins.example.Something.foo : java.lang.String [20] 32 aload_0 [this] 33 aload_0 [this] 34 getfield blevins.example.Something.bitmap$0 : int [15] 37 iconst_1 38 ior 39 putfield blevins.example.Something.bitmap$0 : int [15] 42 getstatic scala.runtime.BoxedUnit.UNIT : scala.runtime.BoxedUnit [26] 45 pop 46 aload_1 47 monitorexit 48 aload_0 [this] 49 getfield blevins.example.Something.foo : java.lang.String [20] 52 areturn 53 aload_1 54 monitorexit 55 athrow 以元组开头的值，如lazy val (x,y) = { ... }通过相同的机制进行嵌套缓存。元组结果是延迟计算和缓存的，对x或y的访问将触发元组计算。从元组中提取单个值是独立和懒惰地进行的(并缓存)。因此，上述双实例化代码将生成一个x，y和一个x$1的Tuple2 类型域

可以定义： implicit def idToSideEffect[A](a: A) = new { def withSideEffect(fun: A => Unit): A = { fun(a); a } def |!>(fun: A => Unit): A = withSideEffect(fun) // forward pipe-like def tap(fun: A => Unit): A = withSideEffect(fun) // public demand & ruby standard } 然后： calcSomeResult() |!> { rs => logger.info("result is:" + rs) } calcSomeResult() tap println

将Scala依赖项添加到maven构建中可以解决以下问题： <dependency> <groupId>org.scala-lang</groupId> <artifactId>scala-library</artifactId> <version>2.10.3</version> </dependency>

在KafkaIO或交替启用自动提交在Kafka消费者配置。请注意，同时commitOffsetsInFinalize()与卡夫卡的自动提交相比，它更多的是与在BEAM中被处理的内容同步，它不能提供精确的一次处理的强有力的保证。想象一个两阶段的流水线，数据流完成卡夫卡阅读器后的第一阶段，而不等待第二阶段完成。如果从零开始重新启动管道，则不会处理完成第一阶段的记录，但第二阶段尚未处理。对PubsubIO来说，这个问题并没有什么不同。 Regd选项(2)：可以配置KafkaIO开始读取特定的时间戳(假设Kafka服务器支持它(版本10+)。但是看起来没有比启用AUTO更好的了_承诺。 也就是说，KafkaIO应该支持Finish。可能比启用AUTO更容易使用_承诺(需要考虑频率等)。我们没有很多用户要求它。如果可以，请在user@beam.apache.org上提及。

作为Daniel和0__的杰出答案的补充，我不得不说，Scala理解一些符号的Unicode类似物，所以不是 for (n <- 1 to 10) n % 2 match { case 0 => println("even") case 1 => println("odd") } 人们可以写 for (n ← 1 to 10) n % 2 match { case 0 ⇒ println("even") case 1 ⇒ println("odd") }

A class是一个定义，一个描述。它用其他类型的方法和组合来定义类型。 一个object是单身人士 - 一个保证独一无二的班级实例。对于object代码中的每一个，都会创建一个匿名类，它从您声明object要实现的任何类继承。这个类不能从Scala源代码中看到 - 尽管你可以通过反射来获得它。 object和之间有关系class。如果一个对象拥有相同的名字，则称它为类的伴侣对象。发生这种情况时，每个人都可以访问private另一方面的可见性方法。虽然这些方法不会自动导入。您必须显式导入它们，或者以类/对象名称作为前缀。 例如： class X { // class X can see private members of object X // Prefix to call def m(x: Int) = X.f(x) // Import and use import X._ def n(x: Int) = f(x) private def o = 2 } object X { private def f(x: Int) = x * x // object X can see private members of class X def g(x: X) = { import x._ x.o * o // fully specified and imported } }

final 成员不能被忽略，比如说，在一个子类或特征中。 合法的： class A { val a = 1 } class B extends A { override val a = 2 } 非法的： class A { final val a = 1 } class B extends A { override val a = 2 } 你会得到这样的错误： ：9：错误：在Int（1）类型的类A中覆盖值a; 值a不能覆盖最终成员

同样的“Scala编程”的第31章更为精确： Java没有与单例对象完全等价的特性，但它确实有静态方法。单例对象的Scala转换使用静态方法和实例方法的组合。对于每个Scala单例对象，编译器将为对象创建一个Java类，并在末尾添加一个美元符号。对于名为App，编译器生成一个名为App$。该类拥有ScalaSingleton对象的所有方法和字段。Java类还有一个名为MODULE$若要保存在运行时创建的类的一个实例，请执行以下操作。作为一个完整的示例，假设您编译了以下单例对象： object App { def main(args: Array[String]) { println("Hello, world!") } } Scala将使用以下字段和方法生成JavaApp$类： $ javap App$ public final class App$ extends java.lang.Object implements scala.ScalaObject{ public static final App$ MODULE$; public static {}; public App$(); public void main(java.lang.String[]); public int $tag(); }