2018 / 12 / 26

by John Yuan

Java 通过命令编译源码并构建可执行 jar 包

一般情况下我们会使用构建工具帮助我生成 jar 包，但工具是建立在底层命令的基础之上的，只会用工具而不知道底层实现原理，通常会让我们心里没底。本文主要记录如何使用 Java 自带的命令（javac、java、jar）来实现项目的编译、运行和打包。

一、概述

在本文中，我们将讨论以下内容：

使用 javac 命令编译项目用到的所有 java 文件
使用 java 命令运行项目主函数
使用 jar 命令创建可执行 jar 包
使用 jar 命令解压 jar 包
使用 javac 命令编译项目中所有 java 文件，无论该文件是否被引用

二、项目结构

作为演示，我们项目的结构如下：

demo-project
├── src
│   └── org
│       └── example
│           ├── app
│           │   └── App.java
│           └── service
│               ├── ByeService.java
│               ├── HelloService.java
│               └── impl
│                   └── HelloServiceImpl.java
└── target
    ├── classes           # 保存生成的 class 文件
    ├── demo-project.jar  # 保存生成的 jar 包
    └── unpackaged        # jar 包的解压目录

注意：我们的源代码中一共有 ByeService 和 HelloService 两个接口，但只提供了 HelloService 的实现（HelloServiceImpl）。这是有意为之，后面演示会进行说明。

三、源代码

org/example/app/App.java：

package org.example.app;

import org.example.service.HelloService;
import org.example.service.impl.HelloServiceImpl;

public class App {
    public static void main(String[] args) {
        HelloService h = new HelloServiceImpl();
        h.hello();
    }
}

org/example/service/ByService.java：

package org.example.service;

public interface ByeService {
    void bye();
}

org/example/service/HelloService：

package org.example.service;

public interface HelloService {
    void hello();
}

org/example/service/impl/HelloServiceImpl：

package org.example.service.impl;

import org.example.service.HelloService;

public class HelloServiceImpl implements HelloService {
    @Override
    public void hello() {
        System.out.println("HelloServiceImpl -> HelloService.hello()");
    }
}

注意：以上代码中我们没有引用 org.example.service.ByeService 这个类。

四、编译项目

首先确保我们创建了第一节中所描述的目录结构，主要是确保 target/classes 目录存在，因为我们会将该目录作为输出目录。

然后进入 src 目录，使用以下命令进行编译：

# 备注：
#  1) 当前所在目录为 src 目录
#  2) -d 用于指导输出目录
#  3) ../target/classes 目录必须存在才能编译成功
javac org/example/app/App.java -d ../target/classes

以上命令会编译 App.java 以及所有被 App.java 引用（import）的文件，由于 ByeService 没有被引用，所以 ByeService.java 文件没有被编译。

以下为编译之后的文件树形结构：

target
└─ classes
    └─ org
        └─ example
            ├─ app
            │   └─ App.class
            └─ service
                ├─ HelloService.class
                └─ impl
                    └─ HelloServiceImpl.class

五、运行程序

编译完成后，进入 target/classes 目录，然后执行以下命令以运行程序：

# 指定入口程序的全类名
java org.example.app.App

输出结果为：

HelloServiceImpl -> HelloService.hello()

六、创建可执行 jar 包

使用 jar 命令，我们可以把生成的 class 文件打包成一个 jar 包。首先我们需要进入 target/classes 目录，然后输入以下命令即可进行打包：

# 备注：
# 1) c 代表创建归档文件（即表明：此操作为打包而不是解压）
# 2) v 代表打印日志信息
# 3) f 代表指定输出文件名
# 4) ../demo-project.jar 即目标文件名
# 5) * 表示打包当前路径下的所有文件
jar cvf ../demo-project.jar *

通过上面的命令创建的不是一个这里所说的可执行 jar 包，但我们可以通过以下命令运行 main 方法：

# 备注：
# 1) -cp 代表指定 classpath，此处指定为生成的 jar 包
# 2) org.example.app.App 表示主程序入口
java -cp demo-project.jar org.example.app.App

上面的方式虽然能够执行 jar 包，但步骤稍显麻烦，而且需要我们记住主程序的全类名，比如这里的 org.example.app.App 这一长串。

下面我们要介绍的打包方式可以在打包时记录主程序的全类名，这样在我们执行这个 jar 包的时候，就不用输入全类名了。首先进入 target/classes 目录，然后执行以下命令：

# 备注：
# 1) 此处添加了 e 选项
# 2) 此处指定了主程序全类名 org.example.app.App
jar cvfe ../demo-project.jar org.example.app.App *

打包完成后，进入 target 目录，使用以下命令即可运行 jar 包：

java -jar demo-project.jar

下一节我们将讨论如何解压 jar 包，并说明 jar 包是如何记录主程序全类名的。

七、解压 jar 包

