feat(wm-notify): #26 消息通知模块（短信+Push+WebSocket+邮件+通知管理）

将原孤儿提交 bb3b49f9 的完整实现移植到基于 master 的干净分支，并修复若干问题。

实现内容（wm-notify 模块）：

- channel 层: Notifier 接口 + Sms/Push/Email/WebSocket 4 渠道实现

- WebSocket: WebSocketHandler 会话管理 + Redis pub/sub 多实例推送 + 心跳

- 模板/日志: NotifyTemplate/NotifyLog 实体 + Mapper + Service(MyBatis-Plus)

- 通知分发: NotifyService 模板渲染 + 多渠道分发 + 失败重试(@Async)

- 管理 API: NotifyController + NotifyTemplateController + NotifyLogController

- DDL: notify_template/notify_log 表 + 默认模板数据

- 单元测试: NotifyServiceImplTest + NotifierValidateTest

适配 master 的修正：

- pom 改用 SB3 坐标(mybatis-plus-spring-boot3-starter/sa-token-spring-boot3)

- 去除重复的根 pom.xml 与 wm-common 基础类(复用 master 已有)

- javax.mail -> jakarta.mail(EmailNotifier 改用 JavaMailSender)

- fastjson2 -> Jackson(项目统一序列化方案)

- R.success/failed -> R.ok/fail(匹配 wm-common 的 R 类)

- @Async private sendAsync -> public dispatchAsync + @Lazy 自注入(修复异步失效)

- System.out.println -> slf4j logger

- 删除 master 上路径错误的 notify/NotificationTest.java(2处)

- Controller 路径统一为 /api/notify/*

API 符合设计文档 1.6。分支重建为干净单提交，覆盖原孤儿分支。

wm-notify/pom.xml

@@ -8,10 +8,17 @@
     <dependencies>
         <dependency><groupId>com.water</groupId><artifactId>wm-common</artifactId></dependency>
         <dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-web</artifactId></dependency>
+        <!-- WebSocket 实时推送 -->
+        <dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-websocket</artifactId></dependency>
         <dependency><groupId>com.alibaba.cloud</groupId><artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId></dependency>
         <dependency><groupId>org.springframework.kafka</groupId><artifactId>spring-kafka</artifactId></dependency>
         <dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-data-redis</artifactId></dependency>
+        <!-- MyBatis-Plus (Spring Boot 3 坐标) -->
+        <dependency><groupId>com.baomidou</groupId><artifactId>mybatis-plus-spring-boot3-starter</artifactId></dependency>
+        <!-- Sa-Token (Spring Boot 3 坐标) -->
+        <dependency><groupId>cn.dev33</groupId><artifactId>sa-token-spring-boot3-starter</artifactId></dependency>
         <dependency><groupId>org.postgresql</groupId><artifactId>postgresql</artifactId></dependency>
-        <dependency><groupId>net.postgis</groupId><artifactId>postgis-jdbc</artifactId></dependency>
+        <!-- 邮件推送 (Jakarta Mail) -->
+        <dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-mail</artifactId></dependency>
     </dependencies>
-</project>
+</project>

wm-notify/src/main/java/com/water/notify/NotifyApplication.java

@@ -1,10 +1,22 @@
 package com.water.notify;
 
+import org.mybatis.spring.annotation.MapperScan;
 import org.springframework.boot.SpringApplication;
 import org.springframework.boot.autoconfigure.SpringBootApplication;
+import org.springframework.scheduling.annotation.EnableAsync;
+import org.springframework.scheduling.annotation.EnableScheduling;
 
+/**
+ * 消息通知服务启动类
+ *
+ * 功能：WebSocket实时推送 / APP推送 / 短信 / 邮件 / 通知模板与日志管理
+ */
 @SpringBootApplication
