萨瓦迪卡

OpenClaw 玩转指南：安装、使用与变现

Thu, 19 Mar 2026 14:49:49 +0800

🦞 EXFOLIATE! EXFOLIATE! —— 这是一只来自未来的 AI 龙虾，正在帮你重新定义个人 AI 助手的边界。

一、什么是 OpenClaw？

OpenClaw 是一个自托管的个人 AI 助手网关（Gateway），开源免费，MIT 协议授权。

简单来说，它做了一件事：让 AI 随时随地回应你。

你在飞书发指令，AI 帮你处理工作流。你在 Telegram 问问题，AI 秒答。你在 WhatsApp 发消息，AI 回你。所有这一切，跑在你自己的设备上，数据不经过任何第三方服务器。

1.1 核心定位

维度	OpenClaw
类型	自托管 AI 网关
开源协议	MIT
运行设备	你自己的 Mac / Linux / Windows / VPS
数据主权	完全在你手中
支持渠道	20+ 主流 IM 平台
支持模型	Claude、GPT、Gemini 等全主流模型

1.2 与其他 AI 工具的核心差异

为什么不直接用 ChatGPT / Claude 网页版？

🔒 隐私：所有对话数据经过 OpenAI/Anthropic 服务器，OpenClaw 的对话只走你的设备→模型 API
📱 随时随地：无需打开网页，直接在你常用的 IM 里发消息
🔧 可定制：自定义人设、记忆、工作流、Skills
🤖 多智能体：同时运行多个 AI 角色（写作专家、代码助手、交易顾问）
💾 持久记忆：AI 真的记住你，跨会话保持上下文

1.3 适合哪些人？

内容创作者：让 AI 助手帮你管理选题、写作、发布全流程
程序员：本地代码 AI，私密安全，工具链完整
副业从业者：批量部署 AI 服务，接单变现
企业用户：内网部署，员工共用一个企业智能体
AI 爱好者：折腾各种自动化场景，探索 AI 边界

二、核心架构与工作原理

2.1 架构全景

OpenClaw 的核心是一个 Gateway（网关）进程，它是整个系统的大脑。

你的消息
    ↓
[IM 渠道] 飞书 / Telegram / WhatsApp / Discord...
    ↓
[Gateway 网关] ← 运行在你的 Mac / Linux / VPS
    ↓           ↙         ↘          ↘
[AI Agent]  [Web UI]  [Mobile Node]  [CLI]
    ↓
[AI 模型 API] Claude / GPT / Gemini...

2.2 核心组件详解

① Gateway（网关）

OpenClaw 的核心服务
负责接收所有渠道消息、路由给 AI、返回结果
本质是一个 Node.js 进程，以系统服务形式常驻后台
默认监听 127.0.0.1:18789

② Agent（智能体）

执行 AI 对话和工具调用的运行时
支持多智能体：不同场景用不同 Agent
工作目录（Workspace）存储：AGENTS.md / SOUL.md / MEMORY.md 等配置文件

③ Skills（技能）

可插拔的能力扩展包
从 ClawHub 市场一键安装
例如：天气查询、飞书文档操作、股票数据、浏览器控制

④ Nodes（节点）

配对的 iOS / Android 设备
支持：摄像头、屏幕录制、位置、语音、Canvas 画布

⑤ Web Control UI（控制界面）

浏览器打开 http://127.0.0.1:18789/
可视化管理：会话、配置、节点、Skills

2.3 会话与记忆机制

OpenClaw 有完整的记忆系统：

MEMORY.md → 长期记忆，跨会话保持
memory/YYYY-MM-DD.md → 每日日志，自动写入
向量搜索 + 全文检索，让 AI 真正"记住你"
会话即将压缩时，自动触发记忆写入，永不遗忘重要信息

三、安装教程（全平台）

3.1 系统要求

项目	要求
操作系统	macOS / Linux / Windows (WSL2)
Node.js	≥ 22（必须）
内存	建议 2GB+
网络	需访问 AI 模型 API

⚠️ Windows 用户强烈建议使用 WSL2，原生 Windows 支持有限。

3.2 方法一：一键安装脚本（推荐）

这是最快的安装方式，自动处理 Node.js 检测、安装和引导。

macOS / Linux / WSL2：

curl -fsSL https://openclaw.ai/install.sh | bash

Windows PowerShell：

iwr -useb https://openclaw.ai/install.ps1 | iex

安装脚本会自动：

检测并安装 Node.js 22+
全局安装 openclaw CLI
启动交互式引导向导（onboard wizard）

3.3 方法二：npm / pnpm 手动安装

如果你已经有 Node 22+ 环境：

# 使用 npm
npm install -g openclaw@latest
openclaw onboard --install-daemon

# 使用 pnpm
pnpm add -g openclaw@latest
pnpm approve-builds -g
openclaw onboard --install-daemon

💡 --install-daemon 参数会将 Gateway 注册为系统服务（macOS launchd / Linux systemd），开机自动启动，无需手动维护。

3.4 引导向导（Onboarding Wizard）详解

运行 openclaw onboard 后，向导会引导你完成：

Step 1：配置 AI 模型

? 选择 AI 提供商
  ❯ Anthropic (Claude)
    OpenAI (GPT)
    Google (Gemini)
    自定义

Step 2：配置频道

? 选择要连接的消息频道
  ❯ 飞书（推荐，官方API稳定 + 文档/表格天然打通）
    Telegram（配置简单，海外用户首选）
    WhatsApp
    Discord
    更多...

💡 为什么推荐飞书？ 飞书使用官方 Bot API + WebSocket 长连接，稳定性极佳、零封号风险。而且飞书的文档、多维表格、审批等能力可以直接被 AI 调用，天然适合搭建自动化工作流。

Step 3：安装 Gateway 服务

# 向导完成后自动安装服务
openclaw gateway status   # 查看状态
openclaw dashboard        # 打开 Web 控制界面

3.5 方法三：Docker 部署

适合服务器/VPS 环境：

# 克隆仓库
git clone https://github.com/openclaw/openclaw.git
cd openclaw

# 一键启动（包含镜像构建+引导）
./docker-setup.sh

高级 Docker 配置：

# 使用远程镜像（更快）
OPENCLAW_IMAGE=ghcr.io/openclaw/openclaw:latest ./docker-setup.sh

# 启用沙盒隔离
OPENCLAW_SANDBOX=1 ./docker-setup.sh

docker-compose.yml 会自动配置端口、持久化卷和环境变量。

3.6 方法四：VPS 云端部署

把 OpenClaw 跑在云服务器上，随时随地通过手机访问。

推荐 VPS 平台：

平台	特点	费用
Oracle Cloud	永久免费 ARM 机器	¥0/月
Railway	一键部署	约 ¥35/月
Fly.io	边缘节点，延迟低	约 ¥14/月起
Hetzner	性价比极高	约 ¥21/月
阿里云/腾讯云	国内访问快	约 ¥30-80/月

VPS 安装步骤：

# 1. SSH 连接服务器
ssh root@your-vps-ip

# 2. 安装 OpenClaw
curl -fsSL https://openclaw.ai/install.sh | bash

# 3. 配置远程访问（Tailscale 推荐）
openclaw gateway --port 18789

# 4. 低配 VPS 优化（可选）
echo 'export NODE_COMPILE_CACHE=/var/tmp/openclaw-compile-cache' >> ~/.bashrc
echo 'export OPENCLAW_NO_RESPAWN=1' >> ~/.bashrc
source ~/.bashrc

安全建议：

Gateway 默认只监听 loopback（127.0.0.1），不暴露公网
通过 SSH 隧道或 Tailscale 访问
必须开启 gateway.auth.token 认证

3.7 验证安装

# 检查版本
openclaw --version

# 检查 Gateway 状态
openclaw gateway status

# 打开控制界面
openclaw dashboard

# 运行健康检查
openclaw doctor

四、配置频道

OpenClaw 支持同时连接多个 IM 平台，下面介绍最常用的几个。

4.1 飞书（⭐ 推荐首选）

为什么首选飞书？

✅ 官方 Bot API：零封号风险，企业级稳定
✅ WebSocket 长连接：不需要公网域名，穿透内网，延迟低
✅ 生态打通：飞书文档、多维表格、审批流可以直接被 AI 读写操作
✅ 适合国内用户：无需翻墙，访问速度快
✅ 免费额度大：个人开发者足够用

配置步骤：

① 创建飞书应用

打开飞书开放平台，注册/登录
点击「创建企业自建应用」
填写应用名称（如 "我的AI助手"）和描述
记下 App ID 和 App Secret

② 申请权限在应用管理后台 → 权限管理，搜索并开通：

im:message — 读取和发送消息（必须）
im:message:send_as_bot — 以机器人身份发送消息（必须）
im:chat — 获取群组信息（推荐）
docx:document — 读写飞书文档（推荐，解锁文档能力）
bitable:app — 读写多维表格（推荐，解锁表格能力）
wiki:wiki — 读写知识库（可选）

③ 开启事件订阅（WebSocket 模式）

应用管理后台 → 事件与回调
订阅方式选择 WebSocket（推荐，无需公网IP）
添加事件：im.message.receive_v1（接收消息）

④ 配置 OpenClaw编辑 OpenClaw 配置文件：

{
  "channels": {
    "feishu": {
      "enabled": true,
      "appId": "cli_xxxxxxxxx",
      "appSecret": "你的AppSecret",
      "connectionMode": "websocket",
      "domain": "feishu"
    }
  }
}

⑤ 发布应用 & 测试

在飞书开放平台点击「创建版本」→「申请发布」
企业管理员审批通过
在飞书中搜索你的机器人名称，发消息即可对话

💡 企业内自用：如果你是企业管理员，审批可以秒过。个人开发者也可以创建测试企业。

💡 飞书 vs Lark：如果用的是国际版 Lark，把 domain 改为 "lark" 即可。

4.2 Telegram（海外用户推荐）

配置最简单：只需一个 Bot Token，3分钟搞定。

配置步骤：

在 Telegram 搜索 @BotFather，发送 /newbot
按提示设置 bot 名称和用户名
获得 Bot Token（格式：1234567890:AAExxxxx）
在 OpenClaw 配置文件写入：

