# jar-deploy

**Repository Path**: techzhi/jar-deploy

## Basic Information

- **Project Name**: jar-deploy
- **Description**: 用于简单的jar部署操作
- **Primary Language**: Java
- **License**: Apache-2.0
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 0
- **Forks**: 0
- **Created**: 2025-09-17
- **Last Updated**: 2025-09-17

## Categories & Tags

**Categories**: Uncategorized

**Tags**: None

## README

# JAR 生产级服务管理设计文档

## 1. 项目概述

### 1.1 目标
在Linux环境（axz 6.6.0-108.0.0.111.oe2403sp1.aarch64）下，为JAR应用（如`breeze-admin.jar`）实现生产级服务管理，包括systemd服务管理、应用日志滚动管理等核心功能。

### 1.2 环境信息
- **操作系统**: Linux axz 6.6.0-108.0.0.111.oe2403sp1.aarch64
- **架构**: aarch64
- **应用路径**: 可配置，默认为`/root/AXZ_DEPLOY/java/breeze-admin.jar`
- **服务管理**: systemd
- **运行用户**: root
- **日志管理**: 应用层日志滚动策略

## 2. 整体架构设计

### 2.1 服务管理架构
```
┌─────────────────┐    ┌─────────────────┐
│   systemd       │    │   breeze-admin  │
│   (服务管理)     │────│   (应用服务)     │
└─────────────────┘    └─────────────────┘
         │                       │
         ▼                       ▼
┌─────────────────┐    ┌─────────────────┐
│   journald      │    │   logback       │
│   (系统日志)     │    │   (应用日志)     │
└─────────────────┘    └─────────────────┘
```

### 2.2 目录结构设计
```
/root/AXZ_DEPLOY/java/
├── [JAR_NAME]                   # 主应用jar包（如：breeze-admin.jar）
├── config/                      # 配置文件目录
│   ├── application.yml          # 应用配置
│   ├── application-prod.yml     # 生产环境配置
│   └── logback-spring.xml       # 日志配置
├── logs/                        # 日志目录
│   ├── breeze-admin.log        # 主日志文件
│   ├── error.log               # 错误日志
│   └── archive/                # 归档日志
├── scripts/                     # 脚本目录
│   ├── start.sh                # 启动脚本
│   ├── stop.sh                 # 停止脚本
│   └── health-check.sh         # 健康检查脚本
└── systemd/                     # systemd配置
    └── breeze-admin.service    # 服务配置
```

## 3. 详细设计

### 3.1 systemd服务配置

#### 3.1.1 服务单元文件设计
- **服务名称**: `breeze-admin.service`
- **服务类型**: `forking`
- **用户**: `root`
- **工作目录**: `/root/AXZ_DEPLOY/java`
- **环境变量**: 通过EnvironmentFile配置
- **资源限制**: 内存、CPU、文件描述符限制
- **依赖关系**: 网络、数据库服务依赖
- **重启策略**: 自动重启，指数退避

### 3.2 日志管理策略

#### 3.2.1 应用层日志架构
```
应用层日志 (logback)
    ↓
日志文件滚动 (按大小和时间)
    ↓
日志归档 (压缩存储)
    ↓
日志清理 (定期清理)
```

#### 3.2.2 日志滚动策略
- **按大小滚动**: 单文件最大100MB
- **按时间滚动**: 每日滚动
- **保留策略**: 保留30天，压缩归档
- **清理策略**: 自动清理过期日志

#### 3.2.3 日志分类
- **应用日志**: 业务逻辑日志
- **错误日志**: 异常和错误信息
- **审计日志**: 操作审计记录

### 3.3 JVM优化配置

#### 3.3.1 内存配置
- **堆内存**: 根据系统内存动态调整
- **元空间**: 256MB
- **直接内存**: 512MB
- **栈内存**: 1MB per thread

#### 3.3.2 GC配置
- **GC算法**: G1GC (生产环境推荐)
- **GC日志**: 详细GC日志记录
- **GC调优**: 根据应用特性优化

## 4. 具体配置文件内容

### 4.1 systemd服务配置文件

