Enumeration<String> headerNames = request.getHeaderNames();
while (headerNames.hasMoreElements()) {
    String name = headerNames.nextElement();
    System.out.println(name + ": " + request.getHeader(name));
}

// 方式1：字节流（适合二进制、JSON 等）
InputStream inputStream = request.getInputStream();

// 方式2：字符流（适合文本）
BufferedReader reader = request.getReader();

public class CachedBodyHttpServletRequest extends HttpServletRequestWrapper {
    private final byte[] cachedBody;

    public CachedBodyHttpServletRequest(HttpServletRequest request) throws IOException {
        super(request);
        this.cachedBody = StreamUtils.copyToByteArray(request.getInputStream());
    }

    @Override
    public ServletInputStream getInputStream() {
        return new ByteArrayServletInputStream(cachedBody);
    }

    @Override
    public BufferedReader getReader() {
        return new BufferedReader(new InputStreamReader(getInputStream()));
    }
}

public void doFilter(ServletRequest req, ServletResponse res, FilterChain chain) {
    HttpServletRequest request = (HttpServletRequest) req;
    CachedBodyHttpServletRequest wrappedRequest = new CachedBodyHttpServletRequest(request);
    chain.doFilter(wrappedRequest, res);
}

HttpSession session = request.getSession(); // true: 无则创建

// 存
session.setAttribute("USER", userDTO);

// 取
UserDTO user = (UserDTO) session.getAttribute("USER");

// 遍历
Enumeration<String> names = session.getAttributeNames();
while (names.hasMoreElements()) {
    String key = names.nextElement();
    Object value = session.getAttribute(key);
    log.info("{}: {}", key, value);
}

Cookie[] cookies = request.getCookies();
if (cookies != null) {
    for (Cookie cookie : cookies) {
        System.out.println(cookie.getName() + "=" + cookie.getValue());
    }
}

package com.healerjean.proj.utils.http;

/**
 * CorsUtils
 *
 * @author zhangyujin
 * @date 2025/11/12
 */

import java.net.URI;
import java.net.URISyntaxException;
import java.util.List;

public class CorsUtils {


    /**
     * 校验 Origin 是否在允许的域名白名单中
     * - 以 "." 开头：表示匹配该域名及所有子域名（如 ".bail.com" 匹配 bail.com, app.bail.com, x.y.bail.com）
     * - 不以 "." 开头：仅精确匹配该主域名（如 "bail.com" 只匹配 bail.com，不匹配 app.bail.com）
     */
    public static boolean isValidOrigin(String origin, List<String> allowedDomains) {
        if (origin == null || origin.trim().isEmpty()) {
            return false;
        }

        String host;
        try {
            host = new URI(origin).getHost();
        } catch (URISyntaxException e) {
            return false;
        }

        if (host == null || host.isEmpty()) {
            return false;
        }

        host = host.toLowerCase();

        for (String pattern : allowedDomains) {
            if (pattern == null || pattern.trim().isEmpty()) {
                continue;
            }
            pattern = pattern.trim().toLowerCase();

            if (pattern.startsWith(".")) {
                // 模式是 .example.com → 匹配 example.com 及 *.example.com
                String domain = pattern.substring(1);
                if (domain.isEmpty()) {
                    continue;
                }

                // 匹配规则：
                // 1. host == domain （主域）
                // 2. host 以 ".domain" 结尾（子域）
                if (host.equals(domain) || host.endsWith("." + domain)) {
                    return true;
                }
            } else {
                // 模式是 example.com → 仅精确匹配
                if (host.equals(pattern)) {
                    return true;
                }
            }
        }

        return false;
    }
}

// src/main/java/com/yourpackage/interceptor/CorsInterceptor.java
package com.yourpackage.interceptor;

import com.yourpackage.util.CorsUtils;
import org.springframework.stereotype.Component;
import org.springframework.web.servlet.HandlerInterceptor;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

@Component
public class CorsInterceptor implements HandlerInterceptor {