{
  "channels": {
    "telegram": {
      "enabled": true,
      "botToken": "你的BotToken",
      "dmPolicy": "pairing",
      "streaming": "partial"
    }
  }
}

重启 Gateway，给你的 Bot 发消息即可对话

优点： 配置极简、功能完整（群组、图片、语音、内联按钮）、无需扫码注意： 国内需要代理访问

4.3 WhatsApp

⚠️ WhatsApp 使用 Baileys 库实现，需要扫码登录个人账号。建议使用备用手机号。

# 引导配置
openclaw onboard
# 选择 WhatsApp → 扫描二维码

配置要点：

使用备用手机号/备用账号（主账号有封号风险）
二维码有效期约 20 秒，扫码后状态持久保存
支持：文字、图片、语音、文档

4.4 Discord

{
  "channels": {
    "discord": {
      "enabled": true,
      "token": "你的Bot Token"
    }
  }
}

Discord Bot 支持频道消息、DM、Thread，适合社区场景。

4.5 多渠道同时运行

OpenClaw 支持所有渠道并行运行，同一 Gateway 服务不同平台的用户：

{
  "channels": {
    "feishu": { "enabled": true, "appId": "...", "appSecret": "..." },
    "telegram": { "enabled": true, "botToken": "..." },
    "whatsapp": { "enabled": true },
    "discord": { "enabled": true, "token": "..." }
  }
}

💡 不同渠道可以绑定不同 Agent（智能体），实现一个 Gateway 多角色服务。

五、技能系统（Skills）

Skills 是 OpenClaw 的能力扩展机制，类似手机 App Store，你可以按需安装各种技能。

5.1 什么是 Skills？

每个 Skill 是一个 SKILL.md 文件（加上可选的脚本/参考资料），告诉 AI 如何完成特定任务。

AI 自动识别用户意图，匹配对应 Skill，按技能指南执行任务。

5.2 Skills 加载路径（优先级）

工作区 Skills    (workspace/skills/)     ← 最高优先级
     ↓
本地安装 Skills  (~/.openclaw/skills/)
     ↓
内置 Skills     (openclaw 内置)          ← 最低优先级

5.3 从 ClawHub 安装技能

ClawHub.com 是官方技能市场。

# 安装 clawhub CLI
npm i -g clawhub

# 搜索技能
clawhub search "weather"
clawhub search "postgres"
clawhub search "github"

# 安装技能
clawhub install weather
clawhub install <作者>/<技能名>

# 更新所有技能
clawhub update --all

5.4 内置核心技能

技能名	功能
weather	查询天气预报（wttr.in / Open-Meteo）
feishu-doc	飞书文档读写
feishu-wiki	飞书知识库管理
coding-agent	调度 AI 编程代理
healthcheck	服务器安全审计
skill-creator	创建新技能

5.5 自创 Skills

只需创建 SKILL.md 文件：

---
name: my-skill
description: 当用户问关于XXX时激活
---

# 我的自定义技能

## 触发条件
用户提到 "XXX" 时

## 执行步骤
1. 步骤一
2. 步骤二
3. 返回结果

这就是 OpenClaw 技能系统的魔力——用自然语言写技能，AI 就会执行。

六、高级功能

6.1 多智能体路由

一个 Gateway，运行多个不同角色的 AI：

{
  "agents": {
    "list": [
      {
        "id": "writer",
        "workspace": "~/.openclaw/workspace-writer"
      },
      {
        "id": "coder",
        "workspace": "~/.openclaw/workspace-coder"
      },
      {
        "id": "trader",
        "workspace": "~/.openclaw/workspace-trader"
      }
    ]
  },
  "bindings": [
    { "agentId": "writer", "match": { "channel": "feishu" } },
    { "agentId": "coder", "match": { "channel": "discord" } }
  ]
}

不同频道绑定不同 AI 角色，互不干扰。

6.2 工作区文件系统

每个 Agent 有独立工作区，核心文件：

文件	作用
AGENTS.md	操作指令 + 工作流定义
SOUL.md	人设、语气、边界
IDENTITY.md	名字、角色、emoji
USER.md	用户画像和偏好
MEMORY.md	长期记忆
TOOLS.md	工具使用偏好
BOOTSTRAP.md	首次运行仪式（执行完删除）

6.3 浏览器控制（Browser Use）

OpenClaw 内置 Playwright 浏览器控制能力：

用户："帮我在京东搜索 iPhone 16，找最低价"
  → AI 打开浏览器
  → 搜索商品
  → 截图分析
  → 返回最低价链接

实际案例：Tesco 超市自动购物——用户发送"帮我按上周购物清单订购本周食材"，AI 自动完成整个下单流程。

6.4 移动节点（Mobile Nodes）

配对 iOS / Android 设备后，AI 可以：

📸 调用手机摄像头拍照
🖥️ 截取手机屏幕
📍 获取当前位置
🎙️ 语音输入输出
📱 控制 Canvas 画布展示

6.5 语音功能（TTS / 语音转文字）

tts:
  enabled: true
  provider: openai  # 或其他支持的 TTS 服务

用户可以发语音消息，AI 转文字处理后，以语音形式回复。

6.6 模型切换与故障转移

{
  "agents": {
    "defaults": {
      "model": {
        "primary": "anthropic/claude-opus-4-6",
        "fallbacks": [
          "anthropic/claude-sonnet-4-5",
          "openai/gpt-4o"
        ]
      }
    }
  }
}

主模型失败时自动切换备用模型，服务永不中断。

会话内切换模型：

/model list           # 查看可用模型
/model openai/gpt-4o  # 切换到 GPT-4o

七、变现思路与商业模式

这是最核心的部分。OpenClaw 不只是个人工具，它是创业的基础设施。

7.1 变现模式一：AI 助手服务接单

目标客户： 中小企业、个体商家、自媒体博主

服务内容：

部署专属 AI 客服（接入飞书 / 企微 / WhatsApp）
每月维护费：¥500-2000/客户
客制化功能开发：¥3000-10000/项目

操作路径：

本地部署一套 OpenClaw，测试跑通
在 VPS 上部署（成本约 ¥30-80/月/客户）
接入客户的 IM 账号
定制 SOUL.md、AGENTS.md（人设 + 工作流）
交付使用，按月收维护费

利润估算：

10个客户 × ¥1000/月 = ¥10,000/月
成本：VPS ¥500 + 模型 API 费用 ¥1000 = ¥1500
净利润：¥8500/月

7.2 变现模式二：自媒体内容生产线

场景： 用 OpenClaw 搭建完整的内容流水线

热点监控(选题专家) 
    → 飞书选题库
    → 审批
    → 笔尖专家写作
    → 发布专家推送
    → 公众号/小红书/抖音

收益来源：

广告分成：公众号/小红书流量变现
知识付费：课程、训练营
接稿：品牌内容合作 ¥2000-10000/篇

核心优势： 一个人运营多个账号，AI 承担 80% 的内容生产工作，人工只做审核和选题判断。

7.3 变现模式三：Skills 开发与销售

ClawHub 平台允许开发者发布和销售 Skills。

机会点：

开发垂直行业 Skill（法律、医疗、电商）
开发工具集成 Skill（CRM、ERP、电商平台）
收费模式：买断 / 订阅 / 使用量计费

开发成本极低：

简单 Skill：一个 SKILL.md 文件
复杂 Skill：SKILL.md + 几个 Python/Shell 脚本

参考案例：一个 Bambu 3D 打印机控制 Skill，让用户通过 Telegram 消息控制打印机，这样的垂直工具在小众社区价值极高。

7.4 变现模式四：企业 AI 内网部署

目标客户： 100-500 人规模的中小企业

方案：

在企业内网服务器部署 OpenClaw
接入飞书/企微/钉钉
配置企业知识库（连接内部文档）
配置各部门专属 AI 角色

报价参考：

基础部署：¥20,000-50,000（一次性）
年度维护：¥10,000-30,000/年
知识库定制：¥5,000-20,000

7.5 变现模式五：教学与培训

市场现状： AI 工具学习需求旺盛，但优质教程稀缺。

变现路径：

录制 OpenClaw 系列课程（B站/知识星球）
开设训练营：¥499-2999/人
1v1 咨询：¥299-599/小时
出版教程文档（本文就是起点）

内容方向：

OpenClaw 从零搭建（入门）
AI 自动化工作流实战（进阶）
企业 AI 转型方案（高端）

7.6 变现模式六：AI 副业平台搭建

场景： 帮助他人搭建 AI 副业工具包

打包售卖：

OpenClaw 配置模板
预置 Skills 包
工作流 SOP 文档
一对一部署支持

定价：¥499-1999/套

7.7 变现成本核算

成本项	月费用
VPS（Hetzner 入门）	¥21
Claude API（轻度使用）	¥70-200
域名（可选）	¥5
总计	¥100-230

ROI 分析： 只需一个付费客户（¥500/月），就能覆盖所有成本，其余全是利润。

八、常见问题 FAQ

Q1：OpenClaw 完全免费吗？

OpenClaw 软件本身完全免费（MIT 开源）。你需要为 AI 模型 API 付费（Claude、GPT 等按用量计费）。VPS 托管按月付费，也可以跑在自己电脑上零成本。

Q2：会不会封号？

飞书：官方 Bot API，零风险 ✅
Telegram Bot：官方支持，零风险 ✅
Discord：官方 Bot API，零风险 ✅
WhatsApp：使

用 Baileys 非官方方案，有一定风险，建议用备用号

Q3：数据安全吗？

所有对话数据在你的设备上处理，只有发给 AI 模型 API 的内容才离开你的设备（这是必须的，模型 API 需要看到内容才能回复）。对话记录存储在本地 JSONL 文件中。

Q4：支持哪些 AI 模型？

主流模型全支持：

Anthropic：Claude Opus / Sonnet / Haiku
OpenAI：GPT-4o / o3 / o4-mini
Google：Gemini 2.0 / 1.5 Pro
本地模型：通过 Ollama 接入（开发中）
自定义 API：兼容 OpenAI 协议的任何服务

便宜的中转推荐: https://www.proxyai.top/

Q5：一台服务器能服务多少用户？

取决于并发量和模型调用频率。个人使用基本零压力。接待 10-20 个活跃用户，2核 4G 的 VPS 完全够用。

Q6：如何更新 OpenClaw？

