跳至主要內容

Java

2023年3月17日大约 27 分钟编程编程语言

Java

java 缺点 - 暴论

入门 java，远离 java。

  • DBeaver 烂，JB 家一堆烂，Minecraft 烂，sonarlint 烂，我接触到的 java 写成的玩意总能给我带来不悦。
  • 作为带 GC 的语言，Java 的性能一般（强类型打不过弱类型）；与其他 GC 语言相比，Java 编写的复杂度又更高。
  • java 社区相较而言也死气沉沉，到处是 java 8（今夕是何年）。
  • java 学到后期全是业务框架，不好玩，没意思。对于喜欢做小项目的我，java 的业务抽象反而是额外的复杂度，也不能让代码可读性和易用性更强。

哦，顺带一提，Android 开发建议直接 kotlin，Google 官方推荐的语言，并且全兼容 java。确实比 java 有意思多了。

然而现在国内的 java 就业需求仍然是最高的，如果为了就业的话就不得不学了。

开发环境

jdk

Windows：使用 scoop，或者去官网下载。Linux：不多说了。

scoop bucket add java
# 然后根据你需要的版本安装对应 jdk。
scoop install openjdk22
scoop install corretto8-jdk
scoop install liberica8-full-jdk

几个不同提供方：

  • corretto* 是 Amazon 维护的免费、生产级 OpenJDK 8 发行版，支持周期长，包含安全修复。
  • temurin* 是社区和其他厂商维护的版本，更改少点。
  • openjdk* 是 oracle 自家的原味版本。注意 openjdk 已经没有 java 8 了。

如果你是为了兴趣学习，安装最新版本 jdk；如果是工作，根据不同要求可以选择安装 java 8 或 java 17。

顺带骂一下，scoop 这个 java 仓库做的真 tm 烂，想下载哪个玩意只能进 bucket 文件夹看源码。

IDE

vscode with IDEA

20260903，JetBrains 宣布推出 Java and Kotlin by IntelliJ IDEA LSP，可以在 vscode 上使用。

该插件直接杀死了比赛。从此你不再需要各种调优、群魔乱舞的插件，只需要一个 Java and Kotlin by IntelliJ IDEA 即可畅游 Java 项目，享受极速跳转。

虽然经常听到 IDEA 内存占用大的声音，但是 Java and Kotlin by IntelliJ IDEA 其实只是 IDEA 的一个 core，没有乱七八糟的功能，内存占用在大项目上其实比 JDT LS 还要低上许多。简直是对 JDT LS 的全方位暴打。

gradle

安装

全局安装 gradle 的话 scoop install gradle 一行完事。如果有需要固定版本还可以 scoop install gradle4、scoop install gradle7 等。

也可以用项目里配置的 gradle 锁定版本，好处是和别人运行起来完全一致，不过可能导致多个 gradle 版本共存。如果运行 ./gradlew build，脚本会帮你下载对应版本的 gradle，而且下载得还贼慢。。。不会做下载器就别做。 此时需要自己下载，然后把整个 zip 放到 C:\Users\<用户名>\.gradle\wrapper\dists\gradle-版本-bin\<一串随机乱码>\ 下。

配置

gradle 的配置还是很重要的，好的配置可以大幅加速编译、避免内存占用。推荐将配置放在 ~/.gradle/gradle.properties 作为全局配置，所有项目生效。

  1. 避免多开 gradle 进程：gradle 复用同一个 daemon 的前提是 gradle 版本、JDK 路径、JVM 参数完全一致。需要确保不同项目之间使用的是同一份配置（全局配置），编辑器里不要配一些可能修改 gradle/JVM 参数的东西。
    org.gradle.daemon=true
org.gradle.jvmargs=-Xmx4g -XX:+HeapDumpOnOutOfMemoryError -XX:+UseG1GC
org.gradle.caching=true
org.gradle.parallel=true
org.gradle.configuration-cache=true
org.gradle.configuration-cache.parallel=true
org.gradle.vfs.watch=true
org.gradle.configureondemand=true
  2. 平常跑的时候就直接用 gradle xxx，不要带其他参数。不要用 --no-daemon，那个很慢。

