package com.example.demo.controller;

import org.springframework.web.bind.annotation.*;
import java.util.Map;

@RestController
@RequestMapping("/api")
public class CorsController {

    // 模拟一个查询接口
    @GetMapping("/data")
    public Map<String, Object> getData() {
        System.out.println(">>> 后端接收到了 /api/data 请求");
        return Map.of(
            "code", 200,
            "message", "数据获取成功",
            "data", "这是来自 8080 端口的机密数据"
        );
    }

    // 模拟一个修改接口 (非简单请求)
    @PostMapping("/update")
    public Map<String, Object> updateData(@RequestBody Map<String, String> payload) {
        System.out.println(">>> 后端接收到了 /api/update 请求，参数：" + payload);
        return Map.of("code", 200, "message", "修改成功");
    }
}

// src/main/java/com/example/config/SecurityConfig.java

@Bean
public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
    http
        // 开启 CORS 配置，使用默认的 CorsConfigurationSource
        .cors(Customizer.withDefaults()) 
        // 禁用 CSRF (前后端分离通常使用 Token，不需要 Session based CSRF 保护)
        .csrf(csrf -> csrf.disable())
        // ... 其他配置
        ;
    return http.build();
}

package com.example.demo.config;

import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.CorsRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

/**
 * Web MVC 全局配置
 * 用于配置跨域、拦截器、资源映射等
 */
@Configuration
public class WebMvcConfig implements WebMvcConfigurer {

    @Override
    public void addCorsMappings(CorsRegistry registry) {
        // 这里的配置相当于告诉浏览器：凡是 /api/** 下的接口，都允许跨域
        registry.addMapping("/**")                  // 1. 匹配所有路径
                // .allowedOrigins("*")             // 注意：Spring Boot 2.4+ 配合 allowCredentials 时禁止使用 *
                .allowedOriginPatterns("*")         // 2. 允许所有源 (支持通配符)
                .allowedMethods("GET", "POST", "PUT", "DELETE", "OPTIONS") // 3. 允许的方法
                .allowedHeaders("*")                // 4. 允许前端携带所有 Header (如 Authorization)
                .exposedHeaders("Authorization")    // 5. 暴露响应头 (让前端能读取到 Token)
                .allowCredentials(true)             // 6. 允许携带凭证 (Cookie)
                .maxAge(3600);                      // 7. 预检请求缓存 1 小时
    }
}

@Override
public void addCorsMappings(CorsRegistry registry) {
    registry.addMapping("/**")
            // ❌ 错误示范：在 allowCredentials(true) 时，严禁使用 allowedOrigins("*")
            // .allowedOrigins("*") 
            
            // ✅ 正确示范：使用 Pattern 进行动态匹配和反射
            .allowedOriginPatterns("*") 
            
            .allowCredentials(true) // 允许 Cookie
            .allowedMethods("*")
            .allowedHeaders("*");
}

package com.example.demo.interceptor;

import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;

@Slf4j
@Component // 交给 Spring 管理，方便后续注入 Service
public class LoginInterceptor implements HandlerInterceptor {

    /**
     * 【前置钩子】
     * 执行时机：进入 Controller 方法之前
     * 核心作用：权限检查、Token 校验、限流
     * 返回值：true = 放行；false = 拦截（后续环节全部中止）
     */
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        log.info(">>> 1. 拦截器前置处理: {}", request.getRequestURI());
        
        // 1. 获取 Token (通常在 Header 中)
        String token = request.getHeader("Authorization");

        // 2. 模拟校验逻辑 (真实场景应调用 JWTUtil 解析)
        if (token == null || !"valid-token-123".equals(token)) {
            log.warn(">>> Token 校验失败，请求拦截");
            
            // 3. 校验失败响应：直接设置状态码并写入 JSON
            response.setStatus(401);
            response.setContentType("application/json;charset=UTF-8");
            response.getWriter().write("{\"code\": 401, \"message\": \"未登录或 Token 失效\"}");
            
            return false; // 🚫 拦截！不再执行后续 Controller
        }

