# 步骤1：创建监控脚本
#!/bin/bash
# ogg_status_check.sh
# from:www.itpux.com.qq113257174.wx:itpux-com
# web: http://www.fgedu.net.cn

OGG_HOME=/GoldenGate/app
LOG_FILE=/GoldenGate/app/logs/monitor.log
ALERT_SCRIPT=/GoldenGate/app/scripts/alert/send_alert.sh

log_message() {
echo “[$(date ‘+%Y-%m-%d %H:%M:%S’)] $1” >> $LOG_FILE
}

# 获取OGG进程状态
get_ogg_status() {
cd $OGG_HOME
echo “INFO ALL” | ./ggsci | grep -E “MANAGER|EXTRACT|REPLICAT” | while read line; do
program=$(echo $line | awk ‘{print $1}’)
status=$(echo $line | awk ‘{print $2}’)
group=$(echo $line | awk ‘{print $3}’)
lag=$(echo $line | awk ‘{print $4}’)

echo “$program|$status|$group|$lag”
done
}

# 检查进程状态
check_status() {
get_ogg_status | while IFS=’|’ read program status group lag; do
if [ “$status” != “RUNNING” ]; then
log_message “告警: $program $group 状态异常: $status”
$ALERT_SCRIPT “P1” “OGG进程异常” “$program $group 状态: $status”
fi

# 检查延迟
if [ “$lag” != “00:00:00” ] && [ -n “$lag” ]; then
lag_seconds=$(echo $lag | awk -F: ‘{print ($1*3600)+($2*60)+$3}’)
if [ $lag_seconds -gt 300 ]; then
log_message “告警: $program $group 延迟过大: $lag”
$ALERT_SCRIPT “P2” “OGG延迟告警” “$program $group 延迟: $lag”
fi
fi
done
}

# 主程序
log_message “开始OGG状态检查”
check_status
log_message “OGG状态检查完成”

# 步骤2：设置执行权限
$ chmod +x /GoldenGate/app/scripts/monitor/ogg_status_check.sh

# 步骤3：测试执行
$ /GoldenGate/app/scripts/monitor/ogg_status_check.sh

[2026-04-10 10:00:00] 开始OGG状态检查
[2026-04-10 10:00:01] OGG状态检查完成

# 步骤4：设置定时任务
$ crontab -e
*/1 * * * * /GoldenGate/app/scripts/monitor/ogg_status_check.sh >> /GoldenGate/app/logs/cron.log 2>&1

#!/bin/bash
# ogg_detail_monitor.sh
# from:www.itpux.com.qq113257174.wx:itpux-com
# web: http://www.fgedu.net.cn

OGG_HOME=/GoldenGate/app
LOG_FILE=/GoldenGate/app/logs/detail_monitor.log
METRICS_FILE=/GoldenGate/app/logs/ogg_metrics.txt

log_message() {
echo “[$(date ‘+%Y-%m-%d %H:%M:%S’)] $1” >> $LOG_FILE
}

# 获取Extract进程详细信息
get_extract_info() {
local extract_name=$1
cd $OGG_HOME

info_output=$(echo “INFO EXTRACT $extract_name, DETAIL” | ./ggsci 2>/dev/null)

# 解析关键信息
status=$(echo “$info_output” | grep “Status” | awk ‘{print $2}’)
checkpoint_lag=$(echo “$info_output” | grep “Checkpoint Lag” | awk ‘{print $3}’)
time_since=$(echo “$info_output” | grep “Time Since Chkpt” | awk ‘{print $4}’)
trail_seq=$(echo “$info_output” | grep “Trail File Seqno” | awk ‘{print $4}’)
trail_rba=$(echo “$info_output” | grep “Trail File RBA” | awk ‘{print $4}’)

echo “EXTRACT|$extract_name|$status|$checkpoint_lag|$time_since|$trail_seq|$trail_rba”
}

# 获取Replicat进程详细信息
get_replicat_info() {
local replicat_name=$1
cd $OGG_HOME

info_output=$(echo “INFO REPLICAT $replicat_name, DETAIL” | ./ggsci 2>/dev/null)

status=$(echo “$info_output” | grep “Status” | awk ‘{print $2}’)
checkpoint_lag=$(echo “$info_output” | grep “Checkpoint Lag” | awk ‘{print $3}’)
time_since=$(echo “$info_output” | grep “Time Since Chkpt” | awk ‘{print $4}’)
trail_rba=$(echo “$info_output” | grep “Trail File RBA” | awk ‘{print $4}’)

echo “REPLICAT|$replicat_name|$status|$checkpoint_lag|$time_since|$trail_rba”
}