杂

  • gradle clean 只会清理项目下的 build/ 文件夹。如果你使用 vscode 开发可能还会有 bin/ 文件夹，这是 Language Support for Java(TM) by Red Hat 进行静态分析的产物，跟 gradle 没有关系。

API Client

写后端，有一个 API Client 几乎是必须的。它的基础功能是导入从浏览器复制的 curl，然后你可以修改一些参数或者 header 再发出请求，进行一些功能验证。

推荐使用 bruno，postman 的开源替代。postman 吃相太难看了。

其他注意事项

  • vscode 按住 ctrl 跳转，跳到了基类实现。但是实际的实现根据传入的对象，可能是基类实现也可能是子类实现。所以开启一下 implementation lens 是比较重要的。不过话又说回来，这个 lens 的加载巨慢，因此可能也是没什么用的。
    {
  "java.implementationCodeLens": "methods",
  "java.referencesCodeLens.enabled": true
}

语言基础

判断

  • java 的 if 语句中只能放入 boolean 或其包装类。

循环

JDK 5 引入了 for (Type var : iterable) {} 的循环。

  • 循环中发生的 copy，对于对象是引用 copy，对于基本类型是值 copy。

var

Java 10 语法糖，类型推断。like C++: auto, but not so powerful.

exception

java 错误处理挺不错的，至今也有人认为 java exception 优于 rust Result<T, E>.

函数可以声明可能抛出的异常，则 throw exception 后会直接跳出这个函数。只有受检异常（非 RuntimeException）必须声明 throws 抛出；RuntimeException 和 Error 是隐式抛出的，不需要声明。

class X1Exception extends Exception{}
class X2Exception extends Exception{}
void t() throws Exception{
    throw new X2Exception("...");
    assert unreachable == true;
}
// ... main
try { t(); } catch(X1Exception | X2Exception e) {
    System.out.println(e.getMessage());
}

java 7 之后还可以使用 try-with-resource 以自动释放资源。

断言

使用非常简单，assert expression。默认不启用检查，需要加入 JVM 参数 -ea 才会触发运行时检查：java -ea Main.java。

关键字

  • final：不可变，immutable。不需要同步，性能高。
  • native：表示函数是外部的，类似 C/rust 的 extern。
  • record：java 14 语法糖，快速创建一个拥有不可变成员的类，自带 toString 等。
  • volatile：用于多线程的关键字，强制数据在内存和 CPU cache 里同步，所有线程看到的变量都是最新的。volatile 不等于加锁。
  • synchronized：互斥锁，同一时间只能有一个线程访问此资源。

数据结构

  • 创建临时数组：
    • >= java 9：使用 List.of，创建不可变的数组。
    • java 8：使用 Arrays.asList。
  • 类似的，创建临时 Map：
    • >= java 9：使用 Map.of。
    • java 8：使用 com.google.common.collect.ImmutableMap，用法跟 Map.of 类似。否则就需要用 Stream + collect 或者手动添加元素创建。
  • 动态数组：
    • Arraylist 和 Vector，后者是线程安全的，更慢。
      private ArrayList<account> accounts = new ArrayList<>(List.of(new account("admin", "admin")));
  • Hashmap：哈希表，不多说。
  • LinkedHashMap：有序的 HashMap，按照添加顺序

面向对象

基础的就不说了。这里随便记一些。

  • 类代码块：class 里可以写一段 static { ... } 静态代码块，内部的代码会在类初始化时执行（构造之前、访问 static 成员之前），有一点点像 Rust LazyLock。如果写 { ... } 就是实例代码块，每次创建实例时都执行。
  • 如果要处理 interface，downcast 到不同的 class：
    • java 8 只能 if (xxx instanceof xxx) 判断然后强转。
    • java 21 可以 switch。
  • 子类可以定义相同的变量“遮掩”父类的变量。两个变量同时存在，访问父类变量需要用 super.，或者 cast 到父类再访问。
  • clone：java 没有原生的 deep clone，很多实现都还在用 json 序列化/反序列化来做 deep clone，实在是丑陋啊。