openclaw update                    # 更新到最新稳定版
openclaw update --channel beta     # 更新到 beta 版

Q7：Windows 支持好吗？

强烈建议使用 WSL2，体验等同 Linux。原生 Windows 支持有限，某些功能（如 iMessage）不可用。

Q8：飞书和 Telegram 该选哪个？

维度	飞书	Telegram
封号风险	零（官方API）	零（官方Bot）
国内访问	✅ 直连	❌ 需代理
配置难度	中等（需创建应用）	极简（BotFather 3分钟）
生态打通	✅ 文档/表格/审批	❌ 仅消息
适合场景	工作流/企业/国内用户	个人/海外/极简需求

建议： 国内用户首选飞书，海外用户首选 Telegram，两个都开最佳。

九、社区与资源

9.1 官方资源

资源	链接
官网	https://openclaw.ai
文档	https://docs.openclaw.ai
GitHub	https://github.com/openclaw/openclaw
技能市场	https://clawhub.com
Discord 社区	https://discord.gg/clawd

9.2 快速命令参考

# 安装
npm install -g openclaw@latest

# 引导向导
openclaw onboard --install-daemon

# 常用命令
openclaw gateway status     # 查看 Gateway 状态
openclaw gateway start      # 启动 Gateway
openclaw gateway stop       # 停止 Gateway
openclaw dashboard          # 打开 Web 控制界面
openclaw doctor             # 健康检查
openclaw update             # 更新版本
openclaw status             # 查看完整状态

9.3 进阶学习路径

第一周： 安装 + 连通飞书/Telegram，发送第一条消息

第二周： 配置 SOUL.md 和 AGENTS.md，打造专属人设

第三周： 安装 3-5 个 Skills，搭建第一个自动化流程

第四周： 进阶玩法

配置多智能体路由（写作、编程、交易各司其职）
接入浏览器控制，解锁网页自动化
配对手机节点，随时随地拍照/定位/语音
自创第一个 Skill 并发布到 ClawHub

🦞 最后一句话： OpenClaw 的上限取决于你的想象力。它是工具，也是平台，更是你的 AI 副业基础设施。装上它，开始折腾吧。

一文说透日志框架发展史及springboot日志

Tue, 13 Jan 2026 15:28:47 +0800

日志框架发展史

一位 老程序员A 根据自己工作中对日志的需求，开发并开源了log4j。后被apatch基金会收纳；

jdk官方 sun 公司, 开发了一个日志框架 jul ，也就是 java.util.logging ；

由于市面上的日志框架非常的混乱，  一个项目  一个模块用   log4j ,   一个模块用 jul ， 一个用jboss-logging.

于是jdk官方 开发了日志门面 JCL ， jakarta Commons Logging JCL ( 不实现日志功能，整合日志的）；

老程序员A 发现JCL并不好用，离开了apatch，独自开发了日志门面 slf4j . ( 不实现日志功能，整合日志的）需要用 适配器、桥接器。

apatch开发了 log4j2 ，其性能比log4j高出好多倍。于是log4j淘汰。

老程序员A 又开发了logback ，性能比log4j2高出好多倍.

日志实现	日志门面
log4j 淘汰（个人、apatch）	JCL（jdk）
jul java.util.logging 别的（jdk）官方	SJF4J（个人）适配器、桥接器
log4j2 （apatch）开源
logback （个人）

log4j的作者觉得jcl不好用，自己写了一个新的接口api，那么就是slf4j。关于slf4j的集成图如下所示：

Slf4j与其他各种日志组件的桥接说明

jar包名	说明
slf4j-log4j12-1.7.13.jar	Log4j1.2版本的桥接器，你需要将Log4j.jar加入Classpath。
log4j-slf4j-impl.jar	Log4j2版本的桥接器,还需要log4j-api.jar log4j-core.jar
slf4j-jdk14-1.7.13.jar	java.util.logging的桥接器，Jdk原生日志框架。
slf4j-nop-1.7.13.jar	NOP桥接器，默默丢弃一切日志。
slf4j-simple-1.7.13.jar	一个简单实现的桥接器，该实现输出所有事件到System.err. 只有Info以及高于该级别的消息被打印，在小型应用中它也许是有用的。
slf4j-jcl-1.7.13.jar	Jakarta Commons Logging 的桥接器. 这个桥接器将Slf4j所有日志委派给Jcl。
logback-classic-1.0.13.jar(requires logback-core-1.0.13.jar)	Slf4j的原生实现，Logback直接实现了Slf4j的接口，因此使用Slf4j与Logback的结合使用也意味更小的内存与计算开销

所以最佳组合是slf4j 和logback，因为作者是一个。

那么如果使用slf4j(门面)+Log4j(实现) ：必须加桥接器

引入slf4j依赖：

<dependency>
   <groupId>org.slf4j</groupId>
   <artifactId>slf4j-api</artifactld>
</dependency>

<dependency)
    <!--添加s1f4j一log4j的桥接器
    <groupId>org.slf4j</groupId>
    <artifactId>slf4j-log4j12</artifactId>
</dependency>
import org.slf4j.Logger;
     // slf4j(门面)，不是具体的日志实现获得Logger日志记录器
     //Logger logger = Logger.getLogger(Test.class);
     //而是 门面日志器接受
      Logger logger = LoggerFactory.getLogger(Test.class);
     logger.info("info");

如果是Jul（实现） +JCl（门面）

<!--引入JCL门面依赖-->
<dependency>
    <groupId>commons-logging</groupId>
    <artifactId>commons-logging</artifactId>
    <version>1.2</version>
</dependency>

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
\\LogFactory
Log log = LogFactory.getLog(Test.class);
log.trace('trace');

这个Log具体的实现类，JCL会在ClassLoader中进行查找。这么做，有三个缺点，缺点一是效率较低，二是容易引发混乱，三是在使用了自定义ClassLoader的程序中，使用JCL会引发内存泄露。
JCL动态查找机制进行日志实例化，执行顺序为：commons-logging.properties---->系统环境变量------->log4j--->jul--->simplelog---->nooplog

将以上两个小组使用的两个个门面统一：只需要添加一个适配器。将jcl或者jul转成slf4j.  添加适配器
   <dependency>
         <groupId>org.slf4j</groupId>
         <artifactId>jcl-over-slf4j</artifactId>
         <version></version>
   </dependency>

spring默认整合了：logback日志的集成

logback跟log4j，跟slf4j都出自同一个作者，所以最佳实现方式就是slf4j+logback

总结：

SpringBoot底层也是使用slf4j+logback的方式进行日志记录

使用了logback与slf4j的桥接器：logback-classic

SpringBoot也把其他的日志都替换成了slf4j；

log4j 适配： log4j-to-slf4j （将log4j转成slf4）
jul适配：jul-to-slf4j （将jul转成slf4）
这两个适配器都是为了适配Spring的默认日志：jcl

SpringBoot日志使用

日志级别

TRACE，DEBUG，INFO，WARN，ERROR，FATAL或OFF，等级依次升高

springboot默认info级别（那么大于info的级别才会起作用）。可设置日志等级

logging:
  level:
    root: "warn"
    org.springframework.web: "debug"
    com.lingling: "error"   //包下日志等级设置

日志格式

2025-12-01 14:01:34.665 TRACE 10072 --- [           main] com.ruoyi.Application            : 跟踪
2025-12-01 14:01:34.665 DEBUG 10072 --- [           main] com.ruoyi.Application            : 调试
2025-12-01 14:01:34.665  INFO 10072 --- [           main] com.ruoyi.Application            : 信息
2025-12-01 14:01:34.665  WARN 10072 --- [           main] com.ruoyi.Application            : 警告
2025-12-01 14:01:34.665 ERROR 10072 --- [           main] com.ruoyi.Application            : 异常

详细介绍

可以使用logging.pattern.console  修改默认的控制的日志格式：

%clr(%d{${LOG_DATEFORMAT_PATTERN:-yyyy-MM-dd HH:mm:ss.SSS}}){faint} %clr(${LOG_LEVEL_PATTERN:-%5p}) %clr(${PID:- }){magenta} %clr(---){faint} %clr([%15.15t]){faint} %clr(%-40.40logger{39}){cyan} %clr(:){faint} %m%n${LOG_EXCEPTION_CONVERSION_WORD:-%wEx}

2025-12-01 14:01:34.665

日期和时间：毫秒精度，易于排序。
%clr(%d{${LOG_DATEFORMAT_PATTERN:-yyyy-MM-dd HH:mm:ss.SSS}}){faint}

%clr 当前内容的颜色 {faint}

(%d{${LOG_DATEFORMAT_PATTERN:-yyyy-MM-dd HH:mm:ss.SSS}})

括号中就是要显示的内容

%d{${LOG_DATEFORMAT_PATTERN:-yyyy-MM-dd HH:mm:ss.SSS}}

${LOG_DATEFORMAT_PATTERN:-yyyy-MM-dd HH:mm:ss.SSS}

${value:value2} springboot的占位符 + null条件的表达式（如果value为null 使用value2)
LOG_DATEFORMAT_PATTERN: 系统环境变量中的值， springboot底层会根据对应的配置项将值设置到对应的环境变量中

如：LOG_DATEFORMAT_PATTERN=logging.pattern.dateformat 可以在官网4.7章节中看到对应的关系。或者去源码中看

%d{-yyyy-MM-dd HH:mm:ss.SSS}

%d logbak的日期显示方式：
{-yyyy-MM-dd HH:mm:ss.SSS} 日期的格式

TRACE

日志级别：ERROR，WARN，INFO，DEBUG，或TRACE。
%clr(${LOG_LEVEL_PATTERN:-%5p})
%clr 颜色会根据不同的日志级别输出对应的颜色
${LOG_LEVEL_PATTERN:-%5p}
%5 代表当前内容所占字符长度
p 输出日志事件的级别。

10072

进程ID。
%clr(${PID:- }){magenta}
%clr {magenta}
${PID:- } springboot的占位符 + null条件的表达式（如果value为null 使用value2)
PID 是系统环境变量中的进程ID（由系统分配）

一个---分离器来区分实际日志消息的开始。

[ main]

线程名称：用方括号括起来（对于控制台输出可能会被截断）。

com.ruoyi.Application

记录日志的类

: 跟踪

日志消息。

文件输出