# 获取统计信息
get_stats() {
local process_name=$1
cd $OGG_HOME

stats_output=$(echo “STATS $process_name, TOTALSONLY” | ./ggsci 2>/dev/null)

total_inserts=$(echo “$stats_output” | grep “Total inserts” | awk ‘{print $3}’)
total_updates=$(echo “$stats_output” | grep “Total updates” | awk ‘{print $3}’)
total_deletes=$(echo “$stats_output” | grep “Total deletes” | awk ‘{print $3}’)

echo “$process_name|$total_inserts|$total_updates|$total_deletes”
}

# 收集所有指标
collect_metrics() {
echo “timestamp=$(date ‘+%Y-%m-%d %H:%M:%S’)” > $METRICS_FILE

# 获取所有进程列表
cd $OGG_HOME
processes=$(echo “INFO ALL” | ./ggsci | grep -E “EXTRACT|REPLICAT” | awk ‘{print $3}’)

for proc in $processes; do
proc_type=$(echo “INFO ALL” | ./ggsci | grep $proc | awk ‘{print $1}’)

if [ “$proc_type” = “EXTRACT” ]; then
get_extract_info $proc >> $METRICS_FILE
elif [ “$proc_type” = “REPLICAT” ]; then
get_replicat_info $proc >> $METRICS_FILE
fi

get_stats $proc >> $METRICS_FILE
done
}

# 主程序
log_message “开始详细监控采集”
collect_metrics
log_message “详细监控采集完成”

# 输出指标文件内容
cat $METRICS_FILE

# 执行结果示例
timestamp=2026-04-10 10:00:00
EXTRACT|E_FGEDU01|RUNNING|00:00:00|00:00:05|123|456789
E_FGEDU01|10000|5000|1000
REPLICAT|R_FGEDU01|RUNNING|00:00:00|00:00:03|456789
R_FGEDU01|10000|5000|1000

#!/bin/bash
# ogg_auto_restart.sh
# from:www.itpux.com.qq113257174.wx:itpux-com
# web: http://www.fgedu.net.cn

OGG_HOME=/GoldenGate/app
LOG_FILE=/GoldenGate/app/logs/auto_restart.log
MAX_RETRIES=3
RETRY_INTERVAL=60

log_message() {
echo “[$(date ‘+%Y-%m-%d %H:%M:%S’)] $1” >> $LOG_FILE
}

# 检查进程状态
check_process_status() {
local process_name=$1
cd $OGG_HOME

status=$(echo “INFO EXTRACT $process_name” | ./ggsci 2>/dev/null | grep “Status” | awk ‘{print $2}’)

if [ -z “$status” ]; then
status=$(echo “INFO REPLICAT $process_name” | ./ggsci 2>/dev/null | grep “Status” | awk ‘{print $2}’)
fi

echo $status
}

# 启动进程
start_process() {
local process_name=$1
local process_type=$2
cd $OGG_HOME

if [ “$process_type” = “EXTRACT” ]; then
echo “START EXTRACT $process_name” | ./ggsci
elif [ “$process_type” = “REPLICAT” ]; then
echo “START REPLICAT $process_name” | ./ggsci
fi

sleep 5

new_status=$(check_process_status $process_name)
if [ “$new_status” = “RUNNING” ]; then
log_message “成功: $process_name 已重启”
return 0
else
log_message “失败: $process_name 重启失败”
return 1
fi
}

# 自动重启逻辑
auto_restart() {
local process_name=$1
local process_type=$2

log_message “检测到 $process_name 状态异常，尝试自动重启”

retry_count=0
while [ $retry_count -lt $MAX_RETRIES ]; do
retry_count=$((retry_count + 1))
log_message “第 $retry_count 次尝试重启 $process_name”

if start_process $process_name $process_type; then
# 发送成功通知
/GoldenGate/app/scripts/alert/send_alert.sh “P2” “OGG进程自动重启成功” “$process_name 已自动重启成功”
return 0
fi

sleep $RETRY_INTERVAL
done

# 重启失败，发送严重告警
log_message “严重: $process_name 自动重启失败，已达最大重试次数”
/GoldenGate/app/scripts/alert/send_alert.sh “P1” “OGG进程自动重启失败” “$process_name 自动重启失败，需要人工介入”
return 1
}