包装类

基本类型例如 bool，包装类 Boolean。

  • 一般尽可能用基本类型，性能好，还有非空保证。但有时候不得不用包装类，比如需要 nullable，或者泛型等。
  • java 中只要是包装类，就有可能是 null，一旦在逻辑判断中直接当做基本类型用（自动拆箱），就会 NPE。比较难防。
    • 这时候需要一些额外操作，例如使用第三方包 org.apache.commons.lang3.BooleanUtils。就是一个默认会判空的 Boolean 判断条件。

lambda

java 8 引入的匿名函数。(parameter1, parameter2) -> expression，expression 也可以是一个花括号 code block。

  • lambda 捕获的局部变量必须是 final 或等效 final（effectively final）的变量。

泛型

泛型在实现上基于类型擦除，是因为泛型出现时大量的代码没有使用泛型，需要保证和老代码的可交互性。这意味着泛型只在编译期存在，运行期不存在，使用 Jackson 等进行反序列化的时候需要添加 TypeReference。

  • 泛型不支持基本类型，只能用包装类。
  • 泛型不可变，比如我不能将 List<T> 转为 List<I>，即使 T implements I。必须新建一个 List，然后强转过去（构造函数强转）。

Stream

Stream (Java 8) 是 java 中很重要的一个概念，可以理解成迭代器。类比 Rust iterator 或 C++20 的 std::ranges。Stream 提供了一组函数式链式操作。

刚发现的写的不错的参考。

基本操作

  • 连接流：Stream.concat(stream1,stream2)
  • 映射：map
  • 过滤：filter
  • 元素操作：forEach(lambda)

常用方法

var list = Stream.of(1,2,3).collect(Collectors.toCollection(ArrayList::new));   // 为 Arraylist 赋值
list.stream();                                                                  // Arraylist 转流
Stream.of(1,2,3).mapToInt(Integer::intValue).max().getAsInt();                  // 计算最大值
// 对于 Arraylist, 更好的做法是 Collections.max(list)
Stream.of(1,2,3).mapToInt(Integer::intValue).average().getAsDouble();           // 计算平均值
Stream.of(1,2,3).sorted();                                                      // 排序（升序）
Stream.of(1,2,3).sorted(Comparator.reverseOrder());                             // 排序（降序）
Stream.of(1,2,3).anyMatch(x -> x == null);                                      // 任一元素满足。使用 allMatch 是所有元素满足。
  • collect(Collectors.toMap(...)) 是超级大坑，toMap 不允许 Value 为 null，否则会直接报 NPE。如果可能为空，需要用 collect(HashMap::new, (m, v) -> m.put(v.getId(), v.getNote()), HashMap::putAll);。

Intstream

以这个结构为例了解其用法。

var temp1 = IntStream.rangeClosed(1, 3);    // 生成闭区间流 1,2,3
var temp2 = IntStream.range(1, 3);          // 生成左闭右开区间流 1,2
var temp3 = temp1.boxed();                  // Intstream 转为 Stream

parallelStream

Java 的 List 只需要调用 .parallelStream() 就可以自动转换为并行多线程处理（CPU bound 的线程池），这个思想实在是太领先了。

Optional

Optional 的作用是强制调用方处理空值。

Optional.ofNullable(A).orElse(B);                               // 最常用的 Optional 用法，相当于 A != null ? A : B
Optional.ofNullable(A).orElseGet(() -> B.fun());                // 如果 else 里是一个比较复杂的函数，使用 orElseGet 可以延迟执行该函数，提高性能
Optional.of(value)                                              // 创建，value 不可为 null
Optional.ofNullable(null)                                       // 创建
Optional.ofNullable(123).ifPresent(u -> System.out.println(u)); // 操作值
Optional.ofNullable(123).map(u -> u + 2);                       // 映射
Optional.ofNullable(123).filter(u -> u < 150);                  // 映射