默认情况下，Spring Boot仅记录到控制台，不写日志文件。如果除了控制台输出外还想写日志文件，则需要设置一个logging.file.name或logging.file.path属性（例如，在中application.properties）。

下表显示了如何logging.*一起使用这些属性：

logging.file.name	logging.file.path	实例	描述
（没有）	（没有）		仅控制台记录。
指定文件名	（没有）	my.log	写入指定的日志文件。
（没有）	具体目录	/var/log	写入spring.log指定的目录。

logging.file.name

可以设置文件的名称，如果没有设置路径会默认在项目的相对路径下（项目的根目录下）
还可以指定路径+文件名：name: D:/sawadika.log

logging.file.path

不可以指定文件名称，必须要指定一个物理文件夹路径，会默认使用spring.log

日志迭代（轮转）：比如日志文件超出了设定的大小，归档。并保留天数后可删除

如果使用的是Logback，可以使用application.properties或application.yaml文件微调日志轮播设置。对于所有其他日志记录系统，您需要直接自己配置轮转设置（例如，如果使用Log4J2，则可以添加log4j.xml文件）。

名称	描述
logging.logback.rollingpolicy.file-name-pattern	归档的文件名
logging.logback.rollingpolicy.clean-history-on-start	如果应在应用程序启动时进行日志归档清理。
logging.logback.rollingpolicy.max-file-size	归档前日志文件的最大大小。
logging.logback.rollingpolicy.total-size-cap	删除日志档案之前可以使用的最大大小。
logging.logback.rollingpolicy.max-history	保留日志存档的天数（默认为7）

如果想要使用logback的高级功能，比如：发送文件、存入数据库等。就必须单独使用logBack的配置文件 比如：logback.xml.也就是自定义配置文件

注意：

如果使用自定义日志配置文件，会使用springboot中全局配置文件里的logging相关配置失效。
结合SpringBoot提供Profile来控制日志的生效

注意：如果要使用 springProfile ，一定要将日志配置文件的文件名改成logback-spring.xml, 因为 logback.xml 会在Springboot容器加载前先被logback给加载到，那么由于logback无法解析springProfile 将会报错：
ERROR in ch.qos.logback.core.joran.spi.Interpreter@4:71 - no applicable action for [springProperty], current ElementPath is [[configuration][springProperty]] ERROR in ch.qos.logback.core.joran.spi.Interpreter@4:71 - no applicable action for [springProfile], current ElementPath is [[configuration][springProfile]]

<configuration>
      <!--还可以引用SpringBoot全局配置文件中的配置项-->
    <springProperty scope="context" name="dateformat" source="logging.pattern.dateformat" defaultValue="yyyy-MM-dd HH:mm:ss.SS"
    <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
        <encoder>
            <!-- 使用springProfile激活dev的配置 -->
            <springProfile name="dev">
                <pattern>%d{${dateformat}}} [%thread] %-5level %logger{100} ======= %msg%n</pattern>
            </springProfile>
            <!-- 如果不是dev 走这里 -->
            <springProfile name="!dev">
                <pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{100} ++++++ %msg%n</pattern>
            </springProfile>
    
        </encoder>
    </appender>
</configuration>

切换日志框架

将 logback切换成log4j2

将logback的场景启动器排除（slf4j只能运行有1个桥接器.）
添加log4j2的场景启动器
添加log4j2的配置文件

<dependencies>
    <dependency>
        <!--starter-web里面自动添加starter-logging 也就是logback的依赖-->
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
        <exclusions>
            <!--排除starter-logging 也就是logback的依赖-->
            <exclusion>
                <artifactId>spring-boot-starter-logging</artifactId>
                <groupId>org.springframework.boot</groupId>
            </exclusion>
        </exclusions>
    </dependency>

    <!--Log4j2的场景启动器-->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-log4j2</artifactId>
    </dependency>
</dependencies>

将 logback切换成log4j

要将logback 与slf4j的桥接器排除

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
    <exclusions>
        <exclusion>
            <artifactId>logback-classic</artifactId>
            <groupId>ch.qos.logback</groupId>
        </exclusion>
    </exclusions>
</dependency>

添加log4j的桥接器

<dependency>
    <groupId>org.slf4j</groupId>
    <artifactId>slf4j-log4j12</artifactId>
</dependency>

添加log4j的配置文件

log4j.properties

#trace<debug<info<warn<error<fatal
log4j.rootLogger=trace, stdout
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%d %p [%c] - %m%n

一文带你入门极其强大的AI智能体—N8N

Thu, 11 Dec 2025 16:34:12 +0800

一、什么是AI智能体？为什么现在人人都该了解它？

“AI智能体”指的是能像人类一样，自主执行多步任务的AI程序。你只要告诉它目标，它就能一步步替你完成流程，不需要你每一步都手动控制。

🔧 举个例子：如果你每天要手动做这些事：

打开Excel → 提取短剧场景 → 设计分镜图 → 合成视频 → 加字幕 → 发布。这就是一个“重复型流程”——智能体可以全自动帮你完成。

智能体包含以下能力：

感知用户指令、表格、网页、图片、语音等输入思考判断接下来该做什么行动主动调用工具（API、脚本、模型、插件）学习通过记忆功能，并记住你之前的偏好，下一次做得更好。

在N8N中，下图就是一个AI智能体比较完整的体现：

AI Agent作为大脑，能够调用Deepseek等AI大模型

并且有记忆功能存储上下文

能利用外部的工具来实现不同复杂的功能

最后通过结构化输出解析器来规范输出

甚至更厉害的就是不同的智能体之间相互能交流沟通，通过更强大的一个智能体进行统一调度执行等等。

二、想做智能体，有三种主流平台路线：N8N、Dify、Coze（扣子）

总结为：

想做“自己指挥的 AI 自动流水线” → N8N

想做“带界面的 AI 应用 / 问答机器人” → Dify

想做“在不同平台里接入 AI 聊天助手” → Coze（扣子）

三、为什么选择 N8N 做核心中控？

N8N 的几个关键特性非常适合 AI 视频创作者或项目开发者：

四、N8N 能做哪些“AI视频相关工作”？

五、零基础实操：N8N本地部署完整指南（面向Windows）

n8n项目地址：https://github.com/n8n-io/n8n

nodejs软件下载地址：https://nodejs.org/en/download

docker软件下载地址：https://www.docker.com/

🔧 方法一：快速试用（适合体验流程）:

前提：已安装 Node.js

打开 http://localhost:5678 即可体验

缺点：流程和数据不持久，适合试验不适合长期用

这种方式，中间运行的数据是临时存储在C盘，能快速体验N8N的完整功能，如果是需要数据持久化，推荐使用方法二，Docker方式部署。

🛠 方法二：Docker方式部署（推荐，长期运行）

安装前准备

下载并安装 Docker Desktop

准备一个空文件夹，用于挂载数据（推荐放非C盘）

在Docker官网中下载对应的版本，如果电脑是Windows系统的话下载下图这个

下载安装后重启电脑，打开Docker，打开设置

保持跟下图一样的设置

这里镜像文件挂载位置放在除C盘外比较大的盘中

创建持久化数据卷，存储相关数据，通过镜像挂载到docker中，创建独立于容器的存储空间，即使容器销毁了，数据还在

docker volume create n8n_data

启动N8N容器

docker run -d --restart unless-stopped --name n8n \
  -p 5678:5678 \
  -v n8n_data:/home/node/.n8n \
  -v "E:/N8N/n8n:/data/files" \
  docker.n8n.io/n8nio/n8n

E:/N8N/n8n 是你的素材存储盘，自行替换

第一次使用建议开启VPN避免镜像拉取失败

注意：这里如果安装失败记得开启魔法

然后打开Docker，就能发现对应的容器了，点击如下链接即可进入n8n的本地端口

接着注册好之后即可开始使用

打开浏览器：访问 http://localhost:5678，注册后开始使用！

六、零基础实操：N8N云部署完整指南（使用zeabur）

N8N本身对于电脑要求不高，可以使用zeabur云端部署，24h执行自动化任务。

、

搜索n8n，进行部署。

可以选择部署到香港地区

也可以在谷歌云，阿里云等云平台部署N8N。

七、N8N实战教程：一步步打造批量文生图流水线

提示词模板参考：

你是智能的Flux提示词助手，能够优化提示词，生成更加专业的提示词，使用模板：视角(后视图，俯视图等) + 景别(中景、特写等) + 人物主体+细节描述(主要特征、服装等) + 动作 + 光线(形状、软硬、角度) + 背景 + 风格(类型、导演、镜头) + 情感氛围。注意：最后只返回英文提示词，不要返回其余内容。

📌 每一步都可拖拽设置，不需要写代码（code代码脚本可选加，主要是为了去掉deepseek-r1深度思考的过程内容）

ComfyUI工作流，是最基础的Flux文生图工作流，对应节点：

再把base64转成文件，存储到本地

然后循环执行这个过程，最终会发现在n8n挂载的文件夹下面会生成对应的分镜图片。

如果需要生成视频的话，可以在上述工作流中增加http调用，充值一些AI视频平台的API，在N8N中授权即可。

十、参考链接

What are AI agents? ： https://www.ibm.com/think/topics/ai-agents

Dify vs. n8n: 2025 年应该用哪个平台来驱动你的 AI 自动化堆栈？：https://medium.com/generative-ai-revolution-ai-native-transformation/dify-vs-n8n-which-platform-should-power-your-ai-automation-stack-in-2025-e6d971f313a5

n8n 与 Dify 与 Coze：自动化和 AI 平台的详细比较：https://www.surfercloud.com/blog/n8n-vs-dify-vs-coze-a-detailed-comparison-of-automation-and-ai-platforms

n8n vs. Dify vs. Coze：自动化和 AI 平台全面对比：https://go.lightnode.com/tech/n8n-dify-coze

N8n Vs Dify || Which Is Better?： https://www.youtube.com/watch?v=j-WTkF_8Cro

主流AI工具使用（关于文本、语音方面）

Mon, 08 Dec 2025 13:03:18 +0800

主要介绍一下ChatGPT和国内的一些主流AI工具的基本使用，我们根据自己的习惯或者最合适的工具去使用就行。

一、ChatGPT 地址：https://chatgpt.com/

特色功能：结构化提示词支持友好；学习能力、逻辑推理能力强；

