package com.movie.websocket;

import java.io.IOException;
import java.util.concurrent.ConcurrentHashMap;

import org.springframework.stereotype.Component;

import jakarta.websocket.OnClose;
import jakarta.websocket.OnMessage;
import jakarta.websocket.OnOpen;
import jakarta.websocket.Session;
import jakarta.websocket.server.PathParam;
import jakarta.websocket.server.ServerEndpoint;

/**
 * WebSocket 服务端
 * 前端连接地址: ws://localhost:8080/ws/{userId}
 */
@Component
@ServerEndpoint("/ws/{userId}")
public class WebSocketServer {

    // 静态变量，用来记录当前在线连接数。应该把它设计成线程安全的。
    private static ConcurrentHashMap<String, Session> sessionMap = new ConcurrentHashMap<>();

    public static ConcurrentHashMap<String, Session> getSessionMap() {
        return sessionMap;
    }

    public static void setSessionMap(ConcurrentHashMap<String, Session> sessionMap) {
        WebSocketServer.sessionMap = sessionMap;
    }

    /**
     * 连接建立成功调用的方法
     */
    @OnOpen
    public void onOpen(Session session, @PathParam("userId") String userId) {
        sessionMap.put(userId, session);
        System.out.println("用户上线:" + userId + ", 当前在线人数:" + sessionMap.size());
    }

    /**
     * 连接关闭调用的方法
     */
    @OnClose
    public void onClose(@PathParam("userId") String userId) {
        sessionMap.remove(userId);
        System.out.println("用户下线:" + userId + ", 当前在线人数:" + sessionMap.size());
    }

    /**
     * 收到客户端消息后调用的方法 (可选)
     */
    @OnMessage
    public void onMessage(String message, Session session) {
        System.out.println("收到消息:" + message);
    }

    /**
     * 自定义发送消息方法 (服务器 -> 客户端)
     */
    @SuppressWarnings("CallToPrintStackTrace")
    public static void sendInfo(String userId, String message) {
        Session session = sessionMap.get(userId);
        if (session != null && session.isOpen()) {
            try {
                session.getBasicRemote().sendText(message);
                System.out.println("推送消息给用户 " + userId + " : " + message);
            } catch (IOException e) {
                e.printStackTrace();
            }
        } else {
            System.out.println("用户 " + userId + " 不在线，消息未发送");
        }
    }