        // 4. 校验通过
        return true; // ✅ 放行
    }

    /**
     * 【后置钩子】
     * 执行时机：Controller 方法执行完毕，但视图渲染（ViewResolver）之前
     * 核心作用：修改 ModelAndView 数据（前后端分离模式下较少使用）
     */
    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) {
        log.info(">>> 2. 拦截器后置处理 (Controller 执行完毕)");
    }

    /**
     * 【最终钩子】
     * 执行时机：整个请求结束（视图渲染完毕），或 Controller 抛出异常后
     * 核心作用：资源清理（如 ThreadLocal.remove）、异常日志记录
     */
    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) {
        log.info(">>> 3. 请求最终结束");
        // 注意：这里的 ex 只有在异常未被 @ExceptionHandler 捕获时才会有值
        // 如果被全局异常处理器捕获并处理了，这里 ex 为 null
    }
}

@Autowired
private LoginInterceptor loginInterceptor;

@Override
public void addInterceptors(InterceptorRegistry registry) {
    // 注册拦截器
    registry.addInterceptor(loginInterceptor)
            // 1. 拦截规则：所有路径
            .addPathPatterns("/**")
            
            // 2. 排除规则：白名单路径
            // 注意：Spring Boot 默认会自动处理静态资源，但为了保险，建议显式排除
            .excludePathPatterns(
                    "/users/login",      // 登录接口
                    "/users/register",   // 注册接口
                    "/error",            // Spring Boot 默认错误转发路径
                    "/swagger-ui/**",    // Swagger 文档
                    "/v3/api-docs/**",   // Swagger 文档数据
                    "/static/**"         // 静态资源
            );
}

package com.example.demo.context;

import lombok.Data;

import java.util.Map;

/**
 * 基于 ThreadLocal 的用户上下文
 * 作用：在同一线程的请求链路中，随时随地获取当前用户信息
 */
@Data
public class UserContext {
    // 使用 ThreadLocal 存储当前线程的 User ID (或其他信息)
    private static final ThreadLocal<Long> USER_ID_HOLDER = new ThreadLocal<>();
    
    // 务必提供清理方法，防止内存泄漏
    public static void remove() {
        USER_ID_HOLDER.remove();
    }
}

@Override
public boolean preHandle(...) {
    // ... Token 校验逻辑 ...
    
    // 假设从 Token 中解析出了 userId = 10086
    Long userId = JwtUtil.getUserId(token);
    
    // 🔑 核心操作：将 userId 放入当前线程的上下文
    UserContext.setUserId(userId);
    
    return true;
}

@GetMapping("/my-info")
public Result<User> getMyInfo() {
    // 🎉 优雅！任何地方都能直接拿到当前用户 ID，不需要传参
    Long currentUserId = UserContext.getUserId();
    
    // 根据 ID 查询数据库...
    return Result.success(userService.getById(currentUserId));
}

@Override
public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) {
    // 🧹 无论请求成功还是失败，必须强制清理 ThreadLocal
    UserContext.remove();
    log.info(">>> 清理用户上下文完毕");
}

@Override
public void addInterceptors(InterceptorRegistry registry) {
    // Order 1: 黑名单 (最先执行)
    registry.addInterceptor(blacklistInterceptor).order(1);
    
    // Order 2: 登录校验
    registry.addInterceptor(loginInterceptor).order(2);
    
    // Order 3: 日志 (最后执行，因为可能需要记录前面是否失败)
    registry.addInterceptor(logInterceptor).order(3);
}

package com.example.demo.utils;

import org.apache.tika.Tika;
import org.springframework.web.multipart.MultipartFile;

import java.io.IOException;
import java.io.InputStream;
import java.util.List;
import java.util.UUID;

public class UploadUtils {

    // Tika 实例加载成本较高但线程安全，建议静态单例复用
    private static final Tika TIKA = new Tika();

    // 白名单机制：仅允许业务需要的 MIME 类型
    // 相比黑名单（禁止 .exe），白名单（只许 .png）更安全
    private static final List<String> ALLOWED_MIME_TYPES = List.of(
            "image/jpeg",
            "image/png",
            "image/gif",
            "application/pdf"
    );

    /**
     * 深度安全校验：使用 Tika 检测文件的真实“指纹”
     * @param file 上传的文件对象
     * @return 是否安全
     */
    public static boolean isSafeFile(MultipartFile file) {
        if (file == null || file.isEmpty()) return false;

        try (InputStream inputStream = file.getInputStream()) {
            // Tika 不仅读取文件头，还会尝试解析文件结构来判断类型
            String detectedMimeType = TIKA.detect(inputStream);
            
            // 严格比对白名单
            if (!ALLOWED_MIME_TYPES.contains(detectedMimeType)) {
                // 实际生产中应记录安全日志：System.log("疑似恶意上传: " + detectedMimeType);
                return false;
            }
            return true;
        } catch (IOException e) {
            // 无法读取流，视为不安全
            return false;
        }
    }