GPT商店页面，右上角【创建】按钮可以创建属于自己的GPTs并发布到商店中（目前仅有 ChatGPT Plus 用户可以创建并发布GPTs）

二、Kimi 地址：https://kimi.moonshot.cn

特色功能：结构化提示词支持友好；长文本能力强，最高支持200万字上下文处理；

三、天工AI 地址：https://www.tiangong.cn/

特色功能：AI搜索功能强大；多模态支持，具有文生文、文生图、文生音乐等功能；能够一键生成PPT；

四、秘塔AI 地址：https://metaso.cn

突出功能：AI搜索功能强大；AI搜索范围更加细化；

和天工AI类似，秘塔AI是一款AI搜索引擎工具，它最强大的地方就是搜索能力。

秘塔AI和天工AI有一点区别，就是秘塔AI的搜索范围更加细分

五、橙篇AI 地址：https://cp.baidu.com

特色功能：

1）长文本写作，一键生成10000+字的长文内容；

2）百度文库团队研发，背后是数亿的百度文库、百度学术数据，适合产出研究性、学术性的内容；

橙篇支持最多100个文件上传，每个文件最大200MB（Kimi最多支持50个文件上传，每个文件最大100MB）。

文件类型包括word、pdf、图片、ppt、excel等。

六、文心一言地址：https://yiyan.baidu.com

进入文心一言主页面，在输入框中输入指令就可以开始对话。

个人在编写逻辑复杂程序，常扔给文心一言编写。

七、通义千问地址：https://tongyi.aliyun.com/qianwen

特色功能：分析音频和视频、实时转录总结会议等语音内容

通义千问主页面相对比较简洁，分析长文档和图片能力比较强大。

八、豆包地址：https://www.doubao.com/

豆包中规中矩，没有特别突出的能力，豆包的能力其它的AI工具也都有。智能体中心也比较丰富。

九、腾讯元宝地址：https://yuanbao.tencent.com

特色功能：总结公众号文章能力强，可以用来辅助写作公众号文章

元宝的特色功能是它对于公众号文章的总结能力和辅助写作公众号文章能力。

因为它是腾讯开发的嘛，所以它在这方面的能力比较强。

十、讯飞星火地址：https://xinghuo.xfyun.cn

特色功能：语音能力强，可以用语音和它对话；友伴功能（虚拟人物对话）

十一、智谱清言地址：https://chatglm.cn

智谱清言的逻辑推理能力不错，功能方面中规中矩，没有特别突出的功能

智谱清言的长文档解析能力大概在20万字以内。

十二、deepseek https://www.deepseek.com/

个人在很严禁的法律方面、短文资料查询等常用

即插即用记录：

1扣子空间。可用于生成PPT

2.纳米AI：视频生成，每月3次免费

3小云雀助手、灵光，手机版本

manus智能体概念的提出者，鼻祖

JVM虚拟机——java类加载机制

Sun, 09 Nov 2025 17:05:10 +0800

那么java类是如何被加载到jvm虚拟机的呢？

一、JAVA8的类加载机制

三句话总结JDK8的类加载机制：

1.类缓存：每个类加载器对加载过的类都有一个缓存。

2.双亲委派机制：向上委托查找，向下委托加载。

（向上委托查找是从缓存中查，为了保证系统内置的类不能够被子类覆盖，比如说Java.long.object,这是所有子类分父类。为了保证父类不被修改）

3.沙箱保护机制：不允许应用程序加载JDK内部的系统类。（不能写java.开头的类）

总结虽然简单，深入去理解，还是很复杂的。

至于JDK具体如何执行的，不同JDK版本的实现方式是不同的。以下以大家最为熟悉的JDK8进行分析。

2、双亲委派机制

JDK8中的两个类加载体系：

左侧是JDK中实现的类加载器，通过parent属性形成父子关系。应用中自定义的类加载器的parent都是AppClassLoader

右侧是JDK中的类加载器实现类。通过类继承的机制形成体系。未来我们就可以通过继承相关的类实现自定义类加载器。

简而言之，左侧是对象，右侧是类。

JDK8中的类加载器都继承于一个统一的抽象类ClassLoader，类加载的核心也在这个父类中。其中，加载类的核心方法如下：

//类加载器的核心方法
 public Class<?> loadClass(String name) throws ClassNotFoundException {
        return loadClass(name, false);
    }


    protected Class<?> loadClass(String name, boolean resolve)
        throws ClassNotFoundException
    {
        synchronized (getClassLoadingLock(name)) {
            // First, check if the class has already been loaded
            Class<?> c = findLoadedClass(name);
            if (c == null) {
                long t0 = System.nanoTime();
                try {
                    if (parent != null) {
                        c = parent.loadClass(name, false);
                    } else {
                        c = findBootstrapClassOrNull(name);
                    }
                } catch (ClassNotFoundException e) {
                    // ClassNotFoundException thrown if class not found
                    // from the non-null parent class loader
                }

                if (c == null) {
                    // If still not found, then invoke findClass in order
                    // to find the class.
                    long t1 = System.nanoTime();
                    c = findClass(name);

                    // this is the defining class loader; record the stats
                    PerfCounter.getParentDelegationTime().addTime(t1 - t0);
                    PerfCounter.getFindClassTime().addElapsedTimeFrom(t1);
                    PerfCounter.getFindClasses().increment();
                }
            }
            if (resolve) {
                resolveClass(c);
            }
            return c;
        }
    }

当一个类加载器要加载一个类时，整体的过程就是通过双亲委派机制向上委托查找，如果没有查找到，就向下委托加载。整个过程整理如下图：

双亲委派机制过程：将某个class类加载到缓存，这个类加载器会先在自己的缓存中找，看有没有加载过，加载过就返回，如果没有加载就到父加载器的缓存中找，如果有返回，没有就到顶层的加载器BootStapClassLoade中找，去缓存里找如果有返回，如果没有就到对应的目录文件中有没有class文件，有加载，没有到下面的子加载器再找。直到上面都没有，就交由自己加载。

另外，还一个有趣的地方，这个loadClass方法中有一个resolve参数，但是，设置这个参数，却只有一个public方法中写死了。

也就是说，在调用类加载器时，程序员是没有办法给这个resolve方法主动传入一个false的。那这个resolve参数设置不是多此一举吗？

其实resolveClass（），是一个native方法。

而其实现的过程称为linking-链接。链接过程的实现功能如下图：

其中关于半初始化状态（准备阶段）就是JDK在处理一个类的static静态属性时，会先给这个属性分配一个默认值，作用是占住内存。然后等连接过程完成后，在后面的初始化阶段，再将静态属性从默认值修改为指定的初始值。

这里注意，static静态的属性，是属于类的，他是在类初始化过程中维护的。而普通的属性是属于对象的，他是在创建对象的过程中维护的。这两个不要搞混了。

对应到class文件当中，一个是方法，一个是方法。

例如参照一下下面这个案例：

class Apple{
    static Apple apple = new Apple(10);
    static double price = 20.00;
    double totalpay;

    public Apple (double discount) {
        System.out.println("===="+price);
        totalpay = price - discount;
    }
}
public class PriceTest01 {
    public static void main(String[] args) {
        System.out.println(Apple.apple.totalpay);
    }
}

程序打印出的结果是-10 ，而不是10。 这感觉有点反直觉，为什么呢？

因为开始静态apple会默认null，price会默认0，当apple在构造方法的时候，apple还在半初始化的状态，0。

其中Apple.apple访问了类的静态变量，会触发类的初始化，即加载-》链接-》初始化

而当main方法执行构造函数时，price还没有初始化完成，处于链接阶段的准备阶段，其值为默认值0。这时构造函数的price就是0，所以最终打印出来的结果是-10，而不是 10 。

如何让结果打印出正常的10呢？

1将 代码块static double price = 20.00;  提前到第一行。代码会从上而下执行。

2在代码前加final ，也就是 final static double price = 20.00。表示这个值永远不会变，所以开始直接就是初始值。

后面解析的过程有两个核心的概念：符号引用和直接引用。。

如果A类中有一个静态属性，引用了另一个B类。那么在对类进行初始化的过程中，因为A和B这两个类都没有初始化，JVM并不知道A和B这两个类的具体地址。所以这时，在A类中，只能创建一个不知道具体地址的引用，指向B类。这个引用就称为符号引用。而当A类和B类都完成初始化后，JVM自然就需要将这个符号引用转而指向B类具体的内存地址，这个引用就称为直接引用。

思考问题：为什么在ClassLoader的这个loadClass方法中，reslove参数只能传个false，而不让传true？

因为在创建对象的过程中是要申请内存的，所有的java内存就是在进程启动的时候，把所有的类创建，而不能在运行过程中去重新申请内存，这样的话，内存管理就不可控。所以不让我们参与这个连接的过程。不过也有办法去参与这个过程，就是用Class.forName，意味着它会走resolveClass方法 走连接，会临时申请内存。临时申请是申请不下来的。所以还是第一种loadClass方法更安全。

3、沙箱保护机制

双亲委派机制有一个最大的作用就是要保护JDK内部的核心类不会被应用覆盖。而为了保护JDK内部的核心类，JAVA在双亲委派的基础上，还加了一层保险。就是ClassLoader中的下面这个方法。

private ProtectionDomain preDefineClass(String name,  ProtectionDomain pd)
    {
        if (!checkName(name))
            throw new NoClassDefFoundError("IllegalName: " + name);
        // 不允许加载核心类
        if ((name != null) && name.startsWith("java.")) {
            throw new SecurityException
                ("Prohibited package name: " +
                 name.substring(0, name.lastIndexOf('.')));
        }
        if (pd == null) {
            pd = defaultDomain;
        }
        if (name != null) checkCerts(name, pd.getCodeSource());
        return pd;
    }

这个方法会用在JAVA在内部定义一个类之前。这种简单粗暴的处理方式，当然是有很多时代的因素。也因此在JDK中，你可以看到很多javax开头的包。这个奇怪的包名也是跟这个沙箱保护机制有关系的。

反编译工具：jd-jui

如何对class文件加密，防止反编译？

可以把class文件的二进制改一改，比如在class文件的基础上加了个1。生成一个新的myclass文件

新的myclass文件如下：

要让这个MyClass文件也可以执行使用，那就写一个自己的MyClassLoader类，重写findClass方法。把01忽略。