    /**
     * 群发消息
     */
    @SuppressWarnings("CallToPrintStackTrace")
    public static void sendAll(String message) {
        for (Session session : sessionMap.values()) {
            if (session.isOpen()) {
                try {
                    session.getBasicRemote().sendText(message);
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        System.out.println("群发消息完成: " + message);
    }
}
package com.movie.utils;

import com.movie.entity.User;

public class UserHolder {
    private static final ThreadLocal<User> tl = new ThreadLocal<>();

    public static void saveUser(User user){
        tl.set(user);
    }

    public static User getUser(){
        return tl.get();
    }

    public static void removeUser(){
        tl.remove();
    }
}package com.movie.task;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;

import com.movie.mapper.OrderMapper;

@Component
public class OrderTask {

    @Autowired
    private OrderMapper orderMapper;

    /**
     * 每分钟执行一次 (Cron表达式: 秒 分 时 日 月 周)
     * 检查是否有电影已经放完了，如果有，把订单改成已观影
     */
    @Scheduled(cron = "0 0/1 * * * ?")
    public void processWatchedOrders() {
        // System.out.println("执行定时任务：更新已观影状态 - " + LocalDateTime.now());
        orderMapper.updateWatchedStatus();
    }
}package com.movie.repository;

import org.springframework.data.elasticsearch.repository.ElasticsearchRepository;

import com.movie.doc.MovieDoc;

public interface MovieRepository extends ElasticsearchRepository<MovieDoc, Long> {
    // Spring Data Elasticsearch 会自动帮我们实现 CRUD 方法
}package com.movie.mapper;


import org.apache.ibatis.annotations.Param;
import org.apache.ibatis.annotations.Select;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.movie.entity.ReviewReply;
import com.movie.vo.ReplyVO;

public interface ReviewReplyMapper extends BaseMapper<ReviewReply> {

    // 查询某条评论下的所有回复 (连表查用户)
    @Select("SELECT r.*, u.nickname, u.avatar_url, tu.nickname as target_nickname " +
            "FROM review_reply r " +
            "LEFT JOIN sys_user u ON r.user_id = u.id " +
            "LEFT JOIN sys_user tu ON r.target_user_id = tu.id " +
            "WHERE r.review_id = #{reviewId} AND r.is_deleted = 0 " +
            "ORDER BY r.create_time ASC")
    Page<ReplyVO> findRepliesByReviewId(Page<ReplyVO> page, @Param("reviewId") Long reviewId);
}package com.movie.mapper;

import org.apache.ibatis.annotations.Param;
import org.apache.ibatis.annotations.Select;
import org.apache.ibatis.annotations.Update;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.movie.entity.Review;
import com.movie.vo.ReviewVO;

public interface ReviewMapper extends BaseMapper<Review> {

    // 自定义分页连表查询
    @Select("SELECT r.*, u.nickname, u.avatar_url " +
            "FROM movie_review r " +
            "LEFT JOIN sys_user u ON r.user_id = u.id " +
            "WHERE r.movie_id = #{movieId} AND r.is_deleted = 0 " +
            "ORDER BY r.create_time DESC")
    Page<ReviewVO> findReviewsByMovieId(Page<ReviewVO> page, @Param("movieId") Long movieId);

    // 使用 <script> 标签支持动态 SQL，如果 keyword 不为空，则搜索 content 或 nickname
    @Select("<script>" +
            "SELECT r.*, u.nickname, u.avatar_url, m.title as movie_title " +
            "FROM movie_review r " +
            "LEFT JOIN sys_user u ON r.user_id = u.id " +
            "LEFT JOIN movie_info m ON r.movie_id = m.id " +
            "WHERE r.is_deleted = 0 " +
            "<if test='keyword != null and keyword != \"\"'> " +
            "  AND (r.content LIKE CONCAT('%', #{keyword}, '%') OR u.nickname LIKE CONCAT('%', #{keyword}, '%')) " +
            "</if>" +
            "ORDER BY r.create_time DESC" +
            "</script>")
    Page<ReviewVO> findAdminReviews(Page<ReviewVO> page, @Param("keyword") String keyword);

    @Update("UPDATE movie_review SET like_count = like_count + 1 WHERE id = #{id}")
    void increaseLikeCount(Long id);

    @Update("UPDATE movie_review SET like_count = like_count - 1 WHERE id = #{id} AND like_count > 0")
    void decreaseLikeCount(Long id);
}package com.movie.mapper;

import java.math.BigDecimal;

import org.apache.ibatis.annotations.Select;
import org.apache.ibatis.annotations.Update;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.movie.entity.Order;

/**
 * <p>
 * 购票订单表 Mapper 接口
 * </p>
 *
 * @author Liu
 * @since 2025-12-25
 */
public interface OrderMapper extends BaseMapper<Order> {
    // 统计总票房 (只算已支付 status=1 的)
    @Select("SELECT IFNULL(SUM(total_price), 0) FROM movie_order WHERE status = 1")
    BigDecimal sumTotalBoxOffice();

    // 统计今日票房 (只算已支付 + 支付时间是今天)
    @Select("SELECT IFNULL(SUM(total_price), 0) FROM movie_order WHERE status = 1 AND DATE(pay_time) = CURDATE()")
    BigDecimal sumTodayBoxOffice();

    // 定时任务专用：把所有 "已支付(1)" 且 "结束时间小于当前时间" 的订单，改为 "已观影(4)"
    // 这里用了连表更新 (UPDATE JOIN)
    @Update("UPDATE movie_order o " +
            "INNER JOIN movie_schedule s ON o.schedule_id = s.id " +
            "SET o.status = 4 " +
            "WHERE o.status = 1 AND s.end_time < NOW()")
    void updateWatchedStatus();
}
package com.movie.listener;

import java.util.List;
import java.util.stream.Collectors;

import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Component;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.movie.config.RabbitMQConfig;
import com.movie.entity.Order;
import com.movie.service.IOrderService;

@Component
public class OrderTimeoutListener {
    @Autowired
    private IOrderService orderService;
    @Autowired
    private StringRedisTemplate redisTemplate;

    // 监听死信队列
    @RabbitListener(queues = RabbitMQConfig.ORDER_RELEASE_QUEUE)
    public void listenOrderTimeout(String orderNo) {
        if (orderNo == null) return;
        
        // 1. 根据订单号查询订单
        QueryWrapper<Order> query = new QueryWrapper<>();
        query.eq("order_no", orderNo);
        Order order = orderService.getOne(query);

        if (order == null) return;

        // 2. 检查订单状态是否仍为“待支付”
        if (order.getStatus() == 0) {
            // 3. 状态仍为 0，说明超时未支付，关闭订单
            order.setStatus(2); // 2-已取消
            orderService.updateById(order);

            // 4. 释放 Redis 中的座位锁
            String lockKeyPrefix = "lock:seat:" + order.getScheduleId() + ":";
            List<String> seats = List.of(order.getSeatInfo().split(","));
            List<String> lockKeys = seats.stream().map(seat -> lockKeyPrefix + seat).collect(Collectors.toList());
            redisTemplate.delete(lockKeys);
        }
    }
}package com.movie.listener;

import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Component;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.movie.config.RabbitMQConfig;
import com.movie.dto.LikeMsgDTO;
import com.movie.entity.Review;
import com.movie.entity.ReviewReply;
import com.movie.entity.UserLikeRecord;
import com.movie.service.IReviewReplyService;
import com.movie.service.IReviewService;
import com.movie.service.IUserLikeRecordService;

@Component
public class LikeCountListener {

    @Autowired private StringRedisTemplate redisTemplate;
    @Autowired private IReviewService reviewService;
    @Autowired private IReviewReplyService replyService;
    @Autowired private IUserLikeRecordService userLikeRecordService; // 记得创建这个Service

    @RabbitListener(queues = RabbitMQConfig.LIKE_COUNT_QUEUE)
    public void handleLikeMessage(LikeMsgDTO msg) {
        if (msg == null) return;

        // 1. 维护 MySQL 的点赞记录表 (持久化)
        if (msg.getIsLike()) {
            // 插入记录 (如果已存在可能会报错，建议加 try-catch 或 ignore)
            try {
                UserLikeRecord record = new UserLikeRecord();
                record.setUserId(msg.getUserId());
                record.setTargetId(msg.getTargetId());
                record.setType(msg.getType()); // 1或2
                userLikeRecordService.save(record);
            } catch (Exception e) {
            }
        } else {
            // 删除记录
            QueryWrapper<UserLikeRecord> query = new QueryWrapper<>();
            query.eq("user_id", msg.getUserId())
                .eq("target_id", msg.getTargetId())
                .eq("type", msg.getType());
            userLikeRecordService.remove(query);
        }

        // 2. 更新 Redis 里的总数 -> 同步到 MySQL 计数列
        String redisKey = (msg.getType() == 1 ? "review:like:" : "reply:like:") + msg.getTargetId();
        Long size = redisTemplate.opsForSet().size(redisKey);
        int count = size != null ? size.intValue() : 0;

        if (msg.getType() == 1) {
            // 更新影评表
            Review review = new Review();
            review.setId(msg.getTargetId());
            review.setLikeCount(count);
            reviewService.updateById(review);
        } else {
            // 更新回复表
            ReviewReply reply = new ReviewReply();
            reply.setId(msg.getTargetId());
            reply.setLikeCount(count);
            replyService.updateById(reply);
        }
    }
}package com.movie.interceptor;

import java.util.concurrent.TimeUnit;

import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.web.servlet.HandlerInterceptor;

import com.movie.entity.User;
import com.movie.utils.UserHolder;

import cn.hutool.core.util.StrUtil;
import cn.hutool.json.JSONUtil;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;

public class LoginInterceptor implements HandlerInterceptor {

    @SuppressWarnings("FieldMayBeFinal")
    private StringRedisTemplate stringRedisTemplate;

    public LoginInterceptor(StringRedisTemplate stringRedisTemplate) {
        this.stringRedisTemplate = stringRedisTemplate;
    }

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        // 1. 获取请求头中的 token
        String token = request.getHeader("authorization");
        if (StrUtil.isBlank(token)) {
            response.setStatus(401); // 401 Unauthorized
            return false;
        }

        // 2. 基于 token 获取 redis 中的用户
        String key  = "login_token:" + token;
        String userJson = stringRedisTemplate.opsForValue().get(key);
        if (StrUtil.isBlank(userJson)) {
            response.setStatus(401);
            return false;
        }

        // 3. 将查询到的 Hash 数据转为 User 对象
        User user = JSONUtil.toBean(userJson, User.class);

        // 4. 保存用户信息到 ThreadLocal
        UserHolder.saveUser(user);

        // 5. 刷新 token 有效期（用户只要在操作，token 就应该续期）
        stringRedisTemplate.expire(key, 24, TimeUnit.HOURS);
        
        // 6. 放行
        return true;
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        // 请求结束后，移除用户，防止内存泄漏
        UserHolder.removeUser();
    }
}package com.movie.interceptor;

import org.springframework.web.servlet.HandlerInterceptor;

import com.movie.entity.User;
import com.movie.utils.UserHolder;

import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;

public class AdminAuthInterceptor implements HandlerInterceptor {

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        // 1. 从 ThreadLocal 获取用户信息 (LoginInterceptor 已经塞进去了)
        User user = UserHolder.getUser();

        // 2. 检查用户是否存在，以及是否是管理员
        if (user == null || Boolean.FALSE.equals(user.getIsAdmin())) {
            response.setStatus(403); // 403 Forbidden - 你有身份，但没权限
            return false;
        }

        // 3. 是管理员，放行
        return true;
    }
}package com.movie.doc;

import java.util.List;

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;

@Document(indexName = "movie_index") // 定义 ES 索引名
public class MovieDoc {
    @Id
    private Long id; // 对应 movie_info 表的 ID