    /**
     * 生成安全的文件名 (UUID + 净化后的后缀)
     * 防御路径遍历攻击
     */
    public static String generateSafeFileName(String originalFilename) {
        // 1. 提取后缀名
        String suffix = "";
        if (originalFilename != null && originalFilename.contains(".")) {
            suffix = originalFilename.substring(originalFilename.lastIndexOf("."));
        }
        
        // 2. 使用 UUID 替换原始文件名
        // 这一步至关重要，它同时解决了三个问题：
        // A. 文件名冲突：UUID 保证唯一性。
        // B. 隐私泄露：隐藏了用户本地的原始文件名（如 "工资条.pdf"）。
        // C. 路径遍历：彻底消除了 "../../" 等恶意字符存在的可能性。
        return UUID.randomUUID().toString().replace("-", "") + suffix;
    }
}

package com.example.demo.service;

import org.springframework.web.multipart.MultipartFile;
import java.io.InputStream;

public interface FileStorageService {
    /**
     * 上传文件
     * @param file 前端传输的文件对象
     * @return 存储后的相对路径（用于后续访问）
     */
    String upload(MultipartFile file);

    /**
     * 下载文件（获取输入流）
     * 这里的返回值是 InputStream，因为无论是本地文件还是网络流，
     * 都可以统一抽象为输入流，从而屏蔽底层差异。
     * @param fileName 文件名或路径
     * @return 文件输入流
     */
    InputStream download(String fileName);
    
    /**
     * 删除文件
     * @param fileName 文件名
     */
    void delete(String fileName);
}

package com.example.demo.service.impl;

import com.example.demo.service.FileStorageService;
import com.example.demo.utils.UploadUtils;
import jakarta.annotation.PostConstruct;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;
import org.springframework.web.multipart.MultipartFile;

import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.nio.file.StandardCopyOption;
import java.time.LocalDate;
import java.time.format.DateTimeFormatter;

@Service("localStorage") // 命名 Bean，方便后续通过 @Qualifier 切换不同实现
public class LocalFileStorageServiceImpl implements FileStorageService {

    @Value("${file.storage.local.path}")
    private String uploadDir; // 注入配置文件中的路径

    // 初始化：Spring 容器启动时自动创建根目录
    @PostConstruct
    public void init() {
        try {
            Files.createDirectories(Paths.get(uploadDir));
        } catch (IOException e) {
            throw new RuntimeException("严重错误：无法初始化文件存储目录", e);
        }
    }

    @Override
    public String upload(MultipartFile file) {
        // 1. 前置检查：安全校验
        if (!UploadUtils.isSafeFile(file)) {
            throw new IllegalArgumentException("文件类型非法或内容受损");
        }

        try {
            // 2. 目录规划：按日期归档 (uploads/2025/10/01/)
            // 避免一个文件夹下存放数百万个文件，导致文件系统索引性能下降
            String datePath = LocalDate.now().format(DateTimeFormatter.ofPattern("yyyy/MM/dd"));
            Path folderPath = Paths.get(uploadDir, datePath);
            Files.createDirectories(folderPath);

            // 3. 文件名生成
            String newFileName = UploadUtils.generateSafeFileName(file.getOriginalFilename());

            // 4. 执行写入 (NIO 核心)
            // Files.copy 利用了操作系统的文件系统优化
            // StandardCopyOption.REPLACE_EXISTING 保证了如果 UUID 碰撞（极低概率）也能覆盖
            Path targetPath = folderPath.resolve(newFileName);
            Files.copy(file.getInputStream(), targetPath, StandardCopyOption.REPLACE_EXISTING);

            // 5. 返回相对路径供业务层使用
            return datePath + "/" + newFileName;

        } catch (IOException e) {
            throw new RuntimeException("文件存储失败", e);
        }
    }

    @Override
    public InputStream download(String fileName) {
        try {
            // 路径安全检查：防止 ../../etc/passwd 攻击
            Path rootPath = Paths.get(uploadDir).toAbsolutePath();
            Path filePath = rootPath.resolve(fileName).normalize().toAbsolutePath();

            // 只有当解析后的路径 确实是以 根目录 开头时，才允许访问
            if (!filePath.startsWith(rootPath)) {
                 throw new SecurityException("非法的文件访问路径");
            }
            
            // 返回文件流，由 Controller 层决定如何通过网络发送
            return new FileInputStream(filePath.toFile());
        } catch (Exception e) {
            throw new RuntimeException("文件读取失败: " + fileName, e);
        }
    }