# 主监控循环
main() {
log_message “开始OGG进程自动监控”

cd $OGG_HOME
processes=$(echo “INFO ALL” | ./ggsci | grep -E “EXTRACT|REPLICAT” | awk ‘{print $1″ “$3}’)

while read proc_type proc_name; do
status=$(check_process_status $proc_name)

if [ “$status” != “RUNNING” ]; then
log_message “告警: $proc_type $proc_name 状态: $status”
auto_restart $proc_name $proc_type
fi
done <<< "$processes" log_message "OGG进程自动监控完成" } main # 执行结果示例 [2026-04-10 10:00:00] 开始OGG进程自动监控 [2026-04-10 10:00:01] 告警: EXTRACT E_FGEDU01 状态: STOPPED [2026-04-10 10:00:01] 检测到 E_FGEDU01 状态异常，尝试自动重启 [2026-04-10 10:00:01] 第 1 次尝试重启 E_FGEDU01 [2026-04-10 10:00:06] 成功: E_FGEDU01 已重启 [2026-04-10 10:00:06] OGG进程自动监控完成

#!/bin/bash
# ogg_lag_handler.sh
# from:www.itpux.com.qq113257174.wx:itpux-com
# web: http://www.fgedu.net.cn

OGG_HOME=/GoldenGate/app
LOG_FILE=/GoldenGate/app/logs/lag_handler.log
LAG_THRESHOLD=300

log_message() {
echo “[$(date ‘+%Y-%m-%d %H:%M:%S’)] $1” >> $LOG_FILE
}

# 获取延迟秒数
get_lag_seconds() {
local process_name=$1
cd $OGG_HOME

lag=$(echo “LAG $process_name” | ./ggsci 2>/dev/null | grep “Last record lag” | awk ‘{print $4}’)

if [ -n “$lag” ]; then
# 转换为秒
hours=$(echo $lag | cut -d: -f1)
minutes=$(echo $lag | cut -d: -f2)
seconds=$(echo $lag | cut -d: -f3)
echo $((hours*3600 + minutes*60 + seconds))
else
echo 0
fi
}

# 分析延迟原因
analyze_lag_cause() {
local process_name=$1
cd $OGG_HOME

log_message “分析 $process_name 延迟原因…”

# 检查数据库性能
db_status=$(echo “INFO $process_name” | ./ggsci 2>/dev/null | grep -i “error” | head -5)

if [ -n “$db_status” ]; then
log_message “发现数据库相关错误: $db_status”
return 1
fi

# 检查网络状态
if echo “INFO $process_name” | ./ggsci 2>/dev/null | grep -qi “network”; then
log_message “发现网络相关问题”
return 2
fi

# 检查资源使用
cpu_usage=$(top -bn1 | grep “Cpu(s)” | awk ‘{print $2}’ | cut -d% -f1)
if [ $(echo “$cpu_usage > 80” | bc) -eq 1 ]; then
log_message “CPU使用率过高: $cpu_usage%”
return 3
fi

log_message “未发现明显延迟原因”
return 0
}

# 自动处理延迟
handle_lag() {
local process_name=$1
local lag_seconds=$2

log_message “开始处理 $process_name 延迟，当前延迟: ${lag_seconds}秒”

# 分析延迟原因
analyze_lag_cause $process_name
cause=$?

case $cause in
1)
log_message “数据库问题，尝试优化参数”
# 调整Extract参数
cd $OGG_HOME
echo “SEND EXTRACT $process_name, TRANLOGOPTIONS MAXBUFSIZE 1048576” | ./ggsci
;;
2)
log_message “网络问题，尝试重连”
cd $OGG_HOME
echo “STOP EXTRACT $process_name” | ./ggsci
sleep 10
echo “START EXTRACT $process_name” | ./ggsci
;;
3)
log_message “资源问题，尝试优化”
# 清理临时文件
find /GoldenGate/app/dirtmp -type f -mtime +1 -delete
;;
*)
log_message “未知原因，发送告警”
/GoldenGate/app/scripts/alert/send_alert.sh “P2” “OGG延迟告警” “$process_name 延迟 ${lag_seconds}秒，原因未知”
;;
esac
}