    // ik_max_word 是中文分词器，ik_smart 是更智能的
    // analyzer 是写入时分词，searchAnalyzer 是搜索时分词
    @Field(type = FieldType.Text, analyzer = "ik_max_word", searchAnalyzer = "ik_smart")
    private String title;

    @Field(type = FieldType.Text, analyzer = "ik_max_word", searchAnalyzer = "ik_smart")
    private String originalTitle;

    @Field(type = FieldType.Keyword) // Keyword 不分词，精确匹配
    private String genre;

    @Field(type = FieldType.Keyword)
    private String country;

    @Field(type = FieldType.Text, analyzer = "ik_max_word", searchAnalyzer = "ik_smart")
    private String synopsis;

    @Field(type = FieldType.Keyword)
    private String posterUrl; // 海报地址

    @Field(type = FieldType.Double)
    private Double rating;    // 评分

    @Field(type = FieldType.Keyword)
    private String releaseDate; // 上映日期（存字符串即可，方便展示）
    
    // --- 关键：把关联信息也存进来 ---
    @Field(type = FieldType.Text, analyzer = "ik_max_word", searchAnalyzer = "ik_smart")
    private List<String> actors; // 演员名列表 ["成龙", "吴彦祖"]

    @Field(type = FieldType.Text, analyzer = "ik_max_word", searchAnalyzer = "ik_smart")
    private List<String> directors; // 导演名列表