java 9 添加了一些 java 8 没有的 Optional.or() 等链式处理为空的逻辑，还包括了 ifPresentOrElse() 当成 rust 的 match 用。

由于 java 泛型不能为基本类型，这里的 Optional 都会自动装箱。为了避免装箱性能损耗，java 8 还额外提供了 OptionalInt、OptionalLong 和 OptionalDouble 三个类型，建议使用。（没有 OptionalBoolean，因为 Boolean 本身就可以表示可空）

当然，在没有强制性要求处理空值的地方（内部调用等），或者对性能敏感的地方，用 @Nullable 注解即可。如果是 Spring 开发场景，优先使用 org.springframework.lang.Nullable。

注解

java 5 （2004 年）引入了注解，非常早。注解现在已经成了业务开发中不可或缺的一部分。注解可以在编译期或运行期被读取，并且改变代码的行为，跟 rust 的 proc macro 还是有一些区别的。之后的 业务内容 会更详细地介绍一些框架注解。

  • java 注解的属性值必须是编译期常量。
  • java 的注解相当混乱，同一个注解可能有一堆 package 提供；不同 package 提供的注解功能不同，不能混用。

序列化

序列化可以将一个 class 进行结构化表示，Jackson 或其他库可以利用这个结构表示将类转换成其他东西，例如 json。

class account implements Serializable {}    // 继承接口

实践中，建议为每一个 implements Serializable 的类都添加一个 private static final long serialVersionUID 成员，用于序列化的兼容检查。反序列化时，如果该 id 不匹配则会抛出异常。

Jackson

最常用的 json 序列化库，Spring 默认。

  • 自定义序列化函数：使用 @JsonValue 自定义序列化过程，使用 @JsonCreator 自定义反序列化过程。对于 enum，这个是比较常用的。
    • @JsonCreator 允许使用 mode 限制反序列化的来源，例如 @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) 限定只能从 json 对象字符串里反序列化，@JsonCreator(mode = JsonCreator.Mode.DELEGATING) 就是非 json 对象字符串（普通字符串）里反序列化。
  • 忽略
    • Jackson 默认忽略 static 和 transient 字段。不需要担心 serialVersionUID 被序列化。
    • 忽略单个字段：@JsonIgnore 修饰字段。
    • 忽略多个字段：@JsonIgnoreProperties({"xxx", "yyy"}) 修饰类。
    • 忽略多余字段：@JsonIgnoreProperties(ignoreUnknown = true) 修饰类。
  • 默认值：直接 private xxx = xxx 即可。
  • 将成员类“展平”，类似 rust #[serde(flatten)]：@JsonUnwrapped
  • 如果希望一个 json object 根据其 keys，可以反序列化到两种不同的 class：使用一个 interface 和 deduction。
    @JsonTypeInfo(use = JsonTypeInfo.Id.DEDUCTION)
@JsonSubTypes({
    @JsonSubTypes.Type(value = Class1.class),
    @JsonSubTypes.Type(value = Class2.class)
})
public interface ObjectItem {}
  • (Java 8+) Jackson 可以配合 lombok，把 @JsonCreator 注入到 lombok 生成的函数上，例如 @AllArgsConstructor(onConstructor_ = {@JsonCreator})

一些坑：

  • 不要定义 get、is 开头的非 getter 函数！否则会当成 getter 进行序列化，最终结果和预期不同。（之前不写 java 的很容易被坑到）

swing

java GUI。原生自带，无需下载其他组件，无需构建系统，单文件就能跑。但是在前端设计上，swing 是不合格的，纯靠布局真的是非常噩梦的体验，没人用。

要不是学校的 java 课要用 swing 做东西，我也不会去用它。

默认折叠，点击展开 swing 相关内容。

组件

  • JPanel：理解为容器
  • JLable
    • 设置字号/字体/效果：lable.setFont(new Font(Font.SERIF, Font.BOLD, 18));
  • JPasswordField：密码输入框。getText() 不安全会被警告，getPassword() 则返回 char[] 需要自行处理。