#### 4.1.1 breeze-admin.service
```ini
[Unit]
Description=Breeze Admin Service
Documentation=https://github.com/nvxclouds/breeze
After=network.target
Wants=network.target

[Service]
Type=forking
User=root
Group=root
WorkingDirectory=/root/AXZ_DEPLOY/java
ExecStart=/root/AXZ_DEPLOY/java/scripts/start.sh
ExecStop=/root/AXZ_DEPLOY/java/scripts/stop.sh
ExecReload=/bin/kill -HUP $MAINPID
PIDFile=/root/AXZ_DEPLOY/java/breeze-admin.pid
Restart=always
RestartSec=10
StartLimitInterval=60
StartLimitBurst=3

# 资源限制
LimitNOFILE=65536
LimitNPROC=32768
MemoryMax=2G
CPUQuota=200%

# 环境变量
Environment=JAVA_HOME=/usr/lib/jvm/java-11-openjdk
Environment=SPRING_PROFILES_ACTIVE=prod
Environment=LOG_PATH=/root/AXZ_DEPLOY/java/logs

# 安全配置
NoNewPrivileges=true
PrivateTmp=true
ProtectSystem=strict
ProtectHome=true
ReadWritePaths=/root/AXZ_DEPLOY/java/logs
ReadWritePaths=/root/AXZ_DEPLOY/java/data

[Install]
WantedBy=multi-user.target
```

### 4.2 启动脚本

#### 4.2.1 start.sh
```bash
#!/bin/bash

# Breeze Admin 启动脚本
# 作者: System Admin
# 日期: $(date +%Y-%m-%d)

set -e

# 配置变量
DEPLOY_DIR="/root/AXZ_DEPLOY/java"
JAR_NAME="breeze-admin.jar"
JAR_FILE="$DEPLOY_DIR/$JAR_NAME"
PID_FILE="/root/AXZ_DEPLOY/java/breeze-admin.pid"
LOG_DIR="/root/AXZ_DEPLOY/java/logs"
CONFIG_DIR="/root/AXZ_DEPLOY/java/config"
JAVA_OPTS_FILE="/root/AXZ_DEPLOY/java/config/java-opts.conf"

# 创建必要目录
mkdir -p "$LOG_DIR"
mkdir -p "$CONFIG_DIR"

# 检查Java环境
if [ -z "$JAVA_HOME" ]; then
    export JAVA_HOME="/usr/lib/jvm/java-11-openjdk"
fi

if [ ! -f "$JAVA_HOME/bin/java" ]; then
    echo "错误: Java环境未找到，请检查JAVA_HOME设置"
    exit 1
fi

# 检查jar文件
if [ ! -f "$JAR_FILE" ]; then
    echo "错误: JAR文件不存在: $JAR_FILE"
    exit 1
fi

# 检查是否已经运行
if [ -f "$PID_FILE" ]; then
    PID=$(cat "$PID_FILE")
    if ps -p "$PID" > /dev/null 2>&1; then
        echo "错误: 服务已经在运行 (PID: $PID)"
        exit 1
    else
        echo "警告: 发现旧的PID文件，正在清理..."
        rm -f "$PID_FILE"
    fi
fi

# 加载JVM参数
JAVA_OPTS=""
if [ -f "$JAVA_OPTS_FILE" ]; then
    JAVA_OPTS=$(cat "$JAVA_OPTS_FILE" | tr '\n' ' ')
fi

# 默认JVM参数
DEFAULT_OPTS="-server -Xms512m -Xmx2g -XX:MetaspaceSize=256m -XX:MaxMetaspaceSize=512m"
DEFAULT_OPTS="$DEFAULT_OPTS -XX:+UseG1GC -XX:MaxGCPauseMillis=200"
DEFAULT_OPTS="$DEFAULT_OPTS -XX:+HeapDumpOnOutOfMemoryError -XX:HeapDumpPath=$LOG_DIR"
DEFAULT_OPTS="$DEFAULT_OPTS -Dspring.profiles.active=prod"
DEFAULT_OPTS="$DEFAULT_OPTS -Dlogging.config=$CONFIG_DIR/logback-spring.xml"
DEFAULT_OPTS="$DEFAULT_OPTS -Dlogging.path=$LOG_DIR"

# 合并JVM参数
FINAL_OPTS="$DEFAULT_OPTS $JAVA_OPTS"

echo "启动 Breeze Admin 服务..."
echo "JAR文件: $JAR_FILE"
echo "日志目录: $LOG_DIR"
echo "JVM参数: $FINAL_OPTS"

# 启动应用
nohup "$JAVA_HOME/bin/java" $FINAL_OPTS -jar "$JAR_FILE" > "$LOG_DIR/startup.log" 2>&1 &

# 保存PID
echo $! > "$PID_FILE"

# 等待启动
sleep 5

# 检查启动状态
if [ -f "$PID_FILE" ]; then
    PID=$(cat "$PID_FILE")
    if ps -p "$PID" > /dev/null 2>&1; then
        echo "服务启动成功 (PID: $PID)"
        echo "日志文件: $LOG_DIR/breeze-admin.log"
        echo "启动日志: $LOG_DIR/startup.log"
    else
        echo "错误: 服务启动失败"
        rm -f "$PID_FILE"
        exit 1
    fi
else
    echo "错误: 无法创建PID文件"
    exit 1
fi
```