    // --- 请手动生成 Getter / Setter ---
    public Long getId() { return id; }
    public void setId(Long id) { this.id = id; }
    public String getTitle() { return title; }
    public void setTitle(String title) { this.title = title; }
    public String getOriginalTitle() { return originalTitle; }
    public void setOriginalTitle(String originalTitle) { this.originalTitle = originalTitle; }
    public String getGenre() { return genre; }
    public void setGenre(String genre) { this.genre = genre; }
    public String getCountry() { return country; }
    public void setCountry(String country) { this.country = country; }
    public String getSynopsis() { return synopsis; }
    public void setSynopsis(String synopsis) { this.synopsis = synopsis; }
    public List<String> getActors() { return actors; }
    public void setActors(List<String> actors) { this.actors = actors; }
    public List<String> getDirectors() { return directors; }
    public void setDirectors(List<String> directors) { this.directors = directors; }

    public String getPosterUrl() {
        return posterUrl;
    }

    public void setPosterUrl(String posterUrl) {
        this.posterUrl = posterUrl;
    }

    public Double getRating() {
        return rating;
    }

    public void setRating(Double rating) {
        this.rating = rating;
    }

    public String getReleaseDate() {
        return releaseDate;
    }

    public void setReleaseDate(String releaseDate) {
        this.releaseDate = releaseDate;
    }
}package com.movie.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.socket.server.standard.ServerEndpointExporter;

@Configuration
public class WebSocketConfig {
    /**
     * 注入 ServerEndpointExporter，
     * 这个 bean 会自动注册使用了 @ServerEndpoint 注解声明的 Websocket endpoint
     */
    @Bean
    public ServerEndpointExporter serverEndpointExporter() {
        return new ServerEndpointExporter();
    }
}package com.movie.config;

import org.springframework.amqp.core.Binding;
import org.springframework.amqp.core.BindingBuilder;
import org.springframework.amqp.core.DirectExchange;
import org.springframework.amqp.core.Queue;
import org.springframework.amqp.core.QueueBuilder;
import org.springframework.amqp.support.converter.Jackson2JsonMessageConverter;
import org.springframework.amqp.support.converter.MessageConverter;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class RabbitMQConfig {

    // --- 点赞队列 (不变) ---
    public static final String LIKE_COUNT_QUEUE = "like.count.queue.v2";
    @Bean
    public Queue likeCountQueue() {
        return new Queue(LIKE_COUNT_QUEUE, true);
    }
    
    // --- 新增：订单超时处理 ---
    public static final String ORDER_TTL_QUEUE = "order.delay.queue"; // 延迟队列
    public static final String ORDER_DLX_EXCHANGE = "order.dlx.exchange"; // 死信交换机
    public static final String ORDER_RELEASE_QUEUE = "order.release.queue"; // 死信接收队列
    public static final String ORDER_DLX_ROUTING_KEY = "order.release.key"; // 死信路由键

    // 1. 定义死信交换机
    @Bean
    public DirectExchange orderDlxExchange() {
        return new DirectExchange(ORDER_DLX_EXCHANGE);
    }
    
    // 2. 定义延迟队列 (消息过期后会进入死信交换机)
    @Bean

    public Queue orderTtlQueue() {
        return QueueBuilder.durable(ORDER_TTL_QUEUE)
                .ttl(900000) // 15分钟 TTL (15 * 60 * 1000)
                .deadLetterExchange(ORDER_DLX_EXCHANGE) // 绑定死信交换机
                .deadLetterRoutingKey(ORDER_DLX_ROUTING_KEY) // 绑定死信路由键
                .build();
    }
    
    // 3. 定义死信队列 (真正消费消息的队列)
    @Bean
    public Queue orderReleaseQueue() {
        return new Queue(ORDER_RELEASE_QUEUE, true);
    }
    
    // 4. 绑定死信队列和死信交换机
    @Bean
    public Binding orderDlxBinding() {
        return BindingBuilder.bind(orderReleaseQueue()).to(orderDlxExchange()).with(ORDER_DLX_ROUTING_KEY);
    }

    @Bean
    public MessageConverter messageConverter() {
        return new Jackson2JsonMessageConverter();
    }
}package com.movie.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import com.baomidou.mybatisplus.annotation.DbType;
import com.baomidou.mybatisplus.extension.plugins.MybatisPlusInterceptor;
import com.baomidou.mybatisplus.extension.plugins.inner.PaginationInnerInterceptor;

@Configuration
public class MybatisPlusConfig {
    @Bean
    public MybatisPlusInterceptor mybatisPlusInterceptor() {
        MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
        // 核心：如果不加这个拦截器，所有的 Page 对象都会失效，直接查全表
        interceptor.addInnerInterceptor(new PaginationInnerInterceptor(DbType.MYSQL));
        return interceptor;
    }
}package com.movie.config;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

import com.movie.interceptor.AdminAuthInterceptor;
import com.movie.interceptor.LoginInterceptor;

@Configuration
public class MvcConfig implements WebMvcConfigurer {

