import org.springframework.stereotype.Component;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.util.Arrays;
import java.util.Map;
/**
 * 自定義攔截器 - 實(shí)現(xiàn)HandlerInterceptor接口
 * 適用于業(yè)務(wù)相關(guān)的預(yù)處理和后處理
 */
@Component
public class CustomInterceptor implements HandlerInterceptor {
    private static final ThreadLocal<Long> startTimeThreadLocal = new ThreadLocal<>();
    /**
     * 預(yù)處理回調(diào)方法 - 在控制器執(zhí)行之前調(diào)用
     * 返回true表示繼續(xù)執(zhí)行，false表示中斷執(zhí)行
     */
    @Override
    public boolean preHandle(HttpServletRequest request, 
                           HttpServletResponse response, 
                           Object handler) throws Exception {
        // 記錄請求開始時間
        startTimeThreadLocal.set(System.currentTimeMillis());
        // 獲取請求信息
        String requestURI = request.getRequestURI();
        String method = request.getMethod();
        String clientIP = getClientIP(request);
        System.out.println("【攔截器-preHandle】請求開始: " + method + " " + requestURI);
        System.out.println("【攔截器-preHandle】客戶端IP: " + clientIP);
        // 1. 權(quán)限驗(yàn)證示例
        if (requiresAuth(requestURI) && !isAuthenticated(request)) {
            response.sendError(HttpServletResponse.SC_UNAUTHORIZED, "未授權(quán)訪問");
            return false; // 中斷請求
        }
        // 2. 參數(shù)預(yù)處理示例
        Map<String, String[]> params = request.getParameterMap();
        if (!params.isEmpty()) {
            System.out.println("【攔截器-preHandle】請求參數(shù): " + paramsToString(params));
        }
        // 3. 設(shè)置請求屬性，供控制器使用
        request.setAttribute("requestStartTime", System.currentTimeMillis());
        return true; // 繼續(xù)執(zhí)行后續(xù)攔截器和控制器
    }
    /**
     * 后處理回調(diào)方法 - 在控制器執(zhí)行之后，視圖渲染之前調(diào)用（返回ModelAndView之前）
     */
    @Override
    public void postHandle(HttpServletRequest request, 
                          HttpServletResponse response, 
                          Object handler, 
                          ModelAndView modelAndView) throws Exception {
        Long startTime = startTimeThreadLocal.get();
        if (startTime != null) {
            long costTime = System.currentTimeMillis() - startTime;
            System.out.println("【攔截器-postHandle】請求處理耗時: " + costTime + "ms");
            // 可以修改ModelAndView
            if (modelAndView != null) {
                modelAndView.addObject("processTime", costTime);
                modelAndView.addObject("interceptorMessage", "經(jīng)過攔截器處理");
            }
        }
    }
    /**
     * 完成回調(diào)方法 - 在整個請求完成之后調(diào)用（視圖渲染完成后）
     * 適合進(jìn)行資源清理
     */
    @Override
    public void afterCompletion(HttpServletRequest request, 
                               HttpServletResponse response, 
                               Object handler, 
                               Exception ex) throws Exception {
        Long startTime = startTimeThreadLocal.get();
        if (startTime != null) {
            long totalTime = System.currentTimeMillis() - startTime;
            int status = response.getStatus();
            System.out.println("【攔截器-afterCompletion】請求完成: " + 
                request.getRequestURI() + " 狀態(tài): " + status + " 總耗時: " + totalTime + "ms");
            if (ex != null) {
                System.err.println("【攔截器-afterCompletion】異常信息: " + ex.getMessage());
            }
            // 清理ThreadLocal，防止內(nèi)存泄漏
            startTimeThreadLocal.remove();
        }
    }
    // ========== 工具方法 ==========
    private String getClientIP(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();
        }
        return ip;
    }
    private boolean requiresAuth(String uri) {
        // 需要認(rèn)證的路徑規(guī)則
        return uri.startsWith("/api/admin") || uri.startsWith("/api/user");
    }
    private boolean isAuthenticated(HttpServletRequest request) {
        // 簡單的認(rèn)證檢查
        String token = request.getHeader("Authorization");
        return token != null && token.startsWith("Bearer ");
    }
    private String paramsToString(Map<String, String[]> params) {
        StringBuilder sb = new StringBuilder();
        for (Map.Entry<String, String[]> entry : params.entrySet()) {
            sb.append(entry.getKey()).append("=")
              .append(Arrays.toString(entry.getValue())).append("; ");
        }
        return sb.toString();
    }
}

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
import java.util.Arrays;
import java.util.List;
@Configuration
public class InterceptorConfig implements WebMvcConfigurer {
    @Autowired
    private CustomInterceptor customInterceptor;
    // 排除路徑
    private static final List<String> EXCLUDE_PATHS = Arrays.asList(
        "/api/public/**",
        "/static/**",
        "/error",
        "/login",
        "/logout"
    );
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        // 注冊自定義攔截器
        registry.addInterceptor(customInterceptor)
                .addPathPatterns("/**")                    // 攔截所有路徑
                .excludePathPatterns(EXCLUDE_PATHS);        // 排除特定路徑
        // 可以注冊多個攔截器，按添加順序執(zhí)行
        registry.addInterceptor(new LoggingInterceptor())
                .addPathPatterns("/api/**")
                .order(1); // 設(shè)置執(zhí)行順序，數(shù)字越小優(yōu)先級越高
    }
}
/**
 * 另一個日志攔截器示例
 */