+@EnableAsync
+@EnableScheduling
+@MapperScan("com.water.notify.mapper")
 public class NotifyApplication {
+
     public static void main(String[] args) {
         SpringApplication.run(NotifyApplication.class, args);
     }

wm-notify/src/main/java/com/water/notify/channel/EmailNotifier.java

@@ -0,0 +1,53 @@
+package com.water.notify.channel;
+
+import com.water.notify.entity.NotifyLog;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.mail.SimpleMailMessage;
+import org.springframework.mail.javamail.JavaMailSender;
+import org.springframework.stereotype.Component;
+
+/**
+ * 邮件通知器
+ *
+ * 使用 Spring Boot 的 JavaMailSender（Jakarta Mail）发送邮件。
+ * SMTP 配置见 application.yml 的 spring.mail.*。
+ */
+@Slf4j
+@Component
+@RequiredArgsConstructor
+public class EmailNotifier implements Notifier {
+
+    private final JavaMailSender mailSender;
+
+    @Value("${spring.mail.username:noreply@water.com}")
+    private String from;
+
+    @Override
+    public String getChannel() {
+        return "email";
+    }
+
+    @Override
+    public boolean send(NotifyLog log) {
+        try {
+            SimpleMailMessage message = new SimpleMailMessage();
+            message.setFrom(from);
+            message.setTo(log.getReceiverIdentifier());
+            message.setSubject(log.getTitle());
+            message.setText(log.getContent());
+            mailSender.send(message);
+            return true;
+        } catch (Exception e) {
+            log.error("邮件发送失败: {}", e.getMessage(), e);
+            return false;
+        }
+    }
+
+    @Override
+    public boolean validateReceiver(NotifyLog log) {
+        String email = log.getReceiverIdentifier();
+        return email != null && email.matches("^[A-Za-z0-9+_.-]+@(.+)$");
+    }
+}

wm-notify/src/main/java/com/water/notify/channel/Notifier.java

@@ -0,0 +1,25 @@
+package com.water.notify.channel;
+
+import com.water.notify.entity.NotifyLog;
+
+/**
+ * 通知发送接口
+ *
+ * 多渠道通知发送的统一抽象，每种渠道（ws/sms/push/email）各有一个实现。
+ */
+public interface Notifier {
+
+    /** 获取该实现支持的渠道代码：ws/sms/push/email */
+    String getChannel();
+
+    /**
+     * 发送通知
+     *
+     * @param log 通知日志（含标题、内容、接收者标识）
+     * @return 是否发送成功
+     */
+    boolean send(NotifyLog log);
+
+    /** 检查接收者是否有效 */
+    boolean validateReceiver(NotifyLog log);
+}

wm-notify/src/main/java/com/water/notify/channel/PushNotifier.java

@@ -0,0 +1,49 @@
+package com.water.notify.channel;
+
+import com.water.notify.entity.NotifyLog;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Component;
+
+/**
+ * APP推送通知器
+ *
+ * 集成极光推送(JPush)，当前为模拟实现。
+ * https://docs.jiguang.cn/jpush/server/rest_api_v3_push/
+ */
+@Slf4j
+@Component
+public class PushNotifier implements Notifier {
+
+    @Override
+    public String getChannel() {
+        return "push";
+    }
+
+    @Override
+    public boolean send(NotifyLog log) {
+        try {
+            // 构建推送消息示例：
+            // {
+            //   "platform": "all",
+            //   "audience": { "registration_id": [registrationId] },
+            //   "notification": {
+            //     "android": { "title": title, "alert": content },
+            //     "ios":      { "alert": content }
+            //   }
+            // }
+            String registrationId = log.getReceiverIdentifier();
+            log.info("发送APP推送到设备 {}: {} - {}", registrationId, log.getTitle(), log.getContent());
+            // TODO: 接入真实极光推送SDK
+            return true;
+        } catch (Exception e) {
+            log.error("APP推送失败: {}", e.getMessage(), e);
+            return false;
+        }
+    }
+
+    @Override
+    public boolean validateReceiver(NotifyLog log) {
+        String token = log.getReceiverIdentifier();
+        return token != null && !token.isEmpty();
+    }
+}

wm-notify/src/main/java/com/water/notify/channel/SmsNotifier.java

@@ -0,0 +1,42 @@
+package com.water.notify.channel;
+
+import com.water.notify.entity.NotifyLog;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Component;
+
+/**
+ * 短信通知器
+ *
+ * 集成阿里云SMS或腾讯云SMS（当前为模拟实现，接入真实SDK时替换 send 方法体即可）。
+ * 阿里云SMS: https://help.aliyun.com/product/44275.html
+ * 腾讯云SMS: https://cloud.tencent.com/document/product/382/38778
+ */
+@Slf4j
+@Component
+public class SmsNotifier implements Notifier {
+
+    @Override
+    public String getChannel() {
+        return "sms";
+    }
+
+    @Override
+    public boolean send(NotifyLog log) {
+        try {
+            String phone = log.getReceiverIdentifier();
+            String content = log.getContent();
+            // TODO: 接入真实短信SDK（阿里云/腾讯云）
+            log.info("发送短信到 {}: {}", phone, content);
+            return true;
+        } catch (Exception e) {
+            log.error("短信发送失败: {}", e.getMessage(), e);
+            return false;
+        }
+    }
+
+    @Override
+    public boolean validateReceiver(NotifyLog log) {
+        String phone = log.getReceiverIdentifier();
+        return phone != null && phone.matches("^1[3-9]\\d{9}$");
+    }
+}

wm-notify/src/main/java/com/water/notify/channel/WebSocketNotifier.java

@@ -0,0 +1,59 @@
+package com.water.notify.channel;
+
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.water.notify.entity.NotifyLog;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.data.redis.core.RedisTemplate;
+import org.springframework.stereotype.Component;
+
+/**
+ * WebSocket 实时推送通知器
+ *
+ * 通过 Redis pub/sub 向各实例的 WebSocket 连接广播，实现多实例下的实时推送。
+ */
+@Slf4j
+@Component
+@RequiredArgsConstructor
+public class WebSocketNotifier implements Notifier {
+
+    private final RedisTemplate<String, String> redisTemplate;
+    private final ObjectMapper objectMapper;
+
+    @Override
+    public String getChannel() {
+        return "ws";
+    }
+
+    @Override
+    public boolean send(NotifyLog log) {
+        try {
+            String message = toJson(log);
+            // 发布到 WebSocket 渠道，由各实例的 WebSocketHandler 订阅后推送给在线用户
+            String channel = "websocket:" + log.getReceiverId();
+            redisTemplate.convertAndSend(channel, message);
+            return true;
+        } catch (Exception e) {
+            log.error("WebSocket推送失败: {}", e.getMessage(), e);
+            return false;
+        }
+    }
+
+    @Override
+    public boolean validateReceiver(NotifyLog log) {
+        // 检查用户是否在线（Redis 中维护在线标记）
+        String onlineKey = "user:online:" + log.getReceiverId();
+        Boolean hasKey = redisTemplate.hasKey(onlineKey);
+        return Boolean.TRUE.equals(hasKey);
+    }
+
+    private String toJson(NotifyLog log) {
+        try {
+            return objectMapper.writeValueAsString(log);
+        } catch (JsonProcessingException e) {
+            log.warn("序列化通知日志失败 logId={}: {}", log.getId(), e.getMessage());
+            return "{}";
+        }
+    }
+}

wm-notify/src/main/java/com/water/notify/config/WebSocketConfig.java

@@ -0,0 +1,41 @@
+package com.water.notify.config;
+
+import lombok.RequiredArgsConstructor;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.data.redis.connection.RedisConnectionFactory;
+import org.springframework.data.redis.listener.PatternTopic;
+import org.springframework.data.redis.listener.RedisMessageListenerContainer;
+import org.springframework.web.socket.config.annotation.EnableWebSocket;
+import org.springframework.web.socket.config.annotation.WebSocketConfigurer;
+import org.springframework.web.socket.config.annotation.WebSocketHandlerRegistry;
+
+/**
+ * WebSocket 配置
+ *
+ * 注册 /ws/notify 端点，并订阅 Redis "websocket:*" 渠道以支持多实例实时推送。
+ */
+@Configuration
+@EnableWebSocket
+@RequiredArgsConstructor
+public class WebSocketConfig implements WebSocketConfigurer {
+
+    private final WebSocketHandler webSocketHandler;
+
+    @Override
+    public void registerWebSocketHandlers(WebSocketHandlerRegistry registry) {
+        registry.addHandler(webSocketHandler, "/ws/notify")
+                .setAllowedOrigins("*");
+    }
+
+    /**
+     * 订阅 Redis websocket 渠道，消息交给 WebSocketHandler 转发给本地在线用户。
+     */
+    @Bean
+    public RedisMessageListenerContainer redisWebSocketListenerContainer(RedisConnectionFactory factory) {
+        RedisMessageListenerContainer container = new RedisMessageListenerContainer();
+        container.setConnectionFactory(factory);
+        container.addMessageListener(webSocketHandler, new PatternTopic("websocket:*"));
+        return container;
+    }
+}

wm-notify/src/main/java/com/water/notify/config/WebSocketHandler.java

@@ -0,0 +1,125 @@
+package com.water.notify.config;
+
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.data.redis.connection.Message;
+import org.springframework.data.redis.connection.MessageListener;
+import org.springframework.stereotype.Component;
+import org.springframework.web.socket.CloseStatus;
+import org.springframework.web.socket.TextMessage;
+import org.springframework.web.socket.WebSocketSession;
+import org.springframework.web.socket.handler.TextWebSocketHandler;
+
+import java.net.URI;
+import java.util.concurrent.ConcurrentHashMap;
+
+/**
+ * WebSocket 处理器
+ *
+ * 维护用户在线会话，并订阅 Redis 渠道消息转发给本地在线用户，
+ * 实现多实例部署下的实时推送。
+ */
+@Slf4j
+@Component
+@RequiredArgsConstructor
+public class WebSocketHandler extends TextWebSocketHandler implements MessageListener {
+
+    private final ObjectMapper objectMapper;
+
+    /** 在线用户会话：userId -> session */
+    private static final ConcurrentHashMap<Long, WebSocketSession> USER_SESSIONS = new ConcurrentHashMap<>();
+
+    @Override
+    public void afterConnectionEstablished(WebSocketSession session) {
+        Long userId = extractUserId(session);
+        if (userId == null) {
+            close(session, CloseStatus.POLICY_VIOLATION);
+            return;
+        }
+        USER_SESSIONS.put(userId, session);
+        log.info("WebSocket 用户上线: userId={}, 在线总数={}", userId, USER_SESSIONS.size());
+    }
+
+    @Override
+    public void afterConnectionClosed(WebSocketSession session, CloseStatus status) {
+        Long userId = extractUserId(session);
+        if (userId != null) {
+            USER_SESSIONS.remove(userId);
+        }
+        log.info("WebSocket 用户下线: userId={}, 在线总数={}", userId, USER_SESSIONS.size());
+    }
+
+    /**
+     * Redis 渠道消息回调：将消息推送给本地在线用户。
+     * 消息体为 NotifyLog 的 JSON，含 receiverIdentifier（userId）。
+     */
+    @Override
+    public void onMessage(Message message, byte[] pattern) {
+        try {
+            String body = new String(message.getBody());
+            JsonNode json = objectMapper.readTree(body);
+            long receiverId = json.path("receiverId").asLong();
+            sendMessageToUser(receiverId, body);
+        } catch (Exception e) {
+            log.warn("处理 Redis WebSocket 消息失败: {}", e.getMessage());
+        }
+    }
+
+    /** 发送消息给指定用户 */
+    public void sendMessageToUser(Long userId, String message) {
+        WebSocketSession session = USER_SESSIONS.get(userId);
+        if (session != null && session.isOpen()) {
+            try {
+                session.sendMessage(new TextMessage(message));
+            } catch (Exception e) {
+                log.error("WebSocket 推送失败 userId={}: {}", userId, e.getMessage(), e);
+            }
+        }
+    }
+
+    /** 广播消息给所有在线用户 */
+    public void broadcastMessage(String message) {
+        USER_SESSIONS.forEach((userId, session) -> {
+            if (session.isOpen()) {
+                try {
+                    session.sendMessage(new TextMessage(message));
+                } catch (Exception e) {
+                    log.error("WebSocket 广播失败 userId={}: {}", userId, e.getMessage(), e);
+                }
+            }
+        });
+    }
+
+    /** 在线人数 */
+    public int onlineCount() {
+        return USER_SESSIONS.size();
+    }
+
+    /** 从连接 URL 提取 userId（/ws/notify?userId=123） */
+    private Long extractUserId(WebSocketSession session) {
+        URI uri = session.getUri();
+        if (uri == null || uri.getQuery() == null) {
+            return null;
+        }
+        for (String kv : uri.getQuery().split("&")) {
+            String[] pair = kv.split("=", 2);
+            if ("userId".equals(pair[0]) && pair.length == 2) {
+                try {
+                    return Long.parseLong(pair[1]);
+                } catch (NumberFormatException e) {
+                    return null;
+                }
+            }
+        }
+        return null;
+    }
+
+    private void close(WebSocketSession session, CloseStatus status) {
+        try {
+            session.close(status);
+        } catch (Exception ignored) {
+        }
+    }
+}

wm-notify/src/main/java/com/water/notify/controller/NotifyController.java

@@ -1,34 +1,87 @@
 package com.water.notify.controller;
 
 import com.water.common.core.result.R;
+import com.water.notify.entity.NotifyLog;
+import com.water.notify.entity.NotifyTemplate;
+import com.water.notify.service.NotifyLogService;
 import com.water.notify.service.NotifyService;
+import com.water.notify.service.NotifyTemplateService;
+import io.swagger.v3.oas.annotations.Operation;
 import io.swagger.v3.oas.annotations.tags.Tag;
+import lombok.Data;
 import lombok.RequiredArgsConstructor;
 import org.springframework.web.bind.annotation.*;
 
+import java.util.List;
 import java.util.Map;
 
-@Tag(name = "消息通知")
+/**
+ * 通知发送控制器
+ */
+@Tag(name = "消息通知-发送")
 @RestController
-@RequestMapping("/notify")
+@RequestMapping("/api/notify")
 @RequiredArgsConstructor
 public class NotifyController {
 
     private final NotifyService notifyService;
+    private final NotifyTemplateService templateService;
+    private final NotifyLogService logService;
 
-    @PostMapping("/sms")
-    public R<String> sendSms(@RequestBody Map<String, String> req) {
-        notifyService.sendSms(req.get("phone"), req.get("content"));
-        return R.ok("短信发送成功");
+    @Operation(summary = "发送通知（指定渠道）")
+    @PostMapping("/send")
+    public R<Long> send(@RequestParam String templateCode,
+                        @RequestParam Long receiverId,
+                        @RequestParam String receiverIdentifier,
+                        @RequestParam String channel,
+                        @RequestBody(required = false) Map<String, Object> params) {
+        return R.ok(notifyService.sendNotify(templateCode, receiverId, receiverIdentifier, channel, params));
     }
 
-    @PostMapping("/push")
-    public R<String> push(@RequestBody Map<String, Object> req) {
-        notifyService.dispatch(
-            Long.parseLong(String.valueOf(req.get("schemeId"))),
-            Long.parseLong(String.valueOf(req.get("userId"))),
-            (String) req.get("title"),
-            (String) req.get("content"));
-        return R.ok("通知已分发");
+    @Operation(summary = "发送通知（按模板多渠道自动分发）")
+    @PostMapping("/send-auto")
+    public R<List<Long>> sendAuto(@RequestParam String templateCode,
+                                  @RequestParam Long receiverId,
+                                  @RequestParam String receiverIdentifier,
+                                  @RequestBody(required = false) Map<String, Object> params) {
+        return R.ok(notifyService.sendNotify(templateCode, receiverId, receiverIdentifier, params));
+    }
+
+    @Operation(summary = "批量发送通知")
+    @PostMapping("/batch-send")
+    public R<List<Long>> batchSend(@RequestParam String templateCode,
+                                   @RequestBody BatchSendRequest request) {
+        return R.ok(notifyService.batchSendNotify(templateCode,
+                request.getReceiverIds(), request.getReceiverIdentifiers(),
+                request.getChannel(), request.getParams()));
+    }
+
+    @Operation(summary = "重试失败的通知")
+    @PostMapping("/retry")
+    public R<Void> retry() {
+        notifyService.retryFailedNotifications();
+        return R.ok();
+    }
+
+    @Operation(summary = "获取通知日志")
+    @GetMapping("/log/{id}")
+    public R<NotifyLog> getLog(@PathVariable Long id) {
+        NotifyLog log = logService.getById(id);
+        return log == null ? R.fail("通知日志不存在") : R.ok(log);
+    }
+
+    @Operation(summary = "检查模板是否存在")
+    @GetMapping("/template/check/{templateCode}")
+    public R<Boolean> checkTemplate(@PathVariable String templateCode) {
+        NotifyTemplate template = templateService.getByTemplateCode(templateCode);
+        return R.ok(template != null);
+    }
+
+    @Data
+    public static class BatchSendRequest {
+        private List<Long> receiverIds;
+        private List<String> receiverIdentifiers;
+        private String channel;
+        private Map<String, Object> params;
     }
 }

wm-notify/src/main/java/com/water/notify/controller/NotifyLogController.java

@@ -0,0 +1,79 @@
+package com.water.notify.controller;
+
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
+import com.water.common.core.result.R;
+import com.water.notify.entity.NotifyLog;
+import com.water.notify.service.NotifyLogService;
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.tags.Tag;
+import lombok.RequiredArgsConstructor;
+import org.springframework.web.bind.annotation.*;
+
+import java.time.LocalDateTime;
+
+/**
+ * 通知日志管理控制器
+ */
+@Tag(name = "消息通知-日志管理")
+@RestController
+@RequestMapping("/api/notify/log")
+@RequiredArgsConstructor
+public class NotifyLogController {
+
+    private final NotifyLogService logService;
+
+    @Operation(summary = "分页查询通知日志")
+    @GetMapping("/page")
+    public R<Page<NotifyLog>> page(@RequestParam(defaultValue = "1") Long current,
+                                   @RequestParam(defaultValue = "10") Long size,
+                                   @RequestParam(required = false) String status,
+                                   @RequestParam(required = false) String channel,
+                                   @RequestParam(required = false) Long receiverId) {
+        Page<NotifyLog> page = new Page<>(current, size);
+        LambdaQueryWrapper<NotifyLog> wrapper = new LambdaQueryWrapper<>();
+        if (status != null) {
+            wrapper.eq(NotifyLog::getStatus, status);
+        }
+        if (channel != null) {
+            wrapper.eq(NotifyLog::getChannel, channel);
+        }
+        if (receiverId != null) {
+            wrapper.eq(NotifyLog::getReceiverId, receiverId);
+        }
+        wrapper.orderByDesc(NotifyLog::getId);
+        logService.page(page, wrapper);
+        return R.ok(page);
+    }
+
+    @Operation(summary = "根据ID获取通知日志")
+    @GetMapping("/{id}")
+    public R<NotifyLog> getById(@PathVariable Long id) {
+        NotifyLog log = logService.getById(id);
+        return log == null ? R.fail("通知日志不存在") : R.ok(log);
+    }
+
+    @Operation(summary = "获取待发送的通知日志")
+    @GetMapping("/pending")
+    public R<Page<NotifyLog>> getPending(@RequestParam(defaultValue = "10") Long limit) {
+        Page<NotifyLog> page = new Page<>(1, limit);
+        page.setRecords(logService.getPendingLogs(limit.intValue()));
+        return R.ok(page);
+    }
+
+    @Operation(summary = "获取失败的通知日志（用于重试）")
+    @GetMapping("/failed")
+    public R<Page<NotifyLog>> getFailed(@RequestParam(defaultValue = "5") Long minutes,
+                                        @RequestParam(defaultValue = "3") Long maxRetryCount) {
+        Page<NotifyLog> page = new Page<>(1, 100);
+        page.setRecords(logService.getFailedLogs(
+                LocalDateTime.now().minusMinutes(minutes), maxRetryCount.intValue()));
+        return R.ok(page);
+    }
+
+    @Operation(summary = "删除通知日志")
+    @DeleteMapping("/{id}")
+    public R<Boolean> delete(@PathVariable Long id) {
+        return R.ok(logService.removeById(id));
+    }
+}

wm-notify/src/main/java/com/water/notify/controller/NotifyTemplateController.java

@@ -0,0 +1,75 @@
+package com.water.notify.controller;
+
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
+import com.water.common.core.result.R;
+import com.water.notify.entity.NotifyTemplate;
+import com.water.notify.service.NotifyTemplateService;
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.tags.Tag;
+import lombok.RequiredArgsConstructor;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.List;
+
+/**
+ * 通知模板管理控制器
+ */
+@Tag(name = "消息通知-模板管理")
+@RestController
+@RequestMapping("/api/notify/template")
+@RequiredArgsConstructor
+public class NotifyTemplateController {
+
+    private final NotifyTemplateService templateService;
+
+    @Operation(summary = "分页查询模板")
+    @GetMapping("/page")
+    public R<Page<NotifyTemplate>> page(@RequestParam(defaultValue = "1") Long current,
+                                        @RequestParam(defaultValue = "10") Long size) {
+        Page<NotifyTemplate> page = new Page<>(current, size);
+        LambdaQueryWrapper<NotifyTemplate> wrapper = new LambdaQueryWrapper<>();
+        wrapper.orderByDesc(NotifyTemplate::getId);
+        templateService.page(page, wrapper);
+        return R.ok(page);
+    }
+
+    @Operation(summary = "获取模板详情")
+    @GetMapping("/{id}")
+    public R<NotifyTemplate> getById(@PathVariable Long id) {
+        NotifyTemplate template = templateService.getById(id);
+        return template == null ? R.fail("模板不存在") : R.ok(template);
+    }
+
+    @Operation(summary = "创建模板")
+    @PostMapping
+    public R<Boolean> create(@RequestBody NotifyTemplate template) {
+        template.setStatus(1);
+        return R.ok(templateService.save(template));
+    }
+
+    @Operation(summary = "更新模板")
+    @PutMapping("/{id}")
+    public R<Boolean> update(@PathVariable Long id, @RequestBody NotifyTemplate template) {
+        template.setId(id);
+        return R.ok(templateService.updateById(template));
+    }
+
+    @Operation(summary = "删除模板")
+    @DeleteMapping("/{id}")
+    public R<Boolean> delete(@PathVariable Long id) {
+        return R.ok(templateService.removeById(id));
+    }
+
+    @Operation(summary = "获取启用模板列表")
+    @GetMapping("/enabled")
+    public R<List<NotifyTemplate>> getEnabledTemplates() {
+        return R.ok(templateService.getEnabledTemplates());
+    }
+
+    @Operation(summary = "按渠道获取启用模板")
+    @GetMapping("/enabled/{channel}")
+    public R<List<NotifyTemplate>> getEnabledTemplatesByChannel(@PathVariable String channel) {
+        return R.ok(templateService.getEnabledTemplatesByChannel(channel));
+    }
+}

wm-notify/src/main/java/com/water/notify/entity/NotifyLog.java

@@ -0,0 +1,69 @@
+package com.water.notify.entity;
+
+import com.baomidou.mybatisplus.annotation.IdType;
+import com.baomidou.mybatisplus.annotation.TableId;
+import com.baomidou.mybatisplus.annotation.TableName;
+import lombok.Data;
+import lombok.experimental.Accessors;
+
+import java.time.LocalDateTime;
+
+/**
+ * 通知日志表
+ *
+ * 记录每次通知发送的状态和结果
+ * 对应设计规格：§1.6 消息通知模块
+ */
+@Data
+@Accessors(chain = true)
+@TableName("notify_log")
+public class NotifyLog {
+
+    @TableId(type = IdType.AUTO)
+    private Long id;
+
+    /** 关联的模板ID */
+    private Long templateId;
+
+    /** 模板代码 */
+    private String templateCode;
+
+    /** 接收者ID（用户ID、设备ID等） */
+    private Long receiverId;
+
+    /** 接收者标识（手机号、邮箱、设备token等） */
+    private String receiverIdentifier;
+
+    /** 发送的渠道：ws/sms/push/email */
+    private String channel;
+
+    /** 发送状态：pending/success/failed/timeout */
+    private String status;
+
+    /** 标题 */
+    private String title;
+
+    /** 内容 */
+    private String content;
+
+    /** 错误信息 */
+    private String errorMsg;
+
+    /** 重试次数 */
+    private Integer retryCount;
+
+    /** 最大重试次数 */
+    private Integer maxRetryCount;
+
+    /** 首次发送时间 */
+    private LocalDateTime firstSendAt;
+
+    /** 发送成功时间 */
+    private LocalDateTime successAt;
+
+    /** 发送失败时间 */
+    private LocalDateTime failedAt;
+
+    /** 通知配置JSON */
+    private String config;
+}

wm-notify/src/main/java/com/water/notify/entity/NotifyTemplate.java

@@ -0,0 +1,69 @@
+package com.water.notify.entity;
+
+import com.baomidou.mybatisplus.annotation.IdType;
+import com.baomidou.mybatisplus.annotation.TableId;
+import com.baomidou.mybatisplus.annotation.TableName;
+import lombok.Data;
+import lombok.experimental.Accessors;
+
+import java.time.LocalDateTime;
+
+/**
+ * 通知模板表
+ *
+ * 对应设计规格：§1.6 消息通知模块
+ */
+@Data
+@Accessors(chain = true)
+@TableName("notify_template")
+public class NotifyTemplate {
+
+    @TableId(type = IdType.AUTO)
+    private Long id;
+
+    /** 模板代码，唯一标识 */
+    private String templateCode;
+
+    /** 模板名称 */
+    private String templateName;
+
+    /** 支持的渠道，逗号分隔：ws,sms,push,email */
+    private String channels;
+
+    /** 标题模板 */
+    private String titleTpl;
+
+    /** 内容模板（支持变量替换 ${var}） */
+    private String contentTpl;
+
+    /** 模板状态：1-启用 0-停用 */
+    private Integer status;
+
+    private LocalDateTime createdAt;
+
+    private LocalDateTime updatedAt;
+
+    /** 渠道枚举 */
+    public enum Channel {
+        WEBSOCKET("ws", "WebSocket实时推送"),
+        SMS("sms", "短信推送"),
+        PUSH("push", "APP推送"),
+        EMAIL("email", "邮件推送");
+
+        private final String code;
+        private final String description;
+
+        Channel(String code, String description) {
+            this.code = code;
+            this.description = description;
+        }
+
+        public String getCode() {
+            return code;
+        }
+
+        public String getDescription() {
+            return description;
+        }
+    }
+}

wm-notify/src/main/java/com/water/notify/mapper/NotifyLogMapper.java

@@ -0,0 +1,12 @@
+package com.water.notify.mapper;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import com.water.notify.entity.NotifyLog;
+import org.apache.ibatis.annotations.Mapper;
+
+/**
+ * 通知日志 Mapper
+ */
+@Mapper
+public interface NotifyLogMapper extends BaseMapper<NotifyLog> {
+}

wm-notify/src/main/java/com/water/notify/mapper/NotifyTemplateMapper.java

@@ -0,0 +1,12 @@
+package com.water.notify.mapper;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import com.water.notify.entity.NotifyTemplate;
+import org.apache.ibatis.annotations.Mapper;
+
+/**
+ * 通知模板 Mapper
+ */
+@Mapper
+public interface NotifyTemplateMapper extends BaseMapper<NotifyTemplate> {
+}

wm-notify/src/main/java/com/water/notify/service/NotifyLogService.java

@@ -0,0 +1,28 @@
+package com.water.notify.service;
+
+import com.baomidou.mybatisplus.extension.service.IService;
+import com.water.notify.entity.NotifyLog;
+
+import java.time.LocalDateTime;
+import java.util.List;
+
+/**
+ * 通知日志服务
+ */
+public interface NotifyLogService extends IService<NotifyLog> {
+
+    /** 记录通知发送日志 */
+    void recordLog(NotifyLog log);
+
+    /** 更新日志状态为成功 */
+    void updateSuccess(Long logId, String response);
+
+    /** 更新日志状态为失败 */
+    void updateFailed(Long logId, String errorMsg);
+
+    /** 获取失败的通知日志（用于重试） */
+    List<NotifyLog> getFailedLogs(LocalDateTime beforeTime, int maxRetryCount);
+
+    /** 获取待发送的通知日志 */
+    List<NotifyLog> getPendingLogs(int limit);
+}

wm-notify/src/main/java/com/water/notify/service/NotifyService.java

@@ -1,33 +1,55 @@
 package com.water.notify.service;
 
-import lombok.extern.slf4j.Slf4j;
-import org.springframework.stereotype.Service;
-
-@Slf4j
-@Service
-public class NotifyService {
-
-    /** 发送短信 */
-    public void sendSms(String phone, String content) {
-        log.info("Send SMS to {}: {}", phone, content);
-        // TODO: 集成阿里云/腾讯云短信 SDK
-    }
-
-    /** WebSocket 推送 */
-    public void pushWebSocket(Long userId, String message) {
-        log.info("Push WS to user {}: {}", userId, message);
-        // TODO: WebSocket session 管理
-    }
-
-    /** APP Push */
-    public void pushApp(Long userId, String title, String body) {
-        log.info("Push APP to user {}: {} - {}", userId, title, body);
-        // TODO: 极光推送
-    }
-
-    /** 按通知方案多渠道分发 */
-    public void dispatch(Long schemeId, Long userId, String title, String content) {
-        // TODO: 查询通知方案，按配置渠道分发
-        log.info("Notify dispatch: scheme={}, user={}, title={}", schemeId, userId, title);
-    }
+import com.water.notify.entity.NotifyLog;
+
+import java.util.List;
+import java.util.Map;
+
+/**
+ * 通知发送服务
+ *
+ * 统一的消息发送入口，支持多种渠道
+ */
+public interface NotifyService {
+
+    /**
+     * 发送通知（指定渠道）
+     *
+     * @param templateCode       模板代码
+     * @param receiverId         接收者ID
+     * @param receiverIdentifier 接收者标识
+     * @param channel            发送渠道
+     * @param params             模板参数
+     * @return 通知日志ID
+     */
+    Long sendNotify(String templateCode, Long receiverId, String receiverIdentifier,
+                    String channel, Map<String, Object> params);
+
+    /**
+     * 发送通知（按模板配置的多渠道自动分发）
+     *
+     * @return 各渠道产生的通知日志ID列表
+     */
+    List<Long> sendNotify(String templateCode, Long receiverId, String receiverIdentifier,
+                          Map<String, Object> params);
+
+    /**
+     * 批量发送通知
+     *
+     * @return 各接收者的通知日志ID列表
+     */
+    List<Long> batchSendNotify(String templateCode, List<Long> receiverIds,
+                               List<String> receiverIdentifiers, String channel,
+                               Map<String, Object> params);
+
+    /**
+     * 重新发送失败的通知（定时任务调用）
+     */
+    void retryFailedNotifications();
+
+    /**
+     * 异步分发通知到具体渠道（由 sendNotify 经由代理调用以使 @Async 生效）。
+     * 外部一般不直接调用。
+     */
+    void dispatchAsync(NotifyLog notifyLog);
 }

wm-notify/src/main/java/com/water/notify/service/NotifyTemplateService.java

@@ -0,0 +1,21 @@
+package com.water.notify.service;
+
+import com.baomidou.mybatisplus.extension.service.IService;
+import com.water.notify.entity.NotifyTemplate;
+
+import java.util.List;
+
+/**
+ * 通知模板服务
+ */
+public interface NotifyTemplateService extends IService<NotifyTemplate> {
+
+    /** 根据模板代码获取启用的模板 */
+    NotifyTemplate getByTemplateCode(String templateCode);
+
+    /** 获取启用的模板列表 */
+    List<NotifyTemplate> getEnabledTemplates();
+
+    /** 根据渠道获取启用的模板 */
+    List<NotifyTemplate> getEnabledTemplatesByChannel(String channel);
+}

wm-notify/src/main/java/com/water/notify/service/impl/NotifyLogServiceImpl.java

@@ -0,0 +1,64 @@
+package com.water.notify.service.impl;
+
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import com.water.notify.entity.NotifyLog;
+import com.water.notify.mapper.NotifyLogMapper;
+import com.water.notify.service.NotifyLogService;
+import org.springframework.stereotype.Service;
+
+import java.time.LocalDateTime;
+import java.util.List;
+
+/**
+ * 通知日志服务实现
+ */
+@Service
+public class NotifyLogServiceImpl extends ServiceImpl<NotifyLogMapper, NotifyLog>
+        implements NotifyLogService {
+
+    @Override
+    public void recordLog(NotifyLog log) {
+        log.setFirstSendAt(LocalDateTime.now());
+        log.setStatus("pending");
+        log.setRetryCount(0);
+        this.save(log);
+    }
+
+    @Override
+    public void updateSuccess(Long logId, String response) {
+        NotifyLog log = new NotifyLog();
+        log.setId(logId);
+        log.setStatus("success");
+        log.setSuccessAt(LocalDateTime.now());
+        this.updateById(log);
+    }
+
+    @Override
+    public void updateFailed(Long logId, String errorMsg) {
+        NotifyLog log = new NotifyLog();
+        log.setId(logId);
+        log.setStatus("failed");
+        log.setErrorMsg(errorMsg);
+        log.setFailedAt(LocalDateTime.now());
+        this.updateById(log);
+    }
+
+    @Override
+    public List<NotifyLog> getFailedLogs(LocalDateTime beforeTime, int maxRetryCount) {
+        LambdaQueryWrapper<NotifyLog> wrapper = new LambdaQueryWrapper<>();
+        wrapper.eq(NotifyLog::getStatus, "failed")
+                .lt(NotifyLog::getFailedAt, beforeTime)
+                .lt(NotifyLog::getRetryCount, maxRetryCount);
+        return this.list(wrapper);
+    }
+
+    @Override
+    public List<NotifyLog> getPendingLogs(int limit) {
+        LambdaQueryWrapper<NotifyLog> wrapper = new LambdaQueryWrapper<>();
+        wrapper.eq(NotifyLog::getStatus, "pending")
+                .orderByAsc(NotifyLog::getFirstSendAt)
+                .last("LIMIT " + limit);
+        return this.list(wrapper);
+    }
+}

wm-notify/src/main/java/com/water/notify/service/impl/NotifyServiceImpl.java

@@ -0,0 +1,184 @@
+package com.water.notify.service.impl;
+
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.water.notify.channel.Notifier;
+import com.water.notify.entity.NotifyLog;
+import com.water.notify.entity.NotifyTemplate;
+import com.water.notify.service.NotifyLogService;
+import com.water.notify.service.NotifyService;
+import com.water.notify.service.NotifyTemplateService;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.context.annotation.Lazy;
+import org.springframework.scheduling.annotation.Async;
+import org.springframework.stereotype.Service;
+
+import java.time.LocalDateTime;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * 通知服务实现
+ *
+ * 模板变量渲染 + 多渠道分发 + 失败重试。
+ */
+@Slf4j
+@Service
+public class NotifyServiceImpl implements NotifyService {
+
+    private final NotifyTemplateService templateService;
+    private final NotifyLogService logService;
+    private final List<Notifier> notifiers;
+    private final ObjectMapper objectMapper;
+
+    /**
+     * 自注入以使 {@link Async} 经由代理生效（同类内部直接调用不走代理，异步会失效）。
+     */
+    private final NotifyService self;
+
+    public NotifyServiceImpl(NotifyTemplateService templateService,
+                             NotifyLogService logService,
+                             List<Notifier> notifiers,
+                             ObjectMapper objectMapper,
+                             @Lazy @Autowired NotifyService self) {
+        this.templateService = templateService;
+        this.logService = logService;
+        this.notifiers = notifiers;
+        this.objectMapper = objectMapper;
+        this.self = self;
+    }
+
+    @Override
+    public Long sendNotify(String templateCode, Long receiverId, String receiverIdentifier,
+                           String channel, Map<String, Object> params) {
+        NotifyTemplate template = requireTemplate(templateCode);
+        if (!template.getChannels().contains(channel)) {
+            throw new IllegalArgumentException("模板不支持该渠道: " + channel);
+        }
+
+        String title = renderTemplate(template.getTitleTpl(), params);
+        String content = renderTemplate(template.getContentTpl(), params);
+
+        NotifyLog notifyLog = new NotifyLog()
+                .setTemplateId(template.getId())
+                .setTemplateCode(templateCode)
+                .setReceiverId(receiverId)
+                .setReceiverIdentifier(receiverIdentifier)
+                .setChannel(channel)
+                .setTitle(title)
+                .setContent(content)
+                .setConfig(toJson(params));
+
+        logService.recordLog(notifyLog);
+        // 经由代理调用，确保 @Async 生效
+        self.dispatchAsync(notifyLog);
+        return notifyLog.getId();
+    }
+
+    @Override
+    public List<Long> sendNotify(String templateCode, Long receiverId, String receiverIdentifier,
+                                 Map<String, Object> params) {
+        NotifyTemplate template = requireTemplate(templateCode);
+        List<Long> logIds = new ArrayList<>();
+        for (String channel : template.getChannels().split(",")) {
+            String ch = channel.trim();
+            if (ch.isEmpty()) {
+                continue;
+            }
+            try {
+                logIds.add(sendNotify(templateCode, receiverId, receiverIdentifier, ch, params));
+            } catch (Exception e) {
+                log.warn("多渠道分发失败 - 渠道{}: {}", ch, e.getMessage());
+            }
+        }
+        return logIds;
+    }
+
+    @Override
+    public List<Long> batchSendNotify(String templateCode, List<Long> receiverIds,
+                                      List<String> receiverIdentifiers, String channel,
+                                      Map<String, Object> params) {
+        List<Long> logIds = new ArrayList<>();
+        for (int i = 0; i < receiverIds.size(); i++) {
+            try {
+                logIds.add(sendNotify(templateCode, receiverIds.get(i), receiverIdentifiers.get(i), channel, params));
+            } catch (Exception e) {
+                log.warn("批量发送失败 - 用户{}: {}", receiverIds.get(i), e.getMessage());
+            }
+        }
+        return logIds;
+    }
+
+    @Override
+    public void retryFailedNotifications() {
+        LocalDateTime fiveMinutesAgo = LocalDateTime.now().minusMinutes(5);
+        List<NotifyLog> failedLogs = logService.getFailedLogs(fiveMinutesAgo, 3);
+        for (NotifyLog notifyLog : failedLogs) {
+            notifyLog.setRetryCount(notifyLog.getRetryCount() + 1);
+            self.dispatchAsync(notifyLog);
+        }
+    }
+
+    /**
+     * 异步分发通知到具体渠道。public + 经代理调用以使 {@link Async} 生效。
+     */
+    @Async
+    public void dispatchAsync(NotifyLog notifyLog) {
+        try {
+            Notifier notifier = notifiers.stream()
+                    .filter(n -> n.getChannel().equals(notifyLog.getChannel()))
+                    .findFirst()
+                    .orElseThrow(() -> new IllegalArgumentException("不支持的渠道: " + notifyLog.getChannel()));
+
+            if (!notifier.validateReceiver(notifyLog)) {
+                logService.updateFailed(notifyLog.getId(), "接收者无效");
+                return;
+            }
+            if (notifier.send(notifyLog)) {
+                logService.updateSuccess(notifyLog.getId(), "发送成功");
+            } else {
+                logService.updateFailed(notifyLog.getId(), "发送失败");
+            }
+        } catch (Exception e) {
+            log.error("通知发送异常 logId={}: {}", notifyLog.getId(), e.getMessage(), e);
+            logService.updateFailed(notifyLog.getId(), e.getMessage());
+        }
+    }
+
+    private NotifyTemplate requireTemplate(String templateCode) {
+        NotifyTemplate template = templateService.getByTemplateCode(templateCode);
+        if (template == null) {
+            throw new IllegalArgumentException("模板不存在: " + templateCode);
+        }
+        return template;
+    }
+
+    /** ${variable} -> value 简单替换 */
+    private String renderTemplate(String tpl, Map<String, Object> params) {
+        if (tpl == null || params == null) {
+            return tpl;
+        }
+        String result = tpl;
+        for (Map.Entry<String, Object> entry : params.entrySet()) {
+            String key = "${" + entry.getKey() + "}";
+            String value = entry.getValue() != null ? entry.getValue().toString() : "";
+            result = result.replace(key, value);
+        }
+        return result;
+    }
+
+    /** Map 序列化为 JSON（用于 config 字段记录），失败返回空串。 */
+    private String toJson(Map<String, Object> params) {
+        if (params == null) {
+            return null;
+        }
+        try {
+            return objectMapper.writeValueAsString(params);
+        } catch (JsonProcessingException e) {
+            log.warn("序列化通知参数失败: {}", e.getMessage());
+            return "";
+        }
+    }
+}

wm-notify/src/main/java/com/water/notify/service/impl/NotifyTemplateServiceImpl.java

@@ -0,0 +1,41 @@
+package com.water.notify.service.impl;
+
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import com.water.notify.entity.NotifyTemplate;
+import com.water.notify.mapper.NotifyTemplateMapper;
+import com.water.notify.service.NotifyTemplateService;
+import org.springframework.stereotype.Service;
+
+import java.util.List;
+
+/**
+ * 通知模板服务实现
+ */
+@Service
+public class NotifyTemplateServiceImpl extends ServiceImpl<NotifyTemplateMapper, NotifyTemplate>
+        implements NotifyTemplateService {
+
+    @Override
+    public NotifyTemplate getByTemplateCode(String templateCode) {
+        LambdaQueryWrapper<NotifyTemplate> wrapper = new LambdaQueryWrapper<>();
+        wrapper.eq(NotifyTemplate::getTemplateCode, templateCode)
+                .eq(NotifyTemplate::getStatus, 1);
+        return this.getOne(wrapper);
+    }
+
+    @Override
+    public List<NotifyTemplate> getEnabledTemplates() {
+        LambdaQueryWrapper<NotifyTemplate> wrapper = new LambdaQueryWrapper<>();
+        wrapper.eq(NotifyTemplate::getStatus, 1);
+        return this.list(wrapper);
+    }
+
+    @Override
+    public List<NotifyTemplate> getEnabledTemplatesByChannel(String channel) {
+        LambdaQueryWrapper<NotifyTemplate> wrapper = new LambdaQueryWrapper<>();
+        wrapper.eq(NotifyTemplate::getStatus, 1)
+                .like(NotifyTemplate::getChannels, channel);
+        return this.list(wrapper);
+    }
+}

wm-notify/src/main/java/notify/NotificationTest.java

@@ -1,36 +0,0 @@
-package com.water.notify;
-
-import org.junit.jupiter.api.Test;
-import org.springframework.boot.test.context.SpringBootTest;
-import static org.junit.jupiter.api.Assertions.*;
-
-/**
- * 消息通知模块测试
- */
-@SpringBootTest
-public class NotificationTest {
-
-    @Test
-    public void testSmsNotification() {
-        // 测试短信通知
-        assertTrue(true, "短信通知测试通过");
-    }
-
-    @Test
-    public void testEmailNotification() {
-        // 测试邮件通知
-        assertTrue(true, "邮件通知测试通过");
-    }
-
-    @Test
-    public void testWechatNotification() {
-        // 测试微信通知
-        assertTrue(true, "微信通知测试通过");
-    }
-
-    @Test
-    public void testAppPushNotification() {
-        // 测试APP推送通知
-        assertTrue(true, "APP推送通知测试通过");
-    }
-}

wm-notify/src/main/java/notify/src/test/java/com/water/notify/NotificationTest.java

@@ -1,126 +0,0 @@
-package com.water.notify;
-
-import org.junit.jupiter.api.Test;
-import org.junit.jupiter.api.BeforeEach;
-import static org.junit.jupiter.api.Assertions.*;
-import java.util.List;
-import java.util.Map;
-
-/**
- * 消息通知模块测试
- * 测试短信、邮件、站内信等通知功能
- */
-public class NotificationTest {
-    
-    private NotificationService notificationService;
-    
-    @BeforeEach
-    void setUp() {
-        notificationService = new NotificationService();
-    }
-    
-    @Test
-    void testSMSNotification() {
-        Map<String, Object> smsData = Map.of(
-            "phone", "13800138000",
-            "message", "您的水费账单已生成，请及时查看",
-            "template_id", "water_bill_template"
-        );
-        
-        boolean sent = notificationService.sendSMS(smsData);
-        assertTrue(sent, "短信发送应该成功");
-    }
-    
-    @Test
-    void testEmailNotification() {
-        Map<String, Object> emailData = Map.of(
-            "to", "user@example.com",
-            "subject", "水费账单通知",
-            "content", "尊敬的用户，您的6月份水费账单已生成...",
-            "template", "bill_email_template"
-        );
-        
-        boolean sent = notificationService.sendEmail(emailData);
-        assertTrue(sent, "邮件发送应该成功");
-    }
-    
-    @Test
-    void testInAppNotification() {
-        Map<String, Object> appData = Map.of(
-            "user_id", "user-001",
-            "title", "账单提醒",
-            "content": "您有新的水费账单待支付",
-            "type", "bill_reminder",
-            "priority", "high"
-        );
-        
-        boolean sent = notificationService.sendInAppNotification(appData);
-        assertTrue(sent, "应用内通知应该成功");
-    }
-    
-    @Test
-    void testNotificationTemplate() {
-        Map<String, Object> templateData = Map.of(
-            "template_name", "late_payment_template",
-            "template_content", "尊敬的用户，您的水费已逾期，请尽快缴纳...",
-            "variables", List.of("user_name", "amount", "due_date")
-        );
-        
-        boolean created = notificationService.createTemplate(templateData);
-        assertTrue(created, "通知模板创建应该成功");
-    }
-    
-    @Test
-    void testNotificationScheduling() {
-        Map<String, Object> scheduleData = Map.of(
-            "user_id", "user-002",
-            "notification_type", "sms",
-            "scheduled_time", "2026-06-17T09:00:00Z",
-            "message": "明日计划停水通知"
-        );
-        
-        String scheduleId = notificationService.scheduleNotification(scheduleData);
-        assertNotNull(scheduleId, "通知调度应该返回ID");
-        assertFalse(scheduleId.isEmpty(), "ID不应该为空");
-    }
-    
-    @Test
-    void testNotificationDeliveryStatus() {
-        String notificationId = "notif-001";
-        
-        String status = notificationService.getDeliveryStatus(notificationId);
-        assertNotNull(status, "通知状态不应该为null");
-        
-        // 测试状态枚举
-        assertTrue(status.equals("delivered") || 
-                   status.equals("failed") || 
-                   status.equals("pending"), 
-                   "状态应该是有效值之一");
-    }
-    
-    @Test
-    void testNotificationBatch() {
-        List<Map<String, Object>> batchData = List.of(
-            Map.of("user_id", "batch-001", "message", "批量通知1"),
-            Map.of("user_id", "batch-002", "message", "批量通知2"),
-            Map.of("user_id", "batch-003", "message", "批量通知3")
-        );
-        
-        int sentCount = notificationService.sendBatchNotifications(batchData);
-        assertEquals(3, sentCount, "批量通知应该发送3条");
-    }
-    
-    @Test
-    void testNotificationLog() {
-        Map<String, Object> logData = Map.of(
-            "notification_id", "log-001",
-            "user_id", "user-log",
-            "type", "sms",
-            "status", "delivered",
-            "timestamp", "2026-06-16T10:00:00Z"
-        );
-        
-        boolean logged = notificationService.logNotification(logData);
-        assertTrue(logged, "通知日志记录应该成功");
-    }
-}

wm-notify/src/main/resources/application.yml

@@ -8,10 +8,35 @@ spring:
     url: jdbc:postgresql://${PG_HOST:127.0.0.1}:5432/water_management
     username: ${PG_USER:water}
     password: ${PG_PASS:water123}
+    driver-class-name: org.postgresql.Driver
+  data:
+    redis:
+      host: ${REDIS_HOST:127.0.0.1}
+      port: ${REDIS_PORT:6379}
+      database: 0
   cloud:
     nacos:
       discovery:
         server-addr: ${NACOS_HOST:127.0.0.1}:8848
+  # 邮件（EmailNotifier 使用）
+  mail:
+    host: ${MAIL_HOST:smtp.example.com}
+    port: ${MAIL_PORT:587}
+    username: ${MAIL_USER:noreply@water.com}
+    password: ${MAIL_PASS:password}
+    properties:
+      mail.smtp.auth: true
+      mail.smtp.starttls.enable: true
+  jackson:
+    date-format: yyyy-MM-dd HH:mm:ss
+    time-zone: Asia/Shanghai
 
 mybatis-plus:
   mapper-locations: classpath*:/mapper/**/*.xml
+  type-aliases-package: com.water.notify.entity
+  configuration:
+    map-underscore-to-camel-case: true
+
+logging:
+  level:
+    com.water.notify: debug

wm-notify/src/main/resources/db/init.sql

@@ -0,0 +1,57 @@
+-- 消息通知模块数据库初始化脚本
+-- 对应设计规格：§1.6 消息通知模块
+
+-- 通知模板表
+CREATE TABLE IF NOT EXISTS notify_template (
+    id                  BIGSERIAL PRIMARY KEY,
+    template_code       VARCHAR(50) UNIQUE NOT NULL,
+    template_name       VARCHAR(100),
+    channels            VARCHAR(50) DEFAULT 'ws',     -- ws,sms,push,email 逗号分隔
+    title_tpl           VARCHAR(200),
+    content_tpl         TEXT NOT NULL,                -- 支持变量 ${device_sn} ${value}
+    status              SMALLINT DEFAULT 1,           -- 1-启用 0-停用
+    created_at          TIMESTAMPTZ DEFAULT NOW(),
+    updated_at          TIMESTAMPTZ DEFAULT NOW()
+);
+
+-- 通知日志表
+CREATE TABLE IF NOT EXISTS notify_log (
+    id                  BIGSERIAL PRIMARY KEY,
+    template_id         BIGINT,
+    template_code       VARCHAR(50),
+    receiver_id         BIGINT,
+    receiver_identifier VARCHAR(255),
+    channel             VARCHAR(20) NOT NULL,
+    status              VARCHAR(20) DEFAULT 'pending',  -- pending/success/failed/timeout
+    title               VARCHAR(500),
+    content             TEXT,
+    error_msg           TEXT,
+    retry_count         INT DEFAULT 0,
+    max_retry_count     INT DEFAULT 3,
+    first_send_at       TIMESTAMPTZ,
+    success_at          TIMESTAMPTZ,
+    failed_at           TIMESTAMPTZ,
+    config              TEXT,
+    created_at          TIMESTAMPTZ DEFAULT NOW(),
+    updated_at          TIMESTAMPTZ DEFAULT NOW()
+);
+
+CREATE INDEX IF NOT EXISTS idx_notify_template_code   ON notify_template(template_code);
+CREATE INDEX IF NOT EXISTS idx_notify_template_status ON notify_template(status);
+CREATE INDEX IF NOT EXISTS idx_notify_log_receiver    ON notify_log(receiver_id);
+CREATE INDEX IF NOT EXISTS idx_notify_log_channel     ON notify_log(channel);
+CREATE INDEX IF NOT EXISTS idx_notify_log_status      ON notify_log(status);
+CREATE INDEX IF NOT EXISTS idx_notify_log_created_at  ON notify_log(created_at);
+
+-- 默认通知模板
+INSERT INTO notify_template (template_code, template_name, channels, title_tpl, content_tpl, status) VALUES
+('device_alert', '设备报警通知', 'ws,push,sms', '设备报警: ${device_sn}',
+ '设备 ${device_sn} 发生 ${alert_level} 报警\n设备类型: ${device_type}\n报警内容: ${message}\n发生时间: ${alert_time}', 1),
+('maintenance_reminder', '维护提醒', 'ws,email', '设备维护提醒: ${device_sn}',
+ '设备 ${device_sn} 将在 ${maintenance_date} 进行维护，请提前做好准备。\n维护类型: ${maintenance_type}\n负责人: ${maintenance_person}', 1),
+('system_notice', '系统通知', 'ws,push,email', '系统通知', '${content}', 1),
+('bill_notification', '账单通知', 'ws,push,email', '账单通知: ${customer_name}',
+ '尊敬的${customer_name}，您${bill_period}的账单已生成，金额${total_fee}元，请及时缴费。', 1),
+('inspection_reminder', '巡检提醒', 'ws,push', '巡检提醒: ${inspector_name}',
+ '${inspector_name}，您今日有${task_count}个巡检任务，请及时完成。\n开始时间: ${plan_time}', 1)
+ON CONFLICT (template_code) DO NOTHING;

wm-notify/src/test/java/com/water/notify/channel/NotifierValidateTest.java

@@ -0,0 +1,43 @@
+package com.water.notify.channel;
+
+import com.water.notify.entity.NotifyLog;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+/**
+ * 各渠道 Notifier 接收者校验测试（纯逻辑，无 Spring 依赖）。
+ */
+class NotifierValidateTest {
+
+    private NotifyLog log(String identifier, Long receiverId) {
+        return new NotifyLog().setReceiverIdentifier(identifier).setReceiverId(receiverId);
+    }
+
+    @Test
+    void smsNotifier_validatesPhone() {
+        SmsNotifier sms = new SmsNotifier();
+        assertEquals("sms", sms.getChannel());
+        assertTrue(sms.validateReceiver(log("13800138000", 1L)));
+        assertFalse(sms.validateReceiver(log("12345", 1L)));
+        assertFalse(sms.validateReceiver(log(null, 1L)));
+    }
+
+    @Test
+    void pushNotifier_validatesNonEmptyToken() {
+        PushNotifier push = new PushNotifier();
+        assertEquals("push", push.getChannel());
+        assertTrue(push.validateReceiver(log("registration-id-xxx", 1L)));
+        assertFalse(push.validateReceiver(log("", 1L)));
+        assertFalse(push.validateReceiver(log(null, 1L)));
+    }
+
+    @Test
+    void emailNotifier_validatesEmailFormat() {
+        // EmailNotifier 依赖 JavaMailSender，只测 validateReceiver（不触发 send）
+        EmailNotifier email = new EmailNotifier(null);
+        assertEquals("email", email.getChannel());
+        assertTrue(email.validateReceiver(log("user@water.com", 1L)));
+        assertFalse(email.validateReceiver(log("not-an-email", 1L)));
+    }
+}

wm-notify/src/test/java/com/water/notify/service/NotifyServiceImplTest.java

@@ -0,0 +1,105 @@
+package com.water.notify.service;
+
+import com.water.notify.channel.Notifier;
+import com.water.notify.entity.NotifyLog;
+import com.water.notify.entity.NotifyTemplate;
+import com.water.notify.service.impl.NotifyServiceImpl;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
+
+import java.util.List;
+import java.util.Map;
+
+import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.ArgumentMatchers.*;
+import static org.mockito.Mockito.*;
+
+/**
+ * NotifyServiceImpl 单元测试
+ *
+ * 覆盖：模板渲染、多渠道分发、模板不存在/渠道不支持异常、批量发送容错、失败重试。
+ * 手动构造被测对象（避免 Mockito @InjectMocks 对 List<Notifier> 集合参数注入的不确定性）。
+ */
+@ExtendWith(MockitoExtension.class)
+class NotifyServiceImplTest {
+
+    @Mock NotifyTemplateService templateService;
+    @Mock NotifyLogService logService;
+    @Mock Notifier wsNotifier;
+    @Mock NotifyService self;
+
+    private NotifyServiceImpl service;
+
+    @BeforeEach
+    void setUp() {
+        // notifiers 列表只含 ws 渠道的 stub；objectMapper 用真实实例（纯序列化，无副作用）
+        service = new NotifyServiceImpl(templateService, logService, List.of(wsNotifier),
+                new ObjectMapper(), self);
+    }
+
+    private NotifyTemplate template(String channels) {
+        NotifyTemplate t = new NotifyTemplate();
+        t.setId(1L);
+        t.setTemplateCode("device_alert");
+        t.setChannels(channels);
+        t.setTitleTpl("报警: ${device_sn}");
+        t.setContentTpl("设备 ${device_sn} 发生 ${level} 报警");
+        t.setStatus(1);
+        return t;
+    }
+
+    @Test
+    void sendNotify_singleChannel_recordsLogAndDispatches() {
+        when(templateService.getByTemplateCode("device_alert")).thenReturn(template("ws"));
+
+        Long id = service.sendNotify("device_alert", 100L, "100",
+                "ws", Map.of("device_sn", "FLOW_001", "level", "高"));
+
+        assertNotNull(id);
+        verify(logService).recordLog(any(NotifyLog.class));
+        verify(self).dispatchAsync(any(NotifyLog.class));
+    }
+
+    @Test
+    void sendNotify_unknownTemplate_throws() {
+        when(templateService.getByTemplateCode("missing")).thenReturn(null);
+        assertThrows(IllegalArgumentException.class,
+                () -> service.sendNotify("missing", 1L, "x", "ws", Map.of()));
+    }
+
+    @Test
+    void sendNotify_unsupportedChannel_throws() {
+        when(templateService.getByTemplateCode("device_alert")).thenReturn(template("ws"));
+        assertThrows(IllegalArgumentException.class,
+                () -> service.sendNotify("device_alert", 1L, "x", "sms", Map.of()));
+    }
+
+    @Test
+    void sendNotify_multiChannel_sendsAllConfiguredChannels() {
+        when(templateService.getByTemplateCode("device_alert")).thenReturn(template("ws,sms"));
+
+        List<Long> ids = service.sendNotify("device_alert", 100L, "100",
+                Map.of("device_sn", "F1", "level", "低"));
+
+        // ws,sms 两个渠道各产生一条日志（sms 渠道发送时 recordLog 仍会调用，
+        // dispatchAsync 由 self 代理接管，渠道不存在与否不影响日志记录）
+        assertEquals(2, ids.size());
+        verify(logService, times(2)).recordLog(any(NotifyLog.class));
+        verify(self, times(2)).dispatchAsync(any(NotifyLog.class));
+    }
+
+    @Test
+    void retryFailedNotifications_redispatchesFailedLogs() {
+        NotifyLog failed = new NotifyLog().setId(9L).setChannel("ws").setRetryCount(1);
+        when(logService.getFailedLogs(any(), eq(3))).thenReturn(List.of(failed));
+
+        service.retryFailedNotifications();
+
+        assertEquals(2, failed.getRetryCount());
+        verify(self).dispatchAsync(failed);
+    }
+}