    @Autowired
    private StringRedisTemplate stringRedisTemplate;

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        // 注册登录拦截器
        registry.addInterceptor(new LoginInterceptor(stringRedisTemplate))
                .addPathPatterns("/**") // 拦截所有
                .excludePathPatterns(   // --- 排除所有公开路径 ---
                        // 用户认证
                        "/user/login",
                        "/user/register",
                        // 文件上传
                        "/file/upload",
                        // 公开内容查询
                        "/movie/search",     // ES 搜索
                        "/movie/top10",      // 热门电影
                        "/movie/detail/**",  // 电影详情
                        "/actorInfo/list",       // 演员列表
                        "/actorInfo/{id}",       // 演员详情
                        "/directorInfo/list",    // 导演列表
                        "/directorInfo/{id}",    // 导演详情
                        "/schedule/list/**", // 某电影的排片
                        "/review/list/**",   // 某电影的评论
                        "/reply/list/**",
                        "/cinema/list",
                        "/hall/list/**"     // 某评论的回复
                ).order(1);

        registry.addInterceptor(new AdminAuthInterceptor())
                .addPathPatterns(
                    // --- 把所有管理员接口都加到这里 ---
                    "/movie/add", "/movie/update", "/movie/delete/**",
                    "/actor/**", "/director/**", 
                    "/cinema/**", "/hall/**", "/schedule/**",
                    "/report/**", "/log/**",
                    "/review/delete/**", "/review/admin/**",
                    "/user/status/**",
                    "/reply/delete/**"
                )
                .excludePathPatterns(
            "/schedule/list/**",
                        "/cinema/list/**" ,// 允许普通用户访问排片列表，不触发管理员检查
                        "/hall/list/**"  // 允许普通用户访问影厅列表，不触发管理员检查
                )
                .order(2);  
    }
}package com.movie.config;

