Erlo

Inside Java Newscast #1 深度解读

收藏 2022-01-07 12:30:06   178   开源中国
页面报错/反馈
点赞

本文是 Inside Java Newscast #1 的个人体验与解读。视频地址:点击这里

⎯⎯⎯⎯⎯⎯ Chapters ⎯⎯⎯⎯⎯⎯

  • 0:00 - Intro
  • 0:57 - Java 16 – Intro
  • 1:16 - Java 16 – Records
  • 1:43 - Java 16 – Type Pattern Matching
  • 1:58 - Java 16 – Sealed Classes - Preview
  • 2:25 - Java 16 – Stream API
  • 2:51 - Java 16 – HTTP/2 API
  • 3:14 - Java 16 – Unix Domain Sockets
  • 3:32 - Java 16 – Project Panama (Incubating)
  • 4:07 - Java 16 – JDK Flight Recorder
  • 4:39 - Java 16 – jpackage
  • 5:02 - Java 16 – Performance
  • 5:23 - Java 16 – Security
  • 5:48 - Java 16 – Ports
  • 5:55 - Java 16 – Deprecations/Limitations
  • 6:49 - Java 16 – Outro
  • 7:08 - Java 17
  • 7:22 - Java 17 – Another Port
  • 7:34 - Java 17 – Applet for Removal
  • 7:55 - Java 17 – Sealed Classes
  • 8:12 - Outro

Java 16 – Records

相关 JEP 地址:

Records 这个特性我仔细研究过实现:参考我写的另一篇文章Java Record 的一些思考 - 默认方法使用以及基于预编译生成相关字节码的底层实

简单说来其实就是(编译后查看下字节码就能看出来),在编译后,根据 Record 源码插入相关域与方法的字节码,包括:

  1. 自动生成的 private final field
  2. 自动生成的全属性构造器
  3. 自动生成的 public getter 方法
  4. 自动生成的 hashCode(),equals(),toString() 方法:
  5. 从字节码可以看出,这三个方法的底层实现是 invokeDynamic 另一个方法
  6. 调用的是 ObjectMethods.java 这个类中的 bootstrap 方法

这个还让我闹了个笑话,我以为这个是 Project Valhala 的 Inline Object 已经实现了(参考我的这个系列: JEP 尝鲜系列),还去 StackOverflow 问,这个 Record 为啥能有 wait() 方法,并且可以进行 synchronized 同步(因为如果是 Project Valhala 的 Inline Object 的话是没有普通类的对象头的,没法用普通类对象的方法实现同步),结果。。。。。最后还是 Goetz 大佬一眼就看出我是误会了

image

Record 这个特性当初是为了适应什么场景设计的,以及某些设计为何被舍弃,可以参考 Gotez 大佬的这篇文章 java-14-feature-spotlight. 其重中主要的看点总结如下:

1.Java Records 最常用于的地方就是方法多个返回结果,原来我们可能需要用 Apache-commons 里面的 Pair 或者 Tuple 这样的对象封装,或者自己新建一个类型。现在可以使用 Record。

2.第二个常见应用即在 Stream 中传递的过程中保持原有对象,并且减少运算,例如 Stream 排序:

List topN
        = players.stream()
             .sorted(Comparator.comparingInt(p -> getScore(p)))
             .limit(N)
             .collect(toList());

这么写的话,每次作比较都会调用一次 getScore(p),这个调用次数是 O(n^2)。利用 Record 可以用比较少的代码和改动实现减少运算:

record PlayerScore(Player player, Score score) {
    // convenience constructor for use by Stream::map
    PlayerScore(Player player) { this(player, getScore(player)); }
}

List topN
    = players.stream()
             .map(PlayerScore::new)
             .sorted(Comparator.comparingInt(PlayerScore::score))
             .limit(N)
             .map(PlayerScore::player)
             .collect(toList());

最后再推荐下我写的这篇关于 Record 的序列化的一些解析和思考:Java Record 的一些思考 - 序列化相关

Java 16 – Type Pattern Matching

相关 JEP 地址:

类型模式匹配一直是一个呼声很高的特性,如果和下一小节的 Sealed Class 特性 以及 Patterns in switch 结合起来使用会有更好的效果,这个我们在下一节会更详细的说明.