class LoggingInterceptor implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) {
        System.out.println("【日志攔截器】請求路徑: " + request.getRequestURI());
        return true;
    }
}

import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;
import javax.servlet.*;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
/**
 * 自定義過濾器 - 實(shí)現(xiàn)Filter接口
 * 適用于通用的請求/響應(yīng)處理
 */
@Component
@Order(1) // 執(zhí)行順序，數(shù)字越小優(yōu)先級越高
public class CustomFilter implements Filter {
    /**
     * 初始化方法
     */
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
        System.out.println("【過濾器】CustomFilter初始化完成");
    }
    /**
     * 過濾處理方法
     */
    @Override
    public void doFilter(ServletRequest request, ServletResponse response, 
                        FilterChain chain) throws IOException, ServletException {
        HttpServletRequest httpRequest = (HttpServletRequest) request;
        HttpServletResponse httpResponse = (HttpServletResponse) response;
        long startTime = System.currentTimeMillis();
        System.out.println("【過濾器-doFilter】請求進(jìn)入: " + httpRequest.getRequestURI());
        // 1. 設(shè)置字符編碼
        httpRequest.setCharacterEncoding("UTF-8");
        httpResponse.setCharacterEncoding("UTF-8");
        httpResponse.setContentType("text/html;charset=UTF-8");
        // 2. 設(shè)置CORS頭（跨域支持）
        httpResponse.setHeader("Access-Control-Allow-Origin", "*");
        httpResponse.setHeader("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, OPTIONS");
        httpResponse.setHeader("Access-Control-Allow-Headers", "Content-Type, Authorization");
        // 3. 預(yù)處理邏輯
        if (isOptionsRequest(httpRequest)) {
            // 處理預(yù)檢請求
            httpResponse.setStatus(HttpServletResponse.SC_OK);
            return;
        }
        // 4. 請求包裝（可以修改請求參數(shù)）
        CustomHttpServletRequestWrapper wrappedRequest = 
            new CustomHttpServletRequestWrapper(httpRequest);
        // 5. 響應(yīng)包裝（可以修改響應(yīng)內(nèi)容）
        CustomHttpServletResponseWrapper wrappedResponse = 
            new CustomHttpServletResponseWrapper(httpResponse);
        try {
            // 繼續(xù)執(zhí)行過濾器鏈
            chain.doFilter(wrappedRequest, wrappedResponse);
            // 后處理邏輯
            long costTime = System.currentTimeMillis() - startTime;
            System.out.println("【過濾器-doFilter】請求完成: " + 
                httpRequest.getRequestURI() + " 耗時: " + costTime + "ms");
            // 可以在這里修改響應(yīng)內(nèi)容
            byte[] responseData = wrappedResponse.getData();
            if (responseData.length > 0) {
                // 對響應(yīng)數(shù)據(jù)進(jìn)行處理
                String modifiedResponse = modifyResponse(new String(responseData));
                response.getOutputStream().write(modifiedResponse.getBytes());
            }
        } catch (Exception e) {
            // 異常處理
            System.err.println("【過濾器-doFilter】處理異常: " + e.getMessage());
            httpResponse.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR, "服務(wù)器內(nèi)部錯誤");
        }
    }
    /**
     * 銷毀方法
     */
    @Override
    public void destroy() {
        System.out.println("【過濾器】CustomFilter銷毀");
    }
    // ========== 工具方法 ==========
    private boolean isOptionsRequest(HttpServletRequest request) {
        return "OPTIONS".equalsIgnoreCase(request.getMethod());
    }
    private String modifyResponse(String originalResponse) {
        // 簡單的響應(yīng)內(nèi)容修改示例
        return originalResponse.replace("舊內(nèi)容", "新內(nèi)容");
    }
}
/**
 * 自定義請求包裝器 - 用于修改請求參數(shù)
 */
