// Cookie
response.addCookie(new Cookie("login_username", "itheima"));
Cookie[] cookies = request.getCookies();

// Session（底层基于 Cookie 的 JSESSIONID）
session.setAttribute("loginUser", "tom");
Object user = session.getAttribute("loginUser");

// 生成 JWT
Map<String, Object> claims = new HashMap<>();
claims.put("id", 1);
claims.put("username", "Tom");

String jwt = Jwts.builder()
    .setClaims(claims)                                            // 自定义数据
    .signWith(SignatureAlgorithm.HS256, "itheima")                // 签名算法 + 密钥
    .setExpiration(new Date(System.currentTimeMillis() + 3600*1000)) // 1小时过期
    .compact();
// 输出：eyJhbGciOiJIUzI1NiJ9.eyJpZCI6MSwidXNlcm5hbWUiOiJUb20iLCJleHAiOi4uLn0.xxx

// 解析 JWT（密钥必须与生成时一致）
Claims claims = Jwts.parser()
    .setSigningKey("itheima")
    .parseClaimsJws(jwt)
    .getBody();
System.out.println(claims.get("id"));        // 1
System.out.println(claims.get("username"));  // Tom

@Component
public class MyJwtUtils {

    @Value("${myjwt.key}")
    private String signKey;

    @Value("${myjwt.time}")
    private Long expire;

    /** 生成 JWT 令牌 */
    public String generateJwt(Map<String, Object> claims) {
        return Jwts.builder()
                .addClaims(claims)
                .signWith(SignatureAlgorithm.HS256, signKey)
                .setExpiration(new Date(System.currentTimeMillis() + expire))
                .compact();
    }

    /** 解析 JWT 令牌 */
    public Claims parseJWT(String jwt) {
        return Jwts.parser()
                .setSigningKey(signKey)
                .parseClaimsJws(jwt)
                .getBody();
    }
}

@RestController
public class LoginController {

    @Autowired
    private EmpService empService;

    @PostMapping("/login")
    public Result login(@RequestBody LoginDto dto) {
        String token = empService.login(dto);
        if (token != null) {
            return Result.success(token);     // 登录成功，返回令牌
        }
        return Result.error("NOT_LOGIN");     // 登录失败
    }
}

@Service
public class EmpServiceImpl implements EmpService {

    @Autowired private EmpMapper empMapper;
    @Autowired private MyJwtUtils myJwtUtils;

    @Override
    public String login(LoginDto dto) {
        Emp emp = empMapper.selectEmpByName(dto.getUsername());
        if (emp == null) return null;
        if (emp.getPassword().equals(dto.getPassword())) {
            // 登录成功，生成令牌
            Map<String, Object> map = Map.of("id", emp.getId(), "name", emp.getName());
            return myJwtUtils.generateJwt(map);
        }
        return null;
    }
}

// 第①步：定义类，实现 Filter 接口
@WebFilter(urlPatterns = "/*")  // 第②步：配置拦截路径
public class MyFilter implements Filter {

    @Override
    public void doFilter(ServletRequest req, ServletResponse resp, FilterChain chain)
            throws IOException, ServletException {
        System.out.println("放行前逻辑...");

        chain.doFilter(req, resp);    // ⚠️ 关键：放行请求！不调用此行无法访问后续资源

        System.out.println("放行后逻辑...");
    }
}

// 第③步：启动类加 @ServletComponentScan，开启 Servlet 组件支持
@ServletComponentScan
@SpringBootApplication
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

@Slf4j
@WebFilter(urlPatterns = "/*")
public class LoginCheckFilter implements Filter {

    @Resource
    private MyJwtUtils myJwtUtils;

    @Override
    public void doFilter(ServletRequest req, ServletResponse resp, FilterChain chain)
            throws IOException, ServletException {
        HttpServletRequest request = (HttpServletRequest) req;
        HttpServletResponse response = (HttpServletResponse) resp;

        // ① 获取请求路径
        String url = request.getRequestURL().toString();

        // ② 登录请求直接放行
        if (url.contains("/login")) {
            chain.doFilter(req, resp);
            return;
        }

        // ③ 获取请求头中的令牌
        String token = request.getHeader("token");

        // ④ 令牌不存在 → 返回 NOT_LOGIN
        if (!StringUtils.hasLength(token)) {
            returnError(response);
            return;
        }

        // ⑤ 解析令牌（失败抛异常）
        try {
            myJwtUtils.parseJWT(token);
        } catch (Exception e) {
            log.info("令牌解析失败");
            returnError(response);
            return;
        }

        // ⑥ 令牌有效，放行
        chain.doFilter(req, resp);
    }

    private void returnError(HttpServletResponse response) throws IOException {
        String json = JSON.toJSONString(Result.error("NOT_LOGIN"));
        response.setContentType("application/json;charset=utf-8");
        response.getWriter().write(json);
    }
}

// 第①步：自定义拦截器类，实现 HandlerInterceptor 接口
@Component
@Slf4j
public class LoginCheckInterceptor implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)
            throws Exception {
        // 获取请求头中的令牌
        String token = request.getHeader("token");

        // 令牌不存在 → 返回 NOT_LOGIN
        if (!StringUtils.hasLength(token)) {
            returnError(response);
            return false;  // 不放行
        }

        // 解析令牌
        try {
            JwtUtils.parseJWT(token);
        } catch (Exception e) {
            returnError(response);
            return false;
        }

        return true;  // 放行
    }

    private void returnError(HttpServletResponse response) throws IOException {
        String json = JSONObject.toJSONString(Result.error("NOT_LOGIN"));
        response.setContentType("application/json;charset=utf-8");
        response.getWriter().write(json);
    }
}

// 第②步：注册拦截器（实现 WebMvcConfigurer，配置类）
@Configuration
public class WebConfig implements WebMvcConfigurer {

    @Autowired
    private LoginCheckInterceptor loginCheckInterceptor;

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(loginCheckInterceptor)
                .addPathPatterns("/**")           // 拦截所有请求
                .excludePathPatterns("/login");   // 排除登录请求
    }
}

public class MyThreadLocalUtils {
    private static final ThreadLocal<Emp> threadLocal = new ThreadLocal<>();

    public static void set(Emp emp) { threadLocal.set(emp); }
    public static Emp get()         { return threadLocal.get(); }
    public static void remove()     { threadLocal.remove(); }   // ⚠️ 必须remove，否则内存泄漏
}

// 拦截器中：解析令牌 → 存入 ThreadLocal → 放行
Claims claims = myJwtUtils.parseJWT(token);
Emp emp = new Emp(claims.get("id", Integer.class), claims.get("name", String.class));
MyThreadLocalUtils.set(emp);

chain.doFilter(req, resp);  // 放行

MyThreadLocalUtils.remove(); // 业务结束后清理

// Controller/Service 中：直接获取当前登录用户
Emp currentUser = MyThreadLocalUtils.get();

@RestControllerAdvice  // 标识全局异常处理类（= @ControllerAdvice + @ResponseBody）
public class GlobalExceptionHandler {

    // 处理运行时异常
    @ExceptionHandler(RuntimeException.class)
    public Result doRuntimeException(RuntimeException e) {
        e.printStackTrace();
        return Result.error("亲，您的操作有问题，请重试...");
    }

    // 处理其他所有异常（兜底）
    @ExceptionHandler(Exception.class)
    public Result doException(Exception e) {
        e.printStackTrace();
        return Result.error("亲，服务器正在升级，请稍后重试...");
    }
}