Nicolai 对 Type Pattern Matching 的说明

Nicolai 的这篇文章 对 Type Pattern Matching 的说明非常详细,总结如下

原来需要这么写的代码:

void feed(Animal animal) {
    if (animal instanceof Elephant) {
	    ((Elephant) animal).eatPlants();
    }
    else if (animal instanceof Tiger) {
	    ((Tiger) animal).eatMeat();
	}
	
}

现在可以直接这么写

void feed(Animal animal) {
	if (animal instanceof Elephant elephant)
		elephant.eatPlants();
	else if (animal instanceof Tiger tiger)
		tiger.eatMeat();
}

不需要空指针判断,因为 instanceof 已经自带 null 判断了,符合条件的 Type Pattern Matching 变量不会为 null。并且, Type Pattern Matching 不支持向上匹配,因为这个没有意义,即下面的代码会编译报错:

public void upcast(String string) {
	// compile error
	if (string instanceof CharSequence sequence)
		System.out.println("Duh");
}

还有一个常用的地方即实现 equals:

// old
@Override
public boolean equals(Object o) {
	if (this == o)
		return true;
	if (!(o instanceof Equals))
		return false;
	Type other = (Type) o;
	return someField.equals(other.someField)
		&& anotherField.equals(other.anotherField);
}

// new
@Override
public final boolean equals(Object o) {
	return o instanceof Type other
		&& someField.equals(other.someField)
		&& anotherField.equals(other.anotherField);
}

其实 Type Pattern Matching 是个语法糖

其实这个特性是一个语法糖,我们可以简单测试下:

public class TypePatternMatching {
	public static void main(String[] args) {
		Object object = new Object();
		if (object instanceof String s) {
			System.out.println("a");
		}
	}
}

查看编译后的字节码:

public class test.TypePatternMatching {
  public test.TypePatternMatching();
    Code:
       0: aload_0
       1: invokespecial #1                  // Method java/lang/Object."":()V
       4: return

  public static void main(java.lang.String[]);
    Code:
       0: new           #2                  // class java/lang/Object
       3: dup
       4: invokespecial #1                  // Method java/lang/Object."":()V
       7: astore_1
       8: aload_1
       9: instanceof    #7                  // class java/lang/String
      12: ifeq          28
      15: aload_1
      16: checkcast     #7                  // class java/lang/String
      19: astore_2
      20: getstatic     #9                  // Field java/lang/System.out:Ljava/io/PrintStream;
      23: ldc           #15                 // String a
      25: invokevirtual #17                 // Method java/io/PrintStream.println:(Ljava/lang/String;)V
      28: return
}

可以看出,字节码其实和下面的写法是一样的:

public static void main(String[] args) {
    Object object = new Object();
    if (object instanceof String) {
        String s = (String)object;
        System.out.println("a");
    }

}

大家可以反编译下这个 class,就能看出来。

Java 16 – Sealed Classes - Preview

Sealed Class 在 Java 17 已经发布了,相关的 JEP 如下:

在某些情况下,我们可能想枚举一个接口的所有实现类,例如:

interface Shape { }
record Circle(double radius) implements Shape { }
record Rectangle(double width, double height) implements Shape { }

double area(Shape shape) {
	if (shape instanceof Circle circle)
		return circle.radius() * circle.radius() * Math.PI;
	if (shape instanceof Rectangle rect)
		return rect.width() * rect.height();
	throw new IllegalArgumentException("Unknown shape");
}

我们如何能确定我们枚举完了所有的 Shape 呢? Sealed Class 这个特性为我们解决这个问题,Sealed Class 可以在声明的时候就决定这个类可以被哪些类继承:

sealed interface Shape permits Rectangle, Circle {}
record Circle(double radius) implements Shape {}
record Rectangle(double width, double height) implements Shape {}
double area(Shape shape) {
	if (shape instanceof Circle circle)
		return circle.radius() * circle.radius() * Math.PI;
	if (shape instanceof Rectangle rect)
		return rect.width() * rect.height();
	throw new IllegalArgumentException("Unknown shape");
}