需要注意，在 remove 后 add 组件，需要重绘。

panel.revalidate();
panel.repaint();

事件

>=Java 8: 请使用 lambda 函数而不是将所有窗口事件在一个函数中处理。

button.addActionListener(e -> {
    ...
});

业务内容

前面的基础结束，现在是业务内容。工作中的 java 业务一般有着一套固定的流程和约定，这里又是一大堆东西。

java 业务开发一般遵守分层架构：Controller 层是对外交互的接口，Service 层是最主要的逻辑区域，Mapper 层是数据库的交互。

基础名词

  • Bean 是一种约定的特殊 class，所有属性 private，通过 getter setter 读取/修改，有一个无参构造函数。各种框架可以根据这样的约定来操作这个类及其实例。
  • DTO（Data transfer object）、DO（data object）都相当于 python dataclass，二者的区别是用途：DO 一般是进 DB 的，DTO 是跟其他服务交互的。
  • DI（Dependency Injection）：依赖注入，之后 Spring 会提到。
  • AOP（Aspect-Oriented Programming）：面向切面编程，类似注入的概念，在运行时将一段逻辑注入到对象里。业务层对 AOP 是无感知的。Spring 的 AOP 是动态代理，在运行期生成一个代理对象。AspectJ 主要是直接修改字节码，功能更强，可以切入构造函数、静态方法、私有方法。

Lombok

Lombok 是一个业务开发必备库，作用是在编译时通过注解自动生成代码。

常用的注解有：

  • @NonNull：可以修饰入参和出参对象。如果为空会 NPE。
    • Lombok 的 @NonNull 是运行时检查，并且不会被 IDE 当作非空类型进行推导。如果需要推导为非空，建议使用 javax.annotation.Nonnull。
  • @Getter / @Setter: 生成字段的 get 和 set 方法。
  • @ToString: 生成 toString() 方法。
  • @EqualsAndHashCode: 生成 hashCode() 和 equals() 方法。
  • @Data: 相当于同时使用了 @Getter、@Setter、@ToString、@EqualsAndHashCode 和 @RequiredArgsConstructor。
  • @Slf4j：生成日志对象，可以在代码中用 log.info 啥的。
  • @RequiredArgsConstructor：为所有 final 字段或 @NonNull 字段生成一个 Constructor。
  • @NoArgsConstructor：生成一个什么也不做的 Constructor。不允许在有 final 字段的类里使用；如果要使用需要用 @NoArgsConstructor(force = true)，可以将其初始化为 default 值。
  • @AllArgsConstructor：生成一个包含类中所有字段作为参数的 Constructor。字面意思。
  • @Builder：builder 模式，不多说。
  • @SuperBuilder(toBuilder = true)：如果父类实现了 @SuperBuilder，则子类也可以用 builder。注意不能和 @Builder 混用。

注解中再包含其他注解需要使用 @__ 语法。一个最常用的例子是 @RequiredArgsConstructor(onConstructor = @__({@Autowired}))，在生成 Constructor 的同时将其标为 @Autowired。

Slf4j

可以在 @Slf4j 的 class 内部使用 log.xxx 进行日志打印（xxx=info, error, ...）。

  • 首个参数可以是一个 fmt string，之后可以接 args。
    • args 可以比 fmt 里的坑多一个 Throwable，这样打印的日志后面可以接这个 Throwable 的调用栈。这是很常见的用法。

Spring

后端必备套件之一。Spring 的核心是自动管理单例，因为在后端开发场景中单例实在是太多了，用 Spring 可以省去自己创建和取对象的麻烦。

  • IoC（Inversion of Control）概念：Spring 启动时其会创建一个巨大的全局对象池，称为容器；并且其为每个 @Service 类在容器里创建一个单例对象。使用时只需通过 @Autowired 即可从对象池里拿到这个实例。
    • 在 Spring 语境下，“Bean” 特指被 Spring 容器管理的对象。