4、类和对象有什么关系

通过类加载模块，我们写的class文件就可以加载到JVM当中。但是类加载模块针对的都是类，而我们写的java程序都是基于对象来执行。类只是创建对象的模板。那么类和对象倒是什么关系呢？

首先：类 Class 在 JVM 中的作用其实就是一个创建对象的模板。也就是说他的作用更多的体现在创建对象的过程当中。而在程序具体执行的过程中，主要是围绕对象在进行，这时候类的作用就不大了。因此，在 JVM 中，类并不直接保存在最宝贵最核心的堆内存当中，而是挪到了堆内存以外的一部分内存中（非堆区）。这部分内存，在 JDK8 以前被成为永久带PermSpace，而在 JDK8 之后被改为了元空间 MetaSpace。

堆空间可以理解为JVM的客厅，所有重要的事情都在客厅处理。元空间可以理解为JVM的库房，东西扔进去基本上就很少管了。

这个元空间逻辑上可以认为是堆空间的一部分，但是他跟堆空间有不同的配置参数，不同的管理方式。因此也可以看成是单独的一块内存。这一块内存就相当于家里的工具间或者地下室，都是放一些用得比较少的东西。最主要就是类的一些相关信息，比如类的元数据、版本信息、注解信息、依赖关系等等。

元空间可以通过-XX:MetaspaceSize 和 -XX:MaxMetaspaceSize参数设置大小。但是大部分情况下，你是不需要管理元空间大小的，JVM 会动态进行分配。

另外，这个元空间也是会进行 GC 垃圾回收的。如果一个类不再使用了，JVM 就会将这个类信息从元空间中删除。但是，显然，对类的回收效率是很低的。大部分情况下，类是不会被回收的。所以堆元空间的垃圾回收基本上是很少有效果的。大部分情况下，我们是不需要管元空间的。除非你的JVM 内存确实非常紧张，这时可以设定 -XX:MaxMetaspaceSize参数，严格控制元空间大小。

然后：在我们创建的每一个对象中，JVM也会保存对应的类信息。

在堆中，每一个对象的头部，还会保存这个对象的类指针(classpoint)，指向元空间中的类。这样我们就可以通过一个对象的getClass方法获取到对象所属的类了。这个类指针，我们也是可以通过一个小工具观察到的。

例如，下面这个 Maven依赖就可以帮我们分析一个对象在堆中保存的信息。

<dependency>
   <groupId>org.openjdk.jol</groupId>
   <artifactId>jol-core</artifactId>
   <version>0.17</version>
</dependency>

然后可以用以下方法简单查看一下对象的内存信息。

public class JOLDemo {
    private String id;
    private String name;
    public static void main(String[] args) {
        JOLDemo o = new JOLDemo();
        System.out.println(ClassLayout.parseInstance(o).toPrintable());

        synchronized (o){
            System.out.println(ClassLayout.parseInstance(o).toPrintable());
        }
    }
}

看到的结果大概是这样：

这里ClassPoint 实际上就是一个指向元空间对应类的一个指针。当然，具体结果是被压缩过的。

另外Markdown标志位就是对象的一些状态信息。包括对象的 HashCode，锁状态，GC分代年龄等等。

一流程序员与二流程序员的分水岭：JVM虚拟机-全面理解

Mon, 22 Sep 2025 10:27:14 +0800

秉承一个信念，要学遍学底层逻辑。那是一通百通的底气。

一、学不学JVM 是自主解决问题的一流程序员与跟着别人做CRUD的二流程序员的分水岭。只有深入了解透彻jvm的工作过程及原理，才能对自己开发出高性能的代码充满信心。

二、JVM虚拟机的本质：将class文件转换成操作系统具体的指令。

一个java文件从编写到执行的过程：通过javac将java文件编译成一个class文件交给虚拟机,虚拟机的工作过程如图：

1首先就是将classFile文件通过类加载（ClassLoader也就是个类）加载到jvm虚拟机的内存中。就是将类加载到就是方法区（元数据区）

2然后交给执行引擎，将类中指令解析出来执行，执行过程中会将类创建对象。

3再将对象创建到堆当中。

那要执行某个东西需要一个逻辑就是线程。因为只有线程是执行程序的唯一单元。在jvm内部，会对每一个线程分配一个虚拟机栈（左数第2列），它是一个先进后出的栈结构。在这个栈里面会记录当前线程运行的所需要的数据。

栈（线程）：存放局部变量。只要有一个线程运行主方法，jvm马上会在线程栈内一大块内存 给当前线程分配一小块独立的内存空间，用来放线程运行中 这些局部变量。（一个线程内有多个方法）

虚拟机栈（线程私有）核心包括：

    栈帧（会为每个方法创建一个专属的内存空间，也就是创建一个栈帧，它把一个线程内的不同的方法内存给隔离开来），栈帧又包含：

 局部变量表：存放每个方法里的局部变量

         操作数栈：就是我们的操作数，在程序运行过程中它要做操作的临时的中转 存放的内存空间。

局部变量表和操作数栈，这两个是执行java文件最基础的数据结构，记录我要执行这个方法需要多少的内存。局部变量对应的操作数。

         动态链接库：是指向方法区的哪个方法

（动态链接是：把符号引用 （常量池的符号）转为 直接引用 （直接地址）。这些符号，程序加载的时候不会解析，main方法会解析，但方法  是在程序运行的时候 需要找到这些符号的代码       （把这些符号转换成代码的直接内存地址）  解析的。这就是调动态链接。）

          返回地址（方法出口）：执行完返回到哪里

（方法出口：方法执行完，要回到哪个地方去。比如：main()里的，Math math = new Math（）;一般来说new一个对象是放在堆里面，那main()的局部变量表是 有个math的，这个math存的是给他分配的对象在堆里面内存地址。）

附加信息：jvm自己实现时附带的信息。

每一个线程中都有一个程序计数器：记录当前线程运行到哪一步了。

执行引擎：具体执行过程中，后很多执行方式，包括：解释执行、编译执行。编译执行又分为C1和C2（默认）两种。

类在元数据区，对象在堆区。

栈和堆的关系：栈里面有很多的局部变量， 栈里面放的都是这些对象在堆里面的内存地址。

方法区和堆的关系：我方法区如果有很多静态变量，其中有些静态变量是对象，放的是堆里面的内存地址。

栈、本地方法栈、程序计数器，是每个线程独有的。

堆和方法区是所有的线程共享的内存区域。

堆：分为年轻代、老年代。对象一般会放在eden区。

假设有一个web7*24小时运行，当堆里eden区对象放满的时候，会触发垃圾收集gc（minor gc ）：就是把无用的对象回收一下。找到非垃圾对象，放到survior区，剩下的干掉。如果一个对象经历过一次gc之后，分代年龄会加1.当分代年龄加到15，会被挪到老年代。

如果老年代放满了，它会触发full gc，它回收的是整个堆以及方法区。那如果有些老年堆里的对象被gc root引入了，回收不了，那就没有新的空间放新的对象，这时会触发OOM.在整个gc的过程中，可能会触发一个 STW机制（stop the word），停止用户线程。STW就是在gc时，会停掉用户的所有线程。用户会感到卡顿了一下，那SWT会对网站的性能有一定的影响的。

什么样的对象最终会别挪到老年代？静态变量对象、缓存对象、spring容器内的对象。

JVM的主要目的就是减少full gc，或者是减少full gc 的时间。因为在full gc的时候收集堆的时间比较长，所以它STW的时间相对也比较长。当然也要减少minor gc的次数。

二、Class 文件规范

1、Class文件结构

实际上，我们需要了解的是，Java 官方实际上只定义了JVM的一种执行规范，也就是class文件的组织规范。理论上，只要你能够写出一个符合标准的class文件，就可以丢到 JVM 中执行。至于这个class文件是怎么来的，JVM 虚拟机是不管的。这也是 JVM 支持多语言的基础。

这个规范到底是什么样子呢？当然，你可以直接去看 Oracle 的官方文档。JDK8 的文档地址：https://docs.oracle.com/javase/specs/jvms/se8/html/index.html 。后面也会有文章详细分析每一个字节。这里，我们只抽取主体内容。

比如，对于一个ByteCodeInterView.class文件，可以用 UltraEdit 工具打开一个class文件，看到的内容部分是这样的：

中间这一部分就是他的二进制内容。当然这是十六进制的表达。空格隔开的部分代表了 8 个bit，而每一位代表的是 4 个 bit字节，也就是一个十六进制的数字。例如 第一个字母 C 就表示十六进制的 12，二进制是 1100。而所有的class文件，都必须以十六进制的 CAFEBABE 开头，这就是 JVM 规范的一部分。这也解释了 Java 这个词的由来，到底是一种咖啡，还是爪哇岛。

Spring6及springboot3已经用到jdk17了，但是我们jdk8 是跑不起来spring6的。

后面的部分就比较复杂了，没法直接看。可以用 javap指令可以直接来看一些class文件。比如：

还是不容易查看或看懂，可以安装并使用插件：jclasslib Bytecode viewer图形化查看：

可以看到jvm的字节码，以及整个的执行过程：

再就是LineNumbertable这里，说明第10行代码执行的 0到6的指令。

SpringBoot快速连接Redis

Fri, 12 Sep 2025 09:54:22 +0800

1、添加Maven依赖：

<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

2核心配置：配置application.yml文件

spring:
  data:
   redis:
    host: 192.168.65.214
    port: 6379
    password: 12345
    .....

当引入maven，并配置好文件后，SpringBoot框架会默认在IOC文件里注入一个RedisTemplate的实现类。

记住一个对象：

@Resource

private RedisTemplateredisTemplate;

按组操作：（使用方式几乎与客户端一一对应）

redisTemplate.opsForValue().xxx       //string类型

redisTemplate.opsForSet().xxx          //set类型

redisTemplate.opsForHash().xxx       //hash类型

redisTemplate.opsForList().xxx         //list类型

redisTemplate.opsForZset().xxx       //Zset类型

redisTemplate.opsForGeo().xxx       //Geo类型

redisTemplate.opsForHyperLogLog().xxx      //hyperLogLog类型

redisTemplate.opsForStream().xxx      //stream类型

redisTemplate.opsForValue().setBit()      //bitmap类型