Sealed Class (可以是 abstract class 或者 interface )在声明时需要指定所有的实现类的名称。针对继承类,有如下限制:

  • Sealed Class 的继承类必须和 Sealed Class 在同一个模块下,如果没有指定模块,就必须在同一个包下
  • 每个继承类必须直接继承 Sealed Class,不能间接继承
  • 每个继承类必须是下面三种之一:
    • final 的 class,Java Record 本身就是 final 的
    • sealed 的 class,可以进一步指定会被哪些子类实现
    • non-sealed 的 class,也是一种扩展,但是打破 Sealed Class 的限制,Sealed Class 不知道也不关心这种的继承类还会有哪些子类。

举个例子即:

sealed interface Shape permits Rectangle, Circle, Triangle, WeirdShape {}
	
record Circle(double radius) implements Shape {}
record Rectangle(double width, double height) implements Shape {}


sealed interface Triangle extends Shape permits RightTriangle, NormalTriangle {}
record RightTriangle(double width, double height) implements Triangle {}
record NormalTriangle(double width, double height) implements Triangle {}

static non-sealed class WeirdShape implements Shape {}
class Star extends WeirdShape {}

double area(Shape shape) {
	if (shape instanceof Circle circle)
		return circle.radius() * circle.radius() * Math.PI;
	if (shape instanceof Rectangle rect)
		return rect.width() * rect.height();
	if (shape instanceof RightTriangle rt)
		return rt.width() * rt.height() / 2;
	if (shape instanceof NormalTriangle nt)
		return nt.width() * nt.height() / 2;
	throw new IllegalArgumentException("Unknown shape");

}

如果结合 Pattern Matching for switch 这个特性,就能实现更加方便的写法,但是目前 Java 17 中,Pattern Matching for switch 还处于 Preview:JEP 406: Pattern Matching for switch (Preview)。我们需要在编译参数和启动参数中加上 --enable-preview,这样就能像下面这样写代码:

double area(Shape shape) {
	return switch (shape) {
		case Circle circle -> circle.radius() * circle.radius() * Math.PI;
		case Rectangle rect -> rect.width() * rect.height();
		case RightTriangle rt -> rt.width() * rt.height() / 2;
		case NormalTriangle nt -> nt.width( ) * nt.height() / 2;
		default -> throw new IllegalArgumentException("Unknown shape");
	};

}

Java 16 – Stream API 更新

Java 16 中针对 Stream API 有两个更新,这里先提一个题外话,如果想看 JDK 不同版本之间有何差异,增加或者删除了哪些 API,可以通过下面这个链接查看:

路径中的两个版本就是要对比的两个版本,其界面如下:

image

同时,我们也可以通过 JDK 内置 jdeps 工具查找过期以及废弃API以及对应的替换


jdeps --jdk-internals -R --class-path 'libs/*' $project

libs是你的所有依赖的目录,$project是你的项目jar包,示例输出:

...
JDK Internal API                         Suggested Replacement
----------------                         ---------------------
sun.misc.BASE64Encoder                   Use java.util.Base64 @since 1.8
sun.reflect.Reflection                   Use java.lang.StackWalker @since 9

关于这个更新,我写了一篇文章进行解析:Java 16 中新增的 Stream 接口的一些思考,核心内容总结如下:

假设有邮件这个 Record 类,包含 id,以及发送到的邮箱和抄送到的邮箱:

record Mail(int id, Set sendTo, Set cc) {}

我们想找到一批邮件的所有不同的联系人,最后放到一个 List 中,可能会这么写:

Set collect = mails.stream().flatMap(mail -> {
	Set result = new HashSet<>();
	result.addAll(mail.sendTo());
	result.addAll(mail.cc());
	return result.stream();
}).collect(Collectors.toSet());

但是,这样写显然很不优雅,首先是对于每一个 Mail 都创建了额外的 Set 和对应的 Stream,并且,对于每个 mail 的 sendTo 还有 cc 都遍历了两遍(addAll 一遍,后续 Stream 又一遍)。其实我们的目前只是将 mail 中的 cc 以及 sendTo 取出来,用于参与后续的 Stream。在这种场景下,就非常适合用 mapMulti:

Set collect = mails.stream().mapMulti((mail, consumer) -> {
	mail.cc().forEach(consumer::accept);
	mail.sendTo().forEach(consumer::accept);
}).collect(Collectors.toSet());

可以看出: