代码语言

知识点思维导图

29 个知识节点

参考资料

Java（34） - A2 - 附录-常用命令

你已经用 node/npm 用得很熟了。这篇不教语法，只解决一个问题：在 Java 世界里，"装环境、装包、跑代码"这三件事分别敲什么命令，以及它们和 node/npm 长得像、但坑在哪。把这页当速查表，忘了回来翻。

一、核心类比（先建直觉，再划边界）

Java 的命令行世界，可以和前端大致对上，但有个关键的多出来的步骤——编译：

前端	Java	作用
`node app.js`	`javac X.java` + `java X`	⚠️ 跑代码要先编译再运行（两步）
`node`（进 REPL）	`jshell`（Java 9+ 的 REPL）	交互式试代码
`npm` / `yarn` / `pnpm`	Maven（`mvn`） / Gradle	包管理 + 构建工具
`node_modules`（每个项目独立）	`~/.m2/repository/`（全局共享）	⚠️ 依赖仓库位置不同
`package.json`	`pom.xml`（Maven）	依赖清单 + 构建配置
`npm install`	`mvn install`	按清单装依赖
`nvm`（切 node 版本）	`sdkman` / 手动配 `JAVA_HOME`	切 JDK 版本

边界（哪里不一样，必须记住）：

多了「编译」这一步。 前端 node app.js 直接跑源码。Java 是「编译型 + 虚拟机」语言，源码 .java 要先用 javac 编译成字节码 .class，再用 java 交给 JVM 运行。日常有 IDEA 和 Maven 帮你做，但要知道底层是两步。详见 37-Java疑问记录.md 的 Q1。
依赖不在项目目录里。 前端 node_modules 每个项目一份、装在项目里。Maven 把所有依赖下载到用户目录 ~/.m2/repository/ 全局共享，项目里只有 pom.xml 声明「我要哪些包」。省磁盘，但第一次会疑惑「装的包哪去了」。
pom.xml 是 XML，不是 JSON。 加依赖要写一段 <dependency> XML，比 package.json 啰嗦。而且它同时管「依赖」和「构建流程」，职责比 package.json 更重。

二、java / javac：编译与运行（最基础）

# 第一步：编译，.java 源码 → .class 字节码（中文源码加 -encoding UTF-8 防乱码）
javac -encoding UTF-8 HelloWorld.java

# 第二步：运行，java 后面跟「类名」，⚠️ 不带 .java 后缀
java HelloWorld

# 一行搞定（&& 表示前一步成功才跑后一步）
javac -encoding UTF-8 HelloWorld.java && java HelloWorld

# 查看版本（确认 JDK 装好、版本对不对）
java -version        # 输出形如 openjdk version "17.0.x"
javac -version       # 编译器版本，应和上面一致

2.1 三个易错点（整理自疑问记录）

java 后面是「类名」不是文件名：✅ java HelloWorld　❌ java HelloWorld.java
类名必须和文件名完全一致（含大小写）：public class HelloWorld → HelloWorld.java
中文乱码就加 -encoding UTF-8

Java 11+ 的便利：单文件可以 java HelloWorld.java 一步跑（内部帮你编译），但只适合单个文件的小实验，正式项目还是走编译流程。

2.2 jshell：Java 的 REPL（≈ 直接敲 node）

# Java 9+ 自带，进交互式环境，逐行试代码，Ctrl+D 或 /exit 退出
jshell

# 进去后可以直接写，不用 public class Main 那套模板
jshell> int a = 1 + 1
a ==> 2
jshell> "hello".toUpperCase()
$2 ==> "HELLO"

用途和前端 node REPL 一样：验证某个 API 怎么用、试个小表达式，不用为此建整个项目。

三、JAVA_HOME 与 JDK 版本（≈ nvm 的活）

前端用 nvm 切 node 版本。Java 这边靠环境变量 JAVA_HOME 指向当前用的 JDK，命令行的 java/javac 跟着它走。

# 查看当前用的是哪个 JDK
java -version              # 看版本号
echo $JAVA_HOME            # 看 JAVA_HOME 指向哪个目录（mac/Linux）

# mac 上列出装了哪些 JDK
/usr/libexec/java_home -V

# 临时切到指定版本（mac，当前终端有效）
export JAVA_HOME=$(/usr/libexec/java_home -v 17)   # 切到 JDK 17
java -version                                       # 验证切过来了

和前端的对照：

前端	Java
`nvm ls`（列出装的 node）	`/usr/libexec/java_home -V`（mac 列出 JDK）
`nvm use 18`	`export JAVA_HOME=$(/usr/libexec/java_home -v 17)`
`.nvmrc`（项目锁 node 版本）	`pom.xml` 里的 `<maven.compiler.source>` 指定编译版本