#### 4.2.2 stop.sh
```bash
#!/bin/bash

# Breeze Admin 停止脚本
# 作者: System Admin
# 日期: $(date +%Y-%m-%d)

set -e

# 配置变量
PID_FILE="/root/AXZ_DEPLOY/java/breeze-admin.pid"
SERVICE_NAME="breeze-admin"

echo "停止 Breeze Admin 服务..."

# 检查PID文件
if [ ! -f "$PID_FILE" ]; then
    echo "警告: PID文件不存在，尝试通过进程名查找..."
    PID=$(pgrep -f "$JAR_NAME" || true)
    if [ -z "$PID" ]; then
        echo "服务未运行"
        exit 0
    fi
else
    PID=$(cat "$PID_FILE")
fi

# 检查进程是否存在
if [ -n "$PID" ] && ps -p "$PID" > /dev/null 2>&1; then
    echo "找到运行中的服务 (PID: $PID)"
    
    # 优雅停止
    echo "发送TERM信号..."
    kill -TERM "$PID"
    
    # 等待进程结束
    for i in {1..30}; do
        if ! ps -p "$PID" > /dev/null 2>&1; then
            echo "服务已优雅停止"
            rm -f "$PID_FILE"
            exit 0
        fi
        echo "等待服务停止... ($i/30)"
        sleep 1
    done
    
    # 强制停止
    echo "服务未响应，发送KILL信号..."
    kill -KILL "$PID"
    sleep 2
    
    if ! ps -p "$PID" > /dev/null 2>&1; then
        echo "服务已强制停止"
        rm -f "$PID_FILE"
    else
        echo "错误: 无法停止服务"
        exit 1
    fi
else
    echo "服务未运行"
    rm -f "$PID_FILE"
fi
```

#### 4.2.3 health-check.sh
```bash
#!/bin/bash

# Breeze Admin 健康检查脚本
# 作者: System Admin
# 日期: $(date +%Y-%m-%d)

set -e

# 配置变量
PID_FILE="/root/AXZ_DEPLOY/java/breeze-admin.pid"
HEALTH_URL="http://localhost:8080/actuator/health"
LOG_FILE="/root/AXZ_DEPLOY/java/logs/health-check.log"

# 创建日志目录
mkdir -p "$(dirname "$LOG_FILE")"

# 记录检查时间
echo "$(date '+%Y-%m-%d %H:%M:%S') - 开始健康检查" >> "$LOG_FILE"

# 检查进程状态
if [ -f "$PID_FILE" ]; then
    PID=$(cat "$PID_FILE")
    if ps -p "$PID" > /dev/null 2>&1; then
        echo "进程运行正常 (PID: $PID)" >> "$LOG_FILE"
    else
        echo "错误: 进程不存在 (PID: $PID)" >> "$LOG_FILE"
        exit 1
    fi
else
    echo "错误: PID文件不存在" >> "$LOG_FILE"
    exit 1
fi

# 检查HTTP健康端点
if command -v curl > /dev/null 2>&1; then
    HTTP_STATUS=$(curl -s -o /dev/null -w "%{http_code}" "$HEALTH_URL" || echo "000")
    if [ "$HTTP_STATUS" = "200" ]; then
        echo "HTTP健康检查通过" >> "$LOG_FILE"
    else
        echo "错误: HTTP健康检查失败 (状态码: $HTTP_STATUS)" >> "$LOG_FILE"
        exit 1
    fi
else
    echo "警告: curl命令不可用，跳过HTTP健康检查" >> "$LOG_FILE"
fi

# 检查日志文件
LOG_DIR="/root/AXZ_DEPLOY/java/logs"
if [ -d "$LOG_DIR" ]; then
    LOG_SIZE=$(du -s "$LOG_DIR" | cut -f1)
    if [ "$LOG_SIZE" -gt 1048576 ]; then  # 1GB
        echo "警告: 日志目录过大 (${LOG_SIZE}KB)" >> "$LOG_FILE"
    fi
else
    echo "错误: 日志目录不存在" >> "$LOG_FILE"
    exit 1
fi

echo "$(date '+%Y-%m-%d %H:%M:%S') - 健康检查完成" >> "$LOG_FILE"
echo "健康检查通过"
```