   // 允许的主域名（支持任意子域名）
    private static final List<String> ALLOWED_DOMAINS = Arrays.asList(
        "a.com",
        "b.com"
        // 可按需添加，如 "example.org"
    );
  
  
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)
            throws IOException {
        String origin = request.getHeader("Origin");
        String method = request.getMethod();

        // 处理预检请求（OPTIONS）
        if ("OPTIONS".equalsIgnoreCase(method)) {
            if (origin != null && CorsUtils.isValidOrigin(origin, ALLOWED_DOMAINS)) {
                setCorsHeaders(response, origin);
            }
            response.setStatus(HttpServletResponse.SC_OK);
            return false; // 终止后续处理
        }

        // 处理实际请求
        if (origin != null && CorsUtils.isValidOrigin(origin, ALLOWED_DOMAINS)) {
            setCorsHeaders(response, origin);
        }

        return true; // 继续执行 Controller
    }

    private void setCorsHeaders(HttpServletResponse response, String origin) {
        response.setHeader("Access-Control-Allow-Origin", origin);
        response.setHeader("Access-Control-Allow-Credentials", "true");
        response.setHeader("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, OPTIONS");
        response.setHeader("Access-Control-Allow-Headers",
            "Content-Type, Authorization, X-Requested-With, Accept, Origin");
        response.setHeader("Access-Control-Max-Age", "3600");
    }
}

import com.yourpackage.interceptor.CorsInterceptor;
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;

@Configuration
public class WebConfig implements WebMvcConfigurer {

    @Autowired
    private CorsInterceptor corsInterceptor;

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(corsInterceptor)
                .addPathPatterns("/**"); // 拦截所有路径
    }
}

// src/main/java/com/yourpackage/util/CorsHelper.java
package com.yourpackage.util;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

public class CorsHelper {

     // 允许的主域名（支持任意子域名）
    private static final List<String> ALLOWED_DOMAINS = Arrays.asList(
        "a.com",
        "b.com"
        // 可按需添加，如 "example.org"
    );
  
    /**
     * 处理 CORS 请求
     *
     * @return true 表示是 OPTIONS 请求且已处理完毕，调用方应直接返回；
     *         false 表示是非 OPTIONS 请求，可继续业务逻辑。
     */
    public static boolean handleCors(HttpServletRequest request, HttpServletResponse response) throws IOException {
        String origin = request.getHeader("Origin");
        if (origin == null || !CorsUtils.isValidOrigin(origin, ALLOWED_DOMAINS)) {
            // 非法 Origin 不设置 CORS 头（同源请求不受影响）
            return !"OPTIONS".equalsIgnoreCase(request.getMethod());
        }

        // 设置 CORS 头
        response.setHeader("Access-Control-Allow-Origin", origin);
        response.setHeader("Access-Control-Allow-Credentials", "true");
        response.setHeader("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, OPTIONS");
        response.setHeader("Access-Control-Allow-Headers",
            "Content-Type, Authorization, X-Requested-With, Accept, Origin");
        response.setHeader("Access-Control-Max-Age", "3600");

        // 如果是 OPTIONS，直接返回
        if ("OPTIONS".equalsIgnoreCase(request.getMethod())) {
            response.setStatus(HttpServletResponse.SC_OK);
            return true;
        }

        return false; // 继续业务
    }
}

package com.hlj.utils.ip;

import com.hlj.utils.ExceptionLogUtils;
import org.apache.commons.lang3.StringUtils;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;

import javax.servlet.http.HttpServletRequest;
import java.net.InetAddress;
import java.net.UnknownHostException;

/**
 * @Desc:
 * @Author HealerJean
 * @Date 2018/7/4  下午2:36.
 */
public class IpUtil {