为什么bit没有一个单独的操作类型？bitmap类型 被合并到了redisTemplate的String类型当中

RedisTemplate中文乱码问题

增加一个配置类：

@Configuration
@EnableCaching
public class RedisConfig {
@Bean
public RedisTemplateredisTemplate(RedisConnectionFactory redisConnectionFactory){
RedisTemplateredisTemplate = new RedisTemplate<>();
redisTemplate.setConnectionFactory(redisConnectionFactory);
// GenericJackson2JsonRedisSerializer jsonSerializer = new GenericJackson2JsonRedisSerializer();
StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
GenericToStringSerializergenericToStringSerializer = new
GenericToStringSerializer<>(String.class);
//指定key和value的序列化方式
redisTemplate.setKeySerializer(stringRedisSerializer);
redisTemplate.setValueSerializer(genericToStringSerializer);
redisTemplate.setHashKeySerializer(stringRedisSerializer);
redisTemplate.setHashValueSerializer(stringRedisSerializer);
redisTemplate.afterPropertiesSet();
return redisTemplate;
}
}

测试：

redis的核心基础数据结构

Mon, 08 Sep 2025 11:01:59 +0800

Redis核心数据类型包括：String（字符串）、Hash（哈希）、List（列表）、Set（集合）、Zset（有序集合）、Bitmaps（位图）、HyperLogLog（基数统计）、Geospatial（地理空间）以及Stream（流）。

redis客户端指令（永远的神）：help (比如help @string)

help命令可返回 Redis 命令列表

Redis 常用的数据类型包括：

1.String（字符串）：    key——value（String）

a.最基本的数据类型，可以存储文本、数字等。

b.用于缓存、计数器等场景。

String常见应用场景

单值缓存：set key value（用户点赞数） Append key value

对象缓存：1、set user:1 {“name”：“roy”，“balance”：888} （比如：用户管理，登录信息）
分布式锁（防止并发冲突）：
SETNX product:10001 true //返回1代表获取锁成功//返回0代表获取锁失败（SETNX当key不存在时value才会设置成功。也就是第一次设置返回1，如果key已经存在了，不会设置成功，返回0）

释放锁：DEL product:10001（比如说处理完了这个订单，释放锁。但是如果服务挂了，锁入如果释放不了，就会造成阻塞。使用TTL product:10001——如果是-1说明没有设置过期时间）
设置过期时间:EXPIRE product:10001 10（10秒过期，自动释放锁）
SET product:10001 true ex 10 nx //防止程序意外终止导致死锁

2.Hash（哈希）：（help @hash）

a.类似于一个键值对集合，适合存储对象。

b.用于存储用户信息等结构化数据。

应用场景：

1对象缓存

HSET user:1 name roy balance 1888

hget user:name ——roy

HMGET user:1 name balance —— roy 1888

3.List（列表）：

a.有序的字符串列表，可以从两端推入或弹出元素。

b.用于消息队列、任务列表等。

常用数据结构

Stack(栈)=LPUSH +LPOP （栈：先进后出，后进先出）
Queue(队列)= LPUSH + RPOP （队列：先进先出，后进后出）
Blocking MQ(阻塞队列)=LPUSH+ BRPOP

常见应用场景

视频列表、签到列表
排队机（比如：吃饭排队）
简化版的MQ

4.Set（集合）：

a.无序的字符串集合，支持集合运算（如交集、并集、差集）。

b.用于标签、唯一性检查等。

Set常用操作

SADD key member [member ... //往集合key中存入元素，元素存在则忽略若key不存在则新建
SREM key member [member ... ///1从集合key中删除元素
SMEMBERS key //获取集合key中所有元素
SCARD key ////获取集合key的元素个数
SISMEMBER key member //判断member元素是否存在于集合key中
SRANDMEMBER key [count //从集合key中选出count个元素，元素不从key中删除
SPOP key [count] //从集合key中选出count个元素，元素从key中删除

Set运算操作

SINTER key 「key ... //交集运算
SINTERSTORE destination key [key ..] //将交集结果存入新集合destination中
SUNION key 「key .. //并集运算
SUNIONSTORE destination key [key ... //将并集结果存入新集合destination中
SDlFF key 「key ... //差集运算
SDIFFSTORE destination key [key ... //将差集结果存入新集合destination中

Set应用场景

微信抽奖小程序

1)点击参与抽奖加入集合 SADD key fuserlD}
2)查看参与抽奖所有用户 SMEMBERS key
3)抽取count名中奖者 SRANDMEMBER key [count] （可以重复中奖）/ SPOP key [count]（不能重复中奖）

• 微信微博点赞，收藏，标签

1) 点赞（key为消息：id，value 点赞数）

SADD like:{消息ID} {用户ID}

2) 取消点赞

SREM like:{消息ID} {用户ID}

3) 检查用户是否点过赞

SISMEMBER like:{消息ID} {用户ID}

4) 获取点赞的用户列表

SMEMBERS like:{消息ID}

5) 获取点赞用户数

SCARD like:{消息ID}

• 集合操作

SINTER set1 set2 set3  { c } 共同关注的人

SUNION set1 set2 set3  { a,b,c,d,e } 朋友圈的人

SDIFF set1 set2 set3  { a } 推荐好友

5.Zset（有序集合）：

Zset 的底层数据结构

Zset（有序集合）的底层实现是通过跳表（Skip List）和哈希表（Hash Table）的结合：

●跳表（Skip List）：

○用于按分数排序元素，支持快速的范围查询和排序操作。

○跳表是一种平衡数据结构，能够在 O(log N) 时间复杂度内完成插入、删除和查找操作。

●哈希表：

○用于快速查找元素的分数。

○哈希表提供了 O(1) 的查找时间复杂度。

通过结合跳表和哈希表，Redis 的 Zset 能够高效地支持按分数排序的操作，同时也能快速查找和更新元素的分数。

a.类似于 Set，但每个元素关联一个分数，元素按分数排序。

b.用于排行榜、优先队列等。

ZSet有序列表类型

•  ZSet常用操作

ZADD key score member [[score member]…] //往有序集合key中加入带分值元素

ZREM key member [member …] //从有序集合key中删除元素

ZSCORE key member //返回有序集合key中元素member的分值

ZINCRBY key increment member //为有序集合key中元素member的分值加上increment

ZCARD key //返回有序集合key中元素个数

ZRANGE key start stop [WITHSCORES] //正序获取有序集合key从start下标到stop下标的元素

ZREVRANGE key start stop [WITHSCORES] //倒序获取有序集合key从start下标到stop下标的元素

• Zset集合操作

ZUNIONSTORE destkey numkeys key [key ...] //并集计算

ZINTERSTORE destkey numkeys key [key …] //交集计算

ZSet应用场景

• Zset集合操作实现排行榜

1）点击新闻

ZINCRBY hotNews:20190819 1 守护香港

2）展示当日排行前十

ZREVRANGE hotNews:20190819 0 9 WITHSCORES

3）七日搜索榜单计算

ZUNIONSTORE hotNews:20190813-20190819 7

hotNews:20190813 hotNews:20190814... hotNews:20190819

4）展示七日排行前十

ZREVRANGE hotNews:20190813-20190819 0 9 WITHSCORES

6.Bitmap（位图）：二进制

a.用于操作位数组，适合存储大量布尔值。

b.用于用户签到、状态标记等。

 Bitmap常用操作

SETBIT key offset value //将一个二进制数组的offset位置设置成value。value只能是0或者1。

GETBIT key offset //返回一个二进制数组的offset位置的值。

BITCOUNT key [start end [BYTE|BIT]] //返回二进制数组中1的个数

BITPOS key bit [start [end [BYTE|BIT]]] //返回bitmap中第一个值为bit的offset位置。

BITOP AND|OR|XOR|NOT destkey key [key ...] //对两个bitmap做二进制的与或非计算。

• 每日签到

SETBIT dailycheck:1 100 1 1号用户第100天完成了签到

BITCOUNT dailycheck:1 统计1号用户的签到次数

BITPOS dailycheck:1 统计1号用户第一天签到的时间

• 优点

快速、高效、节省空间

7.HyperLogLog：

a.用于基数统计，适合估算独立元素的数量（用于统计一个集合中不重复的元素个数。）。

b.用于统计 UV（独立访客数，比如ip）等。

• Hyperloglog常用操作

PFADD visitlog 192.168.65.111 192.168.65.112 192.168.65.111 //添加用户访问记录

PFCOUNT visitlog //统计不同的独立访客

• Hyperloglog其他操作

PFMERGE destkey [sourcekey [sourcekey ...]] //将多个hyperloglong数据整合成一条

8.Geo（地理位置）：

a.用于存储地理位置信息，支持地理位置计算。

b.用于位置服务、附近搜索等。

• 常用操作

GEOADD key [NX|XX] [CH] longitude latitude member [longitude latitude member ...] //添加一个或多个地点

GEOPOS key [member [member ...]] //返回地址的经纬度

GEODIST key member1 member2 [M|KM|FT|MI] //计算两个地点之间的距离

GEORADIUS key longitude latitude radius M|KM|FT|MI [WITHCOORD] [WITHDIST] [WITHHASH] [COUNT count

[ANY]] [ASC|DESC] [STORE key|STOREDIST key] //查询某个经纬度地址附近的地点

GEOSEARCH key FROMMEMBER member|FROMLONLAT longitude latitude BYRADIUS radius

M|KM|FT|MI|BYBOX width height M|KM|FT|MI [ASC|DESC] [COUNT count [ANY]] [WITHCOORD]

[WITHDIST] [WITHHASH] //查询某个地点附近的地点

Geo应用场景

获取经纬度

https://api.map.baidu.com/lbsapi/getpoint/index.html • 添加商家地址

GEOADD changsha 113.017489 28.200454 火车站

112.96903 28.201195 橘子洲 113.017031 28.199706 赛格广

场 113.017004 28.197677 国储

• 查询距离

GEODIST changsha 火车站 橘子洲 M

• 查找火车站附近的景点

GEORADIUSBYMEMBER changsha 火车站 2 KM withdist

withcoord count 4 withhash

9stream类型

• 作用介绍：

Redis版的MQ -- 阻塞队列 + pub/sub

了解即可，企业应用比较少。

• 常用操作