### 4.3 日志配置文件

#### 4.3.1 logback-spring.xml
```xml
<?xml version="1.0" encoding="UTF-8"?>
<configuration>
    <!-- 日志文件路径 -->
    <property name="LOG_PATH" value="/root/AXZ_DEPLOY/java/logs"/>
    <property name="LOG_FILE" value="${LOG_PATH}/breeze-admin"/>
    
    <!-- 控制台输出 -->
    <appender name="CONSOLE" class="ch.qos.logback.core.ConsoleAppender">
        <encoder>
            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n</pattern>
            <charset>UTF-8</charset>
        </encoder>
    </appender>
    
    <!-- 主日志文件 -->
    <appender name="FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <file>${LOG_FILE}.log</file>
        <encoder>
            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n</pattern>
            <charset>UTF-8</charset>
        </encoder>
        <rollingPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedRollingPolicy">
            <fileNamePattern>${LOG_FILE}.%d{yyyy-MM-dd}.%i.log.gz</fileNamePattern>
            <maxFileSize>100MB</maxFileSize>
            <maxHistory>30</maxHistory>
            <totalSizeCap>3GB</totalSizeCap>
        </rollingPolicy>
    </appender>
    
    <!-- 错误日志文件 -->
    <appender name="ERROR_FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <file>${LOG_PATH}/error.log</file>
        <filter class="ch.qos.logback.classic.filter.LevelFilter">
            <level>ERROR</level>
            <onMatch>ACCEPT</onMatch>
            <onMismatch>DENY</onMismatch>
        </filter>
        <encoder>
            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n</pattern>
            <charset>UTF-8</charset>
        </encoder>
        <rollingPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedRollingPolicy">
            <fileNamePattern>${LOG_PATH}/error.%d{yyyy-MM-dd}.%i.log.gz</fileNamePattern>
            <maxFileSize>50MB</maxFileSize>
            <maxHistory>30</maxHistory>
            <totalSizeCap>1GB</totalSizeCap>
        </rollingPolicy>
    </appender>
    
    <!-- 审计日志文件 -->
    <appender name="AUDIT_FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <file>${LOG_PATH}/audit.log</file>
        <encoder>
            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n</pattern>
            <charset>UTF-8</charset>
        </encoder>
        <rollingPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedRollingPolicy">
            <fileNamePattern>${LOG_PATH}/audit.%d{yyyy-MM-dd}.%i.log.gz</fileNamePattern>
            <maxFileSize>100MB</maxFileSize>
            <maxHistory>90</maxHistory>
            <totalSizeCap>5GB</totalSizeCap>
        </rollingPolicy>
    </appender>
    
    <!-- 异步输出 -->
    <appender name="ASYNC_FILE" class="ch.qos.logback.classic.AsyncAppender">
        <appender-ref ref="FILE"/>
        <queueSize>1024</queueSize>
        <discardingThreshold>0</discardingThreshold>
        <includeCallerData>false</includeCallerData>
    </appender>
    
    <appender name="ASYNC_ERROR" class="ch.qos.logback.classic.AsyncAppender">
        <appender-ref ref="ERROR_FILE"/>
        <queueSize>256</queueSize>
        <discardingThreshold>0</discardingThreshold>
        <includeCallerData>true</includeCallerData>
    </appender>
    
    <!-- 特定包的日志级别 -->
    <logger name="com.nvxclouds.baize.breeze" level="INFO" additivity="false">
        <appender-ref ref="ASYNC_FILE"/>
        <appender-ref ref="ASYNC_ERROR"/>
    </logger>
    
    <logger name="com.nvxclouds.baize.breeze.web.controller" level="INFO" additivity="false">
        <appender-ref ref="ASYNC_FILE"/>
        <appender-ref ref="AUDIT_FILE"/>
    </logger>
    
    <!-- 审计日志 -->
    <logger name="AUDIT" level="INFO" additivity="false">
        <appender-ref ref="AUDIT_FILE"/>
    </logger>
    
    <!-- 根日志配置 -->
    <root level="INFO">
        <appender-ref ref="CONSOLE"/>
        <appender-ref ref="ASYNC_FILE"/>
        <appender-ref ref="ASYNC_ERROR"/>
    </root>
</configuration>
```

