胖包与瘦包的打包与部署

在现代软件开发中，高效的打包与部署是确保应用程序稳定运行和快速迭代的关键。尤其是在使用 Java 开发的项目中，选择合适的打包方式不仅影响应用程序的体积和启动速度，还直接关系到部署的便捷性和灵活性。本文将深入探讨 胖包（Fat Package）与 瘦包（Thin Package）的概念、优势，并详细介绍如何使用 deploy 工具将 tio-boot 工程进行打包与部署。

简介

胖包与瘦包概述

在 Java 项目的打包过程中，胖包（Fat Package）和 瘦包（Thin Package）是两种常见的打包方式：

  • 胖包：包含所有的依赖 JAR 包，包括第三方库和自身代码。这种方式生成的可执行文件较大，但独立性强，适合在不同环境下快速部署，无需额外配置依赖环境。
  • 瘦包：仅包含自身代码和资源，不包含第三方库。依赖项需在目标环境中预先安装或单独管理。这种方式的优势在于打包文件体积较小，传输和部署更为快速，但对部署环境的依赖性更高。

瘦包的优势

  • 体积小：瘦包只包含应用程序自身的代码和资源，显著减少包体积，节省存储空间。
  • 部署快：由于体积更小，瘦包可以更快速地传输和部署，特别适用于网络传输或持续交付（CI/CD）场景。

部署时间

  • 胖包：50M 90 秒(大部分是消耗在了网络传输上)
  • 瘦包：152Kb 10 秒

创建工程

本文以 tio-boot 工程为例，展示如何创建一个包含底层依赖和代码的 Java 项目。

项目结构与依赖

首先，配置 pom.xml 文件，定义项目的依赖和构建属性：

<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0
         http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.litongjava.full</groupId>
    <artifactId>thin</artifactId>
    <version>1.0.0</version>
    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <java.version>1.8</java.version>
        <maven.compiler.source>${java.version}</maven.compiler.source>
        <maven.compiler.target>${java.version}</maven.compiler.target>
        <lombok-version>1.18.30</lombok-version>
        <tio-boot.version>1.9.0</tio-boot.version>
        <jfinal-aop.version>1.2.6</jfinal-aop.version>
        <fastjson2.version>2.0.52</fastjson2.version>
        <hotswap-classloader.version>1.2.4</hotswap-classloader.version>
        <final.name>web-hello</final.name>
        <main.class>com.litongjava.full.thin.HelloApp</main.class>
        <assembly>full</assembly>
    </properties>
    <dependencies>
        <dependency>
            <groupId>ch.qos.logback</groupId>
            <artifactId>logback-classic</artifactId>
            <version>1.2.3</version>
        </dependency>
        <dependency>
            <groupId>com.litongjava</groupId>
            <artifactId>tio-boot</artifactId>
            <version>${tio-boot.version}</version>
        </dependency>
        <dependency>
            <groupId>com.litongjava</groupId>
            <artifactId>hotswap-classloader</artifactId>
            <version>${hotswap-classloader.version}</version>
        </dependency>
        <dependency>
            <groupId>com.litongjava</groupId>
            <artifactId>jfinal-aop</artifactId>
            <version>${jfinal-aop.version}</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba.fastjson2</groupId>
            <artifactId>fastjson2</artifactId>
            <version>${fastjson2.version}</version>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>${lombok-version}</version>
            <optional>true</optional>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>
    </dependencies>
</project>

启动类与控制器

创建项目的启动类 HelloApp：

package com.litongjava.full.thin;

import com.litongjava.jfinal.aop.annotation.AComponentScan;
import com.litongjava.tio.boot.TioApplication;

@AComponentScan
public class HelloApp {
    public static void main(String[] args) {
        long start = System.currentTimeMillis();
        TioApplication.run(HelloApp.class, args);
        long end = System.currentTimeMillis();
        System.out.println((end - start) + "ms");
    }
}

创建一个简单的控制器 IndexController：

package com.litongjava.full.thin.controller;

import com.litongjava.annotation.RequestPath;

@RequestPath("/")
public class IndexController {
    @RequestPath()
    public String index() {
        return "index";
    }
}

以上代码完成了一个简单的 tio-boot 工程的创建，包含必要的依赖和基础代码。

打包

配置 Maven

为了灵活地管理不同环境下的打包需求，我们在 pom.xml 中配置了多个 profiles，分别适用于开发和生产环境。并使用 maven-assembly-plugin 插件来实现胖包与瘦包的打包。

pom.xml 配置