# 主程序
main() {
log_message “开始OGG延迟监控”

cd $OGG_HOME
processes=$(echo “INFO ALL” | ./ggsci | grep -E “EXTRACT|REPLICAT” | awk ‘{print $3}’)

for proc in $processes; do
lag_seconds=$(get_lag_seconds $proc)

if [ $lag_seconds -gt $LAG_THRESHOLD ]; then
log_message “告警: $proc 延迟 ${lag_seconds}秒，超过阈值 ${LAG_THRESHOLD}秒”
handle_lag $proc $lag_seconds
fi
done

log_message “OGG延迟监控完成”
}

main

# 执行结果示例
[2026-04-10 10:00:00] 开始OGG延迟监控
[2026-04-10 10:00:01] 告警: E_FGEDU01 延迟 350秒，超过阈值 300秒
[2026-04-10 10:00:01] 开始处理 E_FGEDU01 延迟，当前延迟: 350秒
[2026-04-10 10:00:01] 分析 E_FGEDU01 延迟原因…
[2026-04-10 10:00:02] 未发现明显延迟原因
[2026-04-10 10:00:02] OGG延迟监控完成
from GoldenGate视频:www.itpux.com

# 步骤1：创建Zabbix监控脚本
#!/bin/bash
# zabbix_ogg_monitor.sh
# from:www.itpux.com.qq113257174.wx:itpux-com
# web: http://www.fgedu.net.cn

OGG_HOME=/GoldenGate/app

case “$1” in
discovery)
# 发现所有OGG进程
cd $OGG_HOME
echo “{”
echo ” \”data\”:[”
first=1
echo “INFO ALL” | ./ggsci | grep -E “EXTRACT|REPLICAT” | while read line; do
proc_type=$(echo $line | awk ‘{print $1}’)
proc_name=$(echo $line | awk ‘{print $3}’)

if [ $first -eq 1 ]; then
first=0
else
echo “,”
fi

echo -n ” {\”{#OGG_PROCESS}\”:\”$proc_name\”,\”{#OGG_TYPE}\”:\”$proc_type\”}”
done
echo “”
echo ” ]”
echo “}”
;;

status)
# 获取进程状态
proc_name=$2
cd $OGG_HOME

status=$(echo “INFO EXTRACT $proc_name 2>/dev/null || INFO REPLICAT $proc_name” | ./ggsci | grep “Status” | awk ‘{print $2}’)

case $status in
RUNNING) echo 1 ;;
STOPPED) echo 0 ;;
ABENDED) echo 2 ;;
*) echo -1 ;;
esac
;;

lag)
# 获取延迟秒数
proc_name=$2
cd $OGG_HOME

lag=$(echo “LAG $proc_name” | ./ggsci 2>/dev/null | grep “Last record lag” | awk ‘{print $4}’)

if [ -n “$lag” ]; then
hours=$(echo $lag | cut -d: -f1)
minutes=$(echo $lag | cut -d: -f2)
seconds=$(echo $lag | cut -d: -f3)
echo $((hours*3600 + minutes*60 + seconds))
else
echo 0
fi
;;

*)
echo “用法: $0 {discovery|status|lag} [process_name]”
exit 1
;;
esac

# 步骤2：配置Zabbix Agent
$ vi /etc/zabbix/zabbix_agentd.d/ogg.conf

UserParameter=ogg.discovery,/GoldenGate/app/scripts/zabbix_ogg_monitor.sh discovery
UserParameter=ogg.status[*],/GoldenGate/app/scripts/zabbix_ogg_monitor.sh status $1
UserParameter=ogg.lag[*],/GoldenGate/app/scripts/zabbix_ogg_monitor.sh lag $1

# 步骤3：重启Zabbix Agent
$ systemctl restart zabbix-agent

# 步骤4：测试Zabbix监控
$ zabbix_get -s 127.0.0.1 -k ogg.discovery

