<think>我们之前已经讨论了使用WebSocket实现消息推送的方案。但根据引用[1]中提到的
CIM(即时推送系统)，我们可以考虑另一种更专业的解决方案：集成
CIM来实现消息推送。
CIM支持多端接入（包括移动端），并且基于Netty或Mina，性能较好。下面将结合若依框架，给出集成
CIM实现消息推送的完整方案。
### 方案选择
1. **WebSocket方案**：轻量级，适合简单的消息推送，但需要自行处理连接管理、心跳、重连等。
2. **
CIM方案**：专业推送系统，提供更完善的功能（如连接管理、多端支持），但需要额外集成。
考虑到引用[1]中已经提到若依集成
CIM的案例，这里我们采用
CIM方案。
---
### 一、后端改造（ruoyi-vue）
#### 1. 引入
CIM服务端
- 从[
CIM GitHub](https://github.com/crossoverJie/
cim)
获取代码，并作为子模块引入若依项目。
- 或者直接引入
CIM的依赖（如果提供的话）——但
CIM目前没有直接提供maven依赖，需要自行构建。
#### 2. 修改
CIM服务端配置
在
CIM服务端中，配置Redis（用于存储连接
信息）和RabbitMQ（用于消息队列，可选）：
```yaml
# application.yml
cim:
server:
port: 23456 #
CIM服务端口
route:
url: http://localhost:8083/route # 路由服务地址（这里用若依后端作为路由服务）
```
#### 3. 在若依后端实现路由接口
CIM需要调用路由服务来
获取用户连接在哪个
CIM服务器上。我们在若依后端中提供这个接口：
```java
@RestController
@RequestMapping("/route")
public class RouteController {
@Autowired
private RedisTemplate<String, String> redisTemplate;
// 根据用户ID
获取其连接的
CIM服务器地址
@GetMapping("/get
CIMServer")
public String get
CIMServer(String userId) {
//
CIM在Redis中存储的key格式：
CIM:ROUTE:USERID -> 服务器IP:PORT
String key = "
CIM:ROUTE:" + userId;
return redisTemplate.opsForValue().get(key);
}
}
```
#### 4. 消息推送业务代码
在需要推送消息的地方，调用
CIM提供的API：
```java
@Service
public class MessageService {
@Autowired
private RestTemplate restTemplate;
// 通过
CIM服务端推送消息
public void pushMessage(String userId, String content) {
// 1.
获取用户所在的
CIM服务器地址（通过路由接口）
String
cimServerUrl = restTemplate.getForObject("http://localhost:8080/route/get
CIMServer?userId="+userId, String.class);
// 2. 构建消息体
MessageDTO messageDTO = new MessageDTO();
messageDTO.setUserId(userId);
messageDTO.setContent(content);
// 3. 调用
CIM服务器的推送接口
restTemplate.postForObject("http://"+
cimServerUrl+"/message/send", messageDTO, Void.class);
}
}
```
#### 5. 消息格式（MessageDTO）
```java
@Data
public class MessageDTO {
private String userId; // 接收用户ID
private String content; // 消息内容
// 可以扩展其他字段，如消息类型等
}
```
---
### 二、移动端实现（Android示例）
#### 1. 集成
CIM客户端
在Android项目中引入
CIM的SDK（需要自行编译
CIM的Android SDK，或使用提供的jar包）。
#### 2. 初始化
CIM连接
在用户登录后，建立与
CIM服务器的长连接：
```java
public class
CIMService extends Service {
private
CIMClient client;
@Override
public void onCreate() {
super.onCreate();
// 初始化
CIM客户端
client =
CIMClient.builder()
.host("
cim.yourdomain.com") //
CIM服务器地址
.port(23456) //
CIM服务器端口
.userId(loginUserId) // 当前登录用户ID
.build();
// 设置消息监听器
client.setOnMessageListener(new MessageListener() {
@Override
public void onMessage(String message) {
// 收到消息，处理并显示通知
showNotification(message);
}
});
// 连接
client.connect();
}
private void showNotification(String message) {
// 创建通知
NotificationCompat.Builder builder = new NotificationCompat.Builder(this, "
cim_channel")
.setContentTitle("新消息")
.setContentText(message)
.setSmallIcon(R.drawable.ic_notification);
NotificationManager manager = (NotificationManager) getSystemService(NOTIFICATION_SERVICE);
manager.notify(1, builder.build());
}
}
```
#### 3. 处理应用在后台的情况
如果应用在后台，需要确保通知能正常弹出（如上代码中的`showNotification`方法）。同时，为了保活，需要在Service中实现重连机制。
---
### 三、关键配置
#### 1. Nginx配置
将移动端到
CIM服务器的连接通过Nginx代理（支持负载均衡）：
```nginx
stream {
upstream
cim_backend {
server
cim1:23456; #
CIM服务器集群
server
cim2:23456;
}
server {
listen 23456;
proxy_pass
cim_backend;
}
}
```
#### 2. Redis配置
CIM使用Redis存储路由
信息，确保若依后端和
CIM服务端连接同一个Redis实例。
---
### 四、测试验证
1. 启动
CIM服务端集群
2. 启动若依后端服务
3. 移动端登录并建立长连接
4. 在若依后端调用`pushMessage`方法发送测试消息
5. 移动端检查是否收到通知
---
### 五、常见问题处理
1. **移动端保活**：使用前台Service，并在AndroidManifest.xml中声明权限：
```xml
<uses-permission android:name="android.permission.FOREGROUND_SERVICE" />
```
启动Service时调用`startForeground()`。
2. **离线消息**：
CIM默认不存储离线消息，需要在若依后端实现消息存储，待用户上线后主动拉取或由
CIM推送。
3. **集群部署**：
CIM支持集群，通过Redis共享路由
信息。
---
### 相关问题
1.
CIM与WebSocket方案在性能上有何差异？
2. 如何保证
CIM消息推送的可靠性（不丢失、不重复）？
3. 移动端如何实现离线消息的拉取？
4. 在弱网环境下，
CIM如何保持连接稳定？
[^1]:
CIM项目介绍及若依集成方案
[^2]: Android端通知权限处理</think>### 若依框架实现后端消息推送至移动端的完整方案
在若依框架中实现后端（ruoyi-vue）到移动端的消息推送，推荐采用 **WebSocket + 移动端长连接** 的核心方案。以下是分步骤实现方案：
---
### 一、后端实现（ruoyi-vue）
#### 1. 启用WebSocket支持
在 `ruoyi-framework` 模块添加配置：
```java
// WebSocketConfig.java
@Configuration
public class WebSocketConfig {
@Bean
public ServerEndpointExporter serverEndpointExporter() {
return new ServerEndpointExporter();
}
}
```
#### 2. 实现认证WebSocket端点
```java
// MessageWebSocket.java
@ServerEndpoint("/ws/message/{token}")
@Component
public class MessageWebSocket {
private static final ConcurrentMap<Long, Session> sessions = new ConcurrentHashMap<>();
@Autowired
private TokenService tokenService; // 注入若依的Token服务
@OnOpen
public void onOpen(Session session, @PathParam("token") String token) {
LoginUser loginUser = tokenService.getLoginUser(token);
if (loginUser != null) {
sessions.put(loginUser.getUserId(), session);
} else {
try { session.close(); } catch (IOException e) { /* 处理异常 */ }
}
}
// 消息推送方法
public static void pushMessage(Long userId, String content) {
Session session = sessions.get(userId);
if (session != null && session.isOpen()) {
session.getAsyncRemote().sendText(content);
}
}
}
```
#### 3. 业务层触发消息推送
```java
// 在需要推送的服务中调用
public void sendNotification(Long userId, String message) {
// 构建标准化消息体
JSONObject msg = new JSONObject();
msg.put("type", "SYSTEM_ALERT");
msg.put("content", message);
msg.put("timestamp", System.currentTimeMillis());
MessageWebSocket.pushMessage(userId, msg.toJSONString());
}
```
---
### 二、移动端实现（Android示例）
#### 1. 建立WebSocket连接
```kotlin
// MessageService.kt
class MessageService : Service() {
private lateinit var webSocket: WebSocket
override fun onCreate() {
val client = OkHttpClient.Builder()
.pingInterval(30, TimeUnit.SECONDS) // 心跳保活
.build()
val request = Request.Builder()
.url("wss://your-domain.com/ws/message/${getUserToken()}")
.build()
webSocket = client.newWebSocket(request, object : WebSocketListener() {
override fun onMessage(webSocket: WebSocket, text: String) {
handlePushMessage(text) // 处理推送消息
}
override fun onClosed(webSocket: WebSocket, code: Int, reason: String) {
reconnect() // 断线重连
}
})
}
private fun handlePushMessage(jsonStr: String) {
val msg = Gson().fromJson(jsonStr, Message::class.java)
when(msg.type) {
"SYSTEM_ALERT" -> showNotification(msg)
"TASK_UPDATE" -> updateTaskStatus(msg)
// 其他消息类型...
}
}
}
```
#### 2. 消息实体类
```kotlin
data class Message(
val type: String, // 消息类型
val content: String, // 内容
val timestamp: Long // 时间戳
)
```
#### 3. 前台服务保活（Android 8.0+）
```xml
<!-- AndroidManifest.xml -->
<service
android:name=".MessageService"
android:foregroundServiceType="connectedDevice" />
```
```kotlin
// 在Service中
override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
val notification = createNotification()
startForeground(NOTIFICATION_ID, notification)
return START_STICKY
}
```
---
### 三、离线消息处理
#### 1. 消息存储表设计
```sql
CREATE TABLE sys_push_message (
message_id BIGINT PRIMARY KEY COMMENT '消息ID',
user_id BIGINT NOT NULL COMMENT '接收用户',
msg_type VARCHAR(20) NOT NULL COMMENT '消息类型',
content TEXT NOT NULL COMMENT '消息内容',
status CHAR(1) DEFAULT '0' COMMENT '状态（0未读 1已读）',
create_time DATETIME DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间'
);
```
#### 2. 离线消息处理逻辑
```java
// 消息推送增强方法
public void sendMessageWithStore(Long userId, String content) {
// 1. 尝试实时推送
Session session = MessageWebSocket.sessions.get(userId);
if (session != null && session.isOpen()) {
session.getAsyncRemote().sendText(content);
return;
}
// 2. 存储到数据库
SysMessage message = new SysMessage();
message.setUserId(userId);
message.setContent(content);
message.setStatus("0");
messageMapper.insertMessage(message);
}
```
#### 3. 移动端上线后拉取离线消息
```kotlin
fun fetchOfflineMessages() {
val lastMsgTime = pref.getLong("LAST_MSG_TIME", 0)
apiService.getMessages(lastMsgTime).enqueue(object :
Callback<List<Message>> {
override fun onResponse(
call:
Call<List<Message>>, response: Response<List<Message>>) {
response.body()?.forEach { handlePushMessage(it) }
}
})
}
```
---
### 四、安全与优化配置
#### 1. Nginx代理配置
```nginx
location /ws/ {
proxy_pass http://backend_cluster;
proxy_http_version 1.1;
proxy_set_header Upgrade $http_upgrade;
proxy_set_header Connection "upgrade";
proxy_read_timeout 3600s;
}
```
#### 2. 消息格式标准化
```json
{
"msgId": "202311080001",
"type": "ORDER_UPDATE",
"title": "订单状态变更",
"content": "您的订单已发货",
"payload": {
"orderId": "20231107001",
"status": "SHIPPED"
},
"timestamp": 1699401600000
}
```
---
### 五、测试验证流程
1. **后端测试**：
```java
@Test
public void testPushNotification() {
Long testUserId = 123L;
messageService.sendNotification(testUserId, "测试消息");
// 验证WebSocket session是否存在
Assert.assertTrue(MessageWebSocket.sessions.containsKey(testUserId));
}
```
2. **移动端测试**：
- 使用Charles抓包验证WebSocket连接
- 模拟后台进程测试前台通知
- 测试断网/恢复后的消息补发
---
### 六、替代方案：集成
CIM推送系统
根据引用[1]，若需专业级解决方案可集成
CIM：
1. 部署
CIM推送服务
2. 添加依赖：
```xml
<dependency>
<groupId>com.crossoverjie</groupId>
<artifactId>
cim-spring-boot-starter</artifactId>
<version>1.0.0</version>
</dependency>
```
3. 发送消息：
```java
CIMClient.sendMessage(userId, "您的订单已发货");
```
---
### 相关问题
1. 如何保证WebSocket消息在移动端后台运行时的可靠投递？
2. 若依框架中如何实现WebSocket的集群部署？
3. 移动端断网重连后如何同步错过的消息？
4. WebSocket与HTTP长轮询在移动端消息推送中的性能对比？
5. 如何实现移动端消息的已读/未读状态同步？
> **提示：生产环境需启用WSS加密连接，Android需处理后台启动限制，iOS需配置后台模式[^1][^2]
[^1]: 若依集成
CIM实现即时推送方案
[^2]: Android前台服务与权限处理
扫一扫
70
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
