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 ... 展开详请

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

object Singleton { def method = "Method result" } 然后编译给你 Singleton.class Singleton$.class 对于你找到的字节码，首先Singleton: public final class Singleton extends java.lang.Object{ public static final java.lang.String method(); Signature: ()Ljava/lang/String; Code: 0: getstatic #11; //Field Singleton$.MODULE$:LSingleton$; 3: invokevirtual #13; //Method Singleton$.method:()Ljava/lang/String; 6: areturn } 即，对引用某项内容的类的每个方法都使用一个公共静态方法。Singleton$.MODULE$，以及Singleton$: public final class Singleton$ extends java.lang.Object implements scala.ScalaObject{ public static final Singleton$ MODULE$; Signature: LSingleton$; public static {}; Signature: ()V Code: 0: new #9; //class Singleton$ 3: invokespecial #12; //Method "<init>":()V 6: return public java.lang.String method(); Signature: ()Ljava/lang/String; Code: 0: ldc #16; //String Method result 2: areturn private Singleton$(); Signature: ()V Code: 0: aload_0 1: invokespecial #20; //Method java/lang/Object."<init>":()V 4: aload_0 5: putstatic #22; //Field MODULE$:LSingleton$; 8: return } 你看到的地方MODULE$的实例。Singleton$，和method只是个普通的方法。 所以，这就是它的真正意义：创造Singleton$具有一个静态字段，名为MODULE$若要保存自身的唯一实例，请填充该字段，然后创建Singleton使用将所有静态调用转发到Singleton$。... 展开详请

在Scala中，final声明一个成员不能在子类中重写。例如： class Parent { val a = 1 final val b = 2 } class Subclass extends Parent { override val a = 3 // this line will compile override val b = 4 // this line will not compile } ... 展开详请

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

可以定义： 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... 展开详请

像是编译器安排了一个类级位图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 类型域... 展开详请

作为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 } }... 展开详请