XADD key [NOMKSTREAM] [MAXLEN|MINID [=|~] threshold [LIMIT count]] *|id field value [field value ...]

//往对列的末尾发布一条消息

XDEL key id [id ...] // 删除队列中的一条消息

XLEN key //获取队列的长度

XRANGE key start end [COUNT count] //查询队列中的消息

stream应用示例

• 创建队列，并添加消息 *表示让系统自动生成ID

XADD mystream * name loulan name roy name admin

• 查看对列消息 - 对列开始 + 对列结尾

XRANGE mystream - +

• 创建消费者组 0 从队列头部开始消费。 $ 从队列尾部开始消费

XGROUP CREATE mystream groupA 0

• 消费消息 > 表示从第一条未被消费过的消息消费。也可以指定ID

XREADGROUP GROUP groupA consumer1 count 2 STREAMS mystream >

• 查看消费者组的消费进度

XPENDING mystream groupA

Linux系统集群部署：(Cluster)

Fri, 05 Sep 2025 14:59:07 +0800

redis集群部署也是实现redis故障转移的方案之一，也就是高可用性（支持主从复制和节点的自动故障转移）。还有另一个作用就是：数据分区（集群将数据分散到多个节点，⼀⽅⾯突破了Redis单机内存⼤⼩的限制，存储容量⼤⼤增加。另⼀⽅⾯每个主节点都可以对外提供读服务和写服务，大大提高了集群的响应能力）。主从部署及哨兵部署等，每个节点都包含了完整的主数据，并不是真正的分布式运行模式。

而Redis 集群是 Redis 的⼀种分布式运⾏模式，它通过分⽚（sharding）来提供数据的⾃动分区和管理，从⽽实现数据的⾼可⽤性和可扩展性。

在集群模式下，数据被分割成多个部分（称为槽或slots），分布在多个 Redis 节点上。

1. Redis集群的数据分⽚

Redis集群引⼊了哈希槽的概念 Redis集群有16384个哈希槽（编号0-16383） 集群的每个节点负责⼀部分哈希槽， 每个Key通过CRC16校验后对16384取余来决定放置哪个哈希槽，通过这个值，去找到对应的插槽所对应的节点，然后直接⾃动跳转到这个对应的节点上进⾏存取操作：

以3个节点组成的集群为例： 节点A包含0到5460号哈希槽 ，节点B包含5461到10922号哈希槽， 节点C包含10923到16383号哈希槽。

Redis集群的主从复制模型 集群中具有A、B、C三个节点，如果节点B失败了，整个集群就会因缺少5461-10922这个范围的槽⽽不可以⽤。

为每个节点添加⼀个从节点A1、B1、C1整个集群便有三个Master节点和三个slave节点组成，在节点B失败后，集群选举B1为主节点继续服务。当B和B1都失败后，集群将不可⽤。

2. Reids 集群部署

Redis Cluster被配置为三主三从模式。这意味着每台服务器上的两个Redis节点中，⼀个节点作为主库（master），另⼀个作为从库（slave）。

基于主从架构的基础上，我们会在每一个机器上部署一个6380的redis服务，也就是每个机器上有2个redis服务。也就不能用redis.conf来启动服务了，因为一个redis.conf文件不能同时启用2个服务。

1.4.3.2. redis 集群配置准备

1首先创建一个cluster文件夹，这里面会存储两个redis服务的redis.conf配置，以及两个服务的日志。只不过是以端口区分。

2同时在redis下也创建一个cluster，存放的是两个redis服务的工作目录。也会按照端口进行区分。

3需要注意的是我们三台机器上的6379，6380的服务是完全一样的，只是ip端口不同。因此我们在配置一个机器的时候，另外两个机器的配置可以直接复制过去。先依次修改6379的文件，再依次修改6380的文件。

命令：

-- 创建集群配置文件夹，将下面的2行配置复制过去，另外两个机器重复这个过程
mkdir -p /opt/software/redis/redis-stable/cluster
mkdir -p /opt/software/redis/cluster
vim ./cluster/redis_6379.conf
vim ./cluster/redis_6380.conf
-- 配置⽂件准备完成之后，启动所有redis服务，⽤cluster配
置⽂件
redis-server ./cluster/redis_6379.conf
redis-server ./cluster/redis_6380.conf
-- 检查服务
ps aux | grep redis
-- 创建三主三从集群模式，每⼀个主节点带⼀个从节点
redis-cli --cluster create --cluster-replicas 1 192.168.75.129:6379 192.168.75.129:6380 192.168.75.131:6379 192.168.75.131:6380 192.168.75.132:6379 192.168.75.132:6380
-- 查看集群信息
redis-cli cluster info
-- 查看单个节点信息
redis-cli info replication
-- 查看集群节点身份信息
redis-cli cluster nodes
19-- 停⽌redis服务
redis-cli -p 6379 shutdown
redis-cli -p 6380 shutdown

6379配置 文件

# 允许所有的IP地址
bind * -::* 
# 后台运⾏
daemonize yes 
# 允许远程连接
protected-mode no 
# 开启集群模式
cluster-enabled yes
# 集群节点超时时间
cluster-node-timeout 5000
# 配置数据存储⽬录
dir "/opt/software/redis/cluster"
# 开启AOF持久化
appendonly yes
# 端⼝
port 6379 
# log⽇志
logfile "/opt/software/redis/redis-stable/cluste
r/redis6379.log" 
# 集群配置⽂件
cluster-config-file nodes-6379.conf
# AOF⽂件名
appendfilename "appendonly6379.aof" 
# RBD⽂件名
dbfilename "dump6379.rdb"

6380配置 

# 允许所有的IP地址
bind * -::* 
# 后台运⾏
daemonize yes 
# 允许远程连接
protected-mode no 
# 开启集群模式
cluster-enabled yes
# 集群节点超时时间
cluster-node-timeout 5000
# 配置数据存储⽬录
dir "/opt/software/redis/cluster"
# 开启AOF持久化
appendonly yes
# 端⼝
port 6380
# log⽇志
logfile "/opt/software/redis/redis-stable/cluste
r/redis6380.log" 
# 集群配置⽂件
cluster-config-file nodes-6380.conf
# AOF⽂件名
appendfilename "appendonly6380.aof" 
# RBD⽂件名
dbfilename "dump6380.rdb"

启动6379的服务后，查看下进程：ps aux|grep redis 。这时我们的三台机器上都分别运行了2个cluster服务。

然后使用命令创建集群：注意改成自己的ip及端口。这个命令只需要在一台机器上执行就可以。也就是在129，7号机上执行的。

-- 创建三主三从集群模式，每⼀个主节点带⼀个从节点
redis-cli --cluster create --cluster-replicas 1 192.168.75.129:6379 192.168.75.129:6380 192.168.75.131:6379 192.168.75.131:6380 192.168.75.132:6379 192.168.75.132:6380

回复yes。

然后查看集群信息：

redis-cli cluster inf

也可以查看

-- 查看单个节点信息
redis-cli info replication

可以看到6379的这个节点的端口是master的角色，因为我们没有指明端口的情况下，他默认的就是6379.它的从节点是131的6380

此外，我们还可以：查看节点的配置

-- 查看集群节点身份信息
redis-cli cluster node

可以看到3个master节点，以及分别对应的槽位。也可以根据编号查看对应的从节点。已经搭建完成。

模拟故障转移：

比如129的主节点6379如果故障，那么它的从节点131的6380应该晋升为主节点。

将129的6379的服务干掉：redis-cli shutdown

然后直接查看131的6380角色：redis-cli -p 6380 info replication

将129的6379的服务恢复后，它也有了自己的小弟：

Linux安装redis-哨兵模式部署

Tue, 02 Sep 2025 11:25:24 +0800

哨兵部署：在master节点出现故障后，哨兵进程会自动将master下线，自动将子节点提升为主节点。完成故障转移，实现高可用性。

这个架构图里面，我们部署了3个哨兵节点组成了一个哨兵集群。它们在启动的时候会进行哨兵选举，选举出一个领导者，在出现故障转移的时候，由领导者进行主导，而触发故障转移需要大部分的哨兵节点都认为主节点发生了故障。这个状态我们称为客观下线。与之对应的是主观下线：也就是单个哨兵发现主节点出现故障，会去询问其他的节点，确认当前主节点是否已经出现故障，当其他哨兵确认主节点出现了故障，并且数量超过了大多数。这时就会从主观下线转为客观下线，一旦确认客观下线就会触发故障转移。由领导者主导，将主节点进行下线操作。然后在从节点里选一个晋升为主机点。然后告知客户端，新的主节点在什么位置，实现无缝切换。旧的主节点恢复后会重新加入到整个集群中，只是角色变成了从节点。

3.1. 哨兵模式部署

整体架构：这个结构是基于主从部署的基础上，新增你了3个哨兵节点，每个哨兵节点都是监控同一个主节点129的状态.

3 个机器都需要修改 sentinel.conf 配置（vim sentinel.conf），配置完成之后先从主节点开始启动哨兵。

protected-mode no #6⾏，关闭保护模式
daemonize yes  #15⾏，指定sentinel为后台启动
logfile /opt/software/redis/redis-stable/sentinel.log #34⾏，指定⽇志存放路径
dir /opt/software/redis #73⾏，指定数据库存放路径
sentinel monitor mymaster 192.168.75.129 6379 2#93⾏，修改 指定该哨兵节点监控20.0.0.20:6379这个主节点，该主节点的名称是mymaster，最后的2的含义与主节点的故障判定有关：⾄少需要2个哨兵节点同意，才能判定主节点故障并进⾏故障转移
sentinel down-after-milliseconds mymaster 30000 #134⾏，判定服务器down掉的时间周期，默认30000毫秒（30秒）
sentinel failover-timeout mymaster 180000 #234⾏，故障节点的最⼤超时时间为180000（180秒）

将三个服务都启动redis-server redis.conf后，可以用redis-cli info replication查看下当前主从架构的状态。

操作
然后启动哨兵(主节点操作)：redis-sentinel sentinel.conf
查看哨兵(主节点操作): redis-cli -p 26379 info sentinel

测试：将129主节点下线：redis-cli shutdown，然后查看当前的sentinel.log日志： cat sentinel.log。

节点查看状态：redis-cli info replication。发现131的节点已变成了主节点。