#### 4.3.2 java-opts.conf
```bash
# JVM参数配置文件
# 内存配置
-Xms512m
-Xmx2g
-XX:MetaspaceSize=256m
-XX:MaxMetaspaceSize=512m

# GC配置
-XX:+UseG1GC
-XX:MaxGCPauseMillis=200
-XX:G1HeapRegionSize=16m
-XX:+G1UseAdaptiveIHOP
-XX:G1MixedGCCountTarget=8

# GC日志
-XX:+PrintGC
-XX:+PrintGCDetails
-XX:+PrintGCTimeStamps
-XX:+PrintGCApplicationStoppedTime
-Xloggc:/root/AXZ_DEPLOY/java/logs/gc.log
-XX:+UseGCLogFileRotation
-XX:NumberOfGCLogFiles=5
-XX:GCLogFileSize=100M

# 内存溢出配置
-XX:+HeapDumpOnOutOfMemoryError
-XX:HeapDumpPath=/root/AXZ_DEPLOY/java/logs/
-XX:+ExitOnOutOfMemoryError

# 性能配置
-XX:+UseStringDeduplication
-XX:+OptimizeStringConcat
-XX:+UseCompressedOops
-XX:+UseCompressedClassPointers

# 网络配置
-Djava.net.preferIPv4Stack=true
-Djava.awt.headless=true

# 时区配置
-Duser.timezone=Asia/Shanghai
-Dfile.encoding=UTF-8
```

### 4.4 部署脚本

#### 4.4.1 deploy.sh
```bash
#!/bin/bash

# Breeze Admin 部署脚本
# 作者: System Admin
# 日期: $(date +%Y-%m-%d)

set -e

# 配置变量
DEPLOY_DIR="/root/AXZ_DEPLOY/java"
JAR_NAME="breeze-admin.jar"
JAR_FILE="$DEPLOY_DIR/$JAR_NAME"
SERVICE_NAME="breeze-admin"
BACKUP_DIR="/root/AXZ_DEPLOY/backup"

echo "开始部署 Breeze Admin 服务..."

# 创建必要目录
mkdir -p "$DEPLOY_DIR"/{config,logs,scripts,systemd}
mkdir -p "$BACKUP_DIR"

# 停止现有服务
if systemctl is-active --quiet "$SERVICE_NAME"; then
    echo "停止现有服务..."
    systemctl stop "$SERVICE_NAME"
fi

# 备份现有jar包
if [ -f "$JAR_FILE" ]; then
    echo "备份现有jar包..."
    cp "$JAR_FILE" "$BACKUP_DIR/breeze-admin-$(date +%Y%m%d_%H%M%S).jar"
fi

# 复制新的jar包
if [ -f "$JAR_NAME" ]; then
    echo "复制新的jar包..."
    cp "$JAR_NAME" "$JAR_FILE"
    chmod +x "$JAR_FILE"
else
    echo "错误: 未找到新的jar包文件"
    exit 1
fi

# 复制配置文件
echo "复制配置文件..."
cp -f logback-spring.xml "$DEPLOY_DIR/config/"
cp -f java-opts.conf "$DEPLOY_DIR/config/"

# 复制脚本文件
echo "复制脚本文件..."
cp -f start.sh "$DEPLOY_DIR/scripts/"
cp -f stop.sh "$DEPLOY_DIR/scripts/"
cp -f health-check.sh "$DEPLOY_DIR/scripts/"
chmod +x "$DEPLOY_DIR/scripts"/*.sh

# 复制systemd服务文件
echo "复制systemd服务文件..."
cp -f breeze-admin.service "$DEPLOY_DIR/systemd/"

# 安装systemd服务
echo "安装systemd服务..."
cp "$DEPLOY_DIR/systemd/breeze-admin.service" /etc/systemd/system/
systemctl daemon-reload
systemctl enable "$SERVICE_NAME"

# 启动服务
echo "启动服务..."
systemctl start "$SERVICE_NAME"

# 等待服务启动
sleep 10

# 检查服务状态
if systemctl is-active --quiet "$SERVICE_NAME"; then
    echo "服务启动成功!"
    echo "服务状态:"
    systemctl status "$SERVICE_NAME" --no-pager
else
    echo "错误: 服务启动失败"
    echo "查看日志:"
    journalctl -u "$SERVICE_NAME" --no-pager -n 20
    exit 1
fi

echo "部署完成!"
```