想更省心用 SDKMAN（≈ nvm for Java）：sdk install java 17.0.x 装 JDK，sdk use java 17.0.x 切换，比手动配 JAVA_HOME 顺手。初学阶段用系统装的一个 JDK 就够，多版本再上 SDKMAN。

⚠️ 踩坑提醒：java -version 和 javac -version 显示的版本不一致，通常是 JAVA_HOME 和命令行 PATH 指向了不同 JDK。以 JAVA_HOME 为准排查。

四、Maven（mvn）：包管理 + 构建（≈ npm）

Maven 是 Java 最主流的构建工具，一个命令同时管「装依赖 + 编译 + 测试 + 打包」，比 npm 管得更宽。

# 编译项目（≈ 把 src 下所有 .java 编译，产物进 target/）
mvn compile

# 运行测试
mvn test

# 打包成 jar/war（产物在 target/ 目录，≈ npm run build）
mvn package

# 装依赖 + 编译 + 测试 + 打包 + 装进本地仓库（一条龙）
mvn install

# 清理构建产物（删 target/ 目录）
mvn clean

# 常用组合：先清理再打包（保证干净构建）
mvn clean package

# 跳过测试打包（赶时间时用，⚠️ 别养成习惯）
mvn clean package -DskipTests

# Spring Boot 项目直接启动（≈ npm run dev）
mvn spring-boot:run

4.1 命令对照表

操作	npm	Maven
装依赖	`npm install`	`mvn install`（顺带编译打包）
只装依赖不构建	`npm install`	`mvn dependency:resolve`
构建/打包	`npm run build`	`mvn package`
跑测试	`npm test`	`mvn test`
清理产物	`rm -rf dist`	`mvn clean`
启动开发	`npm run dev`	`mvn spring-boot:run`
查看依赖树	`npm ls`	`mvn dependency:tree`

⚠️ mvn install ≠ npm install：npm install 只是「下载依赖」。mvn install 是「编译 + 测试 + 打包 + 把本项目产物也装进本地仓库」的一条龙，慢得多。只想拉依赖用 mvn dependency:resolve，日常开发靠 IDEA 自动拉。

五、pom.xml：依赖清单（≈ package.json，但是 XML）

前端在 package.json 的 dependencies 里加一行。Maven 在 pom.xml 里加一段 <dependency> XML。

<!-- pom.xml 里 <dependencies> 标签内，每个依赖一段 -->
<dependencies>
    <!-- 一个依赖 = groupId（组织） + artifactId（包名） + version（版本） -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
        <version>3.2.0</version>
    </dependency>

    <dependency>
        <groupId>com.google.guava</groupId>
        <artifactId>guava</artifactId>
        <version>33.0.0-jre</version>
    </dependency>
</dependencies>

和 package.json 的对照：

package.json 字段	pom.xml 对应	说明
包名 `"lodash"`	`<groupId>` + `<artifactId>`	⚠️ Java 用「组织+包名」两段定位，防重名
版本 `"^4.17.21"`	`<version>4.17.21</version>`	⚠️ Maven 默认锁精确版本，没有 `^`/`~` 语义
`dependencies`	`<dependencies>`	生产依赖
`devDependencies`	`<scope>test</scope>`	⚠️ 靠 `<scope>` 区分用途，不是分两个字段

⚠️ 怎么找依赖的坐标：不像 npm 直接 npm install 包名，Maven 要先知道 groupId/artifactId/version 三段坐标。去 mvnrepository.com 搜包名，复制它给的 <dependency> 片段贴进 pom.xml。

改完 pom.xml 后，IDEA 通常会提示「重新加载 Maven 项目」（点一下即可），或命令行 mvn compile 会自动拉新依赖。⚠️ 不像 npm install 要手动跑，IDEA 里改 pom 多是自动拉取。

六、依赖去哪了？本地仓库 /.m2

前端 npm install 后包进了项目的 node_modules，看得见。Maven 的包默认下载到用户目录，很多人第一次会疑惑「装哪去了」。

# Maven 本地仓库（所有项目共享，≈ 一个全局的 node_modules）
ls ~/.m2/repository/

# 依赖按坐标分目录存：groupId/artifactId/version/xxx.jar
ls ~/.m2/repository/com/google/guava/guava/

# settings.xml：Maven 全局配置（如换国内镜像源加速，见下）
cat ~/.m2/settings.xml

和前端的关键差异：

