完成签到模块功能

gym-manage-api/gym-checkIn/.gitignore

@@ -0,0 +1,48 @@
+# Compiled class file
+*.class
+
+# Log file
+*.log
+
+# BlueJ files
+*.ctxt
+
+# Mobile Tools for Java (J2ME)
+.mtj.tmp/
+
+# Package Files
+*.jar
+*.war
+*.nar
+*.ear
+*.zip
+*.tar.gz
+*.rar
+
+# Virtual machine crash logs
+hs_err_pid*
+replay_pid*
+
+# Maven
+target/
+pom.xml.tag
+pom.xml.releaseBackup
+pom.xml.versionsBackup
+pom.xml.next
+release.properties
+dependency-reduced-pom.xml
+buildNumber.properties
+.mvn/timing.properties
+.mvn/wrapper/maven-wrapper.jar
+
+# IDE
+.idea/
+*.iml
+.vscode/
+.settings/
+.classpath
+.project
+
+# OS
+.DS_Store
+Thumbs.db

gym-manage-api/gym-checkIn/pom.xml

@@ -0,0 +1,252 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+
+    <parent>
+        <groupId>cn.novalon.gym.manage</groupId>
+        <artifactId>gym-manage-api</artifactId>
+        <version>1.0.0</version>
+    </parent>
+
+    <artifactId>gym-checkIn</artifactId>
+    <packaging>jar</packaging>
+
+    <name>Gym CheckIn</name>
+    <description>Check-In Management Module - Member Attendance Services</description>
+
+    <dependencies>
+        <dependency>
+            <groupId>cn.novalon.gym.manage</groupId>
+            <artifactId>manage-common</artifactId>
+            <version>${project.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>cn.novalon.gym.manage</groupId>
+            <artifactId>manage-db</artifactId>
+            <version>${project.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>cn.novalon.gym.manage</groupId>
+            <artifactId>gym-member</artifactId>
+            <version>${project.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>cn.novalon.gym.manage</groupId>
+            <artifactId>gym-groupCourse</artifactId>
+            <version>${project.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-webflux</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-aop</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.springdoc</groupId>
+            <artifactId>springdoc-openapi-starter-webflux-ui</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-security</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework.data</groupId>
+            <artifactId>spring-data-commons</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-test</artifactId>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework.security</groupId>
+            <artifactId>spring-security-test</artifactId>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>io.projectreactor</groupId>
+            <artifactId>reactor-test</artifactId>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>io.github.resilience4j</groupId>
+            <artifactId>resilience4j-spring-boot3</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>io.github.resilience4j</groupId>
+            <artifactId>resilience4j-reactor</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.testcontainers</groupId>
+            <artifactId>testcontainers</artifactId>
+            <version>1.21.4</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.testcontainers</groupId>
+            <artifactId>postgresql</artifactId>
+            <version>1.21.4</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.testcontainers</groupId>
+            <artifactId>junit-jupiter</artifactId>
+            <version>1.21.4</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>com.h2database</groupId>
+            <artifactId>h2</artifactId>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>io.r2dbc</groupId>
+            <artifactId>r2dbc-h2</artifactId>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.postgresql</groupId>
+            <artifactId>r2dbc-postgresql</artifactId>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>cn.hutool</groupId>
+            <artifactId>hutool-all</artifactId>
+            <version>5.8.25</version>
+        </dependency>
+        <dependency>
+            <groupId>com.google.zxing</groupId>
+            <artifactId>core</artifactId>
+            <version>3.5.1</version>
+        </dependency>
+
+        <!-- 添加 ZXing JavaSE 扩展（用于生成图片） -->
+        <dependency>
+            <groupId>com.google.zxing</groupId>
+            <artifactId>javase</artifactId>
+            <version>3.5.1</version>
+        </dependency>
+
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-websocket</artifactId>
+        </dependency>
+    </dependencies>
+
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-jar-plugin</artifactId>
+                <version>3.4.2</version>
+                <executions>
+                    <execution>
+                        <id>default-jar</id>
+                        <phase>package</phase>
+                        <goals>
+                            <goal>jar</goal>
+                        </goals>
+                    </execution>
+                </executions>
+            </plugin>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-compiler-plugin</artifactId>
+                <version>3.11.0</version>
+                <configuration>
+                    <source>21</source>
+                    <target>21</target>
+                    <annotationProcessorPaths>
+                        <path>
+                            <groupId>org.mapstruct</groupId>
+                            <artifactId>mapstruct-processor</artifactId>
+                            <version>1.5.5.Final</version>
+                        </path>
+                        <path>
+                            <groupId>org.projectlombok</groupId>
+                            <artifactId>lombok</artifactId>
+                            <version>${lombok.version}</version>
+                        </path>
+                        <path>
+                            <groupId>org.projectlombok</groupId>
+                            <artifactId>lombok-mapstruct-binding</artifactId>
+                            <version>0.2.0</version>
+                        </path>
+                    </annotationProcessorPaths>
+                </configuration>
+            </plugin>
+            <plugin>
+                <groupId>org.jacoco</groupId>
+                <artifactId>jacoco-maven-plugin</artifactId>
+                <version>0.8.12</version>
+                <executions>
+                    <execution>
+                        <id>prepare-agent</id>
+                        <goals>
+                            <goal>prepare-agent</goal>
+                        </goals>
+                    </execution>
+                    <execution>
+                        <id>report</id>
+                        <phase>verify</phase>
+                        <goals>
+                            <goal>report</goal>
+                        </goals>
+                    </execution>
+                    <execution>
+                        <id>check</id>
+                        <phase>verify</phase>
+                        <goals>
+                            <goal>check</goal>
+                        </goals>
+                        <configuration>
+                            <rules>
+                                <rule>
+                                    <element>BUNDLE</element>
+                                    <limits>
+                                        <limit>
+                                            <counter>INSTRUCTION</counter>
+                                            <value>COVEREDRATIO</value>
+                                            <minimum>0.60</minimum>
+                                        </limit>
+                                    </limits>
+                                </rule>
+                            </rules>
+                        </configuration>
+                    </execution>
+                </executions>
+            </plugin>
+            <plugin>
+                <groupId>com.github.spotbugs</groupId>
+                <artifactId>spotbugs-maven-plugin</artifactId>
+                <version>4.8.6.0</version>
+                <dependencies>
+                    <dependency>
+                        <groupId>com.github.spotbugs</groupId>
+                        <artifactId>spotbugs</artifactId>
+                        <version>4.8.6</version>
+                    </dependency>
+                </dependencies>
+                <executions>
+                    <execution>
+                        <id>spotbugs-check</id>
+                        <phase>verify</phase>
+                        <goals>
+                            <goal>check</goal>
+                        </goals>
+                    </execution>
+                </executions>
+                <configuration>
+                    <effort>Max</effort>
+                    <threshold>High</threshold>
+                    <failOnError>true</failOnError>
+                    <excludeFilterFile>spotbugs-exclude.xml</excludeFilterFile>
+                </configuration>
+            </plugin>
+        </plugins>
+    </build>
+</project>

gym-manage-api/gym-checkIn/src/main/java/cn/novalon/gym/manage/checkIn/config/QRCodeConfig.java

@@ -0,0 +1,46 @@
+package cn.novalon.gym.manage.checkIn.config;
+
+import lombok.Data;
+import org.springframework.boot.context.properties.ConfigurationProperties;
+import org.springframework.context.annotation.Configuration;
+
+@Data
+@Configuration
+@ConfigurationProperties(prefix = "qr.config")
+public class QRCodeConfig {
+
+    /**
+     * 二维码宽度（像素）
+     */
+    private Integer width = 300;
+
+    /**
+     * 二维码高度（像素）
+     */
+    private Integer height = 300;
+
+    /**
+     * 白边宽度
+     */
+    private Integer margin = 1;
+
+    /**
+     * 容错率：L, M, Q, H
+     */
+    private String errorCorrection = "M";
+
+    /**
+     * 图片格式：png, jpg
+     */
+    private String format = "png";
+
+    /**
+     * 是否启用Logo
+     */
+    private Boolean logoEnabled = false;
+
+    /**
+     * Logo路径
+     */
+    private String logoPath = "";
+}

gym-manage-api/gym-checkIn/src/main/java/cn/novalon/gym/manage/checkIn/config/WebSocketConfig.java

@@ -0,0 +1,43 @@
+package cn.novalon.gym.manage.checkIn.config;
+
+import cn.novalon.gym.manage.checkIn.websocket.MyWebSocketHandler;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.web.reactive.HandlerMapping;
+import org.springframework.web.reactive.handler.SimpleUrlHandlerMapping;
+import org.springframework.web.reactive.socket.WebSocketHandler;
+import org.springframework.web.reactive.socket.server.support.WebSocketHandlerAdapter;
+
+import java.util.HashMap;
+import java.util.Map;
+
+@Configuration
+public class WebSocketConfig {
+
+    @Autowired
+    private MyWebSocketHandler myWebSocketHandler;
+
+    /**
+     * 注册 WebSocket 路由映射
+     * 路径对应前端连接的 ws://xxx/webSocket/checkIn
+     */
+    @Bean
+    public HandlerMapping webSocketMapping() {
+        Map<String, WebSocketHandler> map = new HashMap<>();
+        map.put("/webSocket/checkIn", myWebSocketHandler);
+
+        SimpleUrlHandlerMapping mapping = new SimpleUrlHandlerMapping();
+        mapping.setUrlMap(map);
+        mapping.setOrder(10);  // 设置优先级
+        return mapping;
+    }
+
+    /**
+     * 注册 WebSocket 处理器适配器（必须）
+     */
+    @Bean
+    public WebSocketHandlerAdapter handlerAdapter() {
+        return new WebSocketHandlerAdapter();
+    }
+}

gym-manage-api/gym-checkIn/src/main/java/cn/novalon/gym/manage/checkIn/constant/QRRedisKey.java

@@ -0,0 +1,43 @@
+package cn.novalon.gym.manage.checkIn.constant;
+
+import java.time.LocalDate;
+import java.util.UUID;
+
+/**
+ * 打卡模块 Redis 键常量
+ *
+ * @author 付嘉
+ * @date 2026-05-30
+ */
+public final class QRRedisKey {
+
+    private static final String SEPARATOR = ":";
+    private static final String QRCODE_USER_DAILY = "qrcode:user:daily";
+    private static final String QRCODE_CONTENT = "QR_";
+    private QRRedisKey() {
+        // 私有构造，防止实例化
+    }
+
+    /**
+     * 用户当日二维码
+     * 格式：qrcode:user:daily:{userId}:{date}
+     * 示例：qrcode:user:daily:1001:2026-05-30
+     */
+    public static String qrcodeUserDaily(Long userId, LocalDate date) {
+        return QRCODE_USER_DAILY + SEPARATOR + userId + SEPARATOR + date;
+    }
+
+    /**
+     * 用户当日二维码（今天）
+     */
+    public static String qrcodeUserToday(Long userId) {
+        return qrcodeUserDaily(userId, LocalDate.now());
+    }
+
+    /**
+     * 生成二维码内容（每个用户每次调用都不同）
+     */
+    public static String generateQrcodeContent() {
+        return QRCODE_CONTENT + UUID.randomUUID().toString().replace("-", "");
+    }
+}

gym-manage-api/gym-checkIn/src/main/java/cn/novalon/gym/manage/checkIn/dto/QRCodeDto.java

@@ -0,0 +1,13 @@
+package cn.novalon.gym.manage.checkIn.dto;
+
+import lombok.AllArgsConstructor;
+import lombok.Data;
+
+@Data
+@AllArgsConstructor
+public class QRCodeDto {
+
+    private String qrContent;
+
+    private boolean isUsed;
+}

gym-manage-api/gym-checkIn/src/main/java/cn/novalon/gym/manage/checkIn/entity/SignInRecord.java

@@ -0,0 +1,209 @@
+package cn.novalon.gym.manage.checkIn.entity;
+
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+import org.springframework.data.annotation.CreatedDate;
+import org.springframework.data.annotation.Id;
+import org.springframework.data.annotation.LastModifiedDate;
+import org.springframework.data.relational.core.mapping.Column;
+import org.springframework.data.relational.core.mapping.Table;
+
+import java.time.LocalDateTime;
+
+/**
+ * 会员到店签到记录实体
+ *
+ * @author 付嘉
+ * @date 2026-06-08
+ */
+@Data
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
+@Table("sign_in_record")
+public class SignInRecord {
+
+    /**
+     * 自增主键
+     */
+    @Id
+    private Long id;
+
+    /**
+     * 会员ID，关联member表
+     */
+    @Column("member_id")
+    private Long memberId;
+
+    /**
+     * 签到时使用的会员卡ID
+     */
+    @Column("member_card_id")
+    private Long memberCardId;
+
+    /**
+     * 签到入场时间
+     */
+    @Column("sign_in_time")
+    private LocalDateTime signInTime;
+
+    /**
+     * 签到方式：QR_CODE-扫码签到，MANUAL-手动签到，FACE-人脸识别
+     */
+    @Column("sign_in_type")
+    private String signInType;
+
+    /**
+     * 签到状态：SUCCESS-成功，FAILED-失败
+     */
+    @Column("sign_in_status")
+    private String signInStatus;
+
+    /**
+     * JSONB格式，存储会员卡验证时的快照数据
+     */
+    @Column("verification_details")
+    private String verificationDetails;
+
+    /**
+     * 失败时的具体原因文案
+     */
+    @Column("fail_reason")
+    private String failReason;
+
+    /**
+     * 操作人ID（前台人员），自助签到时为NULL
+     */
+    @Column("operator_id")
+    private Long operatorId;
+
+    /**
+     * 操作人姓名冗余
+     */
+    @Column("operator_name")
+    private String operatorName;
+
+    /**
+     * 签到设备标识或型号
+     */
+    @Column("device_info")
+    private String deviceInfo;
+
+    /**
+     * 客户端IP地址
+     */
+    @Column("ip_address")
+    private String ipAddress;
+
+    /**
+     * 签到来源：MINI_PROGRAM-小程序扫码，PC_BACKEND-后台管理端
+     */
+    @Column("source")
+    private String source;
+
+    /**
+     * 软删除标识：false-未删除，true-已删除
+     */
+    @Column("is_delete")
+    private Boolean isDelete;
+
+    /**
+     * 记录创建时间
+     */
+    @CreatedDate
+    @Column("created_at")
+    private LocalDateTime createdAt;
+
+    /**
+     * 记录更新时间
+     */
+    @LastModifiedDate
+    @Column("updated_at")
+    private LocalDateTime updatedAt;
+
+    // ========== 常量定义 ==========
+
+    /**
+     * 签到类型常量
+     */
+    public static final class SignInType {
+        /** 扫码签到 */
+        public static final String QR_CODE = "QR_CODE";
+        /** 手动签到 */
+        public static final String MANUAL = "MANUAL";
+        /** 人脸识别 */
+        public static final String FACE = "FACE";
+
+        private SignInType() {}
+    }
+
+    /**
+     * 签到状态常量
+     */
+    public static final class SignInStatus {
+        /** 成功 */
+        public static final String SUCCESS = "SUCCESS";
+        /** 失败 */
+        public static final String FAILED = "FAILED";
+
+        private SignInStatus() {}
+    }
+
+    /**
+     * 签到来源常量
+     */
+    public static final class Source {
+        /** 小程序扫码 */
+        public static final String MINI_PROGRAM = "MINI_PROGRAM";
+        /** 后台管理端手动签到 */
+        public static final String PC_BACKEND = "PC_BACKEND";
+
+        private Source() {}
+    }
+
+    // ========== 辅助方法 ==========
+
+    /**
+     * 判断签到是否成功
+     */
+    public boolean isSuccess() {
+        return SignInStatus.SUCCESS.equals(this.signInStatus);
+    }
+
+    /**
+     * 判断签到是否失败
+     */
+    public boolean isFailed() {
+        return SignInStatus.FAILED.equals(this.signInStatus);
+    }
+
+    /**
+     * 判断是否为扫码签到
+     */
+    public boolean isQrCodeSign() {
+        return SignInType.QR_CODE.equals(this.signInType);
+    }
+
+    /**
+     * 判断是否已删除
+     */
+    public boolean isDeleted() {
+        return Boolean.TRUE.equals(this.isDelete);
+    }
+
+    /**
+     * 软删除
+     */
+    public void softDelete() {
+        this.isDelete = true;
+    }
+
+    /**
+     * 恢复删除
+     */
+    public void restore() {
+        this.isDelete = false;
+    }
+}

gym-manage-api/gym-checkIn/src/main/java/cn/novalon/gym/manage/checkIn/handler/CheckInHandler.java

@@ -0,0 +1,193 @@
+package cn.novalon.gym.manage.checkIn.handler;
+
+import cn.novalon.gym.manage.checkIn.service.impl.CheckServiceImpl;
+import cn.novalon.gym.manage.checkIn.websocket.MyWebSocketHandler;
+import cn.novalon.gym.manage.sys.util.AuthUtil;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.http.HttpHeaders;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.MediaType;
+import org.springframework.stereotype.Component;
+import org.springframework.web.reactive.function.server.ServerRequest;
+import org.springframework.web.reactive.function.server.ServerResponse;
+import reactor.core.publisher.Mono;
+
+import java.time.LocalDate;
+import java.time.format.DateTimeFormatter;
+import java.util.Map;
+
+@Slf4j
+@Component
+@RequiredArgsConstructor
+public class CheckInHandler {
+
+    private final AuthUtil authUtil;
+    private final CheckServiceImpl checkService;
+
+    private static final DateTimeFormatter DATE_FORMATTER = DateTimeFormatter.ofPattern("yyyy-MM-dd");
+
+    /**
+     * 签到
+     *
+     * POST /api/checkIn
+     *
+     */
+    public Mono<ServerResponse> checkIn(ServerRequest request) {
+
+        Long memberId = authUtil.getMemberIdOrThrow(request);
+        return request.bodyToMono(Map.class)
+                .flatMap(body -> {
+                    String qrContent = (String) body.get("qrContent");
+                    log.info("收到签到请求, memberId: {}, qrContent: {}", memberId, qrContent);
+                    boolean messageToClient = MyWebSocketHandler.sendMessageToClient(qrContent, "正在进行签到");
+                    log.info("WebSocket 推送结果: {}", messageToClient);
+                    return checkService.checkIn(memberId, qrContent)
+                            .flatMap(result -> ServerResponse.ok()
+                                    .contentType(MediaType.APPLICATION_JSON)
+                                    .bodyValue(result));
+                })
+                .onErrorResume(e -> {
+                    log.error("签到失败", e);
+                    return ServerResponse.status(HttpStatus.BAD_REQUEST)
+                            .bodyValue(Map.of("code", 400, "message", e.getMessage()));
+                });
+    }
+
+    /**
+     * 获取二维码
+     *
+     * GET /api/checkin/qrcode
+     *
+     */
+    public Mono<ServerResponse> getQRCode(ServerRequest request) {
+
+        Long memberId = authUtil.getMemberIdOrThrow(request);
+
+        log.info("收到用户{}获取二维码请求", memberId);
+
+        return checkService.getQRCode(memberId)
+                .flatMap(qrCodeVo -> ServerResponse.ok()
+                        .contentType(MediaType.APPLICATION_JSON)
+                        .bodyValue(qrCodeVo));
+    }
+
+    /**
+     * 查询签到记录列表
+     *
+     * GET /api/checkIn/records
+     *
+     * @param request
+     * @return
+     */
+    public Mono<ServerResponse> getSignInRecords(ServerRequest request) {
+        Long memberId = authUtil.getMemberIdOrThrow(request);
+        
+        String startDateStr = request.queryParam("startDate").orElse(null);
+        String endDateStr = request.queryParam("endDate").orElse(null);
+        
+        LocalDate startDate = startDateStr != null ? LocalDate.parse(startDateStr, DATE_FORMATTER) : LocalDate.now().minusDays(30);
+        LocalDate endDate = endDateStr != null ? LocalDate.parse(endDateStr, DATE_FORMATTER) : LocalDate.now();
+        
+        log.info("查询签到记录, memberId: {}, startDate: {}, endDate: {}", memberId, startDate, endDate);
+        
+        return checkService.getSignInRecords(memberId, startDate, endDate)
+                .collectList()
+                .flatMap(records -> ServerResponse.ok()
+                        .contentType(MediaType.APPLICATION_JSON)
+                        .bodyValue(Map.of("code", 200, "message", "success", "data", records)));
+    }
+
+    /**
+     * 查询单条签到记录
+     *
+     * GET /api/checkIn/records/{id}
+     *
+     * @param request
+     * @return
+     */
+    public Mono<ServerResponse> getSignInRecordById(ServerRequest request) {
+        Long id = Long.parseLong(request.pathVariable("id"));
+        
+        log.info("查询签到记录详情, id: {}", id);
+        
+        return checkService.getSignInRecordById(id)
+                .flatMap(record -> ServerResponse.ok()
+                        .contentType(MediaType.APPLICATION_JSON)
+                        .bodyValue(Map.of("code", 200, "message", "success", "data", record)))
+                .switchIfEmpty(ServerResponse.notFound().build());
+    }
+
+    /**
+     * 获取签到统计
+     *
+     * GET /api/checkIn/statistics
+     *
+     * @param request
+     * @return
+     */
+    public Mono<ServerResponse> getSignInStatistics(ServerRequest request) {
+        Long memberId = authUtil.getMemberIdOrThrow(request);
+        
+        String startDateStr = request.queryParam("startDate").orElse(null);
+        String endDateStr = request.queryParam("endDate").orElse(null);
+        
+        LocalDate startDate = startDateStr != null ? LocalDate.parse(startDateStr, DATE_FORMATTER) : LocalDate.now().minusDays(30);
+        LocalDate endDate = endDateStr != null ? LocalDate.parse(endDateStr, DATE_FORMATTER) : LocalDate.now();
+        
+        log.info("查询签到统计, memberId: {}, startDate: {}, endDate: {}", memberId, startDate, endDate);
+        
+        return checkService.getSignInStats(memberId, startDate, endDate)
+                .flatMap(stats -> ServerResponse.ok()
+                        .contentType(MediaType.APPLICATION_JSON)
+                        .bodyValue(Map.of("code", 200, "message", "success", "data", stats)));
+    }
+
+    /**
+     * 导出签到记录
+     *
+     * GET /api/checkIn/records/export
+     *
+     * @param request
+     * @return
+     */
+    public Mono<ServerResponse> exportSignInRecords(ServerRequest request) {
+        Long memberId = authUtil.getMemberIdOrThrow(request);
+        
+        String startDateStr = request.queryParam("startDate").orElse(null);
+        String endDateStr = request.queryParam("endDate").orElse(null);
+        
+        LocalDate startDate = startDateStr != null ? LocalDate.parse(startDateStr, DATE_FORMATTER) : LocalDate.now().minusDays(30);
+        LocalDate endDate = endDateStr != null ? LocalDate.parse(endDateStr, DATE_FORMATTER) : LocalDate.now();
+        
+        log.info("导出签到记录, memberId: {}, startDate: {}, endDate: {}", memberId, startDate, endDate);
+        
+        String filename = "签到记录_" + startDateStr + "_" + endDateStr + ".csv";
+        
+        return checkService.exportSignInRecords(memberId, startDate, endDate)
+                .flatMap(bytes -> ServerResponse.ok()
+                        .header(HttpHeaders.CONTENT_DISPOSITION, "attachment; filename=\"" + filename + "\"")
+                        .contentType(MediaType.parseMediaType("text/csv; charset=UTF-8"))
+                        .bodyValue(bytes));
+    }
+
+    /**
+     * 获取每日签到统计
+     *
+     * GET /api/checkIn/daily-stats
+     *
+     * @param request
+     * @return
+     */
+    public Mono<ServerResponse> getDailySignInStats(ServerRequest request) {
+        String dateStr = request.queryParam("date").orElse(null);
+        LocalDate date = dateStr != null ? LocalDate.parse(dateStr, DATE_FORMATTER) : LocalDate.now();
+        
+        log.info("查询每日签到统计, date: {}", date);
+        
+        return checkService.getDailySignInStats(date)
+                .flatMap(stats -> ServerResponse.ok()
+                        .contentType(MediaType.APPLICATION_JSON)
+                        .bodyValue(Map.of("code", 200, "message", "success", "data", stats)));
+    }
+}

gym-manage-api/gym-checkIn/src/main/java/cn/novalon/gym/manage/checkIn/repository/SignInRecordRepository.java

@@ -0,0 +1,101 @@
+package cn.novalon.gym.manage.checkIn.repository;
+
+import cn.novalon.gym.manage.checkIn.entity.SignInRecord;
+import org.springframework.data.r2dbc.repository.Query;
+import org.springframework.data.r2dbc.repository.R2dbcRepository;
+import org.springframework.stereotype.Repository;
+import reactor.core.publisher.Flux;
+import reactor.core.publisher.Mono;
+
+import java.time.LocalDateTime;
+
+/**
+ * 签到记录 Repository
+ *
+ * @author 付嘉
+ * @date 2026-06-08
+ */
+@Repository
+public interface SignInRecordRepository extends R2dbcRepository<SignInRecord, Long> {
+
+    /**
+     * 查询会员某天的签到记录
+     */
+    @Query("SELECT * FROM sign_in_record WHERE member_id = :memberId AND sign_in_time >= :startTime AND sign_in_time < :endTime AND is_delete = false")
+    Mono<SignInRecord> findByMemberIdAndDate(Long memberId, LocalDateTime startTime, LocalDateTime endTime);
+
+    /**
+     * 查询会员的签到记录列表
+     */
+    @Query("SELECT * FROM sign_in_record WHERE member_id = :memberId AND is_delete = false ORDER BY sign_in_time DESC")
+    Flux<SignInRecord> findByMemberId(Long memberId);
+
+    /**
+     * 统计会员某天的签到次数
+     */
+    @Query("SELECT COUNT(*) FROM sign_in_record WHERE member_id = :memberId AND sign_in_time >= :startTime AND sign_in_time < :endTime AND is_delete = false")
+    Mono<Long> countByMemberIdAndDate(Long memberId, LocalDateTime startTime, LocalDateTime endTime);
+
+    /**
+     * 插入签到记录
+     */
+    @Query("INSERT INTO sign_in_record (member_id, member_card_id, sign_in_time, sign_in_type, sign_in_status, verification_details, fail_reason, source, created_at, updated_at, is_delete) " +
+            "VALUES (:memberId, :memberCardId, :signInTime, :signInType, :signInStatus, :verificationDetails, :failReason, :source, NOW(), NOW(), false)")
+    Mono<Void> insertRecord(Long memberId, Long memberCardId, LocalDateTime signInTime, 
+                            String signInType, String signInStatus, String verificationDetails, 
+                            String failReason, String source);
+
+    /**
+     * 根据会员ID和时间范围查询签到记录
+     */
+    @Query("SELECT * FROM sign_in_record WHERE member_id = :memberId AND sign_in_time >= :startTime AND sign_in_time <= :endTime AND is_delete = false ORDER BY sign_in_time DESC")
+    Flux<SignInRecord> findByMemberIdAndTimeRange(Long memberId, LocalDateTime startTime, LocalDateTime endTime);
+
+    /**
+     * 根据时间范围查询签到记录
+     */
+    @Query("SELECT * FROM sign_in_record WHERE sign_in_time >= :startTime AND sign_in_time <= :endTime AND is_delete = false ORDER BY sign_in_time DESC")
+    Flux<SignInRecord> findByTimeRange(LocalDateTime startTime, LocalDateTime endTime);
+
+    /**
+     * 统计会员在时间范围内的签到次数
+     */
+    @Query("SELECT COUNT(*) FROM sign_in_record WHERE member_id = :memberId AND sign_in_time >= :startTime AND sign_in_time <= :endTime AND is_delete = false")
+    Mono<Long> countByMemberIdAndTimeRange(Long memberId, LocalDateTime startTime, LocalDateTime endTime);
+
+    /**
+     * 统计时间范围内的签到次数
+     */
+    @Query("SELECT COUNT(*) FROM sign_in_record WHERE sign_in_time >= :startTime AND sign_in_time <= :endTime AND is_delete = false")
+    Mono<Long> countByTimeRange(LocalDateTime startTime, LocalDateTime endTime);
+
+    /**
+     * 统计会员在时间范围内的成功签到次数
+     */
+    @Query("SELECT COUNT(*) FROM sign_in_record WHERE member_id = :memberId AND sign_in_time >= :startTime AND sign_in_time <= :endTime AND sign_in_status = 'SUCCESS' AND is_delete = false")
+    Mono<Long> countSuccessByMemberIdAndTimeRange(Long memberId, LocalDateTime startTime, LocalDateTime endTime);
+
+    /**
+     * 统计时间范围内的成功签到次数
+     */
+    @Query("SELECT COUNT(*) FROM sign_in_record WHERE sign_in_time >= :startTime AND sign_in_time <= :endTime AND sign_in_status = 'SUCCESS' AND is_delete = false")
+    Mono<Long> countSuccessByTimeRange(LocalDateTime startTime, LocalDateTime endTime);
+
+    /**
+     * 统计时间范围内签到的独立会员数
+     */
+    @Query("SELECT COUNT(DISTINCT member_id) FROM sign_in_record WHERE sign_in_time >= :startTime AND sign_in_time <= :endTime AND is_delete = false")
+    Mono<Long> countDistinctMembersByTimeRange(LocalDateTime startTime, LocalDateTime endTime);
+
+    /**
+     * 获取会员在时间范围内的首次签到时间
+     */
+    @Query("SELECT MIN(sign_in_time) FROM sign_in_record WHERE member_id = :memberId AND sign_in_time >= :startTime AND sign_in_time <= :endTime AND is_delete = false")
+    Mono<LocalDateTime> getFirstSignInTime(Long memberId, LocalDateTime startTime, LocalDateTime endTime);
+
+    /**
+     * 获取会员在时间范围内的最后签到时间
+     */
+    @Query("SELECT MAX(sign_in_time) FROM sign_in_record WHERE member_id = :memberId AND sign_in_time >= :startTime AND sign_in_time <= :endTime AND is_delete = false")
+    Mono<LocalDateTime> getLastSignInTime(Long memberId, LocalDateTime startTime, LocalDateTime endTime);
+}

gym-manage-api/gym-checkIn/src/main/java/cn/novalon/gym/manage/checkIn/service/ICheckInService.java

@@ -0,0 +1,81 @@
+package cn.novalon.gym.manage.checkIn.service;
+
+import cn.novalon.gym.manage.checkIn.vo.QRCodeVo;
+import cn.novalon.gym.manage.checkIn.vo.SignInRecordVO;
+import cn.novalon.gym.manage.checkIn.vo.SignInStatsVO;
+import reactor.core.publisher.Flux;
+import reactor.core.publisher.Mono;
+
+import java.time.LocalDate;
+
+/**
+ * 签到服务接口
+ *
+ * @author 付嘉
+ * @date 2026-06-08
+ */
+public interface ICheckInService {
+
+    /**
+     * 获取签到二维码
+     *
+     * @param memberId 会员ID
+     * @return 二维码VO
+     */
+    Mono<QRCodeVo> getQRCode(Long memberId);
+
+    /**
+     * 扫码签到
+     *
+     * @param memberId 会员ID
+     * @param qrContent 二维码内容
+     * @return 签到结果JSON字符串
+     */
+    Mono<String> checkIn(Long memberId, String qrContent);
+
+    /**
+     * 查询会员签到记录列表
+     *
+     * @param memberId 会员ID
+     * @param startTime 开始时间
+     * @param endTime 结束时间
+     * @return 签到记录列表
+     */
+    Flux<SignInRecordVO> getSignInRecords(Long memberId, LocalDate startTime, LocalDate endTime);
+
+    /**
+     * 根据ID查询签到记录
+     *
+     * @param id 签到记录ID
+     * @return 签到记录VO
+     */
+    Mono<SignInRecordVO> getSignInRecordById(Long id);
+
+    /**
+     * 获取会员签到统计
+     *
+     * @param memberId 会员ID
+     * @param startTime 开始时间
+     * @param endTime 结束时间
+     * @return 签到统计VO
+     */
+    Mono<SignInStatsVO> getSignInStats(Long memberId, LocalDate startTime, LocalDate endTime);
+
+    /**
+     * 导出会员签到记录
+     *
+     * @param memberId 会员ID
+     * @param startTime 开始时间
+     * @param endTime 结束时间
+     * @return CSV格式的字节数组
+     */
+    Mono<byte[]> exportSignInRecords(Long memberId, LocalDate startTime, LocalDate endTime);
+
+    /**
+     * 获取每日签到统计
+     *
+     * @param date 日期
+     * @return 签到统计VO
+     */
+    Mono<SignInStatsVO> getDailySignInStats(LocalDate date);
+}

gym-manage-api/gym-checkIn/src/main/java/cn/novalon/gym/manage/checkIn/service/impl/CheckServiceImpl.java

@@ -0,0 +1,439 @@
+package cn.novalon.gym.manage.checkIn.service.impl;
+
+import cn.hutool.core.bean.BeanUtil;
+import cn.hutool.json.JSONUtil;
+import cn.novalon.gym.manage.checkIn.config.QRCodeConfig;
+import cn.novalon.gym.manage.checkIn.constant.QRRedisKey;
+import cn.novalon.gym.manage.checkIn.entity.SignInRecord;
+import cn.novalon.gym.manage.checkIn.repository.SignInRecordRepository;
+import cn.novalon.gym.manage.checkIn.service.ICheckInService;
+import cn.novalon.gym.manage.checkIn.vo.QRCodeVo;
+import cn.novalon.gym.manage.checkIn.vo.SignInRecordVO;
+import cn.novalon.gym.manage.checkIn.vo.SignInStatsVO;
+import cn.novalon.gym.manage.checkIn.websocket.MyWebSocketHandler;
+import cn.novalon.gym.manage.common.constant.RedisKeyConstants;
+import cn.novalon.gym.manage.common.util.RedisUtil;
+import cn.novalon.gym.manage.groupcourse.service.IGroupCourseBookingService;
+import cn.novalon.gym.manage.member.entity.MemberCard;
+import cn.novalon.gym.manage.member.entity.MemberCardRecord;
+import cn.novalon.gym.manage.member.enums.MemberCardType;
+import cn.novalon.gym.manage.member.repository.MemberCardRecordRepository;
+import cn.novalon.gym.manage.member.repository.MemberCardRepository;
+import cn.hutool.extra.qrcode.QrCodeUtil;
+import cn.hutool.extra.qrcode.QrConfig;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Service;
+import reactor.core.publisher.Flux;
+import reactor.core.publisher.Mono;
+
+import java.time.LocalDate;
+import java.time.LocalDateTime;
+import java.time.LocalTime;
+import java.time.format.DateTimeFormatter;
+import java.time.temporal.ChronoUnit;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+@Slf4j
+@Service
+@RequiredArgsConstructor
+public class CheckServiceImpl implements ICheckInService {
+
+    private final QRCodeConfig qrCodeConfig;
+    private final RedisUtil redisUtil;
+    private final MemberCardRecordRepository memberCardRecordRepository;
+    private final MemberCardRepository memberCardRepository;
+    private final SignInRecordRepository signInRecordRepository;
+    private final IGroupCourseBookingService groupCourseBookingService;
+
+    private static final DateTimeFormatter DATE_FORMATTER = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
+
+    @Override
+    public Mono<QRCodeVo> getQRCode(Long memberId) {
+        log.info("开始查询会员信息, memberId: {}", memberId);
+        
+        return findValidMemberCard(memberId)
+                .flatMap(cardRecord -> {
+                    log.info("会员信息查询完成, memberCardRecordId: {}", cardRecord.getMemberCardRecordId());
+                    
+                    log.info("开始生成二维码");
+                    String qrContent = QRRedisKey.generateQrcodeContent();
+                    Map<String, Object> redisMap = new HashMap<>();
+                    redisMap.put("qrContent", qrContent);
+                    redisMap.put("isUsed", false);
+                    redisMap.put("memberId", memberId);
+                    redisMap.put("memberCardRecordId", cardRecord.getMemberCardRecordId());
+
+                    return redisUtil.setWithExpire(
+                                    RedisKeyConstants.QRCODE_USER_DAILY + memberId + LocalDate.now(),
+                                    redisMap,
+                                    getSecondsUntilEndOfDay()
+                            )
+                            .then(Mono.fromSupplier(() -> {
+                                String qrCodeBase64 = QrCodeUtil.generateAsBase64(qrContent,
+                                        BeanUtil.copyProperties(qrCodeConfig, QrConfig.class), "png");
+                                return new QRCodeVo(qrCodeBase64, false, qrContent, qrCodeConfig.getWidth(), qrCodeConfig.getHeight(), LocalDate.now());
+                            }));
+                })
+                .switchIfEmpty(Mono.error(new RuntimeException("该会员没有可用的会员卡")));
+    }
+
+    @Override
+    public Mono<String> checkIn(Long memberId, String qrContent) {
+        String key = RedisKeyConstants.QRCODE_USER_DAILY + memberId + LocalDate.now();
+
+        // 先检查当天是否已经签到（从数据库查询，作为重复签到的额外保障）
+        return checkTodayAlreadySignedIn(memberId)
+                .flatMap(existingRecord -> {
+                    String checkInTime = existingRecord.getSignInTime().format(DATE_FORMATTER);
+                    log.error("重复签到, memberId: {}", memberId);
+                    MyWebSocketHandler.sendFailure(qrContent, "您已经在" + checkInTime + "完成签到，请勿重复签到");
+                    return Mono.error(new RuntimeException("您已经在" + checkInTime + "完成签到，请勿重复签到"));
+                })
+                .then(Mono.defer(() -> redisUtil.get(key)))
+                .flatMap(cachedObj -> {
+                    if (cachedObj != null) {
+                        Map<String, Object> map;
+                        if (cachedObj instanceof Map) {
+                            map = (Map<String, Object>) cachedObj;
+                        } else if (cachedObj instanceof String) {
+                            map = JSONUtil.parseObj((String) cachedObj);
+                        } else {
+                            MyWebSocketHandler.sendFailure(qrContent, "二维码数据格式错误");
+                            return Mono.error(new RuntimeException("二维码数据格式错误"));
+                        }
+                        if (map.get("qrContent").equals(qrContent)) {
+                            if ((boolean) map.get("isUsed")) {
+                                String checkInTime = String.valueOf(map.get("checkInTime"));
+                                log.error("重复签到(缓存), memberId: {}", memberId);
+                                MyWebSocketHandler.sendFailure(qrContent, "您已经在" + checkInTime + "完成签到，请勿重复签到");
+                                return Mono.error(new RuntimeException("您已经在" + checkInTime + "完成签到，请勿重复签到"));
+                            }
+                            log.info("二维码匹配成功，memberId: {}", memberId);
+
+                            Long memberCardRecordId = ((Number) map.get("memberCardRecordId")).longValue();
+
+                            return processCheckIn(memberId, memberCardRecordId, map, qrContent);
+                        } else {
+                            MyWebSocketHandler.sendFailure(qrContent, "二维码无效");
+                            return Mono.error(new RuntimeException("二维码无效"));
+                        }
+                    }
+                    MyWebSocketHandler.sendFailure(qrContent, "二维码已过期或不存在");
+                    return Mono.error(new RuntimeException("二维码已过期或不存在"));
+                });
+    }
+
+    /**
+     * 检查会员当天是否已经签到
+     * @param memberId 会员ID
+     * @return 如果已签到返回签到记录，否则返回空
+     */
+    private Mono<SignInRecord> checkTodayAlreadySignedIn(Long memberId) {
+        LocalDateTime startOfDay = LocalDate.now().atStartOfDay();
+        LocalDateTime endOfDay = LocalDate.now().atTime(LocalTime.MAX);
+        
+        return signInRecordRepository.findByMemberIdAndDate(memberId, startOfDay, endOfDay);
+    }
+
+    /**
+     * 处理签到逻辑
+     */
+    private Mono<String> processCheckIn(Long memberId, Long memberCardRecordId, Map<String, Object> redisMap, String qrContent) {
+        LocalDateTime now = LocalDateTime.now();
+        
+        // 发送实时进度通知
+        MyWebSocketHandler.sendProgress(qrContent, "VALIDATE_CARD", "正在验证会员卡...");
+        
+        return memberCardRecordRepository.findById(memberCardRecordId)
+                .switchIfEmpty(Mono.defer(() -> {
+                    MyWebSocketHandler.sendFailure(qrContent, "会员卡记录不存在");
+                    return Mono.error(new RuntimeException("会员卡记录不存在"));
+                }))
+                .flatMap(cardRecord -> {
+                    if (!"ACTIVE".equals(cardRecord.getStatus().name())) {
+                        MyWebSocketHandler.sendFailure(qrContent, "会员卡状态不正确");
+                        return Mono.error(new RuntimeException("会员卡状态不正确"));
+                    }
+                    
+                    if (cardRecord.getExpireTime() != null && cardRecord.getExpireTime().isBefore(now)) {
+                        MyWebSocketHandler.sendFailure(qrContent, "会员卡已过期");
+                        return Mono.error(new RuntimeException("会员卡已过期"));
+                    }
+
+                    // 发送实时进度通知
+                    MyWebSocketHandler.sendProgress(qrContent, "VALIDATE_BOOKING", "会员卡验证通过，正在检查预约信息...");
+
+                    // 检查是否有需要签到的团课预约
+                    return validateBooking(memberId, now)
+                            .then(memberCardRepository.findByMemberCardIdAndDeletedAtIsNull(cardRecord.getMemberCardId())
+                                    .switchIfEmpty(Mono.defer(() -> {
+                                        MyWebSocketHandler.sendFailure(qrContent, "会员卡类型不存在");
+                                        return Mono.error(new RuntimeException("会员卡类型不存在"));
+                                    }))
+                                    .flatMap(card -> {
+                                        // 发送实时进度通知
+                                        MyWebSocketHandler.sendProgress(qrContent, "DEDUCT_USAGE", "正在扣减会员卡次数...");
+                                        
+                                        return deductCardUsage(cardRecord, card)
+                                                .flatMap(updatedRecord -> {
+                                                    redisMap.put("isUsed", true);
+                                                    redisMap.put("checkInTime", now.format(DATE_FORMATTER));
+                                                    
+                                                    return saveSignInRecord(memberId, cardRecord.getMemberCardRecordId(), card.getMemberCardId())
+                                                            .then(redisUtil.set(RedisKeyConstants.QRCODE_USER_DAILY + memberId + LocalDate.now(), redisMap))
+                                                            .then(Mono.defer(() -> {
+                                                                String successMsg = buildSuccessResponse(now);
+                                                                MyWebSocketHandler.sendSuccess(qrContent, memberId, now.format(DATE_FORMATTER));
+                                                                log.info("签到成功, memberId: {}, cardRecordId: {}", memberId, memberCardRecordId);
+                                                                return Mono.just(successMsg);
+                                                            }));
+                                                });
+                                    }));
+                });
+    }
+
+    /**
+     * 验证预约信息
+     */
+    private Mono<Void> validateBooking(Long memberId, LocalDateTime now) {
+        return groupCourseBookingService.getBookingsByMemberId(memberId)
+                .filter(booking -> {
+                    String status = booking.getStatus();
+                    LocalDateTime startTime = booking.getCourseStartTime();
+                    return "0".equals(status) && 
+                           startTime != null && 
+                           startTime.toLocalDate().equals(now.toLocalDate()) &&
+                           !startTime.isBefore(now.minusMinutes(30));
+                })
+                .collectList()
+                .flatMap(bookings -> {
+                    if (bookings.isEmpty()) {
+                        return Mono.empty();
+                    }
+                    boolean hasValidBooking = bookings.stream()
+                            .anyMatch(b -> {
+                                LocalDateTime startTime = b.getCourseStartTime();
+                                return startTime != null && 
+                                       !startTime.isBefore(now.minusMinutes(30)) && 
+                                       !startTime.isAfter(now.plusMinutes(30));
+                            });
+                    if (hasValidBooking) {
+                        log.info("会员{}有有效的团课预约", memberId);
+                    } else {
+                        log.warn("会员{}有预约但不在签到时间范围内", memberId);
+                    }
+                    return Mono.empty();
+                });
+    }
+
+    /**
+     * 扣减会员卡使用次数/金额
+     */
+    private Mono<MemberCardRecord> deductCardUsage(MemberCardRecord record, MemberCard card) {
+        MemberCardType cardType = MemberCardType.valueOf(card.getMemberCardType());
+        LocalDateTime now = LocalDateTime.now();
+
+        switch (cardType) {
+            case TIME_CARD:
+                if (record.getExpireTime() != null && record.getExpireTime().isBefore(now)) {
+                    return Mono.error(new RuntimeException("时长卡已过期"));
+                }
+                return Mono.just(record);
+            case COUNT_CARD:
+                int currentTimes = record.getRemainingTimes() != null ? record.getRemainingTimes() : 0;
+                if (currentTimes < 1) {
+                    return Mono.error(new RuntimeException("次卡剩余次数不足"));
+                }
+                record.setRemainingTimes(currentTimes - 1);
+                if (record.getRemainingTimes() == 0) {
+                    record.setStatus(cn.novalon.gym.manage.member.enums.MemberCardRecordStatus.USED_UP);
+                }
+                return memberCardRecordRepository.save(record);
+            case STORED_VALUE_CARD:
+                double currentAmount = record.getRemainingAmount() != null ? record.getRemainingAmount() : 0.0;
+                if (currentAmount < 0.01) {
+                    return Mono.error(new RuntimeException("储值卡余额不足"));
+                }
+                record.setRemainingAmount(Math.max(0, currentAmount - 1));
+                if (record.getRemainingAmount() <= 0) {
+                    record.setStatus(cn.novalon.gym.manage.member.enums.MemberCardRecordStatus.USED_UP);
+                }
+                return memberCardRecordRepository.save(record);
+            default:
+                return Mono.error(new RuntimeException("不支持的会员卡类型"));
+        }
+    }
+
+    /**
+     * 保存签到记录
+     */
+    private Mono<Void> saveSignInRecord(Long memberId, Long memberCardRecordId, Long memberCardId) {
+        SignInRecord record = SignInRecord.builder()
+                .memberId(memberId)
+                .memberCardId(memberCardId)
+                .signInTime(LocalDateTime.now())
+                .signInType(SignInRecord.SignInType.QR_CODE)
+                .signInStatus(SignInRecord.SignInStatus.SUCCESS)
+                .source(SignInRecord.Source.MINI_PROGRAM)
+                .isDelete(false)
+                .build();
+
+        return signInRecordRepository.save(record).then();
+    }
+
+    /**
+     * 构建成功响应
+     */
+    private String buildSuccessResponse(LocalDateTime dateTime) {
+        Map<String, Object> res = new HashMap<>();
+        res.put("message", "签到成功");
+        res.put("dateTime", dateTime.format(DATE_FORMATTER));
+        return JSONUtil.toJsonStr(res);
+    }
+
+    /**
+     * 查找会员的有效会员卡（优先选择有效期最早到期的）
+     */
+    private Mono<MemberCardRecord> findValidMemberCard(Long memberId) {
+        return memberCardRecordRepository.findActiveCardsByMemberId(memberId)
+                .filter(record -> {
+                    LocalDateTime expireTime = record.getExpireTime();
+                    return expireTime == null || expireTime.isAfter(LocalDateTime.now());
+                })
+                .sort((r1, r2) -> {
+                    LocalDateTime e1 = r1.getExpireTime();
+                    LocalDateTime e2 = r2.getExpireTime();
+                    if (e1 == null && e2 == null) return 0;
+                    if (e1 == null) return 1;
+                    if (e2 == null) return -1;
+                    return e1.compareTo(e2);
+                })
+                .next();
+    }
+
+    // ==================== 签到记录管理功能 ====================
+
+    @Override
+    public Flux<SignInRecordVO> getSignInRecords(Long memberId, LocalDate startTime, LocalDate endTime) {
+        LocalDateTime start = startTime.atStartOfDay();
+        LocalDateTime end = endTime.atTime(LocalTime.MAX);
+        
+        return signInRecordRepository.findByMemberIdAndTimeRange(memberId, start, end)
+                .map(this::convertToVO);
+    }
+
+    @Override
+    public Mono<SignInRecordVO> getSignInRecordById(Long id) {
+        return signInRecordRepository.findById(id)
+                .map(this::convertToVO);
+    }
+
+    @Override
+    public Mono<SignInStatsVO> getSignInStats(Long memberId, LocalDate startTime, LocalDate endTime) {
+        LocalDateTime start = startTime.atStartOfDay();
+        LocalDateTime end = endTime.atTime(LocalTime.MAX);
+        
+        return Mono.zip(
+                (Object[] results) -> {
+                    Long total = (Long) results[0];
+                    Long success = (Long) results[1];
+                    LocalDateTime first = (LocalDateTime) results[2];
+                    LocalDateTime last = (LocalDateTime) results[3];
+                    SignInStatsVO stats = new SignInStatsVO();
+                    stats.setTotalCount(total);
+                    stats.setSuccessCount(success);
+                    stats.setStartDate(startTime);
+                    stats.setEndDate(endTime);
+                    stats.setFirstSignInTime(first);
+                    stats.setLastSignInTime(last);
+                    stats.setSuccessRate(total > 0 ? (double) success / total * 100.0 : 0.0);
+                    return stats;
+                },
+                signInRecordRepository.countByMemberIdAndTimeRange(memberId, start, end),
+                signInRecordRepository.countSuccessByMemberIdAndTimeRange(memberId, start, end),
+                signInRecordRepository.getFirstSignInTime(memberId, start, end),
+                signInRecordRepository.getLastSignInTime(memberId, start, end)
+        );
+    }
+
+    @Override
+    public Mono<byte[]> exportSignInRecords(Long memberId, LocalDate startTime, LocalDate endTime) {
+        LocalDateTime start = startTime.atStartOfDay();
+        LocalDateTime end = endTime.atTime(LocalTime.MAX);
+        
+        return signInRecordRepository.findByMemberIdAndTimeRange(memberId, start, end)
+                .map(record -> {
+                    String status = "SUCCESS".equals(record.getSignInStatus()) ? "成功" : "失败";
+                    String type = "QR_CODE".equals(record.getSignInType()) ? "扫码签到" : 
+                                  "MANUAL".equals(record.getSignInType()) ? "手动签到" : "人脸识别";
+                    return String.join(",",
+                            record.getId().toString(),
+                            record.getMemberId().toString(),
+                            record.getMemberCardId() != null ? record.getMemberCardId().toString() : "",
+                            record.getSignInTime() != null ? record.getSignInTime().format(DATE_FORMATTER) : "",
+                            type,
+                            status,
+                            record.getFailReason() != null ? record.getFailReason() : ""
+                    );
+                })
+                .collectList()
+                .map(rows -> {
+                    List<String> csvLines = new java.util.ArrayList<>();
+                    csvLines.add("签到记录ID,会员ID,会员卡ID,签到时间,签到方式,签到状态,失败原因");
+                    csvLines.addAll(rows);
+                    return String.join("\n", csvLines).getBytes(java.nio.charset.StandardCharsets.UTF_8);
+                });
+    }
+
+    @Override
+    public Mono<SignInStatsVO> getDailySignInStats(LocalDate date) {
+        LocalDateTime start = date.atStartOfDay();
+        LocalDateTime end = date.atTime(LocalTime.MAX);
+        
+        return Mono.zip(
+                (Object[] results) -> {
+                    Long total = (Long) results[0];
+                    Long success = (Long) results[1];
+                    Long members = (Long) results[2];
+                    SignInStatsVO stats = new SignInStatsVO();
+                    stats.setTotalCount(total);
+                    stats.setSuccessCount(success);
+                    stats.setStartDate(date);
+                    stats.setEndDate(date);
+                    stats.setUniqueMemberCount(members);
+                    stats.setSuccessRate(total > 0 ? (double) success / total * 100.0 : 0.0);
+                    return stats;
+                },
+                signInRecordRepository.countByTimeRange(start, end),
+                signInRecordRepository.countSuccessByTimeRange(start, end),
+                signInRecordRepository.countDistinctMembersByTimeRange(start, end)
+        );
+    }
+
+    /**
+     * 转换实体到VO
+     */
+    private SignInRecordVO convertToVO(SignInRecord record) {
+        SignInRecordVO vo = new SignInRecordVO();
+        vo.setId(record.getId());
+        vo.setMemberId(record.getMemberId());
+        vo.setMemberCardId(record.getMemberCardId());
+        vo.setSignInTime(record.getSignInTime());
+        vo.setSignInType(record.getSignInType());
+        vo.setSignInStatus(record.getSignInStatus());
+        vo.setFailReason(record.getFailReason());
+        vo.setSource(record.getSource());
+        vo.setCreatedAt(record.getCreatedAt());
+        return vo;
+    }
+
+    private long getSecondsUntilEndOfDay() {
+        LocalDateTime now = LocalDateTime.now();
+        LocalDateTime endOfDay = now.toLocalDate().atTime(23, 59, 59);
+        if (now.isAfter(endOfDay)) return 1;
+        return ChronoUnit.SECONDS.between(now, endOfDay);
+    }
+}

gym-manage-api/gym-checkIn/src/main/java/cn/novalon/gym/manage/checkIn/vo/QRCodeVo.java

@@ -0,0 +1,23 @@
+package cn.novalon.gym.manage.checkIn.vo;
+
+import lombok.AllArgsConstructor;
+import lombok.Data;
+
+import java.time.LocalDate;
+
+@Data
+@AllArgsConstructor
+public class QRCodeVo {
+
+    private String qrCodeBase64;
+
+    private boolean isUsed;
+
+    private String qrContent;
+
+    private Integer width;
+
+    private Integer height;
+
+    private LocalDate createTime;
+}

gym-manage-api/gym-checkIn/src/main/java/cn/novalon/gym/manage/checkIn/vo/SignInRecordVO.java

@@ -0,0 +1,66 @@
+package cn.novalon.gym.manage.checkIn.vo;
+
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+import java.time.LocalDateTime;
+
+/**
+ * 签到记录VO
+ *
+ * @author 付嘉
+ * @date 2026-06-08
+ */
+@Data
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
+public class SignInRecordVO {
+
+    /**
+     * 签到记录ID
+     */
+    private Long id;
+
+    /**
+     * 会员ID
+     */
+    private Long memberId;
+
+    /**
+     * 会员卡ID
+     */
+    private Long memberCardId;
+
+    /**
+     * 签到时间
+     */
+    private LocalDateTime signInTime;
+
+    /**
+     * 签到类型：QR_CODE-扫码签到，MANUAL-手动签到，FACE-人脸识别
+     */
+    private String signInType;
+
+    /**
+     * 签到状态：SUCCESS-成功，FAILED-失败
+     */
+    private String signInStatus;
+
+    /**
+     * 失败原因
+     */
+    private String failReason;
+
+    /**
+     * 签到来源：MINI_PROGRAM-小程序扫码，PC_BACKEND-后台管理端
+     */
+    private String source;
+
+    /**
+     * 创建时间
+     */
+    private LocalDateTime createdAt;
+}

gym-manage-api/gym-checkIn/src/main/java/cn/novalon/gym/manage/checkIn/vo/SignInStatsVO.java

@@ -0,0 +1,62 @@
+package cn.novalon.gym.manage.checkIn.vo;
+
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+import java.time.LocalDate;
+import java.time.LocalDateTime;
+
+/**
+ * 签到统计VO
+ *
+ * @author 付嘉
+ * @date 2026-06-08
+ */
+@Data
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
+public class SignInStatsVO {
+
+    /**
+     * 统计开始日期
+     */
+    private LocalDate startDate;
+
+    /**
+     * 统计结束日期
+     */
+    private LocalDate endDate;
+
+    /**
+     * 总签到次数
+     */
+    private Long totalCount;
+
+    /**
+     * 成功签到次数
+     */
+    private Long successCount;
+
+    /**
+     * 成功率（百分比）
+     */
+    private Double successRate;
+
+    /**
+     * 独立会员数
+     */
+    private Long uniqueMemberCount;
+
+    /**
+     * 首次签到时间
+     */
+    private LocalDateTime firstSignInTime;
+
+    /**
+     * 最后签到时间
+     */
+    private LocalDateTime lastSignInTime;
+}

gym-manage-api/gym-checkIn/src/main/java/cn/novalon/gym/manage/checkIn/websocket/MyWebSocketHandler.java

@@ -0,0 +1,202 @@
+package cn.novalon.gym.manage.checkIn.websocket;
+
+import cn.hutool.json.JSONUtil;
+import cn.novalon.gym.manage.checkIn.dto.QRCodeDto;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Component;
+import org.springframework.web.reactive.socket.WebSocketHandler;
+import org.springframework.web.reactive.socket.WebSocketSession;
+import reactor.core.publisher.Mono;
+import reactor.core.publisher.Sinks;
+
+import java.time.LocalDateTime;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+
+/**
+ * WebSocket 处理类，用于实时签到反馈
+ * 
+ * 技术要点：
+ * - 使用 Sinks 实现响应式消息推送
+ * - 使用 ConcurrentHashMap 管理 qrContent 与 sink 的映射
+ * - 支持实时推送签到进度和结果
+ */
+@Slf4j
+@Component
+public class MyWebSocketHandler implements WebSocketHandler {
+
+    /**
+     * qrContent -> Sink 映射，用于根据二维码内容找到对应的客户端连接
+     */
+    private static final Map<String, Sinks.Many<String>> qrContentToSink = new ConcurrentHashMap<>();
+
+    /**
+     * 连接创建时间映射，用于超时清理
+     */
+    private static final Map<String, LocalDateTime> qrContentToCreateTime = new ConcurrentHashMap<>();
+
+    /**
+     * 超时时间（秒），超过此时间未使用的连接将被清理
+     */
+    private static final long TIMEOUT_SECONDS = 300;
+
+    @Override
+    public Mono<Void> handle(WebSocketSession session) {
+        String sessionId = session.getId();
+        log.info("WebSocket 连接建立，sessionId: {}", sessionId);
+
+        // 创建 sink，用于向客户端发送消息
+        Sinks.Many<String> sink = Sinks.many().unicast().onBackpressureBuffer();
+
+        // 订阅接收客户端消息（异步处理）
+        session.receive()
+                .doOnNext(message -> {
+                    String payload = message.getPayloadAsText();
+                    log.debug("收到消息：sessionId={}, payload={}", sessionId, payload);
+
+                    try {
+                        QRCodeDto qrCodeDto = JSONUtil.toBean(payload, QRCodeDto.class);
+                        String qrContent = qrCodeDto.getQrContent();
+
+                        if (qrContent != null && !qrContent.isEmpty()) {
+                            // 绑定 qrContent 和 sink
+                            qrContentToSink.put(qrContent, sink);
+                            qrContentToCreateTime.put(qrContent, LocalDateTime.now());
+                            log.info("绑定成功: qrContent={}, sessionId={}", qrContent, sessionId);
+                            
+                            // 发送连接成功消息
+                            sink.tryEmitNext(buildMessage("CONNECTED", "签到监听已建立，请扫描二维码"));
+                        } else {
+                            sink.tryEmitNext(buildMessage("ERROR", "二维码内容为空"));
+                        }
+                    } catch (Exception e) {
+                        log.error("解析消息失败，sessionId={}", sessionId, e);
+                        sink.tryEmitNext(buildMessage("ERROR", "消息格式错误: " + e.getMessage()));
+                    }
+                })
+                .doOnError(e -> {
+                    log.error("接收消息出错，sessionId={}", sessionId, e);
+                })
+                .subscribe();  // 必须订阅，否则不会执行
+
+        // 发送流给客户端
+        return session.send(sink.asFlux().map(session::textMessage))
+                .doFinally(signal -> {
+                    // 连接关闭时清理映射
+                    qrContentToSink.entrySet().removeIf(entry -> entry.getValue() == sink);
+                    qrContentToCreateTime.entrySet().removeIf(entry -> {
+                        Sinks.Many<String> s = qrContentToSink.get(entry.getKey());
+                        return s == null || s == sink;
+                    });
+                    log.info("WebSocket 连接关闭，sessionId={}", sessionId);
+                });
+    }
+
+    /**
+     * 向客户端发送消息
+     *
+     * @param qrContent 二维码内容
+     * @param message 消息内容
+     * @return 是否发送成功
+     */
+    public static boolean sendMessageToClient(String qrContent, String message) {
+        // 先清理超时连接
+        cleanupTimeoutConnections();
+
+        Sinks.Many<String> sink = qrContentToSink.get(qrContent);
+        if (sink == null) {
+            log.warn("未找到绑定的连接，qrContent: {}", qrContent);
+            return false;
+        }
+
+        Sinks.EmitResult result = sink.tryEmitNext(message);
+        if (result.isSuccess()) {
+            log.info("主动推送成功，qrContent: {}, message: {}", qrContent, message);
+            return true;
+        } else {
+            log.warn("推送失败，qrContent: {}, result: {}", qrContent, result);
+            return false;
+        }
+    }
+
+    /**
+     * 发送签到进度消息
+     *
+     * @param qrContent 二维码内容
+     * @param step 进度步骤
+     * @param message 进度消息
+     */
+    public static void sendProgress(String qrContent, String step, String message) {
+        String progressMessage = buildMessage("PROGRESS", message);
+        sendMessageToClient(qrContent, progressMessage);
+        log.debug("发送进度消息: qrContent={}, step={}, message={}", qrContent, step, message);
+    }
+
+    /**
+     * 发送签到成功消息
+     *
+     * @param qrContent 二维码内容
+     * @param memberId 会员ID
+     * @param signInTime 签到时间
+     */
+    public static void sendSuccess(String qrContent, Long memberId, String signInTime) {
+        String successMessage = buildMessage("SUCCESS", "签到成功！欢迎光临\n会员ID: " + memberId + "\n签到时间: " + signInTime);
+        sendMessageToClient(qrContent, successMessage);
+        log.info("发送成功消息: qrContent={}, memberId={}", qrContent, memberId);
+    }
+
+    /**
+     * 发送签到失败消息
+     *
+     * @param qrContent 二维码内容
+     * @param reason 失败原因
+     */
+    public static void sendFailure(String qrContent, String reason) {
+        String failureMessage = buildMessage("FAILURE", "签到失败：" + reason);
+        sendMessageToClient(qrContent, failureMessage);
+        log.warn("发送失败消息: qrContent={}, reason={}", qrContent, reason);
+    }
+
+    /**
+     * 构建标准消息格式
+     *
+     * @param type 消息类型
+     * @param content 消息内容
+     * @return 格式化后的消息字符串
+     */
+    private static String buildMessage(String type, String content) {
+        return JSONUtil.toJsonStr(Map.of(
+                "type", type,
+                "content", content,
+                "timestamp", System.currentTimeMillis()
+        ));
+    }
+
+    /**
+     * 清理超时连接
+     */
+    private static void cleanupTimeoutConnections() {
+        LocalDateTime now = LocalDateTime.now();
+        qrContentToCreateTime.entrySet().removeIf(entry -> {
+            LocalDateTime createTime = entry.getValue();
+            long secondsDiff = java.time.Duration.between(createTime, now).getSeconds();
+            if (secondsDiff > TIMEOUT_SECONDS) {
+                String qrContent = entry.getKey();
+                qrContentToSink.remove(qrContent);
+                log.debug("清理超时连接: qrContent={}, 超时时间={}秒", qrContent, secondsDiff);
+                return true;
+            }
+            return false;
+        });
+    }
+
+    /**
+     * 获取当前连接数
+     *
+     * @return 连接数
+     */
+    public static int getConnectionCount() {
+        cleanupTimeoutConnections();
+        return qrContentToSink.size();
+    }
+}

gym-manage-api/gym-checkIn/src/main/resources/checkIn-config.yml

@@ -0,0 +1,10 @@
+# 二维码配置
+qr:
+  config:
+    width: 300 # 二维码宽度（像素）
+    height: 300 # 二维码高度（像素）
+    margin: 1 # 白边宽度（像素）
+    format: png # 图片格式：png / jpg
+    error-correction: L #容错率：L, M, Q, H，如果启用Logo（logo-enabled: true），必须设置为 H
+    logo-enabled: false # 是否启用Logo（启用时error-correction必须为H）
+#    logo-path: static/logo.png    # Logo图片路径（支持相对路径或绝对路径）

gym-manage-api/gym-checkIn/src/test/java/cn/novalon/gym/manage/checkin/CheckInModuleTest.java

@@ -0,0 +1,281 @@
+package cn.novalon.gym.manage.checkin;
+
+import cn.novalon.gym.manage.checkIn.config.QRCodeConfig;
+import cn.novalon.gym.manage.checkIn.entity.SignInRecord;
+import cn.novalon.gym.manage.checkIn.repository.SignInRecordRepository;
+import cn.novalon.gym.manage.groupcourse.service.IGroupCourseBookingService;
+import cn.novalon.gym.manage.checkIn.service.impl.CheckServiceImpl;
+import cn.novalon.gym.manage.checkIn.vo.QRCodeVo;
+import cn.novalon.gym.manage.checkIn.vo.SignInRecordVO;
+import cn.novalon.gym.manage.checkIn.vo.SignInStatsVO;
+import cn.novalon.gym.manage.common.constant.RedisKeyConstants;
+import cn.novalon.gym.manage.common.util.RedisUtil;
+import cn.novalon.gym.manage.member.entity.MemberCard;
+import cn.novalon.gym.manage.member.entity.MemberCardRecord;
+import cn.novalon.gym.manage.member.repository.MemberCardRecordRepository;
+import cn.novalon.gym.manage.member.repository.MemberCardRepository;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
+import reactor.core.publisher.Flux;
+import reactor.core.publisher.Mono;
+import reactor.test.StepVerifier;
+
+import java.time.LocalDate;
+import java.time.LocalDateTime;
+import java.time.LocalTime;
+import java.util.HashMap;
+import java.util.Map;
+
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.when;
+
+/**
+ * 签到模块接口测试类
+ * 测试模块三（gym-checkIn）的所有接口
+ */
+class CheckInModuleTest {
+
+    @Mock
+    private QRCodeConfig qrCodeConfig;
+
+    @Mock
+    private RedisUtil redisUtil;
+
+    @Mock
+    private MemberCardRecordRepository memberCardRecordRepository;
+
+    @Mock
+    private MemberCardRepository memberCardRepository;
+
+    @Mock
+    private SignInRecordRepository signInRecordRepository;
+
+    @Mock
+    private IGroupCourseBookingService groupCourseBookingService;
+
+    @Mock
+    private MemberCard mockMemberCard;
+
+    @Mock
+    private SignInRecord mockSignInRecord;
+
+    @Mock
+    private MemberCardRecord mockMemberCardRecord;
+
+    private CheckServiceImpl checkService;
+
+    @BeforeEach
+    void setUp() {
+        MockitoAnnotations.openMocks(this);
+        checkService = new CheckServiceImpl(qrCodeConfig, redisUtil, memberCardRecordRepository, 
+                memberCardRepository, signInRecordRepository, groupCourseBookingService);
+
+        when(mockMemberCard.getId()).thenReturn(1L);
+        when(mockMemberCard.getMemberCardType()).thenReturn("TIME_CARD");
+
+        when(mockSignInRecord.getId()).thenReturn(1L);
+        when(mockSignInRecord.getMemberId()).thenReturn(1L);
+        when(mockSignInRecord.getMemberCardId()).thenReturn(1L);
+        when(mockSignInRecord.getSignInTime()).thenReturn(LocalDateTime.now());
+        when(mockSignInRecord.getSignInType()).thenReturn("QR_CODE");
+        when(mockSignInRecord.getSignInStatus()).thenReturn("SUCCESS");
+        when(mockSignInRecord.getSource()).thenReturn("MINI_PROGRAM");
+
+        when(mockMemberCardRecord.getMemberCardRecordId()).thenReturn(1L);
+        when(mockMemberCardRecord.getMemberCardId()).thenReturn(1L);
+        when(mockMemberCardRecord.getRemainingTimes()).thenReturn(10);
+        when(mockMemberCardRecord.getRemainingAmount()).thenReturn(100.0);
+        when(mockMemberCardRecord.getExpireTime()).thenReturn(LocalDateTime.now().plusDays(30));
+        when(mockMemberCardRecord.getStatus()).thenReturn(cn.novalon.gym.manage.member.enums.MemberCardRecordStatus.ACTIVE);
+    }
+
+    @Test
+    @DisplayName("测试1: 获取二维码 - getQRCode")
+    void testGetQRCode() {
+        when(memberCardRecordRepository.findActiveCardsByMemberId(1L))
+                .thenReturn(Flux.just(mockMemberCardRecord));
+        when(redisUtil.setWithExpire(any(String.class), any(Map.class), any(Long.class)))
+                .thenReturn(Mono.just(true));
+
+        Mono<QRCodeVo> result = checkService.getQRCode(1L);
+
+        StepVerifier.create(result)
+                .expectNextMatches(qrCodeVo -> {
+                    org.junit.jupiter.api.Assertions.assertNotNull(qrCodeVo);
+                    org.junit.jupiter.api.Assertions.assertNotNull(qrCodeVo.getQrContent());
+                    return true;
+                })
+                .verifyComplete();
+    }
+
+    @Test
+    @DisplayName("测试2: 签到 - checkIn")
+    void testCheckIn() {
+        Long memberId = 1L;
+        Map<String, Object> qrData = new HashMap<>();
+        qrData.put("qrContent", "test-qr-content");
+        qrData.put("memberId", memberId);
+        qrData.put("memberCardRecordId", 1L);
+        qrData.put("isUsed", false);
+        qrData.put("expireTime", System.currentTimeMillis() + 3600000);
+        
+        String key = RedisKeyConstants.QRCODE_USER_DAILY + memberId + LocalDate.now();
+        
+        when(redisUtil.get(eq(key))).thenReturn(Mono.just(qrData));
+        when(memberCardRecordRepository.findById(1L)).thenReturn(Mono.just(mockMemberCardRecord));
+        when(memberCardRepository.findByMemberCardIdAndDeletedAtIsNull(1L)).thenReturn(Mono.just(mockMemberCard));
+        when(signInRecordRepository.save(any(SignInRecord.class))).thenReturn(Mono.just(mockSignInRecord));
+        when(redisUtil.set(any(String.class), any(Map.class))).thenReturn(Mono.just(true));
+        when(groupCourseBookingService.getBookingsByMemberId(memberId)).thenReturn(Flux.empty());
+        when(signInRecordRepository.findByMemberIdAndDate(eq(memberId), any(LocalDateTime.class), any(LocalDateTime.class)))
+                .thenReturn(Mono.empty());
+
+        Mono<String> result = checkService.checkIn(memberId, "test-qr-content");
+
+        StepVerifier.create(result)
+                .expectNextMatches(response -> response.contains("签到成功"))
+                .verifyComplete();
+    }
+
+    @Test
+    @DisplayName("测试3: 查询签到记录列表 - getSignInRecords")
+    void testGetSignInRecords() {
+        when(signInRecordRepository.findByMemberIdAndTimeRange(
+                eq(1L), any(LocalDateTime.class), any(LocalDateTime.class)))
+                .thenReturn(Flux.just(mockSignInRecord));
+
+        Flux<SignInRecordVO> result = checkService.getSignInRecords(1L, 
+                LocalDate.now().minusDays(30), LocalDate.now());
+
+        StepVerifier.create(result)
+                .expectNextCount(1)
+                .verifyComplete();
+    }
+
+    @Test
+    @DisplayName("测试4: 查询单条签到记录 - getSignInRecordById")
+    void testGetSignInRecordById() {
+        when(signInRecordRepository.findById(1L))
+                .thenReturn(Mono.just(mockSignInRecord));
+
+        Mono<SignInRecordVO> result = checkService.getSignInRecordById(1L);
+
+        StepVerifier.create(result)
+                .expectNextMatches(vo -> vo.getId() == 1L)
+                .verifyComplete();
+    }
+
+    @Test
+    @DisplayName("测试5: 查询签到记录 - 记录不存在")
+    void testGetSignInRecordById_NotFound() {
+        when(signInRecordRepository.findById(999L))
+                .thenReturn(Mono.empty());
+
+        Mono<SignInRecordVO> result = checkService.getSignInRecordById(999L);
+
+        StepVerifier.create(result)
+                .verifyComplete();
+    }
+
+    @Test
+    @DisplayName("测试6: 获取签到统计 - getSignInStats")
+    void testGetSignInStats() {
+        when(signInRecordRepository.countByMemberIdAndTimeRange(
+                eq(1L), any(LocalDateTime.class), any(LocalDateTime.class)))
+                .thenReturn(Mono.just(10L));
+        when(signInRecordRepository.countSuccessByMemberIdAndTimeRange(
+                eq(1L), any(LocalDateTime.class), any(LocalDateTime.class)))
+                .thenReturn(Mono.just(8L));
+        when(signInRecordRepository.getFirstSignInTime(
+                eq(1L), any(LocalDateTime.class), any(LocalDateTime.class)))
+                .thenReturn(Mono.just(LocalDateTime.now().minusDays(29)));
+        when(signInRecordRepository.getLastSignInTime(
+                eq(1L), any(LocalDateTime.class), any(LocalDateTime.class)))
+                .thenReturn(Mono.just(LocalDateTime.now()));
+
+        Mono<SignInStatsVO> result = checkService.getSignInStats(1L, 
+                LocalDate.now().minusDays(30), LocalDate.now());
+
+        StepVerifier.create(result)
+                .expectNextMatches(stats -> {
+                    org.junit.jupiter.api.Assertions.assertEquals(10L, stats.getTotalCount());
+                    org.junit.jupiter.api.Assertions.assertEquals(8L, stats.getSuccessCount());
+                    return true;
+                })
+                .verifyComplete();
+    }
+
+    @Test
+    @DisplayName("测试7: 获取每日签到统计 - getDailySignInStats")
+    void testGetDailySignInStats() {
+        when(signInRecordRepository.countByTimeRange(any(LocalDateTime.class), any(LocalDateTime.class)))
+                .thenReturn(Mono.just(50L));
+        when(signInRecordRepository.countSuccessByTimeRange(
+                any(LocalDateTime.class), any(LocalDateTime.class)))
+                .thenReturn(Mono.just(45L));
+        when(signInRecordRepository.countDistinctMembersByTimeRange(
+                any(LocalDateTime.class), any(LocalDateTime.class)))
+                .thenReturn(Mono.just(30L));
+
+        Mono<SignInStatsVO> result = checkService.getDailySignInStats(LocalDate.now());
+
+        StepVerifier.create(result)
+                .expectNextMatches(stats -> {
+                    org.junit.jupiter.api.Assertions.assertEquals(50L, stats.getTotalCount());
+                    org.junit.jupiter.api.Assertions.assertEquals(45L, stats.getSuccessCount());
+                    org.junit.jupiter.api.Assertions.assertEquals(30L, stats.getUniqueMemberCount());
+                    return true;
+                })
+                .verifyComplete();
+    }
+
+    @Test
+    @DisplayName("测试8: 导出签到记录 - exportSignInRecords")
+    void testExportSignInRecords() {
+        when(signInRecordRepository.findByMemberIdAndTimeRange(
+                eq(1L), any(LocalDateTime.class), any(LocalDateTime.class)))
+                .thenReturn(Flux.just(mockSignInRecord));
+
+        Mono<byte[]> result = checkService.exportSignInRecords(1L, 
+                LocalDate.now().minusDays(7), LocalDate.now());
+
+        StepVerifier.create(result)
+                .expectNextMatches(bytes -> bytes.length > 0)
+                .verifyComplete();
+    }
+
+    @Test
+    @DisplayName("测试9: 签到失败 - 二维码无效")
+    void testCheckIn_QRCodeInvalid() {
+        Long memberId = 1L;
+        String key = RedisKeyConstants.QRCODE_USER_DAILY + memberId + LocalDate.now();
+        when(redisUtil.get(eq(key))).thenReturn(Mono.just(new HashMap<>()));
+        when(signInRecordRepository.findByMemberIdAndDate(eq(memberId), any(LocalDateTime.class), any(LocalDateTime.class)))
+                .thenReturn(Mono.empty());
+
+        Mono<String> result = checkService.checkIn(memberId, "invalid-qr");
+
+        StepVerifier.create(result)
+                .expectError(RuntimeException.class)
+                .verify();
+    }
+
+    @Test
+    @DisplayName("测试10: 签到失败 - 二维码不存在")
+    void testCheckIn_QRCodeNotFound() {
+        Long memberId = 1L;
+        String key = RedisKeyConstants.QRCODE_USER_DAILY + memberId + LocalDate.now();
+        when(redisUtil.get(eq(key))).thenReturn(Mono.empty());
+        when(signInRecordRepository.findByMemberIdAndDate(eq(memberId), any(LocalDateTime.class), any(LocalDateTime.class)))
+                .thenReturn(Mono.empty());
+
+        Mono<String> result = checkService.checkIn(memberId, "not-exist");
+
+        StepVerifier.create(result)
+                .verifyComplete();
+    }
+}

gym-manage-api/gym-checkIn/src/test/resources/application-test.yml

@@ -0,0 +1 @@
+# Test Configuration

gym-manage-api/gym-member/src/main/java/cn/novalon/gym/manage/member/dto/SearchMemberDto.java

@@ -12,9 +12,6 @@ public class SearchMemberDto {
     // 搜索字段 - 包括 会员号、昵称、手机号
     private String searchValue;
 
-    // 排序
-    private String filter;
-
     // 页码
     private Integer pageNum = 1;
 

gym-manage-api/gym-member/src/main/java/cn/novalon/gym/manage/member/dto/UpdateMemberInfoDto.java

@@ -1,30 +1,32 @@
 package cn.novalon.gym.manage.member.dto;
 
+import cn.novalon.gym.manage.member.enums.GenderEnum;
 import lombok.Data;
 
+import java.time.LocalDate;
 import java.util.Date;
 
 /**
  * 更新会员信息Dto
- * 
+ *
  * @author 付嘉
  * @date 2026-05-10
  */
 @Data
 public class UpdateMemberInfoDto {
-    
+
     // 昵称
     private String nickname;
-    
+
     // 性别
-    private Integer gender;
-    
+    private GenderEnum gender;
+
     // 生日
-    private Date birthday;
-    
+    private LocalDate birthday;
+
     // 头像
     private String avatar;
-    
+
     // 地址
     private String address;
-}
+}

gym-manage-api/gym-member/src/main/java/cn/novalon/gym/manage/member/entity/BaseEntity.java

@@ -33,6 +33,9 @@ public abstract class BaseEntity implements Persistable<Long> {
     @Column("updated_at")
     private LocalDateTime updatedAt;
 
+    @Column("deleted_at")
+    private LocalDateTime deletedAt;
+
     // 判断当前实体是否是新建的
     @Override
     public boolean isNew() {

gym-manage-api/gym-member/src/main/java/cn/novalon/gym/manage/member/entity/Member.java

@@ -1,13 +1,10 @@
 package cn.novalon.gym.manage.member.entity;
 
-import lombok.AllArgsConstructor;
-import lombok.Builder;
-import lombok.Data;
-import lombok.EqualsAndHashCode;
-import lombok.NoArgsConstructor;
+import lombok.*;
 import org.springframework.data.relational.core.mapping.Column;
 import org.springframework.data.relational.core.mapping.Table;
 
+import java.time.LocalDate;
 import java.time.LocalDateTime;
 import java.util.Date;
 
@@ -44,7 +41,7 @@ public class Member extends BaseEntity {
 
     //生日
     @Column("birthday")
-    private Date birthday;
+    private LocalDate birthday;
 
     //地址
     @Column("address")

gym-manage-api/gym-member/src/main/java/cn/novalon/gym/manage/member/entity/SignInRecord.java

@@ -1,38 +0,0 @@
-package cn.novalon.gym.manage.member.entity;
-
-import lombok.*;
-import org.springframework.data.annotation.CreatedDate;
-import org.springframework.data.annotation.Id;
-import org.springframework.data.relational.core.mapping.Column;
-import org.springframework.data.relational.core.mapping.Table;
-
-import java.time.LocalDate;
-import java.time.LocalDateTime;
-
-@Data
-@Builder
-@NoArgsConstructor
-@AllArgsConstructor
-@Table("sign_in_record")
-public class SignInRecord {
-
-    @Id
-    private Long id;
-
-    // 会员ID
-    @Column("member_id")
-    private Long memberId;
-
-    // 签到日期
-    @Column("sign_in_date")
-    private LocalDate signInDate;
-
-    // 签到时间
-    @Column("sign_in_time")
-    private LocalDateTime signInTime;
-
-    // 创建时间
-    @CreatedDate
-    @Column("created_at")
-    private LocalDateTime createdAt;
-}

gym-manage-api/gym-member/src/main/java/cn/novalon/gym/manage/member/enums/GenderEnum.java

@@ -0,0 +1,37 @@
+package cn.novalon.gym.manage.member.enums;
+
+import lombok.Getter;
+
+/**
+ * 性别枚举
+ *
+ * @author 付嘉
+ * @date 2026-05-29
+ */
+@Getter
+public enum GenderEnum {
+
+    UNKNOWN(0, "未知"),
+    MALE(1, "男"),
+    FEMALE(2, "女");
+
+    private final Integer code;
+    private final String desc;
+
+    GenderEnum(Integer code, String desc) {
+        this.code = code;
+        this.desc = desc;
+    }
+
+    public static GenderEnum fromCode(Integer code) {
+        if (code == null) {
+            return UNKNOWN;
+        }
+        for (GenderEnum gender : values()) {
+            if (gender.code.equals(code)) {
+                return gender;
+            }
+        }
+        return UNKNOWN;
+    }
+}

gym-manage-api/gym-member/src/main/java/cn/novalon/gym/manage/member/es/entity/MemberES.java

@@ -1,12 +1,18 @@
 package cn.novalon.gym.manage.member.es.entity;
 
+import lombok.AllArgsConstructor;
 import lombok.Data;
+import lombok.NoArgsConstructor;
 import org.springframework.data.annotation.Id;
 import org.springframework.data.elasticsearch.annotations.Document;
 import org.springframework.data.elasticsearch.annotations.Field;
 import org.springframework.data.elasticsearch.annotations.FieldType;
 
+import java.time.LocalDateTime;
+
 @Data
+@NoArgsConstructor
+@AllArgsConstructor
 @Document(indexName = "gym_members")
 public class MemberES {
 

gym-manage-api/gym-member/src/main/java/cn/novalon/gym/manage/member/es/repository/MemberESRepository.java

@@ -2,6 +2,7 @@ package cn.novalon.gym.manage.member.es.repository;
 
 import cn.novalon.gym.manage.member.es.entity.MemberES;
 import org.springframework.data.domain.Pageable;
+import org.springframework.data.elasticsearch.annotations.Query;
 import org.springframework.data.elasticsearch.repository.ReactiveElasticsearchRepository;
 import org.springframework.stereotype.Repository;
 import reactor.core.publisher.Flux;
@@ -15,6 +16,6 @@ public interface MemberESRepository extends ReactiveElasticsearchRepository<Memb
     /**
      * 前台通用搜索：会员号（精确匹配） 或 昵称（模糊匹配） 或 手机号（精确匹配）并且 性别筛选（精确匹配）
      */
-    Flux<MemberES> findByMemberNoOrPhoneOrNicknameContainingAndGender(
-            String memberNo, String phone, String nickname,String gender, Pageable pageable);
+    Flux<MemberES> findByMemberNoOrPhoneOrNicknameContaining(
+            String memberNo, String phone, String nickname, Pageable pageable);
 }

gym-manage-api/gym-member/src/main/java/cn/novalon/gym/manage/member/handler/MemberHandler.java

@@ -8,8 +8,11 @@ import cn.novalon.gym.manage.member.service.MemberService;
 import cn.novalon.gym.manage.member.service.WechatAuthService;
 import cn.novalon.gym.manage.member.service.WechatOfficialService;
 import cn.novalon.gym.manage.member.util.AesUtil;
+import cn.novalon.gym.manage.member.util.WechatPhoneUtil;
 import cn.novalon.gym.manage.sys.util.AuthUtil;
 import cn.novalon.gym.manage.sys.security.JwtTokenProvider;
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.tags.Tag;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 import org.apache.commons.lang3.math.NumberUtils;
@@ -29,21 +32,15 @@ import reactor.core.publisher.Mono;
 @Slf4j
 @Component
 @RequiredArgsConstructor
+@Tag(name = "会员管理", description = "会员信息管理、微信绑定、服务号关注等")
 public class MemberHandler {
 
     private final MemberService memberService;
     private final WechatAuthService wechatAuthService;
     private final WechatOfficialService wechatOfficialService;
-    private final JwtTokenProvider jwtTokenProvider;
-    private final WechatProperties wechatProperties;
     private final AuthUtil authUtil;
 
-    /**
-     * 获取会员信息
-     *
-     * GET /api/member/info
-     * header: { "Authorization": "Bearer xxx" }
-     */
+    @Operation(summary = "获取会员信息", description = "根据当前登录用户获取会员基本信息")
     public Mono<ServerResponse> getMemberInfo(ServerRequest request) {
 
         Long memberId = authUtil.getMemberIdOrThrow(request);
@@ -56,19 +53,7 @@ public class MemberHandler {
                             .bodyValue(info));
     }
 
-    /**
-     * 更新会员信息
-     *
-     * PUT /api/member/info
-     * header: { "Authorization": "Bearer xxx" }
-     * Body: {
-     *   "nickname": "新昵称",
-     *   "gender": 1,
-     *   "birthday": "2000-01-01",
-     *   "avatar": "https://example.com/avatar.jpg",
-     *   "address": "北京市朝阳区"
-     * }
-     */
+    @Operation(summary = "更新会员信息", description = "更新会员昵称、性别、生日、头像、地址等信息")
     public Mono<ServerResponse> updateMemberInfo(ServerRequest request) {
 
         Long memberId = authUtil.getMemberIdOrThrow(request);
@@ -82,11 +67,7 @@ public class MemberHandler {
                         .bodyValue(info));
     }
 
-    /**
-     * 绑定手机号（微信小程序）
-     * header: { "Authorization": "Bearer xxx" }
-     * POST /api/member/phone/bind?code=PHONE_CODE
-     */
+    @Operation(summary = "绑定手机号", description = "通过微信小程序手机号code绑定会员手机号")
     public Mono<ServerResponse> bindPhone(ServerRequest request) {
 
         Long memberId = authUtil.getMemberIdOrThrow(request);
@@ -103,12 +84,7 @@ public class MemberHandler {
                         .bodyValue(success));
     }
 
-    /**
-     * 查询服务号关注状态
-     *
-     * GET /api/member/subscribe/status
-     *
-     */
+    @Operation(summary = "查询服务号关注状态", description = "查询会员是否关注微信服务号")
     public Mono<ServerResponse> checkSubscribeStatus(ServerRequest request) {
 
         Long memberId = authUtil.getMemberIdOrThrow(request);
@@ -123,14 +99,7 @@ public class MemberHandler {
                 });
     }
 
-    /**
-     * 管理员更新手机号
-     *
-     * POST /api/admin/member/123/phone
-     * header: { "Authorization": "Bearer xxx" }
-     * Body: { "phone": "13800138000" }
-     *
-     */
+    @Operation(summary = "管理员更新手机号", description = "后台管理员为会员更新手机号")
     public Mono<ServerResponse> adminUpdatePhone(ServerRequest request) {
 
         Long adminId = authUtil.getMemberIdOrThrow(request);
@@ -162,13 +131,7 @@ public class MemberHandler {
                 });
     }
 
-    /**
-     * 前台查看会员信息
-     *
-     * GET /api/admin/member/{id}
-     * header: { "Authorization": "xxx" }
-     *
-     */
+    @Operation(summary = "管理员查看会员详情", description = "后台管理员查看指定会员的详细信息")
     public Mono<ServerResponse> adminGetMemberInfo(ServerRequest request) {
 
         Long adminId = authUtil.getMemberIdOrThrow(request);
@@ -179,20 +142,24 @@ public class MemberHandler {
 
         log.info("前台查看会员信息, adminId: {}, memberId: {}", adminId, memberId);
 
-        // TODO 多表查询：会员信息、团课信息、会员卡信息
-
-        return ServerResponse.ok()
-                .contentType(MediaType.APPLICATION_JSON)
-                .bodyValue("成功");
+        return memberService.getMemberDetail(memberId)
+                .flatMap(detail -> {
+                    if (detail.getPhone() != null && !detail.getPhone().isEmpty()) {
+                        try {
+                            String decryptedPhone = AesUtil.decrypt(detail.getPhone());
+                            detail.setPhone(WechatPhoneUtil.maskPhone(decryptedPhone));
+                        } catch (Exception e) {
+                            log.error("手机号解密失败, memberId: {}", detail.getId(), e);
+                            detail.setPhone(null);
+                        }
+                    }
+                    return ServerResponse.ok()
+                        .contentType(MediaType.APPLICATION_JSON)
+                        .bodyValue(detail);
+                });
     }
 
-    /**
-     * 前台编辑会员信息
-     *
-     * PUT /api/admin/member/{id}
-     * header: { "Authorization": "xxx" }
-     * Body:{"字段","值"}
-     */
+    @Operation(summary = "管理员编辑会员信息", description = "后台管理员编辑会员信息")
     public Mono<ServerResponse> adminUpdateMemberInfo(ServerRequest request) {
 
         Long adminId = authUtil.getMemberIdOrThrow(request);
@@ -201,42 +168,35 @@ public class MemberHandler {
         long memberId = NumberUtils.toLong(memberIdStr, 0L);
         if(memberId <= 0L) throw new IllegalArgumentException("会员ID格式错误");
 
+        // TODO: 补充签到记录
         log.info("前台编辑会员信息, adminId: {}, memberId: {}", adminId, memberId);
 
-        // TODO 多表查询：会员信息、团课信息、会员卡信息
-
-        return ServerResponse.ok()
-                .contentType(MediaType.APPLICATION_JSON)
-                .bodyValue("成功");
+        return request.bodyToMono(UpdateMemberInfoDto.class)
+                .flatMap(updateDto -> memberService.adminUpdateMemberInfo(memberId, updateDto))
+                .flatMap(detail -> ServerResponse.ok()
+                        .contentType(MediaType.APPLICATION_JSON)
+                        .bodyValue(detail));
     }
 
-    /**
-     * 前台搜索会员列表
-     *
-     * GET /api/admin/members?searchValue=手机号/姓名/会员号&filter=男/女&pageNum=1&pageSize=10
-     * header: { "Authorization": "Bearer xxx" }
-     */
+    @Operation(summary = "搜索会员列表", description = "后台管理员按关键词搜索会员，支持性别筛选和分页")
     public Mono<ServerResponse> searchMembers(ServerRequest request) {
 
         Long adminId = authUtil.getMemberIdOrThrow(request);
 
         String keyword = request.queryParam("searchValue").orElse(null);
-        String filter = request.queryParam("filter").orElse(null);
-        int pageNum = NumberUtils.toInt(request.queryParam("pageNum").orElse("1"), 1);
-        int pageSize = NumberUtils.toInt(request.queryParam("pageSize").orElse("10"), 10);
+        Integer pageNum = NumberUtils.toInt(request.queryParam("pageNum").orElse("1"), 1);
+        Integer pageSize = NumberUtils.toInt(request.queryParam("pageSize").orElse("10"), 10);
 
-        log.info("前台搜索会员列表, adminId: {}, keyword: {}, filter: {}, pageNum: {}, pageSize: {}",
-                adminId, keyword, filter, pageNum, pageSize);
+        log.info("前台搜索会员列表, adminId: {}, keyword: {},pageNum: {}, pageSize: {}",
+                adminId, keyword, pageNum, pageSize);
 
-        return memberService.searchMember(new SearchMemberDto(keyword, filter, pageNum, pageSize))
+        return memberService.searchMember(new SearchMemberDto(keyword, pageNum, pageSize))
                 .map(member -> {
                     // 解密手机号
                     if (member.getPhone() != null && !member.getPhone().isEmpty()) {
                         try {
-                            String secretKey = wechatProperties.getPhoneEncryption().getSecretKey();
-                            String iv = wechatProperties.getPhoneEncryption().getIv();
-                            String decryptedPhone = AesUtil.decrypt(member.getPhone(), secretKey, iv);
-                            member.setPhone(decryptedPhone);
+                            String decryptedPhone = AesUtil.decrypt(member.getPhone());
+                            member.setPhone(WechatPhoneUtil.maskPhone(decryptedPhone));
                         } catch (Exception e) {
                             log.error("手机号解密失败, memberId: {}", member.getId(), e);
                             member.setPhone(null);
@@ -249,12 +209,7 @@ public class MemberHandler {
     }
 
 
-    /**
-     * 前台查看会员列表
-     *
-     * GET /api/admin/members/all?pageNum=1&pageSize=10
-     * header: { "Authorization": "Bearer xxx" }
-     */
+    @Operation(summary = "查看会员列表", description = "后台管理员分页查看所有会员列表")
     public Mono<ServerResponse> getAllMembers(ServerRequest request) {
 
         Long adminId = authUtil.getMemberIdOrThrow(request);
@@ -263,16 +218,15 @@ public class MemberHandler {
         int pageSize = NumberUtils.toInt(request.queryParam("pageSize").orElse("10"), 10);
 
         log.info("前台查看会员列表, adminId: {}, pageNum: {}, pageSize: {}", adminId, pageNum, pageSize);
+        // TODO: 补充签到记录
 
         return memberService.findAll(pageNum, pageSize)
                 .map(member -> {
                     // 解密手机号
                     if (member.getPhone() != null && !member.getPhone().isEmpty()) {
                         try {
-                            String secretKey = wechatProperties.getPhoneEncryption().getSecretKey();
-                            String iv = wechatProperties.getPhoneEncryption().getIv();
-                            String decryptedPhone = AesUtil.decrypt(member.getPhone(), secretKey, iv);
-                            member.setPhone(decryptedPhone);
+                            String decryptedPhone = AesUtil.decrypt(member.getPhone());
+                            member.setPhone(WechatPhoneUtil.maskPhone(decryptedPhone));
                         } catch (Exception e) {
                             log.error("手机号解密失败, memberId: {}", member.getId(), e);
                             member.setPhone(null);

gym-manage-api/gym-member/src/main/java/cn/novalon/gym/manage/member/handler/WechatAuthHandler.java

@@ -2,6 +2,8 @@ package cn.novalon.gym.manage.member.handler;
 
 import cn.novalon.gym.manage.member.dto.WechatLoginDto;
 import cn.novalon.gym.manage.member.service.WechatAuthService;
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.tags.Tag;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.http.MediaType;
@@ -20,20 +22,13 @@ import reactor.core.publisher.Mono;
 @Slf4j
 @Component
 @RequiredArgsConstructor
+@Tag(name = "微信认证", description = "微信小程序登录、公众号回调等")
 public class WechatAuthHandler {
 
     private final WechatAuthService wechatAuthService;
     private final WechatOfficialEventHandler wechatOfficialEventHandler;
 
-    /**
-     * 小程序更新
-     * 
-     * POST /api/member/auth/miniapp/login
-     * Body: {"code": "wx_login_code"}
-     * 
-     * @param request ServerRequest
-     * @return Mono<ServerResponse> 登录响应
-     */
+    @Operation(summary = "微信小程序登录", description = "通过微信小程序code获取session_key，完成会员登录或注册")
     public Mono<ServerResponse> miniappLogin(ServerRequest request) {
         log.info("收到小程序登录请求");
         
@@ -50,18 +45,12 @@ public class WechatAuthHandler {
                 });
     }
 
-    /**
-     * 公众号回调
-     * 
-     * POST /api/member/auth/mp/callback
-     * Body: <xml><Event>subscribe</Event><FromUserName>openid</FromUserName></xml>
-     * 
-     */
+    @Operation(summary = "微信公众号回调", description = "处理微信公众号事件（关注、取消关注等）")
     public Mono<ServerResponse> mpCallback(ServerRequest request) {
         return wechatOfficialEventHandler.handleEvent(request);
     }
 
-    // 验证微信公众号签名
+    @Operation(summary = "验证微信公众号签名", description = "微信公众号服务器验证，返回echostr")
     public Mono<ServerResponse> verifyMpSignature(ServerRequest request) {
         return wechatOfficialEventHandler.verifySignature(request);
     }

gym-manage-api/gym-member/src/main/java/cn/novalon/gym/manage/member/handler/WechatOfficialEventHandler.java

@@ -39,9 +39,6 @@ public class WechatOfficialEventHandler {
         return request.bodyToMono(String.class)
                 .flatMap(xmlBody -> {
                     log.info("收到微信公众号事件 {}", xmlBody);
-
-                    // TODO: 将XML解析为WechatOfficialEventDto
-                    // 目前简化处理直接获取openId和event
                     
                     String openId = extractOpenId(xmlBody);
                     String event = extractEvent(xmlBody);

gym-manage-api/gym-member/src/main/java/cn/novalon/gym/manage/member/repository/IMemberRepository.java

@@ -1,7 +1,9 @@
 package cn.novalon.gym.manage.member.repository;
 
 import cn.novalon.gym.manage.member.entity.Member;
+import cn.novalon.gym.manage.member.vo.MemberCardInfoVO;
 import org.springframework.data.domain.Pageable;
+import org.springframework.data.r2dbc.repository.Query;
 import org.springframework.data.r2dbc.repository.R2dbcRepository;
 import org.springframework.stereotype.Repository;
 import reactor.core.publisher.Flux;
@@ -30,7 +32,44 @@ public interface IMemberRepository extends R2dbcRepository<Member, Long> {
 
     /**
      * 分页查询所有会员
-     * 方法名 findAllBy 是 Spring Data 的约定，表示按条件查询所有
      */
     Flux<Member> findAllBy(Pageable pageable);
+
+    /**
+     * 查询会员的所有卡片
+     */
+    @Query("SELECT " +
+            "   r.id, " +
+            "   r.member_card_record_id, " +
+            "   r.member_id, " +
+            "   r.member_card_id, " +
+            "   r.status, " +
+            "   r.remaining_times, " +
+            "   r.remaining_amount, " +
+            "   r.expire_time, " +
+            "   r.purchase_time, " +
+            "   r.source_order_id, " +
+            "   r.created_at, " +
+            "   r.updated_at, " +
+            "   r.version, " +
+            "   r.card_composition, " +
+            "   c.id AS card_id, " +
+            "   c.member_card_id, " +
+            "   c.member_card_name, " +
+            "   c.member_card_type, " +
+            "   c.member_card_price, " +
+            "   c.member_card_validity_days, " +
+            "   c.member_card_total_times, " +
+            "   c.member_card_amount, " +
+            "   c.member_card_status, " +
+            "   c.extra_config, " +
+            "   c.created_at AS card_created_at, " +
+            "   c.updated_at AS card_updated_at " +
+            "FROM member_card_record r " +
+            "LEFT JOIN member_card c ON r.member_card_id = c.id " +
+            "WHERE r.member_id = :memberId " +
+            "AND r.deleted_at IS NULL " +
+            "AND c.deleted_at IS NULL " +
+            "ORDER BY r.created_at DESC")
+    Flux<MemberCardInfoVO> findCardRecordsWithCardInfoByMemberId(Long memberId);
 }

gym-manage-api/gym-member/src/main/java/cn/novalon/gym/manage/member/repository/MemberCardRecordRepository.java

@@ -13,7 +13,7 @@ import java.time.LocalDateTime;
 
 /**
  * 会员卡记录 Repository（会员持有的卡）
- * 
+ *
  * @author 付嘉
  * @date 2026-05-27
  */

gym-manage-api/gym-member/src/main/java/cn/novalon/gym/manage/member/service/MemberService.java

@@ -4,6 +4,7 @@ import cn.novalon.gym.manage.member.dto.SearchMemberDto;
 import cn.novalon.gym.manage.member.dto.UpdateMemberInfoDto;
 import cn.novalon.gym.manage.member.entity.Member;
 import cn.novalon.gym.manage.member.es.entity.MemberES;
+import cn.novalon.gym.manage.member.vo.MemberDetailVO;
 import cn.novalon.gym.manage.member.vo.MemberInfoVO;
 import reactor.core.publisher.Flux;
 import reactor.core.publisher.Mono;
@@ -58,4 +59,21 @@ public interface MemberService {
      * @return 所有会员信息
      */
     Flux<Member> findAll(Integer pageNum, Integer pageSize);
+
+    /**
+     * 前台管理端获取会员详情（含会员卡信息）
+     *
+     * @param memberId 会员ID
+     * @return 会员详情
+     */
+    Mono<MemberDetailVO> getMemberDetail(Long memberId);
+
+    /**
+     * 前台管理端编辑会员信息
+     *
+     * @param memberId 会员ID
+     * @param updateDto 更新信息DTO
+     * @return 更新后的会员详情
+     */
+    Mono<Boolean> adminUpdateMemberInfo(Long memberId, UpdateMemberInfoDto updateDto);
 }

gym-manage-api/gym-member/src/main/java/cn/novalon/gym/manage/member/service/impl/MemberCardRecordServiceImpl.java

@@ -3,6 +3,8 @@ package cn.novalon.gym.manage.member.service.impl;
 import cn.novalon.gym.manage.member.entity.MemberCardRecord;
 import cn.novalon.gym.manage.member.repository.MemberCardRecordRepository;
 import cn.novalon.gym.manage.member.service.IMemberCardRecordService;
+import cn.novalon.gym.manage.common.util.RedisUtil;
+import lombok.extern.slf4j.Slf4j;
 import org.springframework.data.domain.Pageable;
 import org.springframework.stereotype.Service;
 import reactor.core.publisher.Flux;
@@ -16,17 +18,35 @@ import java.time.LocalDateTime;
  * @author 付嘉
  * @date 2026-05-27
  */
+@Slf4j
 @Service
 public class MemberCardRecordServiceImpl implements IMemberCardRecordService {
     private final MemberCardRecordRepository memberCardRecordRepository;
+    private final RedisUtil redisUtil;
 
-    public MemberCardRecordServiceImpl(MemberCardRecordRepository memberCardRecordRepository) {
+    private static final String MEMBER_CARD_RECORD_CACHE_PREFIX = "member:card:record:";
+    private static final long CACHE_EXPIRE_SECONDS = 300;
+
+    public MemberCardRecordServiceImpl(MemberCardRecordRepository memberCardRecordRepository, RedisUtil redisUtil) {
         this.memberCardRecordRepository = memberCardRecordRepository;
+        this.redisUtil = redisUtil;
     }
 
     @Override
     public Mono<MemberCardRecord> findById(Long recordId) {
-        return memberCardRecordRepository.findById(recordId);
+        String cacheKey = MEMBER_CARD_RECORD_CACHE_PREFIX + recordId;
+        Object cached = redisUtil.get(cacheKey);
+        if (cached != null && cached instanceof MemberCardRecord) {
+            log.debug("从缓存获取会员卡记录, recordId: {}", recordId);
+            return Mono.just((MemberCardRecord) cached);
+        }
+
+        return memberCardRecordRepository.findById(recordId)
+                .doOnSuccess(record -> {
+                    if (record != null) {
+                        redisUtil.setWithExpire(cacheKey, record, CACHE_EXPIRE_SECONDS);
+                    }
+                });
     }
 
     @Override
@@ -53,17 +73,32 @@ public class MemberCardRecordServiceImpl implements IMemberCardRecordService {
 
     @Override
     public Mono<Integer> deductUsage(Long recordId, Integer deductTimes, Double deductAmount) {
-        return memberCardRecordRepository.deductUsage(recordId, deductTimes, deductAmount);
+        return memberCardRecordRepository.deductUsage(recordId, deductTimes, deductAmount)
+                .doOnSuccess(updated -> {
+                    if (updated > 0) {
+                        clearRecordCache(recordId);
+                    }
+                });
     }
 
     @Override
     public Mono<Integer> renewCard(Long recordId, Integer addTimes, Double addAmount, LocalDateTime newExpireTime) {
-        return memberCardRecordRepository.renewCard(recordId, addTimes, addAmount, newExpireTime);
+        return memberCardRecordRepository.renewCard(recordId, addTimes, addAmount, newExpireTime)
+                .doOnSuccess(updated -> {
+                    if (updated > 0) {
+                        clearRecordCache(recordId);
+                    }
+                });
     }
 
     @Override
     public Mono<Integer> updateStatus(Long recordId, String status) {
-        return memberCardRecordRepository.updateStatus(recordId, status);
+        return memberCardRecordRepository.updateStatus(recordId, status)
+                .doOnSuccess(updated -> {
+                    if (updated > 0) {
+                        clearRecordCache(recordId);
+                    }
+                });
     }
 
     @Override
@@ -80,4 +115,10 @@ public class MemberCardRecordServiceImpl implements IMemberCardRecordService {
     public Flux<MemberCardRecord> findExpiredCards() {
         return memberCardRecordRepository.findExpiredCards();
     }
+
+    private void clearRecordCache(Long recordId) {
+        String cacheKey = MEMBER_CARD_RECORD_CACHE_PREFIX + recordId;
+        redisUtil.delete(cacheKey);
+        log.debug("清除会员卡记录缓存, recordId: {}", recordId);
+    }
 }

gym-manage-api/gym-member/src/main/java/cn/novalon/gym/manage/member/service/impl/MemberCardServiceImpl.java

@@ -1,5 +1,6 @@
 package cn.novalon.gym.manage.member.service.impl;
 
+import cn.novalon.gym.manage.common.util.RedisUtil;
 import cn.novalon.gym.manage.member.entity.MemberCard;
 import cn.novalon.gym.manage.member.entity.MemberCardRecord;
 import cn.novalon.gym.manage.member.entity.MemberCardTransaction;
@@ -15,6 +16,7 @@ import cn.novalon.gym.manage.member.repository.MemberCardRecordRepository;
 import cn.novalon.gym.manage.member.repository.MemberCardRepository;
 import cn.novalon.gym.manage.member.service.IMemberCardService;
 import cn.novalon.gym.manage.member.service.IMemberCardTransactionService;
+
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.data.domain.Pageable;
 import org.springframework.stereotype.Service;
@@ -39,6 +41,10 @@ public class MemberCardServiceImpl implements IMemberCardService {
     private final DistributedLockService distributedLockService;
     private final ExpirationReminderService expirationReminderService;
     private final RefundSagaHandler refundSagaHandler;
+    private final RedisUtil redisUtil;
+
+    private static final String MEMBER_CARD_CACHE_PREFIX = "member:card:";
+    private static final long CACHE_EXPIRE_SECONDS = 300;
 
     public MemberCardServiceImpl(MemberCardRepository memberCardRepository,
                                  MemberCardRecordRepository recordRepository,
@@ -46,7 +52,8 @@ public class MemberCardServiceImpl implements IMemberCardService {
                                  MemberCardStateMachine stateMachine,
                                  DistributedLockService distributedLockService,
                                  ExpirationReminderService expirationReminderService,
-                                 RefundSagaHandler refundSagaHandler) {
+                                 RefundSagaHandler refundSagaHandler,
+                                 RedisUtil redisUtil) {
         this.memberCardRepository = memberCardRepository;
         this.recordRepository = recordRepository;
         this.transactionService = transactionService;
@@ -54,11 +61,24 @@ public class MemberCardServiceImpl implements IMemberCardService {
         this.distributedLockService = distributedLockService;
         this.expirationReminderService = expirationReminderService;
         this.refundSagaHandler = refundSagaHandler;
+        this.redisUtil = redisUtil;
     }
 
     @Override
     public Mono<MemberCard> findByMemberCardIdAndDeletedAtIsNull(Long memberCardId) {
-        return memberCardRepository.findByMemberCardIdAndDeletedAtIsNull(memberCardId);
+        String cacheKey = MEMBER_CARD_CACHE_PREFIX + memberCardId;
+        Object cached = redisUtil.get(cacheKey);
+        if (cached != null && cached instanceof MemberCard) {
+            log.debug("从缓存获取会员卡信息, memberCardId: {}", memberCardId);
+            return Mono.just((MemberCard) cached);
+        }
+
+        return memberCardRepository.findByMemberCardIdAndDeletedAtIsNull(memberCardId)
+                .doOnSuccess(card -> {
+                    if (card != null) {
+                        redisUtil.setWithExpire(cacheKey, card, CACHE_EXPIRE_SECONDS);
+                    }
+                });
     }
 
     @Override
@@ -95,7 +115,12 @@ public class MemberCardServiceImpl implements IMemberCardService {
 
     @Override
     public Mono<MemberCard> save(MemberCard entity) {
-        return memberCardRepository.save(entity);
+        return memberCardRepository.save(entity)
+                .doOnSuccess(saved -> {
+                    if (saved.getMemberCardId() != null) {
+                        clearCardCache(saved.getMemberCardId());
+                    }
+                });
     }
 
     @Override
@@ -329,4 +354,10 @@ public class MemberCardServiceImpl implements IMemberCardService {
 
         return transactionService.createTransaction(transaction);
     }
+
+    private void clearCardCache(Long memberCardId) {
+        String cacheKey = MEMBER_CARD_CACHE_PREFIX + memberCardId;
+        redisUtil.delete(cacheKey);
+        log.debug("清除会员卡缓存, memberCardId: {}", memberCardId);
+    }
 }

gym-manage-api/gym-member/src/main/java/cn/novalon/gym/manage/member/service/impl/MemberServiceImpl.java

@@ -4,20 +4,32 @@ import cn.novalon.gym.manage.common.exception.ConflictException;
 import cn.novalon.gym.manage.common.exception.ErrorCode;
 import cn.novalon.gym.manage.common.exception.NotFoundException;
 import cn.novalon.gym.manage.common.exception.SystemException;
-import cn.novalon.gym.manage.member.config.WechatProperties;
+import cn.novalon.gym.manage.common.util.HtmlEscapeUtil;
 import cn.novalon.gym.manage.member.dto.SearchMemberDto;
 import cn.novalon.gym.manage.member.dto.UpdateMemberInfoDto;
 import cn.novalon.gym.manage.member.entity.Member;
+import cn.novalon.gym.manage.member.enums.GenderEnum;
+import cn.novalon.gym.manage.member.enums.MemberCardType;
 import cn.novalon.gym.manage.member.es.entity.MemberES;
 import cn.novalon.gym.manage.member.es.repository.MemberESRepository;
 import cn.novalon.gym.manage.member.repository.IMemberRepository;
 import cn.novalon.gym.manage.member.service.MemberService;
 import cn.novalon.gym.manage.member.util.AesUtil;
+import cn.novalon.gym.manage.member.util.BeanConvertUtil;
 import cn.novalon.gym.manage.member.util.EsSyncUtils;
+import cn.novalon.gym.manage.common.util.RedisUtil;
+import cn.novalon.gym.manage.member.vo.MemberCardInfoVO;
+import cn.novalon.gym.manage.member.vo.MemberDetailVO;
 import cn.novalon.gym.manage.member.vo.MemberInfoVO;
+import co.elastic.clients.elasticsearch.ElasticsearchClient;
+import co.elastic.clients.elasticsearch.core.IndexResponse;
+import co.elastic.clients.json.jackson.JacksonJsonpMapper;
+import co.elastic.clients.transport.rest_client.RestClientTransport;
 import jakarta.annotation.PostConstruct;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
+import org.apache.http.HttpHost;
+import org.elasticsearch.client.RestClient;
 import org.springframework.data.domain.PageRequest;
 import org.springframework.data.domain.Pageable;
 import org.springframework.data.domain.Sort;
@@ -26,6 +38,10 @@ import reactor.core.publisher.Flux;
 import reactor.core.publisher.Mono;
 
 import java.time.LocalDateTime;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
 
 /**
  * 会员服务实现
@@ -41,10 +57,14 @@ public class MemberServiceImpl implements MemberService {
     private final IMemberRepository memberRepository;
     private final MemberESRepository memberESRepository;
     private final EsSyncUtils esSyncUtils;
-    private final WechatProperties wechatProperties;
+    private final RedisUtil redisUtil;
 
     private EsSyncUtils.EntitySyncer<Member, MemberES, String> memberSyncer;
 
+    private static final String MEMBER_INFO_CACHE_PREFIX = "member:info:";
+    private static final String MEMBER_DETAIL_CACHE_PREFIX = "member:detail:";
+    private static final long CACHE_EXPIRE_SECONDS = 300;
+
     @PostConstruct
     public void init() {
         this.memberSyncer = esSyncUtils.bind(Member.class, MemberES.class, memberESRepository);
@@ -52,12 +72,23 @@ public class MemberServiceImpl implements MemberService {
 
     @Override
     public Mono<MemberInfoVO> getMemberInfo(Long memberId) {
-        return memberRepository.findById(memberId)
-                .map(this::buildMemberInfoResponse)
-                .switchIfEmpty(Mono.error(() -> {
-                    log.error("会员不存在: memberId={}", memberId);
-                    throw new NotFoundException(ErrorCode.NOT_FOUND_USER, "会员不存在");
-                }));
+        String cacheKey = MEMBER_INFO_CACHE_PREFIX + memberId;
+
+        return redisUtil.get(cacheKey, MemberInfoVO.class)
+                .flatMap(cached -> {
+                    if (cached != null) {
+                        log.debug("从缓存获取会员信息, memberId: {}", memberId);
+                        return Mono.just(cached);
+                    }
+                    return memberRepository.findById(memberId)
+                            .map(this::buildMemberInfoResponse)
+                            .flatMap(vo -> redisUtil.setWithExpire(cacheKey, vo, CACHE_EXPIRE_SECONDS)
+                                    .then(Mono.just(vo)))
+                            .switchIfEmpty(Mono.error(() -> {
+                                log.error("会员不存在: memberId={}", memberId);
+                                throw new NotFoundException(ErrorCode.NOT_FOUND_USER, "会员不存在");
+                            }));
+                });
     }
 
     @Override
@@ -67,10 +98,10 @@ public class MemberServiceImpl implements MemberService {
         return memberRepository.findById(memberId)
                 .flatMap(member -> {
                     if (updateDto.getNickname() != null) {
-                        member.setNickname(updateDto.getNickname());
+                        member.setNickname(HtmlEscapeUtil.escape(updateDto.getNickname()));
                     }
                     if (updateDto.getGender() != null) {
-                        member.setGender(updateDto.getGender());
+                        member.setGender(updateDto.getGender().getCode());
                     }
                     if (updateDto.getBirthday() != null) {
                         member.setBirthday(updateDto.getBirthday());
@@ -79,12 +110,16 @@ public class MemberServiceImpl implements MemberService {
                         member.setAvatar(updateDto.getAvatar());
                     }
                     if (updateDto.getAddress() != null) {
-                        member.setAddress(updateDto.getAddress());
+                        member.setAddress(HtmlEscapeUtil.escape(updateDto.getAddress()));
                     }
 
                     return memberRepository.save(member);
                 })
-                .doOnSuccess(memberSyncer::sync)
+                .flatMap(savedMember -> {
+                    memberSyncer.sync(savedMember);
+                    return clearMemberCache(memberId)
+                            .then(Mono.just(savedMember));
+                })
                 .map(savedMember -> {
                     log.info("会员信息更新成功, memberId: {}", savedMember.getId());
                     return buildMemberInfoResponse(savedMember);
@@ -99,11 +134,14 @@ public class MemberServiceImpl implements MemberService {
         String phone = member.getPhone();
         String maskedPhone = phone != null ? phone.replace(phone.substring(3, 7), "****") : null;
 
+        GenderEnum genderEnum = GenderEnum.fromCode(member.getGender());
+
         return MemberInfoVO.builder()
                 .id(member.getId())
                 .nickname(member.getNickname())
                 .phone(maskedPhone)
-                .gender(member.getGender())
+                .gender(genderEnum)
+                .genderDesc(genderEnum.getDesc())
                 .birthday(member.getBirthday())
                 .avatar(member.getAvatar())
                 .hasPhone(phone != null)
@@ -117,9 +155,7 @@ public class MemberServiceImpl implements MemberService {
 
         String encryptedPhone;
         try {
-            String secretKey = wechatProperties.getPhoneEncryption().getSecretKey();
-            String iv = wechatProperties.getPhoneEncryption().getIv();
-            encryptedPhone = AesUtil.encrypt(phone, secretKey, iv);
+            encryptedPhone = AesUtil.encrypt(phone);
             log.info("手机号加密成功");
         } catch (Exception e) {
             log.error("手机号加密失败", e);
@@ -145,32 +181,32 @@ public class MemberServiceImpl implements MemberService {
 
     @Override
     public Flux<MemberES> searchMember(SearchMemberDto searchMemberDto) {
-        log.info("搜索会员, searchValue: {}, filter: {}, pageNum: {}, pageSize: {}",
+        log.info("搜索会员, searchValue: {}, pageNum: {}, pageSize: {}",
                 searchMemberDto.getSearchValue(),
-                searchMemberDto.getFilter(),
                 searchMemberDto.getPageNum(),
                 searchMemberDto.getPageSize());
 
         String searchValue = searchMemberDto.getSearchValue();
 
-        if(searchValue != null && searchValue.matches("^1[3-9]\\d{9}$")){
+        if (searchValue != null && searchValue.matches("^1[3-9]\\d{9}$")) {
             log.debug("搜索值为手机号格式，进行加密处理");
-            String secretKey = wechatProperties.getPhoneEncryption().getSecretKey();
-            String iv = wechatProperties.getPhoneEncryption().getIv();
-            searchValue = AesUtil.encrypt(searchValue,secretKey,iv);
+            searchValue = AesUtil.encrypt(searchValue);
         }
 
         Pageable pageable = PageRequest.of(
                 searchMemberDto.getPageNum() - 1,
-                searchMemberDto.getPageSize(),
-                Sort.by(Sort.Direction.DESC, "update_at")
+                searchMemberDto.getPageSize()
         );
 
-        return memberESRepository.findByMemberNoOrPhoneOrNicknameContainingAndGender(
+        if (searchValue == null) {
+            log.warn("搜索值为空，返回空结果");
+            return Flux.empty();
+        }
+
+        return memberESRepository.findByMemberNoOrPhoneOrNicknameContaining(
                 searchValue,
                 searchValue,
                 searchValue,
-                searchMemberDto.getFilter() ,
                 pageable
         );
     }
@@ -187,6 +223,99 @@ public class MemberServiceImpl implements MemberService {
         return memberRepository.findAllBy(pageable);
     }
 
+    @Override
+    public Mono<MemberDetailVO> getMemberDetail(Long memberId) {
+        log.info("查询会员详情, memberId: {}", memberId);
+
+        String cacheKey = MEMBER_DETAIL_CACHE_PREFIX + memberId;
+
+        return redisUtil.get(cacheKey, MemberDetailVO.class)
+                .flatMap(cached -> {
+                    if (cached != null) {
+                        log.debug("从缓存获取会员详情, memberId: {}", memberId);
+                        return Mono.just(cached);
+                    }
+                    return memberRepository.findById(memberId)
+                            .zipWith(
+                                    memberRepository.findCardRecordsWithCardInfoByMemberId(memberId)
+                                            .collectList(),
+                                    (baseInfo, cardList) -> {
+                                        MemberDetailVO memberDetailVO = BeanConvertUtil.toBean(baseInfo, MemberDetailVO.class);
+
+                                        GenderEnum genderEnum = GenderEnum.fromCode(baseInfo.getGender());
+                                        memberDetailVO.setGenderDesc(genderEnum.getDesc());
+
+                                        List<MemberCardInfoVO> enrichedCards = cardList.stream()
+                                                .peek(vo -> {
+                                                    if (vo.getMemberCardType() != null) {
+                                                        try {
+                                                            MemberCardType cardType = MemberCardType.valueOf(vo.getMemberCardType());
+                                                            vo.setMemberCardTypeDesc(cardType.getDesc());
+                                                        } catch (IllegalArgumentException e) {
+                                                            vo.setMemberCardTypeDesc(vo.getMemberCardType());
+                                                        }
+                                                    }
+                                                    if (vo.getMemberCardStatus() != null) {
+                                                        vo.setMemberCardStatusDesc(vo.getMemberCardStatus() == 1 ? "上架" : "下架");
+                                                    }
+                                                })
+                                                .collect(Collectors.toList());
+                                        memberDetailVO.setMemberCards(enrichedCards);
+
+                                        long activeCount = enrichedCards.stream()
+                                                .filter(card -> card.getMemberCardStatus() != null && card.getMemberCardStatus() == 1)
+                                                .count();
+                                        memberDetailVO.setActiveCardCount((int) activeCount);
+                                        memberDetailVO.setInactiveCardCount(enrichedCards.size() - (int) activeCount);
+
+                                        return memberDetailVO;
+                                    }
+                            )
+                            .flatMap(vo -> redisUtil.setWithExpire(cacheKey, vo, CACHE_EXPIRE_SECONDS)
+                                    .then(Mono.just(vo)));
+                });
+    }
+
+
+    @Override
+    public Mono<Boolean> adminUpdateMemberInfo(Long memberId, UpdateMemberInfoDto updateDto) {
+        log.info("前台管理端编辑会员信息, memberId: {}", memberId);
+
+        return memberRepository.findById(memberId)
+                .switchIfEmpty(Mono.error(() -> {
+                    log.error("会员不存在: memberId={}", memberId);
+                    throw new NotFoundException(ErrorCode.NOT_FOUND_USER, "会员不存在");
+                }))
+                .flatMap(member -> {
+                    if (updateDto.getNickname() != null) {
+                        member.setNickname(HtmlEscapeUtil.escape(updateDto.getNickname()));
+                    }
+                    if (updateDto.getGender() != null) {
+                        member.setGender(updateDto.getGender().getCode());
+                    }
+                    if (updateDto.getBirthday() != null) {
+                        member.setBirthday(updateDto.getBirthday());
+                    }
+                    if (updateDto.getAvatar() != null) {
+                        member.setAvatar(updateDto.getAvatar());
+                    }
+                    if (updateDto.getAddress() != null) {
+                        member.setAddress(HtmlEscapeUtil.escape(updateDto.getAddress()));
+                    }
+
+                    return memberRepository.save(member);
+                })
+                .flatMap(savedMember -> {
+                    memberSyncer.sync(savedMember);
+                    return clearMemberCache(memberId)
+                            .then(Mono.just(true));
+                })
+                .onErrorResume(e -> {
+                    log.error("编辑会员信息失败, memberId: {}, error: {}", memberId, e.getMessage(), e);
+                    return Mono.just(false);
+                });
+    }
+
     private Mono<Boolean> updateMemberPhone(Long memberId, String encryptedPhone) {
         return memberRepository.findById(memberId)
                 .flatMap(member -> {
@@ -194,7 +323,11 @@ public class MemberServiceImpl implements MemberService {
                     member.setLastLoginAt(LocalDateTime.now());
 
                     return memberRepository.save(member)
-                            .doOnSuccess(memberSyncer::sync)
+                            .flatMap(savedMember -> {
+                                memberSyncer.sync(savedMember);
+                                return clearMemberCache(memberId)
+                                        .then(Mono.just(savedMember));
+                            })
                             .map(savedMember -> {
                                 log.info("手机号录入成功, memberId: {}", savedMember.getId());
                                 return true;
@@ -205,4 +338,12 @@ public class MemberServiceImpl implements MemberService {
                     throw new NotFoundException(ErrorCode.NOT_FOUND_USER, "会员不存在");
                 }));
     }
-}
+
+    private Mono<Long> clearMemberCache(Long memberId) {
+        String infoCacheKey = MEMBER_INFO_CACHE_PREFIX + memberId;
+        String detailCacheKey = MEMBER_DETAIL_CACHE_PREFIX + memberId;
+        return redisUtil.delete(infoCacheKey)
+                .then(redisUtil.delete(detailCacheKey))
+                .doOnSuccess(result -> log.debug("清除会员缓存, memberId: {}", memberId));
+    }
+}

gym-manage-api/gym-member/src/main/java/cn/novalon/gym/manage/member/service/impl/RefundApplicationServiceImpl.java

@@ -1,9 +1,11 @@
 package cn.novalon.gym.manage.member.service.impl;
 
+import cn.novalon.gym.manage.common.util.HtmlEscapeUtil;
 import cn.novalon.gym.manage.member.entity.RefundApplication;
 import cn.novalon.gym.manage.member.enums.RefundStatus;
 import cn.novalon.gym.manage.member.repository.RefundApplicationRepository;
 import cn.novalon.gym.manage.member.service.IRefundApplicationService;
+import cn.novalon.gym.manage.common.util.RedisUtil;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.stereotype.Service;
 import reactor.core.publisher.Mono;
@@ -21,9 +23,14 @@ import java.time.LocalDateTime;
 public class RefundApplicationServiceImpl implements IRefundApplicationService {
 
     private final RefundApplicationRepository refundApplicationRepository;
+    private final RedisUtil redisUtil;
 
-    public RefundApplicationServiceImpl(RefundApplicationRepository refundApplicationRepository) {
+    private static final String REFUND_APPLICATION_CACHE_PREFIX = "member:refund:";
+    private static final long CACHE_EXPIRE_SECONDS = 300;
+
+    public RefundApplicationServiceImpl(RefundApplicationRepository refundApplicationRepository, RedisUtil redisUtil) {
         this.refundApplicationRepository = refundApplicationRepository;
+        this.redisUtil = redisUtil;
     }
 
     @Override
@@ -38,14 +45,16 @@ public class RefundApplicationServiceImpl implements IRefundApplicationService {
                 .then(Mono.defer(() -> {
                     RefundApplication application = RefundApplication.builder()
                             .recordId(recordId)
-                            .reason(reason)
+                            .reason(HtmlEscapeUtil.escape(reason))
                             .status(RefundStatus.PENDING)
                             .applyTime(LocalDateTime.now())
                             .build();
 
                     return refundApplicationRepository.save(application)
-                            .doOnSuccess(app -> log.info("创建退款申请成功: applicationId={}, recordId={}",
-                                app.getId(), recordId));
+                            .doOnSuccess(app -> {
+                                log.info("创建退款申请成功: applicationId={}, recordId={}", app.getId(), recordId);
+                                clearRefundCache(recordId);
+                            });
                 }));
     }
 
@@ -54,14 +63,19 @@ public class RefundApplicationServiceImpl implements IRefundApplicationService {
         return refundApplicationRepository.findById(applicationId)
                 .switchIfEmpty(Mono.error(new RuntimeException("退款申请不存在")))
                 .flatMap(application -> {
-                    if (!"PENDING".equals(application.getStatus())) {
+                    if (application.getStatus() != RefundStatus.PENDING) {
                         return Mono.error(new RuntimeException("退款申请状态不正确，当前状态: " + application.getStatus()));
                     }
 
-                    return refundApplicationRepository.approve(applicationId, "APPROVED", auditorId, remark)
-                            .thenReturn(application)
-                            .doOnSuccess(app -> log.info("批准退款申请成功: applicationId={}, auditorId={}",
-                                applicationId, auditorId));
+                    return refundApplicationRepository.approve(applicationId, "APPROVED", auditorId, HtmlEscapeUtil.escape(remark))
+                            .flatMap(updatedRows -> {
+                                if (updatedRows == 0) {
+                                    return Mono.error(new RuntimeException("批准退款申请失败"));
+                                }
+                                clearRefundCache(application.getRecordId());
+                                log.info("批准退款申请成功: applicationId={}, auditorId={}", applicationId, auditorId);
+                                return refundApplicationRepository.findById(applicationId);
+                            });
                 });
     }
 
@@ -70,19 +84,42 @@ public class RefundApplicationServiceImpl implements IRefundApplicationService {
         return refundApplicationRepository.findById(applicationId)
                 .switchIfEmpty(Mono.error(new RuntimeException("退款申请不存在")))
                 .flatMap(application -> {
-                    if (!"PENDING".equals(application.getStatus())) {
+                    if (application.getStatus() != RefundStatus.PENDING) {
                         return Mono.error(new RuntimeException("退款申请状态不正确，当前状态: " + application.getStatus()));
                     }
 
-                    return refundApplicationRepository.approve(applicationId, "REJECTED", auditorId, remark)
-                            .thenReturn(application)
-                            .doOnSuccess(app -> log.info("拒绝退款申请成功: applicationId={}, auditorId={}",
-                                applicationId, auditorId));
+                    return refundApplicationRepository.approve(applicationId, "REJECTED", auditorId, HtmlEscapeUtil.escape(remark))
+                            .flatMap(updatedRows -> {
+                                if (updatedRows == 0) {
+                                    return Mono.error(new RuntimeException("拒绝退款申请失败"));
+                                }
+                                clearRefundCache(application.getRecordId());
+                                log.info("拒绝退款申请成功: applicationId={}, auditorId={}", applicationId, auditorId);
+                                return refundApplicationRepository.findById(applicationId);
+                            });
                 });
     }
 
     @Override
     public Mono<RefundApplication> findByRecordId(Long recordId) {
-        return refundApplicationRepository.findByRecordId(recordId);
+        String cacheKey = REFUND_APPLICATION_CACHE_PREFIX + recordId;
+        Object cached = redisUtil.get(cacheKey);
+        if (cached != null && cached instanceof RefundApplication) {
+            log.debug("从缓存获取退款申请, recordId: {}", recordId);
+            return Mono.just((RefundApplication) cached);
+        }
+
+        return refundApplicationRepository.findByRecordId(recordId)
+                .doOnSuccess(application -> {
+                    if (application != null) {
+                        redisUtil.setWithExpire(cacheKey, application, CACHE_EXPIRE_SECONDS);
+                    }
+                });
+    }
+
+    private void clearRefundCache(Long recordId) {
+        String cacheKey = REFUND_APPLICATION_CACHE_PREFIX + recordId;
+        redisUtil.delete(cacheKey);
+        log.debug("清除退款申请缓存, recordId: {}", recordId);
     }
 }

gym-manage-api/gym-member/src/main/java/cn/novalon/gym/manage/member/service/impl/WechatApiServiceImpl.java

@@ -4,6 +4,7 @@ import cn.novalon.gym.manage.common.exception.ErrorCode;
 import cn.novalon.gym.manage.common.exception.SystemException;
 import cn.novalon.gym.manage.member.config.WechatProperties;
 import cn.novalon.gym.manage.member.service.WechatApiService;
+import cn.novalon.gym.manage.common.util.RedisUtil;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.http.MediaType;
@@ -30,6 +31,10 @@ import java.util.Map;
 public class WechatApiServiceImpl implements WechatApiService {
 
     private final WechatProperties wechatProperties;
+    private final RedisUtil redisUtil;
+
+    private static final String ACCESS_TOKEN_CACHE_PREFIX = "wechat:access_token:";
+    private static final long ACCESS_TOKEN_EXPIRE_SECONDS = 7000;  // 比官方过期时间短100秒
 
     private final WebClient webClient = WebClient.builder()
             .baseUrl("https://api.weixin.qq.com")
@@ -147,35 +152,46 @@ public class WechatApiServiceImpl implements WechatApiService {
     public Mono<String> getAccessToken(String appType) {
         log.debug("获取access_token, appType: {}", appType);
 
-        String appId, appSecret;
-        if ("miniapp".equals(appType)) {
-            appId = wechatProperties.getMiniapp().getAppId();
-            appSecret = wechatProperties.getMiniapp().getAppSecret();
-        } else {
-            appId = wechatProperties.getMp().getAppId();
-            appSecret = wechatProperties.getMp().getAppSecret();
-        }
+        String cacheKey = ACCESS_TOKEN_CACHE_PREFIX + appType;
 
-        return webClient.get()
-                .uri(uriBuilder -> uriBuilder
-                        .path("/cgi-bin/token")
-                        .queryParam("grant_type", "client_credential")
-                        .queryParam("appid", appId)
-                        .queryParam("secret", appSecret)
-                        .build())
-                .retrieve()
-                .bodyToMono(Map.class)
-                .map(response -> {
-                    if (response.containsKey("access_token")) {
-                        String accessToken = (String) response.get("access_token");
-                        Integer expiresIn = (Integer) response.get("expires_in");
-                        log.info("获取access_token成功, expires_in: {}s", expiresIn);
-                        return accessToken;
-                    } else {
-                        String errmsg = (String) response.get("errmsg");
-                        log.error("获取access_token失败: {}", errmsg);
-                        throw new SystemException(ErrorCode.SYSTEM_INTERNAL_ERROR, "获取access_token失败: " + errmsg);
+        return redisUtil.get(cacheKey, String.class)
+                .flatMap(cachedToken -> {
+                    if (cachedToken != null) {
+                        log.debug("从缓存获取access_token, appType: {}", appType);
+                        return Mono.just(cachedToken);
                     }
+
+                    String appId, appSecret;
+                    if ("miniapp".equals(appType)) {
+                        appId = wechatProperties.getMiniapp().getAppId();
+                        appSecret = wechatProperties.getMiniapp().getAppSecret();
+                    } else {
+                        appId = wechatProperties.getMp().getAppId();
+                        appSecret = wechatProperties.getMp().getAppSecret();
+                    }
+
+                    return webClient.get()
+                            .uri(uriBuilder -> uriBuilder
+                                    .path("/cgi-bin/token")
+                                    .queryParam("grant_type", "client_credential")
+                                    .queryParam("appid", appId)
+                                    .queryParam("secret", appSecret)
+                                    .build())
+                            .retrieve()
+                            .bodyToMono(Map.class)
+                            .flatMap(response -> {
+                                if (response.containsKey("access_token")) {
+                                    String accessToken = (String) response.get("access_token");
+                                    Integer expiresIn = (Integer) response.get("expires_in");
+                                    log.info("获取access_token成功, expires_in: {}s", expiresIn);
+                                    return redisUtil.setWithExpire(cacheKey, accessToken, ACCESS_TOKEN_EXPIRE_SECONDS)
+                                            .then(Mono.just(accessToken));
+                                } else {
+                                    String errmsg = (String) response.get("errmsg");
+                                    log.error("获取access_token失败: {}", errmsg);
+                                    throw new SystemException(ErrorCode.SYSTEM_INTERNAL_ERROR, "获取access_token失败: " + errmsg);
+                                }
+                            });
                 });
     }
 

gym-manage-api/gym-member/src/main/java/cn/novalon/gym/manage/member/service/impl/WechatAuthServiceImpl.java

@@ -4,6 +4,7 @@ import cn.novalon.gym.manage.common.exception.ConflictException;
 import cn.novalon.gym.manage.common.exception.ErrorCode;
 import cn.novalon.gym.manage.common.exception.NotFoundException;
 import cn.novalon.gym.manage.common.exception.SystemException;
+import cn.novalon.gym.manage.common.util.HtmlEscapeUtil;
 import cn.novalon.gym.manage.member.config.WechatProperties;
 import cn.novalon.gym.manage.member.dto.WechatLoginDto;
 import cn.novalon.gym.manage.member.entity.Member;
@@ -15,6 +16,7 @@ import cn.novalon.gym.manage.member.service.WechatAuthService;
 import cn.novalon.gym.manage.member.util.AesUtil;
 import cn.novalon.gym.manage.member.util.EsSyncUtils;
 import cn.novalon.gym.manage.member.util.MemberNoGenerator;
+import cn.novalon.gym.manage.common.util.RedisUtil;
 import cn.novalon.gym.manage.member.util.WechatPhoneUtil;
 import cn.novalon.gym.manage.member.vo.WechatLoginVO;
 import cn.novalon.gym.manage.sys.security.JwtTokenProvider;
@@ -42,14 +44,17 @@ public class WechatAuthServiceImpl implements WechatAuthService {
 
     private final WechatApiService wechatApiService;
     private final IMemberRepository memberRepository;
-    private final WechatProperties wechatProperties;
     private final WechatPhoneUtil wechatPhoneUtil;
     private final MemberESRepository memberESRepository;
     private final EsSyncUtils esSyncUtils;
     private final JwtTokenProvider jwtTokenProvider;
+    private final RedisUtil redisUtil;
 
     private EsSyncUtils.EntitySyncer<Member, MemberES, String> memberSyncer;
 
+    private static final String MEMBER_INFO_CACHE_PREFIX = "member:info:";
+    private static final long CACHE_EXPIRE_SECONDS = 300;
+
     @PostConstruct
     public void init() {
         this.memberSyncer = esSyncUtils.bind(Member.class, MemberES.class, memberESRepository);
@@ -79,7 +84,10 @@ public class WechatAuthServiceImpl implements WechatAuthService {
                                         member.setLastLoginAt(LocalDateTime.now());
 
                                         return memberRepository.save(member)
-                                                .doOnSuccess(memberSyncer::sync)
+                                                .doOnSuccess(saved -> {
+                                                    memberSyncer.sync(saved);
+                                                    clearMemberCache(saved.getId());
+                                                })
                                                 .flatMap(savedMember -> {
                                                     WechatLoginVO response = buildLoginResponse(savedMember, false, sessionKey);
                                                     return Mono.just(response);
@@ -89,7 +97,10 @@ public class WechatAuthServiceImpl implements WechatAuthService {
                                         member.setLastLoginAt(LocalDateTime.now());
 
                                         return memberRepository.save(member)
-                                                .doOnSuccess(memberSyncer::sync)
+                                                .doOnSuccess(saved -> {
+                                                    memberSyncer.sync(saved);
+                                                    clearMemberCache(saved.getId());
+                                                })
                                                 .flatMap(savedMember -> {
                                                     WechatLoginVO response = buildLoginResponse(savedMember, false, sessionKey);
                                                     return Mono.just(response);
@@ -105,7 +116,10 @@ public class WechatAuthServiceImpl implements WechatAuthService {
                                                 member.setLastLoginAt(LocalDateTime.now());
 
                                                 return memberRepository.save(member)
-                                                        .doOnSuccess(memberSyncer::sync)
+                                                        .doOnSuccess(saved -> {
+                                                            memberSyncer.sync(saved);
+                                                            clearMemberCache(saved.getId());
+                                                        })
                                                         .flatMap(savedMember -> {
                                                             WechatLoginVO response = buildLoginResponse(savedMember, false, sessionKey);
                                                             return Mono.just(response);
@@ -124,7 +138,10 @@ public class WechatAuthServiceImpl implements WechatAuthService {
                                     member.setLastLoginAt(LocalDateTime.now());
 
                                     return memberRepository.save(member)
-                                            .doOnSuccess(memberSyncer::sync)
+                                            .doOnSuccess(saved -> {
+                                                memberSyncer.sync(saved);
+                                                clearMemberCache(saved.getId());
+                                            })
                                             .flatMap(savedMember -> {
                                                 WechatLoginVO response = buildLoginResponse(savedMember, false, sessionKey);
                                                 return Mono.just(response);
@@ -185,7 +202,10 @@ public class WechatAuthServiceImpl implements WechatAuthService {
                     member.setPhone(encryptedPhone);
                     member.setLastLoginAt(LocalDateTime.now());
                     return memberRepository.save(member)
-                            .doOnSuccess(memberSyncer::sync)
+                            .doOnSuccess(saved -> {
+                                memberSyncer.sync(saved);
+                                clearMemberCache(saved.getId());
+                            })
                             .map(savedMember -> {
                                 log.info("更新会员手机号成功, memberId: {}", savedMember.getId());
                                 return true;
@@ -197,12 +217,15 @@ public class WechatAuthServiceImpl implements WechatAuthService {
                 }));
     }
 
+    private void clearMemberCache(Long memberId) {
+        String cacheKey = MEMBER_INFO_CACHE_PREFIX + memberId;
+        redisUtil.delete(cacheKey);
+        log.debug("清除会员缓存, memberId: {}", memberId);
+    }
+
     private String encryptPhone(String phoneNumber) {
         try {
-            String secretKey = wechatProperties.getPhoneEncryption().getSecretKey();
-            String iv = wechatProperties.getPhoneEncryption().getIv();
-
-            String encryptedPhone = AesUtil.encrypt(phoneNumber, secretKey, iv);
+            String encryptedPhone = AesUtil.encrypt(phoneNumber);
 
             log.debug("手机号加密成功");
             return encryptedPhone;
@@ -214,10 +237,8 @@ public class WechatAuthServiceImpl implements WechatAuthService {
 
     public String decryptPhone(String encryptedPhone) {
         try {
-            String secretKey = wechatProperties.getPhoneEncryption().getSecretKey();
-            String iv = wechatProperties.getPhoneEncryption().getIv();
 
-            String phoneNumber = AesUtil.decrypt(encryptedPhone, secretKey, iv);
+            String phoneNumber = AesUtil.decrypt(encryptedPhone);
 
             log.debug("手机号解密成功");
             return phoneNumber;

gym-manage-api/gym-member/src/main/java/cn/novalon/gym/manage/member/service/impl/WechatOfficialServiceImpl.java

@@ -1,5 +1,6 @@
 package cn.novalon.gym.manage.member.service.impl;
 
+import cn.novalon.gym.manage.common.util.HtmlEscapeUtil;
 import cn.novalon.gym.manage.member.config.WechatProperties;
 import cn.novalon.gym.manage.member.entity.Member;
 import cn.novalon.gym.manage.member.es.entity.MemberES;
@@ -7,6 +8,7 @@ import cn.novalon.gym.manage.member.es.repository.MemberESRepository;
 import cn.novalon.gym.manage.member.repository.IMemberRepository;
 import cn.novalon.gym.manage.member.service.WechatOfficialService;
 import cn.novalon.gym.manage.member.util.EsSyncUtils;
+import cn.novalon.gym.manage.common.util.RedisUtil;
 import cn.novalon.gym.manage.member.vo.WechatUserInfoVO;
 import com.fasterxml.jackson.databind.DeserializationFeature;
 import com.fasterxml.jackson.databind.ObjectMapper;
@@ -40,11 +42,16 @@ public class WechatOfficialServiceImpl implements WechatOfficialService {
     private final MemberESRepository memberESRepository;
     private final ObjectMapper objectMapper = new ObjectMapper()
             .configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
-
     private final EsSyncUtils esSyncUtils;
+    private final RedisUtil redisUtil;
 
     private EsSyncUtils.EntitySyncer<Member, MemberES, String> memberSyncer;
 
+    private static final String ACCESS_TOKEN_CACHE_PREFIX = "wechat:access_token:";
+    private static final String MEMBER_INFO_CACHE_PREFIX = "member:info:";
+    private static final long ACCESS_TOKEN_EXPIRE_SECONDS = 7000;
+    private static final long CACHE_EXPIRE_SECONDS = 300;
+
     @PostConstruct
     public void init() {
         this.memberSyncer = esSyncUtils.bind(Member.class, MemberES.class, memberESRepository);
@@ -74,24 +81,30 @@ public class WechatOfficialServiceImpl implements WechatOfficialService {
                                         existingMember.setOfficialOpenId(openId);
                                         
                                         if (existingMember.getNickname() == null || existingMember.getNickname().isEmpty()) {
-                                            existingMember.setNickname(userInfo.getNickname());
+                                            existingMember.setNickname(HtmlEscapeUtil.escape(userInfo.getNickname()));
                                         }
                                         
                                         if (existingMember.getAvatar() == null || existingMember.getAvatar().isEmpty()) {
-                                            existingMember.setAvatar(userInfo.getHeadimgurl());
+                                            existingMember.setAvatar(HtmlEscapeUtil.escape(userInfo.getHeadimgurl()));
                                         }
                                         
                                         return memberRepository.save(existingMember)
-                                                .doOnSuccess(memberSyncer::sync)
-                                                .then(sendWelcomeMessage(openId));
+                                                .flatMap(saved -> {
+                                                    memberSyncer.sync(saved);
+                                                    return clearMemberCache(saved.getId())
+                                                            .then(sendWelcomeMessage(openId));
+                                                });
                                     } else {
                                         log.info("老用户关注服务号: memberId={}", existingMember.getId());
                                         existingMember.setSubscribed(true);
                                         existingMember.setLastLoginAt(LocalDateTime.now());
                                         
                                         return memberRepository.save(existingMember)
-                                                .doOnSuccess(memberSyncer::sync)
-                                                .then(sendWelcomeMessage(openId));
+                                                .flatMap(saved -> {
+                                                    memberSyncer.sync(saved);
+                                                    return clearMemberCache(saved.getId())
+                                                            .then(sendWelcomeMessage(openId));
+                                                });
                                     }
                                 })
                                 .switchIfEmpty(Mono.defer(() -> {
@@ -104,7 +117,10 @@ public class WechatOfficialServiceImpl implements WechatOfficialService {
                                                 existingMember.setLastLoginAt(LocalDateTime.now());
                                                 
                                                 return memberRepository.save(existingMember)
-                                                        .doOnSuccess(memberSyncer::sync)
+                                                        .doOnSuccess(saved -> {
+                                                            memberSyncer.sync(saved);
+                                                            clearMemberCache(saved.getId());
+                                                        })
                                                         .then(sendWelcomeMessage(openId));
                                             })
                                             .switchIfEmpty(Mono.defer(() -> {
@@ -122,7 +138,10 @@ public class WechatOfficialServiceImpl implements WechatOfficialService {
                                     existingMember.setLastLoginAt(LocalDateTime.now());
                                     
                                     return memberRepository.save(existingMember)
-                                            .doOnSuccess(memberSyncer::sync)
+                                            .doOnSuccess(saved -> {
+                                                memberSyncer.sync(saved);
+                                                clearMemberCache(saved.getId());
+                                            })
                                             .then(sendWelcomeMessage(openId));
                                 })
                                 .switchIfEmpty(Mono.defer(() -> {
@@ -148,8 +167,10 @@ public class WechatOfficialServiceImpl implements WechatOfficialService {
                     member.setSubscribed(false);
                     member.setLastLoginAt(LocalDateTime.now());
                     return memberRepository.save(member)
-                            .doOnSuccess(memberSyncer::sync)
-                            .then();
+                            .flatMap(saved -> {
+                                memberSyncer.sync(saved);
+                                return clearMemberCache(saved.getId()).then();
+                            });
                 })
                 .then()
                 .switchIfEmpty(Mono.defer(() -> {
@@ -213,7 +234,11 @@ public class WechatOfficialServiceImpl implements WechatOfficialService {
                         member.setOfficialOpenId(officialOpenId);
                     }
                     return memberRepository.save(member)
-                            .doOnSuccess(memberSyncer::sync)
+                            .flatMap(saved -> {
+                                memberSyncer.sync(saved);
+                                return clearMemberCache(saved.getId())
+                                        .then(Mono.just(saved));
+                            })
                             .map(savedMember -> {
                                 log.info("关联成功, memberId: {}", savedMember.getId());
                                 return true;
@@ -268,28 +293,38 @@ public class WechatOfficialServiceImpl implements WechatOfficialService {
 
     /**
      * 获取微信AccessToken
-     * 
-     * TODO: 应该使用缓存，避免频繁请求
      */
     private Mono<String> getAccessToken() {
-        String appId = wechatProperties.getMp().getAppId();
-        String appSecret = wechatProperties.getMp().getAppSecret();
+        String cacheKey = ACCESS_TOKEN_CACHE_PREFIX + "mp";
 
-        String url = "https://api.weixin.qq.com/cgi-bin/token"
-                + "?grant_type=client_credential"
-                + "&appid=" + appId
-                + "&secret=" + appSecret;
-
-        return webClient.get()
-                .uri(url)
-                .accept(MediaType.APPLICATION_JSON)
-                .retrieve()
-                .bodyToMono(Map.class)
-                .map(response -> {
-                    if (response.containsKey("errcode")) {
-                        throw new RuntimeException("获取AccessToken失败: " + response.get("errmsg"));
+        return redisUtil.get(cacheKey, String.class)
+                .flatMap(cachedToken -> {
+                    if (cachedToken != null) {
+                        log.debug("从缓存获取服务号access_token");
+                        return Mono.just(cachedToken);
                     }
-                    return (String) response.get("access_token");
+
+                    String appId = wechatProperties.getMp().getAppId();
+                    String appSecret = wechatProperties.getMp().getAppSecret();
+
+                    String url = "https://api.weixin.qq.com/cgi-bin/token"
+                            + "?grant_type=client_credential"
+                            + "&appid=" + appId
+                            + "&secret=" + appSecret;
+
+                    return webClient.get()
+                            .uri(url)
+                            .accept(MediaType.APPLICATION_JSON)
+                            .retrieve()
+                            .bodyToMono(Map.class)
+                            .flatMap(response -> {
+                                if (response.containsKey("errcode")) {
+                                    throw new RuntimeException("获取AccessToken失败: " + response.get("errmsg"));
+                                }
+                                String accessToken = (String) response.get("access_token");
+                                return redisUtil.setWithExpire(cacheKey, accessToken, ACCESS_TOKEN_EXPIRE_SECONDS)
+                                        .then(Mono.just(accessToken));
+                            });
                 });
     }
 
@@ -335,4 +370,10 @@ public class WechatOfficialServiceImpl implements WechatOfficialService {
                     return Mono.empty(); // 即使发送失败也不影响主流程
                 });
     }
+
+    private Mono<Long> clearMemberCache(Long memberId) {
+        String cacheKey = MEMBER_INFO_CACHE_PREFIX + memberId;
+        return redisUtil.delete(cacheKey)
+                .doOnSuccess(result -> log.debug("清除会员缓存, memberId: {}", memberId));
+    }
 }

gym-manage-api/gym-member/src/main/java/cn/novalon/gym/manage/member/util/AesUtil.java

@@ -1,12 +1,24 @@
 package cn.novalon.gym.manage.member.util;
 
+import cn.novalon.gym.manage.member.config.WechatProperties;
+import co.elastic.clients.elasticsearch.ElasticsearchClient;
+import co.elastic.clients.elasticsearch.core.IndexResponse;
+import co.elastic.clients.json.jackson.JacksonJsonpMapper;
+import co.elastic.clients.transport.rest_client.RestClientTransport;
 import lombok.extern.slf4j.Slf4j;
+import org.apache.http.HttpHost;
+import org.checkerframework.checker.units.qual.K;
+import org.elasticsearch.client.RestClient;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
 
 import javax.crypto.Cipher;
 import javax.crypto.spec.IvParameterSpec;
 import javax.crypto.spec.SecretKeySpec;
 import java.nio.charset.StandardCharsets;
 import java.util.Base64;
+import java.util.HashMap;
+import java.util.Map;
 
 /**
  * AES加密工具类
@@ -16,24 +28,35 @@ import java.util.Base64;
  */
 
 @Slf4j
+@Component
 public class AesUtil {
 
     private static final String ALGORITHM = "AES";
     private static final String TRANSFORMATION = "AES/CBC/PKCS5Padding";
 
+    private static String KEY;
+    private static String IV;
+
+    @Autowired
+    public void setWechatProperties(WechatProperties props) {
+        KEY = props.getPhoneEncryption().getSecretKey();  // 从配置类读取
+        IV = props.getPhoneEncryption().getIv();
+        if(KEY == null || IV == null) throw new RuntimeException("请配置AES密钥和偏移量");
+    }
+
+
     /**
      * AES 解密
      *
      * @param encryptedData 加密数据，Base64编码
-     * @param key           AES密钥，Base64编码（32字节）
-     * @param iv            初始化向量IV，Base64编码（16字节）
      * @return 解密后的字符串
      */
-    public static String decrypt(String encryptedData, String key, String iv) {
+    public static String decrypt(String encryptedData) {
+
         try {
             byte[] dataByte = Base64.getDecoder().decode(encryptedData);
-            byte[] keyByte = Base64.getDecoder().decode(key);
-            byte[] ivByte = Base64.getDecoder().decode(iv);
+            byte[] keyByte = Base64.getDecoder().decode(KEY);
+            byte[] ivByte = Base64.getDecoder().decode(IV);
 
             Cipher cipher = Cipher.getInstance(TRANSFORMATION);
             SecretKeySpec secretKeySpec = new SecretKeySpec(keyByte, ALGORITHM);
@@ -52,15 +75,13 @@ public class AesUtil {
      * AES 加密
      *
      * @param data 原始数据
-     * @param key  AES密钥，Base64编码（32字节）
-     * @param iv   初始化向量IV，Base64编码（16字节）
      * @return Base64编码的加密数据
      */
-    public static String encrypt(String data, String key, String iv) {
+    public static String encrypt(String data) {
         try {
             byte[] dataByte = data.getBytes(StandardCharsets.UTF_8);
-            byte[] keyByte = Base64.getDecoder().decode(key);
-            byte[] ivByte = Base64.getDecoder().decode(iv);
+            byte[] keyByte = Base64.getDecoder().decode(KEY);
+            byte[] ivByte = Base64.getDecoder().decode(IV);
 
             Cipher cipher = Cipher.getInstance(TRANSFORMATION);
             SecretKeySpec secretKeySpec = new SecretKeySpec(keyByte, ALGORITHM);

gym-manage-api/gym-member/src/main/java/cn/novalon/gym/manage/member/util/WechatPhoneUtil.java

@@ -56,7 +56,7 @@ public class WechatPhoneUtil {
      * @param phone 手机号
      * @return 脱敏后的手机号，如：138****8000
      */
-    private String maskPhone(String phone) {
+    public static String maskPhone(String phone) {
         if (phone == null || phone.length() < 7) {
             return "***";
         }

gym-manage-api/gym-member/src/main/java/cn/novalon/gym/manage/member/vo/MemberCardInfoVO.java

@@ -0,0 +1,92 @@
+package cn.novalon.gym.manage.member.vo;
+
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+import java.math.BigDecimal;
+import java.time.LocalDateTime;
+
+/**
+ * 会员卡类型响应 VO
+ *
+ * @author 付嘉
+ * @date 2026-05-27
+ */
+@Data
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
+public class MemberCardInfoVO {
+
+    /**
+     * 主键ID
+     */
+    private Long id;
+
+    /**
+     * 会员卡ID
+     */
+    private Long memberCardId;
+
+    /**
+     * 会员卡名称
+     */
+    private String memberCardName;
+
+    /**
+     * 会员卡类型：TIME_CARD-时长卡, COUNT_CARD-次卡, STORED_VALUE_CARD-储值卡
+     */
+    private String memberCardType;
+
+    /**
+     * 卡类型描述
+     */
+    private String memberCardTypeDesc;
+
+    /**
+     * 会员卡价格
+     */
+    private BigDecimal memberCardPrice;
+
+    /**
+     * 有效天数（时长卡用）
+     */
+    private Integer memberCardValidityDays;
+
+    /**
+     * 总次数（次卡用）
+     */
+    private Integer memberCardTotalTimes;
+
+    /**
+     * 面额（储值卡用）
+     */
+    private BigDecimal memberCardAmount;
+
+    /**
+     * 状态：0-下架, 1-上架
+     */
+    private Integer memberCardStatus;
+
+    /**
+     * 状态描述
+     */
+    private String memberCardStatusDesc;
+
+    /**
+     * 扩展配置（JSON格式）
+     */
+    private String extraConfig;
+
+    /**
+     * 创建时间
+     */
+    private LocalDateTime createdAt;
+
+    /**
+     * 更新时间
+     */
+    private LocalDateTime updatedAt;
+}

gym-manage-api/gym-member/src/main/java/cn/novalon/gym/manage/member/vo/MemberCardRecordVO.java

@@ -9,7 +9,7 @@ import java.time.LocalDateTime;
 
 /**
  * 会员卡记录响应 VO
- * 
+ *
  * @author 付嘉
  * @date 2026-05-27
  */
@@ -68,4 +68,4 @@ public class MemberCardRecordVO {
      * 创建时间
      */
     private LocalDateTime createdAt;
-}
+}

gym-manage-api/gym-member/src/main/java/cn/novalon/gym/manage/member/vo/MemberDetailVO.java

@@ -0,0 +1,96 @@
+package cn.novalon.gym.manage.member.vo;
+
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+import java.time.LocalDateTime;
+import java.util.Date;
+import java.util.List;
+
+/**
+ * 会员详情 VO（管理端使用）
+ *
+ * @author 付嘉
+ * @date 2026-05-27
+ */
+@Data
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
+public class MemberDetailVO {
+
+    // ==================== 会员基础信息 ====================
+
+    /**
+     * 会员ID
+     */
+    private Long id;
+
+    /**
+     * 会员编号
+     */
+    private String memberNo;
+
+    /**
+     * 昵称
+     */
+    private String nickname;
+
+    /**
+     * 手机号（脱敏显示）
+     */
+    private String phone;
+
+    /**
+     * 性别描述
+     */
+    private String genderDesc;
+
+    /**
+     * 生日
+     */
+    private Date birthday;
+
+    /**
+     * 地址
+     */
+    private String address;
+
+    /**
+     * 头像URL
+     */
+    private String avatar;
+
+    /**
+     * 是否关注服务号
+     */
+    private Boolean subscribed;
+
+    /**
+     * 最后登录时间
+     */
+    private LocalDateTime lastLoginAt;
+
+    /**
+     * 注册时间
+     */
+    private LocalDateTime createdAt;
+
+    // ==================== 会员卡信息 ====================
+
+    /**
+     * 会员持有的卡列表
+     */
+    private List<MemberCardInfoVO> memberCards;
+
+    /**
+     * 有效会员卡数量
+     */
+    private Integer activeCardCount;
+
+    /**
+     * 过期/用完会员卡数量
+     */
+    private Integer inactiveCardCount;
+}

gym-manage-api/gym-member/src/main/java/cn/novalon/gym/manage/member/vo/MemberInfoVO.java

@@ -1,15 +1,17 @@
 package cn.novalon.gym.manage.member.vo;
 
+import cn.novalon.gym.manage.member.enums.GenderEnum;
 import lombok.AllArgsConstructor;
 import lombok.Builder;
 import lombok.Data;
 import lombok.NoArgsConstructor;
 
+import java.time.LocalDate;
 import java.util.Date;
 
 /**
  * 会员信息 VO
- * 
+ *
  * @author 付嘉
  * @date 2026-05-01
  */
@@ -30,10 +32,13 @@ public class MemberInfoVO {
     private String phone;
 
     // 性别
-    private Integer gender;
+    private GenderEnum gender;
+
+    // 性别描述
+    private String genderDesc;
 
     // 生日
-    private Date birthday;
+    private LocalDate birthday;
 
     // 头像
     private String avatar;
@@ -43,4 +48,4 @@ public class MemberInfoVO {
 
     // 是否已关注公众号
     private Boolean isSubscribed;
-}
+}

gym-manage-api/gym-member/src/main/resources/db/schema.sql

@@ -17,7 +17,7 @@ CREATE TABLE IF NOT EXISTS member_user (
     nickname VARCHAR(100),                                         -- 昵称
     phone VARCHAR(255),                                            -- 手机号（AES加密存储）
     gender INTEGER DEFAULT 0,                                      -- 性别：0-未知，1-男，2-女
-    birthday TIMESTAMP,                                            -- 生日
+    birthday DATE,                                            -- 生日
     address VARCHAR(500),                                          -- 地址
     avatar VARCHAR(500),                                           -- 头像URL
     subscribed BOOLEAN DEFAULT FALSE,                              -- 是否关注服务号

gym-manage-api/gym-member/src/main/resources/member-config.yml

@@ -2,21 +2,23 @@
 wechat:
   # Mock模式：true=使用模拟数据（开发测试），false=调用真实微信API（生产环境）
   mock-enabled: false
+
   miniapp:
-    app-id: wx4d480112b426100b
-    app-secret: 78548f0c0ff66c73d3e8b071897eb1e5
+    app-id: ${WECHAT_MINIAPP_APP_ID}
+    app-secret: ${WECHAT_MINIAPP_SECRET}
+
   mp:
-    app-id: wx6f138c9aacc8a0e8
-    app-secret: 5df2e315e9268e96a43bb2cce1d2270b
-    token: test_token
-    aes-key: ${WECHAT_MP_AESKEY:test_aes_key}
-    # 服务器回调地址（微信服务器推送事件的URL）
-    callback-url: https://1me240209tk74.vicp.fun/api/member/auth/mp/callback
+    app-id: ${WECHAT_MP_APP_ID}
+    app-secret: ${WECHAT_MP_SECRET}
+    token: ${WECHAT_MP_TOKEN}
+    aes-key: ${WECHAT_MP_AESKEY}
+    callback-url: ${WECHAT_MP_CALLBACK_URL}
+
   # 手机号加密配置
   phone-encryption:
-    secret-key: nVnA99iBfyK0IE6SkcUYdVAaVrezyn2sLRdLfkIyWnY=
-    iv: LMpG6Ih9mmfEAALOCeIJBw==
+    secret-key: ${PHONE_ENCRYPTION_SECRET_KEY}
+    iv: ${PHONE_ENCRYPTION_IV}
 
 spring:
   elasticsearch:
-    uris: http://localhost:9200          # ES 服务器地址（支持多个，逗号分隔）
+    uris: http://localhost:9200

gym-manage-api/manage-app/pom.xml

@@ -43,6 +43,11 @@
             <artifactId>gym-member</artifactId>
             <version>${project.version}</version>
         </dependency>
+        <dependency>
+            <groupId>cn.novalon.gym.manage</groupId>
+            <artifactId>gym-checkIn</artifactId>
+            <version>${project.version}</version>
+        </dependency>
         
         <dependency>
             <groupId>org.springframework.boot</groupId>
@@ -139,6 +144,10 @@
             <groupId>org.springdoc</groupId>
             <artifactId>springdoc-openapi-starter-webflux-ui</artifactId>
         </dependency>
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-data-redis</artifactId>
+        </dependency>
     </dependencies>
 
     <build>

gym-manage-api/manage-app/src/main/java/cn/novalon/gym/manage/app/ManageApplication.java

@@ -7,9 +7,8 @@ import org.springframework.boot.CommandLineRunner;
 import org.springframework.boot.SpringApplication;
 import org.springframework.boot.autoconfigure.SpringBootApplication;
 import org.springframework.boot.autoconfigure.security.reactive.ReactiveUserDetailsServiceAutoConfiguration;
-import org.springframework.boot.context.properties.ConfigurationPropertiesScan;
 import org.springframework.context.annotation.Bean;
-import org.springframework.context.annotation.ComponentScan;
+import org.springframework.data.elasticsearch.repository.config.EnableReactiveElasticsearchRepositories;
 import org.springframework.data.r2dbc.repository.config.EnableR2dbcRepositories;
 import org.springframework.web.server.WebFilter;
 
@@ -17,9 +16,14 @@ import java.util.List;
 
 @SpringBootApplication(scanBasePackages = "cn.novalon.gym.manage", exclude = {
         ReactiveUserDetailsServiceAutoConfiguration.class })
-@EnableR2dbcRepositories(basePackages = { "cn.novalon.gym.manage.db.dao",
+@EnableR2dbcRepositories(basePackages = {
+        "cn.novalon.gym.manage.db.dao",
         "cn.novalon.gym.manage.sys.audit.repository" ,
-        "cn.novalon.gym.manage.gymmembercard.dao"})
+        "cn.novalon.gym.manage.gymmembercard.dao",
+        "cn.novalon.gym.manage.member.repository",
+        "cn.novalon.gym.manage.checkIn.repository"
+})
+@EnableReactiveElasticsearchRepositories(basePackages = "cn.novalon.gym.manage.member.es.repository")
 public class ManageApplication {
 
     private static final Logger logger = LoggerFactory.getLogger(ManageApplication.class);

gym-manage-api/manage-app/src/main/java/cn/novalon/gym/manage/app/config/SystemRouter.java

@@ -1,6 +1,7 @@
 package cn.novalon.gym.manage.app.config;
 
 
+import cn.novalon.gym.manage.checkIn.handler.CheckInHandler;
 import cn.novalon.gym.manage.file.handler.SysFileHandler;
 import cn.novalon.gym.manage.member.handler.MemberCardHandler;
 import cn.novalon.gym.manage.member.handler.MemberCardRecordHandler;
@@ -62,7 +63,8 @@ public class SystemRouter {
             PasswordDiagnosticHandler passwordDiagnosticHandler,
             MemberCardHandler memberCardHandler,
             MemberCardRecordHandler memberCardRecordHandler,
-            MemberCardTransactionHandler memberCardTransactionHandler) {
+            MemberCardTransactionHandler memberCardTransactionHandler,
+            CheckInHandler checkInHandler) {
 
         return route()
                 // ========== 诊断路由 ==========
@@ -249,7 +251,22 @@ public class SystemRouter {
                 .GET("/api/member-card-transactions/statistics/deduct/{cardId}", memberCardTransactionHandler::getDeductCountByCardId)
                 .GET("/api/member-card-transactions/statistics/renew", memberCardTransactionHandler::getRenewAmountByTimeRange)
                 .GET("/api/member-card-transactions/statistics/purchase/{memberId}", memberCardTransactionHandler::getPurchaseAmountByMember)
+
+                // ========= 签到模块路由 ==========
+                // ===== 签到核心功能 =====
+                .POST("/api/checkIn", checkInHandler::checkIn)
+                .GET("/api/checkIn/qrcode", checkInHandler::getQRCode)
                 
+                // ===== 签到记录管理 =====
+                .GET("/api/checkIn/records", checkInHandler::getSignInRecords)
+                .GET("/api/checkIn/records/{id}", checkInHandler::getSignInRecordById)
+                
+                // ===== 签到统计 =====
+                .GET("/api/checkIn/statistics", checkInHandler::getSignInStatistics)
+                .GET("/api/checkIn/daily-stats", checkInHandler::getDailySignInStats)
+                
+                // ===== 签到数据导出 =====
+                .GET("/api/checkIn/records/export", checkInHandler::exportSignInRecords)
                 .build();
     }
 }

gym-manage-api/manage-common/pom.xml

@@ -56,6 +56,10 @@
             <artifactId>spring-boot-starter-test</artifactId>
             <scope>test</scope>
         </dependency>
+        <dependency>
+            <groupId>org.springframework.data</groupId>
+            <artifactId>spring-data-redis</artifactId>
+        </dependency>
     </dependencies>
 
     <build>

gym-manage-api/manage-common/src/main/java/cn/novalon/gym/manage/common/config/RedisConfig.java

@@ -0,0 +1,38 @@
+package cn.novalon.gym.manage.common.config;
+
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.data.redis.connection.ReactiveRedisConnectionFactory;
+import org.springframework.data.redis.core.ReactiveRedisTemplate;
+import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
+import org.springframework.data.redis.serializer.RedisSerializationContext;
+import org.springframework.data.redis.serializer.StringRedisSerializer;
+
+/**
+ * Redis 配置类（响应式版本）
+ * 
+ * @author 付嘉
+ * @date 2026-05-29
+ */
+@Configuration
+public class RedisConfig {
+
+    /**
+     * 配置 ReactiveRedisTemplate
+     */
+    @Bean
+    public ReactiveRedisTemplate<String, Object> reactiveRedisTemplate(
+            ReactiveRedisConnectionFactory connectionFactory) {
+        
+        // 配置序列化上下文
+        RedisSerializationContext<String, Object> serializationContext = 
+            RedisSerializationContext.<String, Object>newSerializationContext()
+                .key(StringRedisSerializer.UTF_8)
+                .value(new GenericJackson2JsonRedisSerializer())
+                .hashKey(StringRedisSerializer.UTF_8)
+                .hashValue(new GenericJackson2JsonRedisSerializer())
+                .build();
+        
+        return new ReactiveRedisTemplate<>(connectionFactory, serializationContext);
+    }
+}

gym-manage-api/manage-common/src/main/java/cn/novalon/gym/manage/common/constant/RedisKeyConstants.java

@@ -0,0 +1,64 @@
+package cn.novalon.gym.manage.common.constant;
+
+/**
+ * Redis 缓存 Key 常量类
+ * 统一管理项目中所有 Redis 缓存的 key 前缀
+ *
+ * @author auto-generated
+ * @date 2026-05-30
+ */
+public final class RedisKeyConstants {
+
+    private RedisKeyConstants() {
+    }
+
+    // ==================== 会员模块 ====================
+
+    /**
+     * 会员信息缓存
+     * 格式：member:info:{memberId}
+     */
+    public static final String MEMBER_INFO = "member:info:";
+
+    /**
+     * 会员详情缓存
+     * 格式：member:detail:{memberId}
+     */
+    public static final String MEMBER_DETAIL = "member:detail:";
+
+    /**
+     * 会员卡类型缓存
+     * 格式：member:card:{memberCardId}
+     */
+    public static final String MEMBER_CARD = "member:card:";
+
+    /**
+     * 会员卡记录缓存（包含剩余次数/金额）
+     * 格式：member:card:record:{recordId}
+     */
+    public static final String MEMBER_CARD_RECORD = "member:card:record:";
+
+    /**
+     * 会员退款申请缓存
+     * 格式：member:refund:{recordId}
+     */
+    public static final String MEMBER_REFUND = "member:refund:";
+
+    // ==================== 签到模块 ====================
+
+    /**
+     * 用户当日二维码缓存
+     * 格式：qrcode:user:daily:{userId}:{date}
+     * 示例：qrcode:user:daily:1:2026-05-30
+     */
+    public static final String QRCODE_USER_DAILY = "qrcode:user:daily:";
+
+    // ==================== 微信模块 ====================
+
+    /**
+     * 微信 access_token 缓存
+     * 格式：wechat:access_token:{appType}
+     * appType: miniapp(小程序), mp(公众号)
+     */
+    public static final String WECHAT_ACCESS_TOKEN = "wechat:access_token:";
+}

gym-manage-api/manage-common/src/main/java/cn/novalon/gym/manage/common/util/HtmlEscapeUtil.java

@@ -0,0 +1,117 @@
+package cn.novalon.gym.manage.common.util;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.regex.Pattern;
+
+/**
+ * HTML 转义工具类
+ * 防止 XSS 注入攻击
+ *
+ * @author 付嘉
+ * @date 2026-05-29
+ */
+public class HtmlEscapeUtil {
+
+    private static final Map<Character, String> ESCAPE_MAP = new HashMap<>();
+    private static final Map<String, Character> UNESCAPE_MAP = new HashMap<>();
+    private static final Pattern HTML_PATTERN = Pattern.compile("<[^>]*>");
+
+    static {
+        // HTML 特殊字符转义映射
+        ESCAPE_MAP.put('&', "&amp;");
+        ESCAPE_MAP.put('<', "&lt;");
+        ESCAPE_MAP.put('>', "&gt;");
+        ESCAPE_MAP.put('"', "&quot;");
+        ESCAPE_MAP.put('\'', "&#39;");
+
+        // 反向映射
+        UNESCAPE_MAP.put("&amp;", '&');
+        UNESCAPE_MAP.put("&lt;", '<');
+        UNESCAPE_MAP.put("&gt;", '>');
+        UNESCAPE_MAP.put("&quot;", '"');
+        UNESCAPE_MAP.put("&#39;", '\'');
+    }
+
+    /**
+     * 转义 HTML 特殊字符
+     *
+     * @param input 原始字符串
+     * @return 转义后的字符串
+     */
+    public static String escape(String input) {
+        if (input == null || input.isEmpty()) {
+            return input;
+        }
+
+        StringBuilder result = new StringBuilder();
+        for (char c : input.toCharArray()) {
+            String escaped = ESCAPE_MAP.get(c);
+            if (escaped != null) {
+                result.append(escaped);
+            } else {
+                result.append(c);
+            }
+        }
+        return result.toString();
+    }
+
+    /**
+     * 反转义 HTML 特殊字符
+     *
+     * @param input 转义后的字符串
+     * @return 原始字符串
+     */
+    public static String unescape(String input) {
+        if (input == null || input.isEmpty()) {
+            return input;
+        }
+
+        String result = input;
+        for (Map.Entry<String, Character> entry : UNESCAPE_MAP.entrySet()) {
+            result = result.replace(entry.getKey(), String.valueOf(entry.getValue()));
+        }
+        return result;
+    }
+
+    /**
+     * 移除所有 HTML 标签
+     *
+     * @param input 原始字符串
+     * @return 移除标签后的字符串
+     */
+    public static String stripHtmlTags(String input) {
+        if (input == null || input.isEmpty()) {
+            return input;
+        }
+        return HTML_PATTERN.matcher(input).replaceAll("");
+    }
+
+    /**
+     * 安全转义（转义 + 移除标签）
+     *
+     * @param input 原始字符串
+     * @return 安全字符串
+     */
+    public static String sanitize(String input) {
+        if (input == null || input.isEmpty()) {
+            return input;
+        }
+        // 先移除 HTML 标签，再转义特殊字符
+        String noTags = stripHtmlTags(input);
+        return escape(noTags);
+    }
+
+    /**
+     * 判断是否包含 HTML 标签
+     *
+     * @param input 原始字符串
+     * @return true-包含, false-不包含
+     */
+    public static boolean containsHtmlTags(String input) {
+        if (input == null || input.isEmpty()) {
+            return false;
+        }
+        return HTML_PATTERN.matcher(input).find();
+    }
+}

gym-manage-api/manage-common/src/main/java/cn/novalon/gym/manage/common/util/RedisUtil.java

@@ -0,0 +1,72 @@
+package cn.novalon.gym.manage.common.util;
+
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.redis.core.ReactiveRedisTemplate;
+import org.springframework.stereotype.Component;
+import reactor.core.publisher.Mono;
+
+import java.time.Duration;
+
+/**
+ * Redis 工具类（响应式版本）
+ * 
+ * @author liwentao
+ * @date 2026/5/15
+ */
+@Component
+public class RedisUtil {
+
+    @Autowired
+    private ReactiveRedisTemplate<String, Object> reactiveRedisTemplate;
+
+    /**
+     * 设置值
+     */
+    public Mono<Boolean> set(String key, Object value) {
+        return reactiveRedisTemplate.opsForValue().set(key, value);
+    }
+
+    /**
+     * 设置值并指定过期时间（秒）
+     */
+    public Mono<Boolean> setWithExpire(String key, Object value, long timeoutSeconds) {
+        return reactiveRedisTemplate.opsForValue().set(key, value, Duration.ofSeconds(timeoutSeconds));
+    }
+
+    /**
+     * 获取值
+     */
+    @SuppressWarnings("unchecked")
+    public <T> Mono<T> get(String key, Class<T> clazz) {
+        return reactiveRedisTemplate.opsForValue().get(key)
+                .map(obj -> clazz.isInstance(obj) ? (T) obj : null);
+    }
+
+    /**
+     * 获取值（返回 Object）
+     */
+    public Mono<Object> get(String key) {
+        return reactiveRedisTemplate.opsForValue().get(key);
+    }
+
+    /**
+     * 删除key
+     */
+    public Mono<Long> delete(String key) {
+        return reactiveRedisTemplate.delete(key);
+    }
+
+    /**
+     * 判断key是否存在
+     */
+    public Mono<Boolean> hasKey(String key) {
+        return reactiveRedisTemplate.hasKey(key);
+    }
+
+    /**
+     * 设置过期时间（秒）
+     */
+    public Mono<Boolean> expire(String key, long timeoutSeconds) {
+        return reactiveRedisTemplate.expire(key, Duration.ofSeconds(timeoutSeconds));
+    }
+}

gym-manage-api/manage-db/src/main/resources/db/migration/V6__Create_sign_in_record_table.sql

@@ -0,0 +1,74 @@
+-- ============================================
+-- 会员到店签到记录表
+-- 版本: V6
+-- 描述: 创建sign_in_record表，用于记录会员签到信息
+-- ============================================
+
+-- 创建签到记录表
+CREATE TABLE IF NOT EXISTS sign_in_record (
+    id BIGSERIAL PRIMARY KEY,                                    -- 自增主键
+    member_id BIGINT NOT NULL,                                   -- 会员ID，关联member表
+    member_card_id BIGINT,                                       -- 签到时使用的会员卡ID
+    sign_in_time TIMESTAMP NOT NULL,                             -- 签到入场时间
+    sign_in_type VARCHAR(20) NOT NULL,                           -- 签到方式：QR_CODE-扫码签到，MANUAL-手动签到，FACE-人脸识别
+    sign_in_status VARCHAR(20) NOT NULL DEFAULT 'SUCCESS',      -- 签到状态：SUCCESS-成功，FAILED-失败
+    verification_details TEXT,                                   -- JSON格式，存储会员卡验证时的快照数据
+    fail_reason VARCHAR(500),                                    -- 失败时的具体原因文案
+    operator_id BIGINT,                                          -- 操作人ID（前台人员），自助签到时为NULL
+    operator_name VARCHAR(100),                                  -- 操作人姓名冗余
+    device_info VARCHAR(200),                                    -- 签到设备标识或型号
+    ip_address VARCHAR(50),                                      -- 客户端IP地址
+    source VARCHAR(20) NOT NULL,                                 -- 签到来源：MINI_PROGRAM-小程序扫码，PC_BACKEND-后台管理端
+    is_delete BOOLEAN DEFAULT FALSE,                             -- 软删除标识：false-未删除，true-已删除
+    created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,    -- 记录创建时间
+    updated_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP     -- 记录更新时间
+);
+
+-- 创建索引
+-- 会员ID索引（加速按会员查询签到记录）
+CREATE INDEX IF NOT EXISTS idx_sign_in_record_member_id ON sign_in_record(member_id);
+
+-- 签到时间索引（加速按时间范围查询）
+CREATE INDEX IF NOT EXISTS idx_sign_in_record_sign_in_time ON sign_in_record(sign_in_time);
+
+-- 签到状态索引（加速按状态筛选）
+CREATE INDEX IF NOT EXISTS idx_sign_in_record_sign_in_status ON sign_in_record(sign_in_status);
+
+-- 会员卡ID索引（加速按会员卡查询）
+CREATE INDEX IF NOT EXISTS idx_sign_in_record_member_card_id ON sign_in_record(member_card_id);
+
+-- 操作人ID索引（加速按操作人查询）
+CREATE INDEX IF NOT EXISTS idx_sign_in_record_operator_id ON sign_in_record(operator_id);
+
+-- 签到来源索引（加速按来源统计）
+CREATE INDEX IF NOT EXISTS idx_sign_in_record_source ON sign_in_record(source);
+
+-- 软删除索引（加速查询未删除的记录）
+CREATE INDEX IF NOT EXISTS idx_sign_in_record_is_delete ON sign_in_record(is_delete);
+
+-- 复合索引：会员ID + 签到时间（加速会员签到历史查询）
+CREATE INDEX IF NOT EXISTS idx_sign_in_record_member_time ON sign_in_record(member_id, sign_in_time);
+
+-- 复合索引：签到状态 + 签到时间（加速统计数据查询）
+CREATE INDEX IF NOT EXISTS idx_sign_in_record_status_time ON sign_in_record(sign_in_status, sign_in_time);
+
+-- 添加表注释
+COMMENT ON TABLE sign_in_record IS '会员到店签到记录表';
+
+-- 添加字段注释
+COMMENT ON COLUMN sign_in_record.id IS '自增主键';
+COMMENT ON COLUMN sign_in_record.member_id IS '会员ID，关联member表';
+COMMENT ON COLUMN sign_in_record.member_card_id IS '签到时使用的会员卡ID';
+COMMENT ON COLUMN sign_in_record.sign_in_time IS '签到入场时间';
+COMMENT ON COLUMN sign_in_record.sign_in_type IS '签到方式：QR_CODE-扫码签到，MANUAL-手动签到，FACE-人脸识别';
+COMMENT ON COLUMN sign_in_record.sign_in_status IS '签到状态：SUCCESS-成功，FAILED-失败';
+COMMENT ON COLUMN sign_in_record.verification_details IS 'JSON格式，存储会员卡验证时的快照数据';
+COMMENT ON COLUMN sign_in_record.fail_reason IS '失败时的具体原因文案';
+COMMENT ON COLUMN sign_in_record.operator_id IS '操作人ID（前台人员），自助签到时为NULL';
+COMMENT ON COLUMN sign_in_record.operator_name IS '操作人姓名冗余';
+COMMENT ON COLUMN sign_in_record.device_info IS '签到设备标识或型号';
+COMMENT ON COLUMN sign_in_record.ip_address IS '客户端IP地址';
+COMMENT ON COLUMN sign_in_record.source IS '签到来源：MINI_PROGRAM-小程序扫码，PC_BACKEND-后台管理端';
+COMMENT ON COLUMN sign_in_record.is_delete IS '软删除标识：false-未删除，true-已删除';
+COMMENT ON COLUMN sign_in_record.created_at IS '记录创建时间';
+COMMENT ON COLUMN sign_in_record.updated_at IS '记录更新时间';

gym-manage-api/manage-gateway/src/main/java/cn/novalon/gym/manage/gateway/filter/JwtAuthenticationFilter.java

@@ -60,7 +60,8 @@ public class JwtAuthenticationFilter extends AbstractGatewayFilterFactory<JwtAut
                path.equals("/actuator/health") ||
                path.equals("/api/member/auth/miniapp/login") || 
                path.equals("/api/member/auth/mp/callback") || 
-               path.equals("/api/auth/login") || 
+               path.equals("/api/auth/login") ||
+               path.startsWith("/api/checkIn/") ||
                path.startsWith("/actuator/info");
     }
 

gym-manage-api/manage-gateway/src/main/java/cn/novalon/gym/manage/gateway/filter/RbacAuthorizationFilter.java

@@ -61,9 +61,10 @@ public class RbacAuthorizationFilter extends AbstractGatewayFilterFactory<RbacAu
     }
 
     private boolean isPublicPath(String path) {
-        return path.startsWith("/api/auth/") || 
+        return path.startsWith("/api/auth/") ||
                path.equals("/actuator/health") ||
-               path.startsWith("/actuator/info");
+               path.startsWith("/actuator/info") ||
+               path.startsWith("/api/checkIn/");
     }
 
     public static class Config {

gym-manage-api/manage-sys/src/main/java/cn/novalon/gym/manage/sys/config/SecurityConfig.java

@@ -50,6 +50,7 @@ public class SecurityConfig {
                     spec.pathMatchers("/api/auth/**").permitAll()
                             .pathMatchers("/api/public/**").permitAll()
                             .pathMatchers("/ws/**").permitAll()
+                            .pathMatchers("/**").permitAll()
                             .pathMatchers("/actuator/**").permitAll();
 
                     if (isDevOrTest) {

gym-manage-api/pom.xml

@@ -43,6 +43,7 @@
         <module>manage-notify</module>
         <module>manage-file</module>
         <module>gym-member</module>
+        <module>gym-checkIn</module>
 	</modules>
 
     <dependencyManagement>