import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import io.minio.MinioClient;

/**
 * MinIO 配置类
 * 作用：读取 application.yml 中的 minio 配置，并注册 MinioClient 到 Spring 容器
 */
@Configuration
@ConfigurationProperties(prefix = "minio") // 告诉 Spring 读取 minio 开头的配置
public class MinioConfig {

    private String endpoint;
    private String accessKey;
    private String secretKey;
    private String bucketName;

    /**
     * 注入 MinioClient 客户端
     * 以后在代码里直接 @Autowired MinioClient minioClient 就能用了
     */
    @Bean
    public MinioClient minioClient() {
        return MinioClient.builder()
                .endpoint(endpoint)
                .credentials(accessKey, secretKey)
                .build();
    }

    public String getEndpoint() {
        return endpoint;
    }

    public void setEndpoint(String endpoint) {
        this.endpoint = endpoint;
    }

    public String getAccessKey() {
        return accessKey;
    }

    public void setAccessKey(String accessKey) {
        this.accessKey = accessKey;
    }

    public String getSecretKey() {
        return secretKey;
    }

    public void setSecretKey(String secretKey) {
        this.secretKey = secretKey;
    }

    public String getBucketName() {
        return bucketName;
    }

    public void setBucketName(String bucketName) {
        this.bucketName = bucketName;
    }
}package com.movie.common;

public class Result<T> {
    private Integer code; // 200成功，500失败
    private String message;
    private T data;

    public static <T> Result<T> success(T data) {
        Result<T> r = new Result<>();
        r.code = 200;
        r.message = "success";
        r.data = data;
        return r;
    }