维度	前端	Maven
依赖位置	每个项目 `node_modules`（本地）	`~/.m2/repository`（全局共享）
磁盘占用	每项目一份，重复且大	全局一份，多项目复用
项目里放什么	`node_modules` + `package.json`	只有 `pom.xml`（不含 jar）
换源加速	`.npmrc` 配 registry	`~/.m2/settings.xml` 配 mirror

⚠️ 换国内镜像加速（第一次拉依赖极慢时）：在 ~/.m2/settings.xml 的 <mirrors> 里加阿里云镜像，类比前端把 npm registry 换成淘宝源：

<mirror>
    <id>aliyun</id>
    <mirrorOf>central</mirrorOf>
    <name>阿里云公共仓库</name>
    <url>https://maven.aliyun.com/repository/public</url>
</mirror>

七、jar 包：打包与运行（≈ 打成一个可执行产物）

.jar 是 Java 的打包格式（≈ 把整个项目 + 依赖压成一个可运行文件）。

# 打包（Spring Boot 项目会打成一个「胖 jar」，含所有依赖，能独立运行）
mvn clean package

# 运行打好的 jar（≈ node app.js 跑构建产物）
java -jar target/myapp-1.0.0.jar

# 运行时传参（Spring Boot 覆盖配置，如改端口）
java -jar target/myapp-1.0.0.jar --server.port=9090

# 指定 JVM 内存参数（生产常用，-Xmx 最大堆内存）
java -Xmx512m -jar target/myapp-1.0.0.jar

锚点：Spring Boot 的「胖 jar（fat jar）」把你的代码 + 所有依赖 + 内嵌 Tomcat 全打进一个文件，java -jar 直接就能起一个 Web 服务，不用单独装服务器。这是它比传统 Java Web 部署省心的地方。详见第 09、10 篇。

八、一页速查（贴墙版）

# === 环境 ===
java -version                     # 确认 JDK 版本
javac -version                    # 确认编译器版本（应一致）
echo $JAVA_HOME                   # 看当前 JDK 指向
/usr/libexec/java_home -V         # mac：列出所有 JDK

# === 编译运行（原始方式）===
javac -encoding UTF-8 X.java      # 编译（中文加 -encoding）
java X                            # 运行（跟类名，不带 .java）
jshell                            # 进 REPL 试代码

# === Maven 构建 ===
mvn clean package                 # 清理 + 打包（最常用）
mvn clean package -DskipTests     # 跳过测试打包
mvn spring-boot:run               # 启动 Spring Boot（≈ npm run dev）
mvn test                          # 跑测试
mvn dependency:tree               # 看依赖树（排查冲突）

# === 运行 jar ===
java -jar target/app.jar          # 跑打好的 jar
java -jar target/app.jar --server.port=9090  # 传参覆盖配置

# === 依赖位置 ===
ls ~/.m2/repository/              # 本地仓库（全局共享的「node_modules」）

九、总结

核心类比（先建直觉，再划边界）：多了「编译」这一步。前端 node app.js 直接跑源码。Java 是「编译型 + 虚拟机」语言，源码 .java 要先用 javac 编译成字节码 .class，再用 java 交给 JVM 运行。日常有 IDEA 和 Maven 帮你做，但要知道底层是两步。详见 37-Java疑问记录.md 的 Q1。 -> 依赖不在项目目录里。前端 node_modules 每个项目一份、装在项目里。Maven 把所有依赖下载到用户目录 /.m2/repository/ 全局共享，项目里只有 pom.xml 声明「我要哪些包」。省磁盘，但第一次会疑惑「装的包哪去了」。 -> pom.xml 是 XML，不是 JSON。
java / javac：编译与运行（最基础）：java 后面是「类名」不是文件名：✅ java HelloWorld ❌ java HelloWorld.java -> 类名必须和文件名完全一致（含大小写）：public class HelloWorld → HelloWorld.java -> 中文乱码就加 -encoding UTF-8
JAVA_HOME 与 JDK 版本（≈ nvm 的活）：Java 这边靠环境变量 JAVA_HOME 指向当前用的 JDK，命令行的 java/javac 跟着它走。
Maven（mvn）：包管理 + 构建（≈ npm）：Maven 是 Java 最主流的构建工具，一个命令同时管「装依赖 + 编译 + 测试 + 打包」，比 npm 管得更宽。
pom.xml：依赖清单（≈ package.json，但是 XML）：| devDependencies | test | ⚠️ 靠区分用途，不是分两个字段 |
依赖去哪了？本地仓库 /.m2：前端 npm install 后包进了项目的 node_modules，看得见。