#### 4.4.2 应用配置文件示例

##### application-prod.yml
```yaml
server:
  port: 8080
  servlet:
    context-path: /
  tomcat:
    max-threads: 200
    min-spare-threads: 10
    max-connections: 8192
    accept-count: 100

spring:
  profiles:
    active: prod
  application:
    name: breeze-admin
  
  # 数据库配置
  datasource:
    url: jdbc:postgresql://localhost:5432/breeze
    username: ${DB_USERNAME:breeze}
    password: ${DB_PASSWORD:breeze123}
    driver-class-name: org.postgresql.Driver
    hikari:
      maximum-pool-size: 20
      minimum-idle: 5
      connection-timeout: 30000
      idle-timeout: 600000
      max-lifetime: 1800000
  
  # Redis配置
  redis:
    host: ${REDIS_HOST:localhost}
    port: ${REDIS_PORT:6379}
    password: ${REDIS_PASSWORD:}
    database: 0
    timeout: 5000
    lettuce:
      pool:
        max-active: 20
        max-idle: 10
        min-idle: 5

# 日志配置
logging:
  level:
    com.nvxclouds.baize.breeze: INFO
    org.springframework: WARN
    org.apache.ibatis: WARN
  pattern:
    console: "%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n"

# 管理端点配置
management:
  endpoints:
    web:
      exposure:
        include: health,info,metrics
  endpoint:
    health:
      show-details: when-authorized
  health:
    db:
      enabled: true
    redis:
      enabled: true
```

## 5. 配置说明

### 5.1 JAR文件名配置

本方案支持通用的JAR文件名配置，您只需要修改各个脚本文件中的`JAR_NAME`变量即可适配不同的应用：

#### 5.1.1 需要修改的文件
- `deploy.sh`: 部署脚本
- `scripts/start.sh`: 启动脚本  
- `scripts/stop.sh`: 停止脚本
- `scripts/health-check.sh`: 健康检查脚本
- `quick-start.sh`: 快速启动脚本

#### 5.1.2 配置示例
```bash
# 将JAR_NAME变量修改为您的应用名称
JAR_NAME="your-application.jar"
```

#### 5.1.3 服务名称配置
同时建议修改`SERVICE_NAME`变量以匹配您的应用：
```bash
SERVICE_NAME="your-application"
```

## 6. 部署步骤

### 6.1 准备工作
1. 确保Java环境已安装 (Java 11+)
2. 确保systemd服务可用
3. 创建部署目录结构

### 6.2 部署流程
1. **复制文件**: 将jar包和配置文件复制到目标目录
2. **配置服务**: 安装systemd服务配置
3. **启动服务**: 启动并验证服务状态
4. **验证功能**: 检查日志和健康状态

### 6.3 常用命令
```bash
# 服务管理
systemctl start breeze-admin      # 启动服务
systemctl stop breeze-admin       # 停止服务
systemctl restart breeze-admin    # 重启服务
systemctl status breeze-admin     # 查看状态
systemctl enable breeze-admin     # 开机自启

# 日志查看
journalctl -u breeze-admin -f     # 实时查看系统日志
tail -f /root/AXZ_DEPLOY/java/logs/breeze-admin.log  # 查看应用日志

# 健康检查
/root/AXZ_DEPLOY/java/scripts/health-check.sh
```

## 7. 总结

本设计文档提供了JAR应用在生产环境下的完整服务管理方案，具有良好的通用性和可配置性，包括：

1. **systemd服务管理**: 标准化的服务启动、停止、重启管理
2. **应用日志滚动**: 基于logback的日志管理和滚动策略
3. **JVM优化配置**: 生产级的JVM参数调优
4. **健康检查机制**: 进程和HTTP健康检查
5. **自动化部署**: 完整的部署脚本和配置

该方案简化了部署复杂度，专注于jar包服务本身的管理，提供了稳定可靠的生产级服务保障。