在 pom.xml 中定义不同的 profiles，如下所示：

<profiles>
    <!-- 开发环境配置 -->
    <profile>
        <id>development</id>
        <activation>
            <activeByDefault>true</activeByDefault>
        </activation>
        <build>
            <plugins>
                <!-- Spring Boot Maven 插件 -->
                <plugin>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-maven-plugin</artifactId>
                    <version>2.7.4</version>
                    <configuration>
                        <fork>true</fork>
                        <mainClass>${main.class}</mainClass>
                        <excludeGroupIds>org.projectlombok</excludeGroupIds>
                        <arguments>
                            <argument>--mode=dev</argument>
                        </arguments>
                    </configuration>
                </plugin>
            </plugins>
        </build>
    </profile>

    <!-- 生产环境配置 -->
    <profile>
        <id>production</id>
        <build>
            <plugins>
                <!-- Spring Boot Maven 插件 -->
                <plugin>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-maven-plugin</artifactId>
                    <version>2.7.4</version>
                    <configuration>
                        <mainClass>${main.class}</mainClass>
                        <excludeGroupIds>org.projectlombok</excludeGroupIds>
                    </configuration>
                    <executions>
                        <execution>
                            <goals>
                                <goal>repackage</goal>
                            </goals>
                        </execution>
                    </executions>
                </plugin>
            </plugins>
        </build>
    </profile>

    <!-- Assembly 配置 -->
    <profile>
        <id>assembly</id>
        <build>
            <plugins>
                <!-- Maven Assembly 插件 -->
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-assembly-plugin</artifactId>
                    <version>3.3.0</version>
                    <configuration>
                        <!-- 不在发布文件名中追加 assembly id -->
                        <appendAssemblyId>false</appendAssemblyId>
                        <descriptors>
                            <descriptor>assembly-${assembly}.xml</descriptor>
                        </descriptors>
                    </configuration>
                    <executions>
                        <execution>
                            <id>make-assembly</id>
                            <phase>package</phase>
                            <goals>
                                <goal>single</goal>
                            </goals>
                        </execution>
                    </executions>
                </plugin>
            </plugins>
            <!-- 资源配置 -->
            <resources>
                <resource>
                    <directory>src/main/resources</directory>
                    <includes>
                        <include>**/*.*</include>
                    </includes>
                </resource>
            </resources>
        </build>
    </profile>
</profiles>

说明：

  • 开发环境 (development)：使用 spring-boot-maven-plugin 插件进行打包和运行，支持快速迭代和调试。默认激活。
  • 生产环境 (production)：同样使用 spring-boot-maven-plugin，但配置略有不同，适用于生成生产环境所需的包。
  • Assembly 配置 (assembly)：使用 maven-assembly-plugin 插件，根据不同的 assembly 描述文件（assembly-full.xml 或 assembly-thin.xml）生成胖包或瘦包。

assembly-full.xml 配置

assembly-full.xml 用于定义胖包的打包规则。将所有依赖的 JAR 包和必要的脚本文件打包到最终的 ZIP 文件中。

文件路径：项目根目录下创建 assembly-full.xml

<assembly
    xmlns="http://maven.apache.org/plugins/maven-assembly-plugin/assembly/1.1.0"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/plugins/maven-assembly-plugin/assembly/1.1.0
                        http://maven.apache.org/xsd/assembly-1.1.0.xsd">
    <id>zipPackage</id>
    <formats>
        <format>zip</format>
    </formats>
    <includeBaseDirectory>true</includeBaseDirectory>
    <fileSets>
        <!-- 所有的 JAR 包 -->
        <fileSet>
            <directory>${project.build.directory}/lib</directory>
            <outputDirectory>lib</outputDirectory>
            <includes>
                <include>*.jar</include>
            </includes>
        </fileSet>

        <!-- Linux 启动脚本 -->
        <fileSet>
            <directory>${basedir}/src/main/bin</directory>
            <lineEnding>unix</lineEnding>
            <outputDirectory></outputDirectory>
            <!-- 脚本文件在 Linux 下的权限设为 755，无需 chmod 可直接运行 -->
            <fileMode>755</fileMode>
            <includes>
                <include>*.sh</include>
            </includes>
        </fileSet>

        <!-- 复制 Service 文件 -->
        <fileSet>
            <directory>${basedir}/src/main/bin</directory>
            <lineEnding>unix</lineEnding>
            <outputDirectory>service</outputDirectory>
            <includes>
                <include>*.service</include>
            </includes>
        </fileSet>

        <!-- Windows 启动脚本 -->
        <fileSet>
            <directory>${basedir}/src/main/bin</directory>
            <lineEnding>windows</lineEnding>
            <outputDirectory></outputDirectory>
            <includes>
                <include>*.bat</include>
            </includes>
        </fileSet>
    </fileSets>
    <!-- 依赖的 JAR 包复制到 lib 目录下 -->
    <dependencySets>
        <dependencySet>
            <outputDirectory>lib</outputDirectory>
        </dependencySet>
    </dependencySets>
</assembly>

主要内容：

  • 格式 (formats)：定义最终生成的包的格式为 ZIP。
  • 文件集合 (fileSets)：指定需要打包的文件及其在目标路径中的存放位置。
    • lib 目录下的所有 JAR 包。
    • src/main/bin 目录下的 Linux 和 Windows 启动脚本及 Service 文件。
  • 依赖集合 (dependencySets)：将项目的所有依赖包复制到 lib 目录下，确保运行时所需的所有依赖均已包含在包内。

assembly-thin.xml 配置

assembly-thin.xml 用于定义瘦包的打包规则。仅包含应用程序自身的代码和资源，不包含第三方依赖。

文件路径：项目根目录下创建 assembly-thin.xml

<assembly
    xmlns="http://maven.apache.org/plugins/maven-assembly-plugin/assembly/1.1.0"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/plugins/maven-assembly-plugin/assembly/1.1.0
                        http://maven.apache.org/xsd/assembly-1.1.0.xsd">
    <id>zipPackage</id>
    <formats>
        <format>zip</format>
    </formats>
    <includeBaseDirectory>true</includeBaseDirectory>
    <fileSets>
        <!-- 仅包含应用程序自身的 JAR 包 -->
        <fileSet>
            <directory>${project.build.directory}</directory>
            <outputDirectory>lib</outputDirectory>
            <includes>
                <include>*.jar</include>
            </includes>
        </fileSet>
    </fileSets>
</assembly>

主要内容：

  • 文件集合 (fileSets)：仅包含项目构建输出目录下的 JAR 包，排除第三方依赖。

执行打包命令

根据不同的打包需求，执行以下命令：

  • 全量包（胖包）：

    set JAVA_HOME=D:\java\jdk1.8.0_121
mvn clean package -DskipTests -Passembly -Dassembly=full

    该命令使用 assembly-full.xml 配置文件，生成包含所有依赖的胖包。

  • 瘦包：

    set JAVA_HOME=D:\java\jdk1.8.0_121
mvn clean package -DskipTests -Passembly -Dassembly=thin

    该命令使用 assembly-thin.xml 配置文件，生成仅包含自身代码的瘦包。

启动应用

根据不同操作系统，使用相应的命令启动应用程序：

  • Windows 启动：

    java -Xverify:none -cp config;lib\*;static ${MAIN_CLASS}

    示例：

    java -Xverify:none -cp config;lib\*;static com.litongjava.full.thin.HelloApp

  • Linux 启动：

    java -Xverify:none -cp ./config:./lib/*:./static ${MAIN_CLASS}

    示例：

    java -Xverify:none -cp ./config:./lib/*:./static com.litongjava.full.thin.HelloApp

  • 指定启动参数：

    可以通过在命令行中添加参数，指定应用程序的运行配置：

    java -Xverify:none -cp ./config:./lib/*:./static com.litongjava.full.thin.HelloApp --server.port=1003

部署

打包完成后，接下来是将应用程序部署到目标服务器。本文将介绍如何使用 deploy 工具实现自动化部署，支持多平台，并通过配置文件定义不同环境的部署步骤。

使用 deploy 工具 部署到 Docker

deploy 工具旨在简化部署流程，提高部署效率。它支持多平台，通过配置文件来定义不同环境的部署步骤。

配置文件说明

部署过程涉及两个主要配置文件：

  1. .build.txt：定义打包时的环境变量和命令。
  2. .deploy.toml：定义部署时的服务器地址、压缩包路径、解压路径等。
.build.txt 配置

该文件用于配置项目在不同操作系统上的打包命令。以下是示例配置：

[win.env]
set JAVA_HOME=D:\java\jdk1.8.0_121

[win.build]
mvn clean package -DskipTests -Passembly -Dassembly=full

[linux.env]
export JAVA_HOME=/usr/java/jdk1.8.0_121

[linux.build]
mvn clean package -DskipTests -Passembly -Dassembly=full

[mac.env]
export JAVA_HOME=~/java/jdk1.8.0_121

[mac.build]
mvn clean package -DskipTests -Passembly -Dassembly=full

说明：

  • 环境变量配置：分别为 Windows、Linux 和 macOS 系统配置 JAVA_HOME 环境变量。
  • 打包命令：在不同系统下执行相应的 Maven 打包命令，生成胖包或瘦包。
.deploy.toml 配置

该文件用于定义不同环境（如开发、测试、生产）的部署操作。以下是示例配置：

[dev.upload-run]
url = "http://192.168.1.2:10405/deploy/file/upload-run/"
p = "123456"
b = ".build.txt"
file = "target/tio-boot-full-thin-demo01-1.0.0.zip"
d = "unzip/tio-boot-full-thin-demo01"
c1 = "mkdir -p /data/apps/tio-boot-full-thin-demo01 && mkdir -p backup/tio-boot-full-thin-demo01"
c2 = "[ -d /data/apps/tio-boot-full-thin-demo01 ] && cp -r /data/apps/tio-boot-full-thin-demo01 backup/tio-boot-full-thin-demo01/$(date +%Y%m%d_%H%M%S)"
c3 = "cp -r unzip/tio-boot-full-thin-demo01/* /data/apps/tio-boot-full-thin-demo01/"
c4 = "if [ $(docker ps -qa -f name=tio-boot-full-thin-demo01) ]; then docker stop tio-boot-full-thin-demo01 && docker rm -f tio-boot-full-thin-demo01; fi"
c5 = "cd /data/apps/tio-boot-full-thin-demo01/tio-boot-full-thin-demo01-1.0.0 && docker run -dit --name tio-boot-full-thin-demo01 --restart=always --net=host -v $(pwd):/app -w /app -e TZ=Asia/Shanghai -e LANG=C.UTF-8 litongjava/jdk:8u391-stable-slim java -Xverify:none -cp ./config:./lib/*:./static com.litongjava.full.thin.HelloApp"
c = "docker ps | grep tio-boot-full-thin-demo01"

配置项说明：

  • url: 上传文件的服务端地址。
  • p: 密码，用于身份验证。
  • b: 指定打包配置文件（即 .build.txt）。
  • file: 上传的压缩包文件名。
  • d: 解压路径。
  • c1-c5: 一系列 Shell 命令，依次执行创建目录、备份旧版本、复制新文件、停止并删除旧容器、启动新容器等操作。
  • c: 检查容器是否成功启动的命令。

部署到 Docker

根据 .build.txt 和 .deploy.toml 配置文件，执行以下步骤将应用程序部署到 Docker 环境：

  1. 胖包部署：

    使用全量包进行部署，执行以下命令：

    deploy

    该命令将根据 .deploy.toml 中 dev.upload-run 配置，将胖包上传至服务器，解压并通过 Docker 启动新的容器。

  2. 瘦包部署：

    修改 .build.txt 中的 -Dassembly=full 为 -Dassembly=thin，然后执行：

    deploy

    该命令将生成瘦包并进行相应的部署操作。

部署到 systemctl

除了使用 Docker，deploy 工具还支持通过 systemctl 管理应用程序的部署。以下是具体步骤：

  1. 配置 .deploy.toml：

    [test.upload-run]
url = "http://52.9.164.136:10405/deploy/file/upload-run/"
p = "123456"
b = ".build.txt"
file = "target/max-blog-app-backend-1.0.0.zip"
d = "unzip/max-blog-app-backend"
c1 = "mkdir -p backup/max-blog-app-backend"
c2 = "[ -d /data/apps/max-blog-app-backend ] && cp -r /data/apps/max-blog-app-backend backup/max-blog-app-backend/$(date +%Y%m%d_%H%M%S)"
c3 = "mkdir -p /data/apps/max-blog-app-backend"
c4 = "cp -r unzip/max-blog-app-backend/* /data/apps/max-blog-app-backend/"
c = "systemctl restart max-blog-app-backend"

  2. 执行部署命令：

    deploy -e test

    该命令将根据 test.upload-run 配置，上传并解压瘦包，然后通过 systemctl 重启服务。

配置 Systemd 服务

为确保应用程序能够在系统启动时自动运行，并提供便捷的管理方式，我们需要配置 Systemd 服务。

创建 Service 文件

在服务器上创建一个 Systemd Service 文件，以管理 max-blog-app-backend 应用。

创建文件：

vi /etc/systemd/system/max-blog-app-backend.service

填写内容：

[Unit]
Description=max-blog-app-backend
After=network.target

[Service]
Type=simple
User=root
Restart=on-failure
RestartSec=5s
WorkingDirectory=/data/apps/max-blog-app-backend/max-blog-app-backend-1.0.0
ExecStart=/usr/java/jdk1.8.0_411/bin/java -Xverify:none -cp ./config:./lib/*:./static com.litongjava.max.blog.MaxBlogApp --app.env=test

[Install]
WantedBy=multi-user.target

配置说明：

  • [Unit]：
    • Description: 服务描述。
    • After: 指定服务启动的先后顺序，此处为网络服务启动后再启动本服务。
  • [Service]：
    • Type: 服务类型，此处为简单类型。
    • User: 运行服务的用户。
    • Restart: 服务失败时的重启策略。
    • RestartSec: 重启前的等待时间。
    • WorkingDirectory: 服务的工作目录。
    • ExecStart: 启动服务的命令。
  • [Install]：
    • WantedBy: 指定服务的目标状态，此处为多用户运行级别。

启动并启用服务

执行以下命令以启动并启用服务：

systemctl daemon-reload
systemctl start max-blog-app-backend
systemctl status max-blog-app-backend
systemctl enable max-blog-app-backend

命令说明：

  • daemon-reload：重新加载 Systemd 配置文件。
  • start：启动服务。
  • status：查看服务状态。
  • enable：设置服务开机自启。

.deploy.toml 配置

[test.upload-run]
url = "http://192.168.1.2:10405/deploy/file/upload-run/"
p = "123456"
b = ".build.txt"
file = "target/max-blog-app-backend-1.0.0.zip"
d = "unzip/max-blog-app-backend"
c1 = "mkdir -p backup/max-blog-app-backend"
c2 = "[ -d /data/apps/max-blog-app-backend ] && cp -r /data/apps/max-blog-app-backend backup/max-blog-app-backend/$(date +%Y%m%d_%H%M%S)"
c3 = "mkdir -p /data/apps/max-blog-app-backend"
c4 = "cp -r unzip/max-blog-app-backend/* /data/apps/max-blog-app-backend/"
c = "systemctl restart max-blog-app-backend"

使用 Shell 脚本管理应用

为了更灵活地管理应用程序的启动、停止和重启，可以使用 Shell 脚本进行控制。

启动脚本 tio.sh

创建一个 Shell 脚本 tio.sh，用于在 Unix 系统中管理应用程序。该脚本提供了标准的服务管理功能，如启动、停止、重启和查看状态。

脚本内容：

#!/bin/sh
# chkconfig: 345 99 01
# description:tio

##########################
# 获取应用主目录
###########################
PRG="$0"
while [ -h "$PRG" ] ; do
  ls=`ls -ld "$PRG"`
  link=`expr "$ls" : '.*-> \(.*\)$'`
  if expr "$link" : '/.*' > /dev/null; then
    PRG="$link"
  else
    PRG=`dirname "$PRG"`/"$link"
  fi
done

##########################
# 自定义变量
###########################
MAIN_CLASS=""
JAVA_HOME=""
if [ -z "$JAVA_HOME" ]; then
  JAVA_HOME=${JAVA_HOME:-$(dirname $(readlink -f $(which java)))/..}
fi
APP_HOME=`dirname "$PRG"`
APP_NAME=`basename "$PRG"`
PID_FILE=$APP_HOME/$APP_NAME.pid
CP=$APP_HOME/config:$APP_HOME/lib/*:$APP_HOME/static

# Java 命令行参数，根据需要开启下面的配置，注意等号前后不能有空格
# JAVA_OPTS="-Xms256m -Xmx1024m -Dundertow.port=80 -Dundertow.host=0.0.0.0"
# JAVA_OPTS="-Dundertow.port=80 -Dundertow.host=0.0.0.0"

#########################
# 定义函数
##########################
lock_dir=/var/lock/subsys
lock_file=$lock_dir/$APP_NAME
createLockFile(){
  [ -w $lock_dir ] && touch $lock_file
}

start(){
  # 检查 Java 命令是否存在
  if [ ! -x "$JAVA_HOME/bin/java" ]; then
    echo "Error: Java command not found at $JAVA_HOME/bin/java"
    exit 1
  fi

  # 检查 MAIN_CLASS 是否定义
  if [ -z "$MAIN_CLASS" ]; then
    echo "Error: MAIN_CLASS is not defined. Please provide a valid main class."
    exit 1
  fi

  [ -e $APP_HOME/logs ] || mkdir $APP_HOME/logs -p

  if [ -f $PID_FILE ]
  then
    echo '应用已在运行...'
  else
    CMD="$JAVA_HOME/bin/java -Xverify:none ${JAVA_OPTS} -cp ${CP} ${MAIN_CLASS}"
    echo $CMD
    nohup $CMD >> $APP_HOME/logs/$APP_NAME.log 2>&1 &
    echo $! > $PID_FILE
    createLockFile
    echo "[启动成功]"
  fi
}

stop(){
  if [ -f $PID_FILE ]
  then
    kill `cat $PID_FILE`
    rm -f $PID_FILE
    echo "[停止成功]"
  else
    echo '应用未在运行...'
  fi
}

restart(){
  stop
  start
}

status(){
  if [ -f $PID_FILE ]; then
    echo "应用正在运行，PID：$(cat $PID_FILE)"
  else
    echo "应用未运行"
  fi
}

##########################
# 执行动作
##########################
ACTION=$1
if [ -n "$2" ]; then
  MAIN_CLASS=$2
fi

case $ACTION in
  start)
    start
    ;;
  stop)
    stop
    ;;
  restart)
    restart
    ;;
  status)
    status
    ;;
  *)
    echo "用法: $0 {start|stop|restart|status} [main class]"
    ;;
esac

脚本说明：

  • 获取应用主目录：通过解析符号链接，确定脚本的实际位置，从而获取应用的主目录。
  • 自定义变量：
    • MAIN_CLASS：应用的主类，需要在执行脚本时提供。
    • JAVA_HOME：Java 安装目录，若未设置则自动检测。
    • APP_HOME：应用的主目录。
    • APP_NAME：应用名称。
    • PID_FILE：存储应用进程 ID 的文件。
    • CP：类路径，包含配置、库和静态资源目录。
    • JAVA_OPTS：Java 启动参数，可根据需要进行配置。
  • 函数定义：
    • start：启动应用程序。
    • stop：停止应用程序。
    • restart：重启应用程序。
    • status：查看应用程序状态。
  • 执行动作：根据传入的参数执行相应的操作（启动、停止、重启或查看状态）。

配置 Service 文件

为方便使用 Systemd 管理应用程序，通过 tio.sh 脚本创建 Service 文件。

创建文件：

vi /etc/systemd/system/tio.service

填写内容：

[Unit]
Description=tio
After=network.target

[Service]
ExecStart=/opt/tio-hello/tio-hello-1.0/tio.sh start com.litongjava.full.thin.HelloApp
ExecStop=/opt/tio-hello/tio-hello-1.0/tio.sh stop
ExecReload=/opt/tio-hello/tio-hello-1.0/tio.sh restart com.litongjava.full.thin.HelloApp
Type=forking
PrivateTmp=true

[Install]
WantedBy=multi-user.target

配置说明：

  • [Unit]：
    • Description: 服务描述。
    • After: 指定服务启动的先后顺序，此处为网络服务启动后再启动本服务。
  • [Service]：
    • ExecStart: 启动服务的命令，包含主类参数。
    • ExecStop: 停止服务的命令。
    • ExecReload: 重启服务的命令，包含主类参数。
    • Type: 服务类型，此处为 forking，表示服务启动后会派生出子进程。
    • PrivateTmp: 为服务提供独立的临时目录。
  • [Install]：
    • WantedBy: 指定服务的目标状态，此处为多用户运行级别。

启动并启用服务：

systemctl daemon-reload
systemctl start tio.service
systemctl status tio.service
systemctl enable tio.service

命令说明：

  • daemon-reload：重新加载 Systemd 配置文件。
  • start：启动服务。
  • status：查看服务状态。
  • enable：设置服务开机自启。

工具源码

本文中提到的 deploy 工具已开源，欢迎开发者参考和贡献。以下是相关源码仓库的链接：

通过这些工具，您可以实现高效、自动化的项目部署流程，显著提升开发与运维效率。

结语

本文详细介绍了 胖包 与 瘦包 的概念及其在 Java 项目中的应用，并通过 tio-boot 工程示例，展示了如何使用 Maven 进行不同类型的打包，以及如何使用 deploy 工具实现自动化部署。无论是基于 Docker 还是 Systemd 的部署方式，都能够满足不同环境下的需求。希望本文档能够帮助您快速上手并顺利完成项目的打包与部署。

如有任何疑问或建议，欢迎在项目的 GitHub 仓库中提出。