    @Override
    public void delete(String fileName) {
        try {
             Path filePath = Paths.get(uploadDir).resolve(fileName);
             Files.deleteIfExists(filePath);
        } catch (IOException e) {
            throw new RuntimeException("删除失败", e);
        }
    }
}

package com.example.demo.controller;

import com.example.demo.service.FileStorageService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.http.HttpHeaders;
import org.springframework.http.MediaType;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;
import org.springframework.web.servlet.mvc.method.annotation.StreamingResponseBody;

import java.io.InputStream;
import java.io.OutputStream;
import java.util.Map;

@RestController
@RequestMapping("/api/files")
public class FileController {

    // 注入接口，解耦实现
    @Autowired
    @Qualifier("localStorage") 
    private FileStorageService fileStorageService;

    /**
     * 文件上传接口
     */
    @PostMapping("/upload")
    public Map<String, Object> upload(@RequestParam("file") MultipartFile file) {
        String path = fileStorageService.upload(file);
        // 返回用于前端展示的 URL（配合后续的静态资源映射）
        String accessUrl = "/static/" + path;
        return Map.of("code", 200, "url", accessUrl, "path", path);
    }

    /**
     * 高性能流式下载接口
     * 场景：下载私有文件、大文件，或强制浏览器弹出“保存”对话框
     * 
     * @param filename 相对路径，如 2025/10/01/xxx.png
     */
    @GetMapping("/download")
    public ResponseEntity<StreamingResponseBody> download(@RequestParam("filename") String filename) {
        
        // 1. 获取文件输入流 (抽象层)
        InputStream inputStream = fileStorageService.download(filename);

        // 2. 封装为 StreamingResponseBody (Spring MVC 异步流处理)
        // 这个回调函数会在 Spring 托管的异步线程中执行，不会阻塞 Servlet 主线程
        StreamingResponseBody responseBody = new StreamingResponseBody() {
            @Override
            public void writeTo(OutputStream outputStream) throws java.io.IOException {
                // 定义 8KB 缓冲区，分块读取并写入响应流
                // 这就是“零拷贝”思想的应用层体现：数据在流之间直接传递
                byte[] buffer = new byte[8192];
                int bytesRead;
                // try-with-resources 自动关闭输入流
                try (inputStream) { 
                    while ((bytesRead = inputStream.read(buffer)) != -1) {
                        outputStream.write(buffer, 0, bytesRead);
                    }
                }
            }
        };

        // 3. 提取下载时的文件名 (从路径中截取)
        String downloadName = filename.substring(filename.lastIndexOf("/") + 1);
        
        // 4. 构建响应头
        return ResponseEntity.ok()
                // Content-Disposition: attachment 强制浏览器下载而非预览
                .header(HttpHeaders.CONTENT_DISPOSITION, "attachment; filename=\"" + downloadName + "\"")
                .contentType(MediaType.APPLICATION_OCTET_STREAM)
                .body(responseBody);
    }
}

package com.example.demo.config;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Configuration;
import org.springframework.http.CacheControl;
import org.springframework.web.servlet.config.annotation.ResourceHandlerRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

import java.util.concurrent.TimeUnit;

@Configuration
public class WebMvcConfig implements WebMvcConfigurer {

    @Value("${file.storage.local.path}")
    private String storagePath;

    @Override
    public void addResourceHandlers(ResourceHandlerRegistry registry) {
        // 关键逻辑：构建 file 协议路径
        // 如果 storagePath 是 "/data/files/uploads/"
        // 则 location 必须是 "file:/data/files/uploads/"
        String resourceLocation = "file:" + storagePath;
        if (!resourceLocation.endsWith("/")) {
            resourceLocation += "/"; // 规范要求必须以斜杠结尾
        }

        // 映射规则：URL 中的 /static/**  ==>  磁盘上的 file: path
        registry.addResourceHandler("/static/**")
                .addResourceLocations(resourceLocation)
                // 性能优化：为静态资源设置 7 天的浏览器缓存
                // 这能显著减少服务器带宽压力，提升用户加载速度
                .setCacheControl(CacheControl.maxAge(7, TimeUnit.DAYS).cachePublic());
    }
}