    public static <T> Result<T> error(String msg) {
        Result<T> r = new Result<>();
        r.code = 500;
        r.message = msg;
        return r;
    }

    public Integer getCode() {
        return code;
    }

    public void setCode(Integer code) {
        this.code = code;
    }

    public String getMessage() {
        return message;
    }

    public void setMessage(String message) {
        this.message = message;
    }

    public T getData() {
        return data;
    }

    public void setData(T data) {
        this.data = data;
    }
}package com.movie.aspect;

import java.lang.reflect.Method;
import java.time.LocalDateTime;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;

import com.movie.annotation.SysLog;
import com.movie.entity.Log;
import com.movie.entity.User;
import com.movie.service.ILogService;
import com.movie.utils.UserHolder;

import cn.hutool.json.JSONUtil;
import jakarta.servlet.http.HttpServletRequest;

@Aspect
@Component
public class LogAspect {

    @Autowired
    private ILogService logService;

    @Around("@annotation(com.movie.annotation.SysLog)")
    public Object saveLog(ProceedingJoinPoint point) throws Throwable {
        long beginTime = System.currentTimeMillis();

        // 1. 执行目标方法
        Object result = point.proceed();

        // 2. 计算执行时长
        long time = System.currentTimeMillis() - beginTime;

        // 3. 异步保存日志
        recordLog(point, time);

        return result;
    }

    private void recordLog(ProceedingJoinPoint point, long time) {
        MethodSignature signature = (MethodSignature) point.getSignature();
        Method method = signature.getMethod();

        Log sysLog = new Log();

        // --- 1. 设置操作内容 (Action) ---
        SysLog logAnnotation = method.getAnnotation(SysLog.class);
        if (logAnnotation != null) {
            sysLog.setAction(logAnnotation.value());
        }

        // --- 2. 设置方法名 (Method) ---
        String className = point.getTarget().getClass().getName();
        String methodName = signature.getName();
        sysLog.setMethod(className + "." + methodName + "()");

        // --- 3. 设置参数 (Params) ---
        // 使用 Hutool 工具类序列化参数，并截取过长内容防止数据库报错
        try {
            Object[] args = point.getArgs();
            String params = JSONUtil.toJsonStr(args);
            if (params.length() > 500) {
                params = params.substring(0, 500) + "...";
            }
            sysLog.setParams(params);
        } catch (Exception e) {
            // 参数解析失败不影响日志记录
        }

        // --- 4. 设置操作人 (Username) ---
        User user = UserHolder.getUser();
        if (user != null) {
            sysLog.setUsername(user.getUsername());
        } else {
            sysLog.setUsername("游客/未登录");
        }

        // --- 5. 设置 IP 地址 (核心优化) ---
        // 获取 Request 对象
        ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
        if (attributes != null) {
            HttpServletRequest request = attributes.getRequest();
            String ip = getIpAddr(request); // 使用增强版 IP 获取方法
            sysLog.setIp(ip);
        }

        // --- 6. 设置耗时 (Time) - 对应你的数据库字段 ---
        sysLog.setTime(time); 

        // --- 7. 设置创建时间 ---
        sysLog.setCreateTime(LocalDateTime.now());

        // 保存到数据库
        logService.save(sysLog);
    }

    /**
     * 获取客户端真实IP地址 (处理代理和本地IPv6问题)
     */
    private String getIpAddr(HttpServletRequest request) {
        String ip = request.getHeader("x-forwarded-for");
        if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
            ip = request.getHeader("Proxy-Client-IP");
        }
        if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
            ip = request.getHeader("WL-Proxy-Client-IP");
        }
        if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
            ip = request.getRemoteAddr();
        }
        // 处理本地开发环境的 IPv6 地址 0:0:0:0:0:0:0:1 转为 127.0.0.1
        if ("0:0:0:0:0:0:0:1".equals(ip)) {
            return "127.0.0.1";
        }
        return ip;
    }
}package com.movie.annotation;

import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target(ElementType.METHOD) // 作用在方法上
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface SysLog {
    String value() default ""; // 操作描述，例如 "删除电影"
}