摘要
在现代互联网应用中，消息推送是用户触达的核心手段。从站内信、短信、邮件到APP推送、实时通知，企业需要一个统一的消息中心来管理多种推送渠道。本文基于神话B2C电商平台的实践经验，详细阐述了企业级消息中心的架构设计、技术选型、核心功能实现以及高可用保障方案，重点介绍了多渠道适配、实时推送（WebSocket/SSE）、消息队列集成等关键技术，为构建统一消息平台提供参考。
目录
一、为什么需要消息中心？
1.1 传统推送方式的痛点
在微服务架构流行之前，各业务系统独立实现消息推送功能，这种"烟囱式"架构带来了诸多问题：
问题1：重复建设，资源浪费
订单服务 → 自己实现短信推送
营销服务 → 自己实现短信推送
支付服务 → 自己实现短信推送
...每个服务都要：
- 对接短信服务商API
- 维护API密钥和配置
- 处理发送失败重试
- 记录发送日志
问题2：多渠道割裂，无法统一管理
同一个业务事件（如订单支付成功），需要推送到多个渠道：
- 站内信通知
- 短信通知
- APP推送
- 邮件账单
但这些渠道分散在不同系统，无法统一配置、统计和监控。
问题3：缺乏灵活性
- 模板硬编码在代码中，修改需要发版
- 无法动态调整推送策略（如渠道降级）
- 难以支持A/B测试
问题4：成本管控困难
- 无法统计各业务的推送量
- 难以设置配额和限流
- 费用分摊不清晰
1.2 消息中心的核心价值
统一消息中心作为基础设施层的核心服务，解决了上述所有问题：
推送渠道
消息中心
业务服务层
订单服务
营销服务
支付服务
用户服务
统一API
渠道管理
模板管理
推送引擎
站内信
短信
邮件
APP推送
WebSocket
SSE
核心优势：
- 统一接入：业务方只需调用一个API
- 多渠道支持：9种渠道（站内信、短信、邮件、APP推送、WebSocket、SSE、企业微信、钉钉、小程序）
- 灵活配置：模板化管理，无需发版
- 成本可控：统一限流、配额管理
- 数据可视：统一统计、监控、报表
1.3 适用场景
消息中心适用于以下场景：
| 场景分类 | 具体场景 | 推荐渠道 |
|---|---|---|
| 交易通知 | 订单确认、支付成功、发货通知 | 站内信 + 短信 + APP推送 |
| 营销活动 | 优惠券发放、限时抢购、会员权益 | 站内信 + APP推送 + 小程序 |
| 系统通知 | 账号安全、服务变更、系统维护 | 站内信 + 邮件 |
| 实时协作 | 在线客服、工单处理、协同编辑 | WebSocket + 站内信 |
| 企业内部 | 审批通知、任务提醒、OA消息 | 企业微信 + 钉钉 |
| 验证码 | 登录验证、支付验证、绑定手机 | 短信 |
二、消息中心核心概念
2.1 消息的生命周期
一条消息从创建到送达，经历完整的生命周期：
创建消息
开始推送
所有渠道成功
部分渠道成功
所有渠道失败
重试失败渠道
重试
超过重试次数
用户查看（站内信）
待发送
发送中
发送成功
部分成功
发送失败
已过期
已读
状态说明：
- 待发送（PENDING）：消息已创建，等待推送
- 发送中（SENDING）：正在向各渠道推送
- 发送成功（SUCCESS）：所有渠道推送成功
- 部分成功（PARTIAL_SUCCESS）：部分渠道成功，部分失败
- 发送失败（FAILED）：所有渠道推送失败
- 已过期（EXPIRED）：超过有效期或重试次数上限
2.2 消息的组成要素
一条完整的消息包含以下要素：
yaml
消息ID: msg_202601071200001
模板编码: ORDER_PAID_SUCCESS
消息类型: TRANSACTIONAL # 交易类/营销类/通知类
业务类型: ORDER # 订单/营销/用户/系统
接收用户: [userId: 10001]
推送渠道: [IN_APP, SMS, PUSH] # 多渠道组合
变量数据:
orderNo: SO202601071200001
amount: 299.00
productName: 商品名称
优先级: HIGH # 高/中/低
过期时间: 2026-01-08 12:00:002.3 渠道的分类
消息中心支持9种推送渠道，可分为以下几类：
按实时性分类：
| 实时性 | 渠道 | 延迟 | 适用场景 |
|---|---|---|---|
| 实时 | WebSocket、SSE | < 1秒 | 在线客服、协作编辑 |
| 准实时 | APP推送 | 1-5秒 | 重要通知、营销活动 |
| 异步 | 短信、邮件、站内信 | 5-30秒 | 交易通知、系统通知 |
按触达率分类：
| 触达率 | 渠道 | 说明 |
|---|---|---|
| 高 | 短信 | 99%以上，但成本高 |
| 中 | APP推送、站内信 | 依赖用户在线/打开APP |
| 低 | 邮件 | 可能进垃圾箱 |
按成本分类：
| 成本 | 渠道 | 价格 |
|---|---|---|
| 高 | 短信 | 0.03-0.05元/条 |
| 中 | APP推送 | 按量计费，约0.001元/条 |
| 低 | 站内信、WebSocket、SSE | 仅服务器成本 |
2.4 模板的作用
模板是消息内容的蓝图，实现了内容与代码的解耦：
传统方式（硬编码）：
java
// ❌ 修改内容需要发版
String smsContent = "您的订单" + orderNo + "已支付成功，金额" + amount + "元";模板方式：
java
// ✅ 模板可在管理后台动态修改
模板定义:
短信模板: "您的订单${orderNo}已支付成功，金额${amount}元"
变量定义: [
{name: "orderNo", type: "String", required: true},
{name: "amount", type: "BigDecimal", required: true}
]
代码调用:
messageClient.send("ORDER_PAID_SUCCESS", userId,
Map.of("orderNo", "SO123", "amount", 299.00)
);模板的优势：
- 内容修改无需发版
- 多渠道内容统一管理
- 支持变量校验和类型转换
- 支持审核流程
三、业界主流方案对比
在设计消息中心之前，我们调研了业界主流的消息推送平台。
3.1 友盟消息推送（第三方SaaS）
定位：移动APP推送服务
核心特性：
- ✅ 专注于APP推送（iOS、Android）
- ✅ 开发者友好，SDK集成简单
- ✅ 支持标签、别名、地理位置推送
- ✅ 提供推送统计和分析
局限性：
- ❌ 仅支持APP推送，不支持站内信、短信等
- ❌ SaaS服务，数据在第三方
- ❌ 无法定制化开发
适用场景：小型APP，无自建需求
3.2 极光推送（第三方SaaS）
定位：移动开发者服务平台
核心特性：
- ✅ APP推送、短信、即时通讯全覆盖
- ✅ 稳定性好，支持千万级并发
- ✅ 提供VIP专线通道（付费）
- ✅ 支持富媒体推送（图片、音频）
局限性：
- ❌ 费用较高（按推送量计费）
- ❌ 数据无法自主管控
- ❌ 无法与企业内部系统深度集成
适用场景：中大型APP，预算充足
3.3 阿里云消息服务（云服务）
定位：企业级消息队列与推送服务
核心特性：
- ✅ 提供消息队列（RocketMQ）+ 移动推送
- ✅ 与阿里云生态深度集成
- ✅ 支持高并发、高可用
- ✅ 按量付费，成本可控
局限性：
- ❌ 需要组合多个云产品
- ❌ 学习成本高
- ❌ 锁定云厂商
适用场景：已采用阿里云的企业
3.4 自建消息中心（自研）
定位：企业内部统一消息平台
核心特性：
- ✅ 完全自主可控
- ✅ 深度定制，满足特殊需求
- ✅ 数据安全，符合合规要求
- ✅ 支持所有渠道（9种）
- ✅ 与企业系统无缝集成
局限性：
- ⚠️ 开发成本高
- ⚠️ 需要专业团队维护
适用场景：大中型企业，有技术团队
3.5 方案对比总结
| 维度 | 友盟/极光 | 阿里云 | 自建（神话） |
|---|---|---|---|
| 渠道数量 | 1-2种 | 2-3种 | 9种 ✅ |
| 数据安全 | 第三方 | 云端 | 自主 ✅ |
| 定制能力 | 弱 | 中 | 强 ✅ |
| 成本 | 高 | 中 | 低（长期） ✅ |
| 技术门槛 | 低 | 中 | 高 |
| 维护成本 | 低 | 低 | 中 |
神话消息中心的选择理由：
- 业务需求：需要支持9种渠道，第三方无法满足
- 数据安全：金融级安全要求，必须自主可控
- 技术积累：有成熟的微服务团队
- 长期成本：自建后边际成本低
四、整体架构设计
4.1 分层架构
神话消息中心采用经典的四层架构：
┌─────────────────────────────────────────────────┐
│ 前端展现层（管理后台） │
│ • 渠道管理 • 模板管理 • 推送记录 • 数据统计 │
└────────────────────┬────────────────────────────┘
│ HTTPS
┌────────────────────┴────────────────────────────┐
│ 接口层（API网关） │
│ • 路由转发 • 鉴权认证 • 限流熔断 • 日志监控 │
└────────────────────┬────────────────────────────┘
│
┌────────────────────┴────────────────────────────┐
│ 业务服务层 │
│ ┌─────────────┐ ┌─────────────┐ │
│ │ 管理服务 │ │ 发送服务 │ │
│ │ • 渠道配置 │ │ • 消息分发 │ │
│ │ • 模板管理 │ │ • 渠道路由 │ │
│ │ • 用户群 │ │ • 发送执行 │ │
│ └─────────────┘ └─────────────┘ │
│ ┌─────────────┐ ┌─────────────┐ │
│ │ 推送服务 │ │ 统计服务 │ │
│ │ • WebSocket │ │ • 实时统计 │ │
│ │ • SSE推送 │ │ • 数据分析 │ │
│ └─────────────┘ └─────────────┘ │
└────────────────────┬────────────────────────────┘
│
┌────────────────────┴────────────────────────────┐
│ 数据存储层 │
│ • MySQL（消息、模板、配置） │
│ • Redis（连接管理、缓存、Pub/Sub） │
│ • RocketMQ（消息队列、异步处理） │
└─────────────────────────────────────────────────┘各层职责：
- 前端展现层：Vue3 + TypeScript，运营人员可视化管理
- 接口层：Spring Cloud Gateway，统一入口
- 业务服务层：核心业务逻辑，微服务拆分
- 数据存储层：数据持久化和缓存
4.2 核心服务模块
模块划分原则：高内聚、低耦合
| 模块 | 职责 | 技术栈 |
|---|---|---|
| 渠道管理 | 渠道配置、测试、启停 | Spring Boot + MyBatis-Plus |
| 模板管理 | 模板CRUD、审核、版本控制 | Spring Boot + Freemarker |
| 消息发送 | 消息创建、渠道路由、发送执行 | Spring Boot + RocketMQ |
| 推送服务 | WebSocket/SSE连接管理、实时推送 | Spring WebSocket/SSE |
| 用户群管理 | 用户分组、群体推送 | Spring Boot + MySQL |
| 统计分析 | 实时统计、数据分析、报表 | Spring Boot + Redis + ECharts |
4.3 技术选型
后端技术栈
| 技术 | 版本 | 用途 | 选型理由 |
|---|---|---|---|
| Java | 17+ | 开发语言 | 高性能、生态成熟 |
| Spring Boot | 3.3.0 | 微服务框架 | 开发效率高 |
| Spring Cloud | 2023.0.2 | 分布式解决方案 | 全家桶支持 |
| MyBatis-Plus | 3.5.6 | ORM框架 | 简化CRUD |
| MySQL | 8.4.0 | 关系型数据库 | 事务支持、成熟稳定 |
| Redis | Latest | 缓存+Pub/Sub | 高性能、支持多种数据结构 |
| RocketMQ | 5.x | 消息队列 | 支持定时消息、事务消息 |
| Redisson | 3.27.2 | 分布式锁 | 功能强大、易用 |
| MapStruct | Latest | 对象转换 | 编译时生成，性能好 |
前端技术栈
| 技术 | 版本 | 用途 |
|---|---|---|
| Vue | 3.4+ | 前端框架 |
| TypeScript | 5.x | 类型安全 |
| Element Plus | 2.5+ | UI组件库 |
| ECharts | 5.5+ | 数据可视化 |
| Pinia | 2.1+ | 状态管理 |
4.4 数据库设计
消息中心共有7张核心表：
| 表名 | 说明 | 核心字段 |
|---|---|---|
mc_channel_config |
渠道配置 | channel_type, provider, api_config, rate_limit |
mc_message_template |
消息模板 | template_code, message_type, content_*, variables |
mc_message_record |
消息主记录 | template_code, receiver_id, status, expire_time |
mc_message_send_detail |
发送明细 | record_id, channel_type, receiver, send_status |
mc_user_group |
用户群 | group_name, group_type, member_count |
mc_user_group_member |
用户群成员 | group_id, user_id |
mc_push_record |
推送记录 | group_id, total_count, success_count |
五、多渠道统一管理
5.1 渠道抽象设计
为了支持9种推送渠道并保持可扩展性，我们采用策略模式 + 工厂模式的组合：
核心接口定义：
java
/**
* 渠道提供者接口
* 所有渠道实现类必须实现此接口
*/
public interface ChannelProvider {
/**
* 获取渠道编码
* @return IN_APP, SMS, EMAIL, PUSH等
*/
String getChannelCode();
/**
* 发送消息
*/
ChannelSendResult send(ChannelSendRequest request);
/**
* 测试渠道配置
*/
ChannelTestResult test(ChannelTestRequest request);
}渠道工厂：
java
@Component
public class ChannelProviderFactory {
// Spring自动注入所有ChannelProvider实现
private final Map<String, ChannelProvider> providerMap;
@Autowired
public ChannelProviderFactory(List<ChannelProvider> providers) {
this.providerMap = providers.stream()
.collect(Collectors.toMap(
ChannelProvider::getChannelCode,
Function.identity()
));
}
public ChannelProvider getProvider(String channelCode) {
ChannelProvider provider = providerMap.get(channelCode);
if (provider == null) {
throw new BusinessException("不支持的渠道: " + channelCode);
}
return provider;
}
}5.2 支持的9种渠道
| 渠道类型 | 编码 | 服务商 | 使用场景 | 实现类 |
|---|---|---|---|---|
| 站内信 | IN_APP | 自建 | 所有通知 | InAppChannelProvider |
| 短信 | SMS | 阿里云 | 验证码、重要通知 | SmsChannelProvider |
| 邮件 | SMTP/阿里云 | 账单、报表 | EmailChannelProvider | |
| APP推送 | PUSH | 极光/个推 | 实时提醒 | PushChannelProvider |
| WebSocket | WEBSOCKET | 自建 | 在线客服、协作 | WebSocketChannelProvider |
| SSE | SSE | 自建 | Web实时通知 | SseChannelProvider |
| 企业微信 | WECHAT_WORK | 企业微信API | B端内部通知 | WechatWorkChannelProvider |
| 钉钉 | DINGTALK | 钉钉开放平台 | 企业通知 | DingtalkChannelProvider |
| 小程序 | MINI_PROGRAM | 微信开放平台 | 小程序订阅 | MiniProgramChannelProvider |
5.3 渠道配置管理
每个渠道有独立的配置，存储在 mc_channel_config 表：
java
@Data
@TableName("mc_channel_config")
public class ChannelConfig {
private Long id;
// 渠道信息
private String channelType; // 渠道类型（IN_APP/SMS/EMAIL等）
private String channelName; // 渠道名称
private String provider; // 服务商（ALIYUN/JIGUANG等）
// API配置（JSON格式，加密存储）
private String apiConfig; // {"apiKey": "xxx", "apiSecret": "yyy"}
// 限流配置
private Integer rateLimit; // 每小时限制条数
private Integer dailyLimit; // 每日限制条数
// 重试配置
private Integer maxRetry; // 最大重试次数
private Integer retryInterval; // 重试间隔（秒）
// 状态
private Integer status; // 1-启用 0-停用
private Integer priority; // 优先级（用于渠道降级）
}配置示例（短信渠道）：
json
{
"channelType": "SMS",
"channelName": "阿里云短信",
"provider": "ALIYUN",
"apiConfig": {
"accessKeyId": "LTAI5t***",
"accessKeySecret": "nE8K***",
"signName": "神话商城",
"regionId": "cn-hangzhou"
},
"rateLimit": 10000,
"dailyLimit": 100000,
"maxRetry": 3,
"retryInterval": 60,
"status": 1,
"priority": 1
}5.4 渠道实现示例
短信渠道实现：
java
@Component
public class SmsChannelProvider implements ChannelProvider {
private static final TraceLogger log = TraceLogger.getLogger(SmsChannelProvider.class);
@Autowired
private ChannelConfigRepository channelConfigRepository;
@Override
public String getChannelCode() {
return "SMS";
}
@Override
public ChannelSendResult send(ChannelSendRequest request) {
// 1. 加载渠道配置
ChannelConfig config = channelConfigRepository.findByChannelType("SMS");
if (config == null || config.getStatus() == 0) {
return ChannelSendResult.failed("短信渠道未配置或已停用");
}
// 2. 解析API配置
JSONObject apiConfig = JSON.parseObject(config.getApiConfig());
String accessKeyId = apiConfig.getString("accessKeyId");
String accessKeySecret = apiConfig.getString("accessKeySecret");
String signName = apiConfig.getString("signName");
// 3. 调用阿里云短信API
try {
IAcsClient client = new DefaultAcsClient(
DefaultProfile.getProfile("cn-hangzhou", accessKeyId, accessKeySecret)
);
SendSmsRequest smsRequest = new SendSmsRequest();
smsRequest.setPhoneNumbers(request.getReceiver());
smsRequest.setSignName(signName);
smsRequest.setTemplateCode(request.getTemplateCode());
smsRequest.setTemplateParam(JSON.toJSONString(request.getVariables()));
SendSmsResponse response = client.getAcsResponse(smsRequest);
if ("OK".equals(response.getCode())) {
log.info("短信发送成功, phone={}, bizId={}",
request.getReceiver(), response.getBizId());
return ChannelSendResult.success(response.getBizId());
} else {
log.error("短信发送失败, code={}, message={}",
response.getCode(), response.getMessage());
return ChannelSendResult.failed(response.getMessage());
}
} catch (Exception e) {
log.error("短信发送异常", e);
return ChannelSendResult.failed("发送异常: " + e.getMessage());
}
}
@Override
public ChannelTestResult test(ChannelTestRequest request) {
// 测试短信配置是否正确
try {
JSONObject apiConfig = JSON.parseObject(request.getApiConfig());
// 发送测试短信
ChannelSendRequest testRequest = new ChannelSendRequest();
testRequest.setReceiver(request.getTestReceiver());
testRequest.setContent("【测试】这是一条测试短信");
ChannelSendResult result = send(testRequest);
return result.isSuccess()
? ChannelTestResult.success("测试成功")
: ChannelTestResult.failed("测试失败: " + result.getMessage());
} catch (Exception e) {
return ChannelTestResult.failed("测试异常: " + e.getMessage());
}
}
}5.5 渠道路由策略
当一条消息需要发送到多个渠道时，消息中心支持多种路由策略：
策略1：全部发送
java
// 所有配置的渠道都发送
List<String> channels = Arrays.asList("IN_APP", "SMS", "PUSH");策略2：优先级降级
java
// 按优先级尝试，成功一个即停止
// 1. 尝试APP推送（成本低、实时）
// 2. 失败则发送短信（成本高、可靠）
if (!pushChannel.send(request).isSuccess()) {
smsChannel.send(request);
}策略3：A/B测试
java
// 随机50%用户发送新渠道
if (Math.random() < 0.5) {
newChannel.send(request);
} else {
oldChannel.send(request);
}5.6 渠道限流保护
为了避免短时间大量消息冲击第三方服务，消息中心实现了多级限流：
限流层级：
通过
拒绝
通过
拒绝
通过
拒绝
消息发送请求
全局限流
渠道限流
返回限流错误
用户限流
发送消息
实现方案（Redis + Lua）：
java
@Component
public class RateLimiter {
@Autowired
private RedisTemplate<String, String> redisTemplate;
/**
* 渠道级限流
* @param channelType 渠道类型
* @param limit 每小时限制数
* @return true-通过 false-拒绝
*/
public boolean tryAcquire(String channelType, int limit) {
String key = "rate:limit:channel:" + channelType;
Long count = redisTemplate.opsForValue().increment(key);
if (count == 1) {
// 首次访问，设置1小时过期
redisTemplate.expire(key, 1, TimeUnit.HOURS);
}
return count <= limit;
}
/**
* 用户级限流（防骚扰）
* @param userId 用户ID
* @param channelType 渠道类型
* @param limit 每天限制数
*/
public boolean tryAcquireUser(Long userId, String channelType, int limit) {
String key = "rate:limit:user:" + userId + ":" + channelType + ":"
+ LocalDate.now();
Long count = redisTemplate.opsForValue().increment(key);
if (count == 1) {
redisTemplate.expire(key, 1, TimeUnit.DAYS);
}
return count <= limit;
}
}六、实时推送技术实现
实时推送是消息中心的核心能力，支持WebSocket和SSE两种模式。
6.1 WebSocket vs SSE
| 维度 | WebSocket | SSE |
|---|---|---|
| 通信方式 | 全双工（双向） | 半双工（服务器→客户端） |
| 协议 | 独立协议（ws://） | HTTP协议 |
| 浏览器支持 | 现代浏览器 | 现代浏览器（除IE） |
| 自动重连 | 需手动实现 | 浏览器自动重连 |
| 传输格式 | 二进制/文本 | 文本（UTF-8） |
| 复杂度 | 中等 | 简单 |
| 适用场景 | 在线客服、游戏 | Web通知、实时数据 |
神话消息中心的选择：
- APP端：使用WebSocket（双向交互需求）
- Web端：使用SSE（单向推送，更简单）
6.2 WebSocket连接管理
连接生命周期：
业务服务 Redis WebSocket服务 客户端 业务服务 Redis WebSocket服务 客户端 loop [心跳保活] 1. 建立连接（携带token） 2. 验证token 3. 注册连接到本地Map 4. 记录连接信息（userId ->> nodeId） 5. 返回连接成功 心跳ping 心跳pong 6. 查询用户连接节点 7. 返回nodeId 8. 推送消息（如果是当前节点） 9. 发送消息 10. 关闭连接 11. 删除连接记录
连接管理器实现：
java
@Component
public class WebSocketConnectionManager {
private static final TraceLogger log =
TraceLogger.getLogger(WebSocketConnectionManager.class);
// 本地连接映射: userId -> WebSocketSession
private final ConcurrentHashMap<Long, WebSocketSession> localConnections =
new ConcurrentHashMap<>();
@Autowired
private RedisTemplate<String, String> redisTemplate;
@Autowired
private String nodeId; // 当前节点ID（从配置读取）
/**
* 注册WebSocket连接
*/
public void register(Long userId, WebSocketSession session) {
// 1. 存储到本地Map
localConnections.put(userId, session);
// 2. 记录到Redis（用于集群路由）
String key = "push:connection:ws:" + userId;
redisTemplate.opsForValue().set(key, nodeId, 2, TimeUnit.HOURS);
log.info("WebSocket连接已注册, userId={}, nodeId={}", userId, nodeId);
}
/**
* 移除连接
*/
public void unregister(Long userId) {
localConnections.remove(userId);
redisTemplate.delete("push:connection:ws:" + userId);
log.info("WebSocket连接已移除, userId={}", userId);
}
/**
* 推送消息给指定用户
*/
public boolean push(Long userId, String message) {
WebSocketSession session = localConnections.get(userId);
if (session == null || !session.isOpen()) {
log.warn("用户未连接或连接已关闭, userId={}", userId);
return false;
}
try {
session.sendMessage(new TextMessage(message));
log.info("消息推送成功, userId={}", userId);
return true;
} catch (IOException e) {
log.error("消息推送失败, userId=" + userId, e);
unregister(userId);
return false;
}
}
/**
* 查询用户连接所在节点
*/
public String findNodeId(Long userId) {
String key = "push:connection:ws:" + userId;
return redisTemplate.opsForValue().get(key);
}
/**
* 获取在线用户数
*/
public int getOnlineCount() {
return localConnections.size();
}
}WebSocket端点实现：
java
@Component
@ServerEndpoint(value = "/ws/message", configurator = SpringConfigurator.class)
public class MessageWebSocketEndpoint {
private static WebSocketConnectionManager connectionManager;
private static JwtTokenUtil jwtTokenUtil;
@Autowired
public void setConnectionManager(WebSocketConnectionManager manager) {
MessageWebSocketEndpoint.connectionManager = manager;
}
@Autowired
public void setJwtTokenUtil(JwtTokenUtil util) {
MessageWebSocketEndpoint.jwtTokenUtil = util;
}
private Long userId;
private Session session;
@OnOpen
public void onOpen(Session session, @PathParam("token") String token) {
this.session = session;
// 1. 验证token
try {
this.userId = jwtTokenUtil.getUserIdFromToken(token);
} catch (Exception e) {
log.error("Token验证失败", e);
try {
session.close(new CloseReason(CloseReason.CloseCodes.VIOLATED_POLICY, "认证失败"));
} catch (IOException ex) {
// ignore
}
return;
}
// 2. 注册连接
connectionManager.register(userId, session);
log.info("WebSocket连接建立, userId={}", userId);
}
@OnClose
public void onClose() {
if (userId != null) {
connectionManager.unregister(userId);
log.info("WebSocket连接关闭, userId={}", userId);
}
}
@OnError
public void onError(Throwable error) {
log.error("WebSocket错误, userId=" + userId, error);
if (userId != null) {
connectionManager.unregister(userId);
}
}
@OnMessage
public void onMessage(String message) {
// 处理客户端消息（如心跳pong）
if ("ping".equals(message)) {
try {
session.getBasicRemote().sendText("pong");
} catch (IOException e) {
log.error("心跳响应失败", e);
}
}
}
}6.3 SSE推送实现
SSE（Server-Sent Events）是HTML5标准，基于HTTP协议，更简单：
SSE控制器：
java
@RestController
@RequestMapping("/api/message/v1")
public class SseController {
@Autowired
private SseConnectionManager sseConnectionManager;
/**
* 建立SSE连接
*/
@GetMapping("/sse/subscribe")
public SseEmitter subscribe(@RequestParam String token) {
// 1. 验证token
Long userId = jwtTokenUtil.getUserIdFromToken(token);
// 2. 创建SseEmitter（超时2小时）
SseEmitter emitter = new SseEmitter(2 * 60 * 60 * 1000L);
// 3. 注册连接
sseConnectionManager.register(userId, emitter);
// 4. 设置回调
emitter.onCompletion(() -> sseConnectionManager.unregister(userId));
emitter.onTimeout(() -> sseConnectionManager.unregister(userId));
emitter.onError((e) -> sseConnectionManager.unregister(userId));
// 5. 发送欢迎消息
try {
emitter.send(SseEmitter.event()
.name("connected")
.data("连接成功"));
} catch (IOException e) {
log.error("发送欢迎消息失败", e);
}
return emitter;
}
}SSE连接管理器：
java
@Component
public class SseConnectionManager {
private final ConcurrentHashMap<Long, SseEmitter> localConnections =
new ConcurrentHashMap<>();
@Autowired
private RedisTemplate<String, String> redisTemplate;
@Autowired
private String nodeId;
public void register(Long userId, SseEmitter emitter) {
localConnections.put(userId, emitter);
redisTemplate.opsForValue().set("push:connection:sse:" + userId, nodeId, 2, TimeUnit.HOURS);
}
public void unregister(Long userId) {
localConnections.remove(userId);
redisTemplate.delete("push:connection:sse:" + userId);
}
public boolean push(Long userId, String eventName, Object data) {
SseEmitter emitter = localConnections.get(userId);
if (emitter == null) {
return false;
}
try {
emitter.send(SseEmitter.event()
.name(eventName)
.data(data));
return true;
} catch (IOException e) {
log.error("SSE推送失败, userId=" + userId, e);
unregister(userId);
return false;
}
}
}前端SSE接入：
javascript
// 建立SSE连接
const eventSource = new EventSource(`/api/message/v1/sse/subscribe?token=${token}`);
// 监听连接事件
eventSource.addEventListener('connected', (event) => {
console.log('连接成功:', event.data);
});
// 监听消息事件
eventSource.addEventListener('message', (event) => {
const message = JSON.parse(event.data);
console.log('收到消息:', message);
// 显示通知
showNotification(message);
});
// 错误处理
eventSource.onerror = (error) => {
console.error('SSE连接错误:', error);
// 浏览器会自动重连
};6.4 集群推送方案
在集群环境下，用户连接可能在不同节点，需要跨节点推送：
方案：Redis Pub/Sub
Redis
消息中心集群
业务服务
推送给用户B
查Redis：用户B在节点2
广播消息
推送
订单服务
节点1
用户A连接
节点2
用户B连接
节点3
用户C连接
Pub/Sub
用户B
实现代码：
java
@Component
public class ClusterPushService {
@Autowired
private WebSocketConnectionManager wsManager;
@Autowired
private SseConnectionManager sseManager;
@Autowired
private RedisTemplate<String, String> redisTemplate;
@Autowired
private String nodeId;
/**
* 推送消息给指定用户（支持集群）
*/
public void pushToUser(Long userId, String message, String channelType) {
// 1. 查询用户连接所在节点
String key = "push:connection:" + channelType.toLowerCase() + ":" + userId;
String targetNodeId = redisTemplate.opsForValue().get(key);
if (targetNodeId == null) {
log.warn("用户未在线, userId={}", userId);
return;
}
// 2. 如果在当前节点，直接推送
if (nodeId.equals(targetNodeId)) {
boolean success = "WEBSOCKET".equals(channelType)
? wsManager.push(userId, message)
: sseManager.push(userId, "message", message);
log.info("本地推送{}, userId={}, success={}", channelType, userId, success);
return;
}
// 3. 如果在其他节点，通过Redis Pub/Sub转发
PushMessage pushMsg = new PushMessage(userId, message, channelType, targetNodeId);
redisTemplate.convertAndSend("channel:push", JSON.toJSONString(pushMsg));
log.info("跨节点推送{}, userId={}, targetNode={}", channelType, userId, targetNodeId);
}
}
/**
* Redis消息监听器
*/
@Component
public class PushMessageListener implements MessageListener {
@Autowired
private WebSocketConnectionManager wsManager;
@Autowired
private SseConnectionManager sseManager;
@Autowired
private String nodeId;
@Override
public void onMessage(Message message, byte[] pattern) {
String content = new String(message.getBody(), StandardCharsets.UTF_8);
PushMessage pushMsg = JSON.parseObject(content, PushMessage.class);
// 只处理发给当前节点的消息
if (!nodeId.equals(pushMsg.getTargetNodeId())) {
return;
}
// 推送消息
if ("WEBSOCKET".equals(pushMsg.getChannelType())) {
wsManager.push(pushMsg.getUserId(), pushMsg.getMessage());
} else if ("SSE".equals(pushMsg.getChannelType())) {
sseManager.push(pushMsg.getUserId(), "message", pushMsg.getMessage());
}
}
}七、核心功能详解
7.1 消息发送完整流程
数据库 渠道提供者 渠道路由 RocketMQ 发送服务 消息API 业务服务 数据库 渠道提供者 渠道路由 RocketMQ 发送服务 消息API 业务服务 异步处理 loop [多渠道并发] 1. 发送消息请求 2. 参数验证 3. 加载模板 4. 渲染内容（替换变量） 5. 创建消息记录 6. 发送到消息队列 7. 返回消息ID 8. 返回成功 9. 消费消息 10. 选择渠道 11. 调用渠道发送 12. 记录发送明细 13. 更新消息状态
代码实现：
java
@Service
public class MessageSendServiceImpl implements MessageSendService {
@Autowired
private MessageTemplateService templateService;
@Autowired
private MessageRecordService recordService;
@Autowired
private RocketMQTemplate rocketMQTemplate;
/**
* 发送消息
*/
@Transactional(rollbackFor = Exception.class)
@Override
public Long send(MessageSendRequest request) {
// 1. 参数验证
validateRequest(request);
// 2. 加载模板
MessageTemplate template = templateService.findByCode(request.getTemplateCode());
if (template == null) {
throw new BusinessException("模板不存在: " + request.getTemplateCode());
}
// 3. 渲染内容
Map<String, String> contents = renderContents(template, request.getVariables());
// 4. 创建消息记录
MessageRecord record = new MessageRecord();
record.setTemplateCode(request.getTemplateCode());
record.setMessageType(template.getMessageType());
record.setBusinessType(template.getBusinessType());
record.setReceiverId(request.getReceiverId());
record.setChannels(String.join(",", request.getChannels()));
record.setVariables(JSON.toJSONString(request.getVariables()));
record.setStatus(MessageStatus.PENDING.getCode());
record.setPriority(request.getPriority());
record.setExpireTime(calculateExpireTime(request));
recordService.save(record);
// 5. 发送到消息队列
MessageDispatchEvent event = new MessageDispatchEvent();
event.setRecordId(record.getId());
event.setChannels(request.getChannels());
event.setContents(contents);
event.setReceiver(request.getReceiver());
rocketMQTemplate.asyncSend("message-dispatch", event, new SendCallback() {
@Override
public void onSuccess(SendResult sendResult) {
log.info("消息入队成功, recordId={}", record.getId());
}
@Override
public void onException(Throwable e) {
log.error("消息入队失败, recordId=" + record.getId(), e);
// 更新消息状态为失败
recordService.updateStatus(record.getId(), MessageStatus.FAILED);
}
});
return record.getId();
}
/**
* 渲染各渠道内容
*/
private Map<String, String> renderContents(MessageTemplate template,
Map<String, Object> variables) {
Map<String, String> contents = new HashMap<>();
// 站内信内容
if (StringUtils.isNotBlank(template.getContentInApp())) {
contents.put("IN_APP", renderTemplate(template.getContentInApp(), variables));
}
// 短信内容
if (StringUtils.isNotBlank(template.getContentSms())) {
contents.put("SMS", renderTemplate(template.getContentSms(), variables));
}
// 邮件内容
if (StringUtils.isNotBlank(template.getContentEmail())) {
contents.put("EMAIL", renderTemplate(template.getContentEmail(), variables));
}
// APP推送内容
if (StringUtils.isNotBlank(template.getContentPush())) {
contents.put("PUSH", renderTemplate(template.getContentPush(), variables));
}
return contents;
}
/**
* 模板渲染（使用Freemarker或简单替换）
*/
private String renderTemplate(String template, Map<String, Object> variables) {
String result = template;
for (Map.Entry<String, Object> entry : variables.entrySet()) {
String placeholder = "${" + entry.getKey() + "}";
result = result.replace(placeholder, String.valueOf(entry.getValue()));
}
return result;
}
}7.2 消息重试机制
重试策略：指数退避（Exponential Backoff）
第1次重试: 立即
第2次重试: 1分钟后
第3次重试: 5分钟后
第4次重试: 15分钟后
超过最大次数: 标记为失败实现代码：
java
@Component
public class MessageRetryScheduler {
@Autowired
private MessageRecordService recordService;
@Autowired
private ChannelDispatcher dispatcher;
/**
* 定时扫描需要重试的消息（每分钟执行）
*/
@Scheduled(cron = "0 * * * * ?")
public void retryFailedMessages() {
// 1. 查询需要重试的消息
LocalDateTime now = LocalDateTime.now();
List<MessageRecord> records = recordService.findRetryable(now);
if (records.isEmpty()) {
return;
}
log.info("开始重试失败消息, count={}", records.size());
// 2. 逐条重试
for (MessageRecord record : records) {
try {
// 增加重试次数
record.setRetryCount(record.getRetryCount() + 1);
// 计算下次重试时间
LocalDateTime nextRetryTime = calculateNextRetryTime(
record.getRetryCount()
);
record.setNextRetryTime(nextRetryTime);
// 执行重试
boolean success = dispatcher.dispatch(record);
if (success) {
record.setStatus(MessageStatus.SUCCESS.getCode());
log.info("消息重试成功, recordId={}", record.getId());
} else if (record.getRetryCount() >= record.getMaxRetry()) {
// 超过最大重试次数
record.setStatus(MessageStatus.FAILED.getCode());
log.warn("消息重试失败，已达最大次数, recordId={}", record.getId());
} else {
// 继续等待下次重试
record.setStatus(MessageStatus.RETRY.getCode());
}
recordService.updateById(record);
} catch (Exception e) {
log.error("消息重试异常, recordId=" + record.getId(), e);
}
}
}
/**
* 计算下次重试时间（指数退避）
*/
private LocalDateTime calculateNextRetryTime(int retryCount) {
int[] delays = {0, 1, 5, 15, 30}; // 分钟
int delayMinutes = delays[Math.min(retryCount, delays.length - 1)];
return LocalDateTime.now().plusMinutes(delayMinutes);
}
}7.3 群体推送实现
群体推送用于向大量用户发送消息（如活动通知、系统公告）：
流程：
小于1000
大于1000
创建群体推送任务
查询用户群成员
成员数量检查
直接推送
分批推送
创建消息记录
每批1000条
发送到消息队列
更新推送统计
实现代码：
java
@Service
public class GroupPushServiceImpl implements GroupPushService {
@Autowired
private UserGroupService userGroupService;
@Autowired
private MessageSendService messageSendService;
@Autowired
private PushRecordService pushRecordService;
/**
* 群体推送
*/
@Transactional(rollbackFor = Exception.class)
@Override
public Long groupPush(GroupPushRequest request) {
// 1. 创建推送记录
PushRecord record = new PushRecord();
record.setGroupId(request.getGroupId());
record.setTemplateCode(request.getTemplateCode());
record.setChannels(String.join(",", request.getChannels()));
record.setVariables(JSON.toJSONString(request.getVariables()));
record.setStatus(PushStatus.PENDING.getCode());
pushRecordService.save(record);
// 2. 查询用户群成员
List<Long> memberIds = userGroupService.getMemberIds(request.getGroupId());
record.setTotalCount(memberIds.size());
pushRecordService.updateById(record);
// 3. 分批推送（异步）
CompletableFuture.runAsync(() -> {
try {
pushToMembers(record.getId(), memberIds, request);
} catch (Exception e) {
log.error("群体推送失败, recordId=" + record.getId(), e);
pushRecordService.updateStatus(record.getId(), PushStatus.FAILED);
}
});
return record.getId();
}
/**
* 分批推送给成员
*/
private void pushToMembers(Long recordId, List<Long> memberIds,
GroupPushRequest request) {
int batchSize = 1000;
int totalBatch = (memberIds.size() + batchSize - 1) / batchSize;
int successCount = 0;
for (int i = 0; i < totalBatch; i++) {
int fromIndex = i * batchSize;
int toIndex = Math.min(fromIndex + batchSize, memberIds.size());
List<Long> batchIds = memberIds.subList(fromIndex, toIndex);
log.info("推送第{}/{}批, size={}", i + 1, totalBatch, batchIds.size());
// 批量发送消息
for (Long userId : batchIds) {
try {
MessageSendRequest sendRequest = new MessageSendRequest();
sendRequest.setTemplateCode(request.getTemplateCode());
sendRequest.setReceiverId(userId);
sendRequest.setChannels(request.getChannels());
sendRequest.setVariables(request.getVariables());
messageSendService.send(sendRequest);
successCount++;
} catch (Exception e) {
log.error("推送失败, userId=" + userId, e);
}
}
// 更新推送进度
pushRecordService.updateProgress(recordId, successCount);
}
// 更新最终状态
pushRecordService.updateStatus(recordId, PushStatus.COMPLETED);
log.info("群体推送完成, recordId={}, total={}, success={}",
recordId, memberIds.size(), successCount);
}
}八、高可用与性能优化
8.1 高可用架构
集群部署拓扑：
数据层
缓存层
消息队列
应用层（3节点）
接入层
主从复制
主从复制
监控
主从复制
Nginx
负载均衡
IP Hash
消息中心-1
WebSocket/SSE连接
消息中心-2
WebSocket/SSE连接
消息中心-3
WebSocket/SSE连接
RocketMQ-Master
RocketMQ-Slave
Redis-Master
Redis-Slave
Redis-Sentinel
MySQL-Master
MySQL-Slave
各层高可用策略：
- 接入层：Nginx双活 + Keepalived VIP
- 应用层：至少3节点，无状态（连接信息存Redis）
- 消息队列：RocketMQ主从部署
- 缓存层：Redis Sentinel自动故障转移
- 数据层：MySQL主从 + MHA故障切换
8.2 性能优化策略
优化1：消息队列削峰
java
// 高并发场景，先入队再异步处理
@Override
public Long send(MessageSendRequest request) {
// 同步：创建消息记录
MessageRecord record = createRecord(request);
// 异步：发送到消息队列
rocketMQTemplate.asyncSend("message-dispatch", record);
// 立即返回消息ID
return record.getId();
}效果：
- 接口响应时间从 500ms → 50ms
- 支持 1000+ QPS
优化2：连接预热
java
@Component
public class WebSocketPreWarmer implements ApplicationRunner {
@Autowired
private WebSocketConnectionManager connectionManager;
@Override
public void run(ApplicationArguments args) {
// 启动时预创建连接池
log.info("WebSocket连接池预热开始...");
// 初始化连接管理器资源
connectionManager.preWarm();
log.info("WebSocket连接池预热完成");
}
}优化3：Redis管道批量操作
java
// 批量查询用户连接节点
public Map<Long, String> batchFindNodeIds(List<Long> userIds) {
List<String> keys = userIds.stream()
.map(id -> "push:connection:ws:" + id)
.collect(Collectors.toList());
// 使用Pipeline批量查询
List<Object> results = redisTemplate.executePipelined((RedisCallback<Object>) connection -> {
for (String key : keys) {
connection.get(key.getBytes());
}
return null;
});
// 组装结果
Map<Long, String> nodeMap = new HashMap<>();
for (int i = 0; i < userIds.size(); i++) {
if (results.get(i) != null) {
nodeMap.put(userIds.get(i), (String) results.get(i));
}
}
return nodeMap;
}8.3 监控告警
关键指标：
| 类别 | 指标 | 阈值 | 告警级别 |
|---|---|---|---|
| 在线连接 | WebSocket连接数 | < 100（异常低） | Warning |
| 在线连接 | SSE连接数 | < 50（异常低） | Warning |
| 消息发送 | 消息发送失败率 | > 1% | Critical |
| 消息发送 | 消息发送延迟P99 | > 5秒 | Warning |
| 队列堆积 | RocketMQ堆积消息数 | > 10000 | Critical |
| 系统资源 | Redis内存使用率 | > 80% | Warning |
| 系统资源 | MySQL连接数 | > 200 | Warning |
监控实现（Prometheus + Grafana）：
java
@Component
public class MetricsCollector {
@Autowired
private WebSocketConnectionManager wsManager;
@Autowired
private MeterRegistry meterRegistry;
@PostConstruct
public void init() {
// 注册指标：WebSocket在线连接数
Gauge.builder("message.websocket.connections", wsManager,
WebSocketConnectionManager::getOnlineCount)
.description("WebSocket在线连接数")
.register(meterRegistry);
// 注册指标：消息发送成功率
Counter.builder("message.send.success")
.description("消息发送成功次数")
.register(meterRegistry);
Counter.builder("message.send.failed")
.description("消息发送失败次数")
.register(meterRegistry);
}
}