class CustomHttpServletRequestWrapper extends HttpServletRequestWrapper {
    public CustomHttpServletRequestWrapper(HttpServletRequest request) {
        super(request);
    }
    @Override
    public String getParameter(String name) {
        // 可以在這里修改請求參數(shù)
        String value = super.getParameter(name);
        if ("username".equals(name) && value != null) {
            return value.trim(); // 去除用戶名前后空格
        }
        return value;
    }
}
/**
 * 自定義響應(yīng)包裝器 - 用于捕獲和修改響應(yīng)內(nèi)容
 */
class CustomHttpServletResponseWrapper extends HttpServletResponseWrapper {
    private final CustomServletOutputStream outputStream;
    private final PrintWriter printWriter;
    public CustomHttpServletResponseWrapper(HttpServletResponse response) {
        super(response);
        this.outputStream = new CustomServletOutputStream();
        this.printWriter = new PrintWriter(outputStream);
    }
    @Override
    public ServletOutputStream getOutputStream() {
        return outputStream;
    }
    @Override
    public PrintWriter getWriter() {
        return printWriter;
    }
    public byte[] getData() {
        try {
            printWriter.flush();
            return outputStream.toByteArray();
        } catch (IOException e) {
            return new byte[0];
        }
    }
}
/**
 * 自定義Servlet輸出流
 */
class CustomServletOutputStream extends ServletOutputStream {
    private final ByteArrayOutputStream buffer = new ByteArrayOutputStream();
    @Override
    public void write(int b) {
        buffer.write(b);
    }
    @Override
    public boolean isReady() {
        return true;
    }
    @Override
    public void setWriteListener(WriteListener listener) {
        // 不需要實(shí)現(xiàn)
    }
    public byte[] toByteArray() {
        return buffer.toByteArray();
    }
}

import org.springframework.boot.web.servlet.FilterRegistrationBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
public class FilterConfig {
    @Bean
    public FilterRegistrationBean<CustomFilter> customFilterRegistration() {
        FilterRegistrationBean<CustomFilter> registration = new FilterRegistrationBean<>();
        registration.setFilter(new CustomFilter());
        registration.addUrlPatterns("/*"); // 過濾所有請求
        registration.setOrder(1); // 執(zhí)行順序
        registration.setName("customFilter");
        // 可以設(shè)置初始化參數(shù)
        registration.addInitParameter("param1", "value1");
        return registration;
    }
    @Bean
    public FilterRegistrationBean<LoggingFilter> loggingFilterRegistration() {
        FilterRegistrationBean<LoggingFilter> registration = new FilterRegistrationBean<>();
        registration.setFilter(new LoggingFilter());
        registration.addUrlPatterns("/api/*");
        registration.setOrder(2);
        return registration;
    }
}
/**
 * 日志過濾器
 */
class LoggingFilter implements Filter {
    @Override
    public void doFilter(ServletRequest request, ServletResponse response, 
                        FilterChain chain) throws IOException, ServletException {
        HttpServletRequest httpRequest = (HttpServletRequest) request;
        System.out.println("【日志過濾器】請求: " + httpRequest.getMethod() + " " + httpRequest.getRequestURI());
        chain.doFilter(request, response);
    }
}

import javax.servlet.annotation.WebFilter;
import javax.servlet.annotation.WebInitParam;
@WebFilter(
    urlPatterns = "/*",
    initParams = {
        @WebInitParam(name = "encoding", value = "UTF-8"),
        @WebInitParam(name = "enableCors", value = "true")
    }
)
public class AnnotationFilter implements Filter {
    // 實(shí)現(xiàn)同上
}

@SpringBootApplication
@ServletComponentScan // 掃描@WebFilter、@WebServlet等注解
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

/**
 * 完整的請求處理鏈?zhǔn)纠?
 * 過濾器(通用處理) → 攔截器(業(yè)務(wù)處理) → 控制器
 */
// 1. 過濾器：處理字符編碼、CORS等通用邏輯
@Component
@Order(1)
public class GlobalFilter implements Filter {
    // 處理所有請求的通用邏輯
}
// 2. 攔截器：處理業(yè)務(wù)相關(guān)的邏輯
@Component  
public class AuthInterceptor implements HandlerInterceptor {
    // 處理需要認(rèn)證的業(yè)務(wù)邏輯
}
// 3. 控制器：處理具體業(yè)務(wù)
@RestController
public class BusinessController {
    // 業(yè)務(wù)實(shí)現(xiàn)
}