{
“data”:[
{“{#OGG_PROCESS}”:”E_FGEDU01″,”{#OGG_TYPE}”:”EXTRACT”},
{“{#OGG_PROCESS}”:”R_FGEDU01″,”{#OGG_TYPE}”:”REPLICAT”}
]
}

$ zabbix_get -s 127.0.0.1 -k “ogg.status[E_FGEDU01]”
1

$ zabbix_get -s 127.0.0.1 -k “ogg.lag[E_FGEDU01]”
0

#!/bin/bash
# send_alert.sh
# from:www.itpux.com.qq113257174.wx:itpux-com
# web: http://www.fgedu.net.cn

ALERT_LEVEL=$1
ALERT_TITLE=$2
ALERT_MESSAGE=$3
LOG_FILE=/GoldenGate/app/logs/alert.log

log_alert() {
echo “[$(date ‘+%Y-%m-%d %H:%M:%S’)] [$ALERT_LEVEL] $ALERT_TITLE: $ALERT_MESSAGE” >> $LOG_FILE
}

# 发送邮件告警
send_email() {
local subject=”[$ALERT_LEVEL] OGG告警: $ALERT_TITLE”
local body=”告警级别: $ALERT_LEVEL\n告警标题: $ALERT_TITLE\n告警内容: $ALERT_MESSAGE\n告警时间: $(date)\n服务器: $(hostname)”

echo -e “$body” | mail -s “$subject” dba@fgedu.net.cn
}

# 发送企业微信告警
send_wechat() {
local webhook=”https://qyapi.weixin.qq.com/cgi-bin/webhook/send?key=your-key”

local json_data=$(cat < 级别: **$ALERT_LEVEL**\n> 标题: $ALERT_TITLE\n> 内容: $ALERT_MESSAGE\n> 时间: $(date)\n> 服务器: $(hostname)”
}
}
EOF
)

curl -s -X POST -H ‘Content-Type: application/json’ -d “$json_data” $webhook
}

# 发送短信告警
send_sms() {
local phones=”13800138000,13900139000″
local message=”【OGG告警】[$ALERT_LEVEL] $ALERT_TITLE: $ALERT_MESSAGE”

# 调用短信接口
curl -s “http://sms-api/send?phones=$phones&message=$message”
}

# 根据告警级别发送通知
case $ALERT_LEVEL in
P1)
send_email
send_wechat
send_sms
;;
P2)
send_email
send_wechat
;;
P3|P4)
send_email
;;
*)
send_email
;;
esac

log_alert

# 执行示例
$ ./send_alert.sh P1 “进程异常” “E_FGEDU01进程已停止”

[2026-04-10 10:00:00] [P1] 进程异常: E_FGEDU01进程已停止

# 项目背景
– 环境：10套OGG同步链路
– 要求：7×24小时监控
– 告警：5分钟内响应

# 监控架构
+——————-+
| Grafana仪表板 |
+——————-+
|
+——————-+
| Prometheus |
| 数据存储 |
+——————-+
|
+——————-+
| Node Exporter |
| OGG Exporter |
+——————-+
|
+——————-+
| OGG进程 |
+——————-+

# 监控指标配置
# prometheus.yml
scrape_configs:
– job_name: ‘ogg’
static_configs:
– targets: [‘192.168.1.100:9101’, ‘192.168.1.101:9101’]
metrics_path: /metrics
scrape_interval: 30s

# 告警规则
# alert_rules.yml
groups:
– name: ogg_alerts
rules:
– alert: OGGProcessDown
expr: ogg_process_status != 1
for: 1m
labels:
severity: critical
annotations:
summary: “OGG进程异常”
description: “进程 {{ $labels.process }} 状态异常”

– alert: OGGLagHigh
expr: ogg_process_lag_seconds > 300
for: 5m
labels:
severity: warning
annotations:
summary: “OGG延迟过高”
description: “进程 {{ $labels.process }} 延迟 {{ $value }}秒”

# 监控效果
– 实时监控所有OGG进程
– 延迟超过阈值自动告警
– 自动重启异常进程
– 历史数据可追溯
– 可视化仪表板展示

# 问题1：监控脚本执行超时
# 现象
脚本执行时间过长，导致监控数据延迟

# 解决方案
# 1. 优化脚本执行效率
# 2. 设置超时时间
timeout 30s ./ogg_status_check.sh

# 3. 使用后台执行
./ogg_status_check.sh &

# 问题2：告警风暴
# 现象
同一告警重复发送多次