Spring 在运行时会自动起一个 tomcat 来运行服务。（tomcat 是一种网络容器，用它可以方便地部署网络应用）

uri 相关注解

uri 一般是 /{context-path}/{Class-Mapping}/{Method-Mapping} 形式。

  • context-path：一个全局前缀，用的比较少。直接搜 context-path 即可。
  • Class-Mapping：class 上定义的 @RequestMapping 注解。
  • Method-Mapping：类的方法的注解，可以是 @GetMapping 等。
  • @RequestParam：指定 GET 请求的 http param。默认是必填 param 的，如果想要选填需要加 required = false。

Swagger

用于自动生成 RESTful API 文档的工具。只需要注解即可生成。

Swagger 有 v2 和 v3 两个版本，看 import 能看出项目使用的是哪个版本。v3 版本在 import 语句里一定包含 v3. 字样。

v2

随便记点。

  • 注意：swagger 生成的类型并不完全正确！！因为生成时依赖 Bean Getter，但是序列化和反序列化时又是依赖 Jackson 或者其他逻辑。
    • 因此最好不要在 DTO 上使用 org.apache.commons.lang3.tuple.Pair，因为 swagger 不能正确生成它的类型。
  • 对于 @XXX("xxx")，一般等价于 @XXX(value = "xxx")。如果括号内有多个 kv，必须显式写 value =。
  • @ApiModel：将 class 或 enum 设为请求参数 / 响应类型。
  • @ApiModelProperty：修饰 ApiModel 的成员。
  • swagger v2 对 interface 的支持不太好，例如两个 class 实现了同一个接口，然后对这个接口做反序列化，swagger 不会自动关联到这两个类。有点致命。

Mybatis

后端必备套件之一。

Mybatis 是一个数据库操作套件，用于把数据库操作集成到代码中。我不认为其是一个 ORM，毕竟也需要自己写 SQL。

Mybatis 有两种模式，注解模式和 XML Mapper 模式。注解模式是在注解中写 SQL 语句，Mapper 模式相当于是一个 DSL。对于复杂查询或者大型项目，用 Mapper 模式的更多。

  • 如果不想学 Mapper 模式的 DSL，可以让 AI 写或者翻译 SQL 到 Mapper。
  • Mapper 模式下有 <mapper namespace="com.xxx.xxx">，这里的 namespace 必须是一个 xxx.java 模块的完整路径；在这个模块里写一个 public interface XXXMapper，然后声明每一个接口方法即可。XML 标签的 id 必须与 java 接口的方法名一致。

JVM 调优

GC

  • java 8 有这些 GC：Serial GC, Parallel GC, CMS (Concurrent Mark Sweep), G1 (Garbage-First)
    • 后二者将 GC 分为几个阶段，只在其中部分阶段 stop the world
    • CMS（标记 - 清除，没有整理）：初始标记（停顿）-> 并发标记 -> 重新标记（停顿） -> 并发清除
    • G1（标记 - 整理）：类似文件系统分块，新生代和老年代不再连续。优点：可预测，无内存碎片
    • ZGC：全部都是 Full GC；动态分块
      • 使用 Load Barriers，进行类似 CAS 的复制块访问
      • 染色指针，有四位信息存在指针本身上
      • 优点：吞吐量大，停顿短，不需要太多干预；缺点：CPU 占用高
  • java 的 gc 是从根节点开始扫描不可达对象。
  • JDK8 的 GC 是分两代，新生代和老年代。新生代里又有三个区（eden, Survivor（s1, s2））。在新生代 gc 叫 minor gc，gc 老年代 + 新生代叫 full gc。
    • 每次 gc 会使新生代对象的 age + 1，当 age 超过一定值时将被移入老年代
    • Survivor 区的对象总年龄超过 50% 时也会将部分年龄最大的移入老年代
  • java 8 的几个 GC 都是 stop the world 的，调优目的就是减少 full gc，减少 stop the world。

工具

jvisualvm 是 jdk 里自带的 GUI 分析工具，可以追踪 GC 状况，日志，系统资源占用等。

最近更新：