jar 包其实也是一种压缩包格式，我们可以使用 jar 命令解压 jar 包。以上面生成的 demo-project.jar 为例，首先我们进入 target/unpackaged 目录，确保 target/demo-project.jar 文件存在，然后执行以下命令：

# 备注：
# 1) x 代表解压
# 2) v 表示打印日志
# 3) f 指定要解压的文件名
# 4) 当前目录为 unpackaged，解压结果会保存到当前目录
jar xvf ../demo-project.jar

解压完成后，unpackaged 的目录结构如下：

unpackaged
├── META-INF
│   └── MANIFEST.MF
└── org
    └── example
        ├── app
        │   └── App.class
        └── service
            ├── HelloService.class
            └── impl
                └── HelloServiceImpl.class

可以看到，解压后的文件夹中除了我们的 class 文件外，还多了一个 META-INF 文件夹，该文件夹中的文件就是用来保存当前 jar 包的相关信息的。其中 META-INF/MANIFEST.MF 的文件内容如下：

Manifest-Version: 1.0
Created-By: 1.8.0_191 (Oracle Corporation)
Main-Class: org.example.app.App

可以看到，该文件使用 Main-Class 字段保存了主程序的全类名。

八、编译所有源文件

前面我们已经说过，由于我们的程序没有引用 ByeService.java 这个文件，所以我们在编译 App.java 的时候，编译器并不会去编译 ByeService.java 这个文件。但有些时候，我们需要编译源码目录下的所有文件，不管这些文件是否被引用。

要做到这一点，我们需手动告诉编译器我们需要编译哪些文件，比如下面这样：

# 备注：运行时确保我们处于 src 目录下
javac org/example/app/App.java org/example/service/ByeService.java -d ../target/classes

在上面的命令中，我们明确指示编译器要对 org/example/service/ByeService.java 这个文件进行编译。命令完成后，我们可以发现 org/example/service/ByeService.class 已经编译完成。

如果我们的项目很大，里面有无数的 .java 源文件，我们也不能清楚的记得哪些文件被引用了，而哪些文件没有被引用。这个时候，如果要求我们在编译时指定没有被引用的文件，就稍显麻烦了。所以最保险的办法是让编译器编译所有的源文件。也就是说，我们需要在 javac 命令中指定所有 .java 文件的路径。不过由于这个操作太反人类了，我们可以使用以下的 shell 脚本来帮我们完成：

#!/bin/bash
# 备注：
# 请将这个文件保存在项目根目录下（与 src 目录同级）
# 并命名为 build.sh

# 获取脚本文件所在目录
readonly __DIR__=$(cd $(dirname $0) && pwd)
# 源码目录
readonly SRC_DIR="${__DIR__}/src"
# 目标目录
readonly TARGET_DIR="${__DIR__}/target"
# class 文件目录
readonly CLASSES_DIR="${TARGET_DIR}/classes"
# 创建一个临时文件路径
readonly TEMP_FILE=$(mktemp)

# 打印提示信息
echo
echo "    SRC_DIR: ${SRC_DIR}"
echo " TARGET_DIR: ${TARGET_DIR}"
echo "CLASSES_DIR: ${CLASSES_DIR}"
echo "  TEMP_FILE: ${TEMP_FILE}"
echo

# 如果源码目录不存在，则退出程序
if [ ! -d "${SRC_DIR}" ]
then
    echo "ERROR: ${SRC_DIR} is not a directory."
    echo
    exit 1
fi

# 查找所有 .java 文件，并将文件名保存至临时文件
# 1. 首先进入源码目录
cd $SRC_DIR
# 2. 找到所有以 .java 结尾的文件名，并判断该文件是不是普通文件（排除目录）
for filename in $(find . -name "*.java")
do
    # 如果是普通文件，则将文件名保存至临时文件
    if [ -f "${filename}" ]
    then
        echo $filename >> $TEMP_FILE
    fi
done

# 将文件名列表保存至变量
readonly FILE_LIST=$(cat $TEMP_FILE)

# 如果文件列表为空，则退出程序
if [ "${FILE_LIST}" == "" ]
then
    echo "ERROR: There is no java file in ${SRC_DIR} directory."
    echo
    exit 1
fi

# 开始编译
# 1. 首先删除原有文件
rm -rf $CLASSES_DIR
# 2. 创建一个空目录
mkdir -p $CLASSES_DIR
# 3. 编译（此处可以根据实际需要添加其他参数）
javac $FILE_LIST -d $CLASSES_DIR

# 打印已经编译的文件名列表
echo "Compiled file list:"
echo
cat $TEMP_FILE
echo

# 删除临时文件
rm -rf $TEMP_FILE

# 编译完成，退出程序
exit

将以上文件内容保存至项目根目录下，并命名为 build.sh，然后执行以下命令给该文件添加可执行权限：

chmod +x build.sh

然后执行 build.sh 文件即可编译所有源文件：

./build.sh

本文完。