# 解决方案
# 1. 添加告警抑制逻辑
ALERT_CACHE=/tmp/ogg_alert_cache
CACHE_EXPIRE=300

check_alert_cache() {
local alert_key=$1
local cache_file=”${ALERT_CACHE}/${alert_key}”

if [ -f “$cache_file” ]; then
last_time=$(cat $cache_file)
current_time=$(date +%s)

if [ $((current_time – last_time)) -lt $CACHE_EXPIRE ]; then
return 1
fi
fi

echo $(date +%s) > $cache_file
return 0
}

# 问题3：自动重启失败
# 现象
进程自动重启后仍然异常

# 解决方案
# 1. 检查进程错误日志
GGSCI> VIEW REPORT process_name

# 2. 检查数据库连接
sqlplus fgedu/fgedu@fgedudb

# 3. 检查Trail文件
ls -la /GoldenGate/app/dirdat/

# 4. 手动处理
GGSCI> STOP process_name
GGSCI> START process_name

# 解决方案1：完整监控脚本
#!/bin/bash
# ogg_complete_monitor.sh
# from:www.itpux.com.qq113257174.wx:itpux-com
# web: http://www.fgedu.net.cn

OGG_HOME=/GoldenGate/app
LOG_FILE=/GoldenGate/app/logs/complete_monitor.log
METRICS_DIR=/GoldenGate/app/logs/metrics

mkdir -p $METRICS_DIR

log_message() {
echo “[$(date ‘+%Y-%m-%d %H:%M:%S’)] $1″ >> $LOG_FILE
}

# 收集所有监控数据
collect_all_metrics() {
local timestamp=$(date ‘+%Y%m%d_%H%M%S’)
local metrics_file=”${METRICS_DIR}/metrics_${timestamp}.txt”

cd $OGG_HOME

# 进程状态
echo “=== 进程状态 ===” > $metrics_file
echo “INFO ALL” | ./ggsci >> $metrics_file

# 延迟信息
echo “” >> $metrics_file
echo “=== 延迟信息 ===” >> $metrics_file
for proc in $(echo “INFO ALL” | ./ggsci | grep -E “EXTRACT|REPLICAT” | awk ‘{print $3}’); do
echo “LAG $proc” | ./ggsci >> $metrics_file
done

# 统计信息
echo “” >> $metrics_file
echo “=== 统计信息 ===” >> $metrics_file
for proc in $(echo “INFO ALL” | ./ggsci | grep -E “EXTRACT|REPLICAT” | awk ‘{print $3}’); do
echo “STATS $proc, TOTALSONLY” | ./ggsci >> $metrics_file
done

# 系统资源
echo “” >> $metrics_file
echo “=== 系统资源 ===” >> $metrics_file
echo “CPU: $(top -bn1 | grep ‘Cpu(s)’ | awk ‘{print $2}’)” >> $metrics_file
echo “内存: $(free -m | grep Mem | awk ‘{print $3″/”$2″MB”}’)” >> $metrics_file
echo “磁盘: $(df -h /GoldenGate | tail -1 | awk ‘{print $5}’)” >> $metrics_file

# Trail文件
echo “” >> $metrics_file
echo “=== Trail文件 ===” >> $metrics_file
ls -lh /GoldenGate/app/dirdat/ >> $metrics_file

echo $metrics_file
}

# 分析监控数据
analyze_metrics() {
local metrics_file=$1

# 检查异常进程
abnormal=$(grep -E “STOPPED|ABENDED” $metrics_file | grep -v “^===”)
if [ -n “$abnormal” ]; then
log_message “发现异常进程: $abnormal”
/GoldenGate/app/scripts/auto/ogg_auto_restart.sh
fi

# 检查延迟
high_lag=$(grep “Lag at Chkpt” $metrics_file | awk ‘$4 ~ /^[0-9]+$/ && $4 > 60’)
if [ -n “$high_lag” ]; then
log_message “发现高延迟: $high_lag”
/GoldenGate/app/scripts/auto/ogg_lag_handler.sh
fi
}

# 清理旧指标文件
cleanup_old_metrics() {
find $METRICS_DIR -name “metrics_*.txt” -mtime +7 -delete
}

# 主程序
main() {
log_message “开始完整监控”

metrics_file=$(collect_all_metrics)
analyze_metrics $metrics_file
cleanup_old_metrics

log_message “完整监控完成”
}

main