    public static String getIp(){
        HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();
        if(request==null)return null;
        String ip = request.getHeader("x-forwarded-for");
        if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
            ip = request.getHeader("X-Real-IP");
        }
        if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
            ip = request.getRemoteAddr();
        }
        if(ip.toLowerCase().contains("x-forwarded-for")){
            String ip_temp = "";
            if(ip.contains(":") && ip.split(":").length>0 && !ip.endsWith(":")){
                ip_temp = ip.split(":")[1];
                if(StringUtils.isBlank(ip_temp)) ip_temp = ip.substring(0,ip.lastIndexOf("X-Forwarded-For"));
            }else{
                ip_temp = ip.substring(0,ip.lastIndexOf("X-Forwarded-For"));
            }
            ip = ip_temp.replaceAll(" ","");
        }
        if (ip.indexOf(",") > -1) {
            String ip_temp = ip.split(",")[0];
            ip_temp = ip_temp.replaceAll(" ", "");
            if(ip_temp.startsWith("10.") && ip.split(",").length>1){
                ip = ip.split(",")[1];
                ip = ip.replaceAll(" ", "");
            }else ip = ip_temp;
        }
        return ip;
    }


      /**
     * 获取调用的http/https+ 域名 + 端口
     * @param urlTarget
     * @return
     */
    public static String getDomainAndPort(String urlTarget)
    {
        //跳转到对应的回调地址
        String domain = "";
        try {
            URL url = new URL(urlTarget);
            String host = url.getHost();
            int port = url.getPort();
            String s = url.toString();
            domain = s.substring(0,s.indexOf(host)+host.length());
            if(port != -1) {
                domain = domain + ":" + port;
            }
        } catch (MalformedURLException e) {
            log.info("获取域名失败");
        }
        return domain ;
    }



    /**
     * 获取服务器ip
     * @return
     */
    public static  String getHostIp(){
        try {
            InetAddress ia2 = InetAddress.getLocalHost();
            return  ia2.getHostAddress();
        } catch (UnknownHostException e) {
            ExceptionLogUtils.log(e,IpUtil.class);
            return  null ;
        }
    }

    /**
     * 根据域名获取ip
     * www.baidu.com
     * @param url
     * @return
     */
    public  static String getIpByUrl(String url) {
        try {
            InetAddress ia2 = InetAddress.getByName(url);
            return ia2.getHostAddress();
        } catch (UnknownHostException e) {
            ExceptionLogUtils.log(e,IpUtil.class );
            return  null;
        }
    }

    public static IPEntry getAddress(String ip){
        return  IPSeeker.getInstance().getAddress(ip);
    }

    public static void main(String[] args) {
        System.out.println(getAddress("106.39.75.134"));
    }

}

import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;

/**
 * 静态获取HttpServletRequest 和 session的方法
 * 要使用此类需要在web.xml注册org.springframework.web.context.request.RequestContextListener
 */
public class RequestHolder {

    public static HttpSession getSession() {
        HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();
        return request.getSession();
    }

    public static HttpServletRequest getRequest() {
        return ((ServletRequestAttributes)RequestContextHolder.getRequestAttributes()).getRequest();
    }

    public static HttpServletResponse getResponse() {
        return ((ServletRequestAttributes)RequestContextHolder.getRequestAttributes()).getResponse();
    }

}

package com.duodian.youhui.admin.utils.cookie;

import com.duodian.youhui.admin.utils.RequestHolder;
import org.apache.commons.lang3.StringUtils;

import javax.servlet.http.Cookie;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

/**
 * @Desc: Cookie 工具类
 * @Date:  2018/9/12 下午1:02.
 */

public class CookieHelper {


    public static void setCookie(String key,String value,Integer seconds){
        HttpServletResponse response = RequestHolder.getResponse();
        Cookie add = new Cookie(key,value);
        add.setMaxAge(seconds);
        add.setPath("/");
        response.addCookie(add);
    }

    public static String getCookieValue(String key){
        HttpServletRequest request = RequestHolder.getRequest();
        Cookie[] cookies = request.getCookies();
        if (cookies == null){
            return null;
        }
        for (Cookie cookie : cookies){
            if (StringUtils.equals(cookie.getName(), key)){
                return cookie.getValue();
            }
        }
        return null;
    }

    public static void clearCookie(String key){
        HttpServletResponse response = RequestHolder.getResponse();
        Cookie clear = new Cookie(key,"");
        clear.setMaxAge(0);
        clear.setComment("清除cookie");
        clear.setPath("/");
        response.addCookie(clear);
    }


}

package com.duodian.admore.home.utils;

import com.duodian.admore.constants.AppConstants;
import com.duodian.admore.core.spring.RequestHolder;
import com.duodian.admore.entity.db.user.User;

import javax.servlet.http.HttpSession;

public class SessionUtils {

   
    public static final String SESSION_USER = "user";


    public static void initSession(User user){
        HttpSession session = RequestHolder.getSession();
        session.setAttribute(SESSION_USER,user);
    }

    public static void clearSession(){
        HttpSession session = RequestHolder.getSession();
        session.invalidate();
    }

    public static User getSessionUser(){
        HttpSession session = RequestHolder.getSession();
        User user = (User)session.getAttribute(SESSION_USER);
        return user;
    }


}