编码技巧——客户端HTTP请求封装&登录态校验

男娘i 2023-09-29 08:46 5阅读 0赞

对于做C端的服务单开发来说，除了要定义好和前端/客户端的HTTP接口出入参，接口协议还包含header/cookies的参数，如请求类型、支持的类型、cookies中的K/V、origin等；而其中cookies中的参数往往会放一些token、签名、设备型号、浏览器版本等；本篇介绍下开发中使用到的封装前端/客户端HTTPRequest的工具类，以及其中的1种简单应用——用户登录态校验（此外可用来做操作频次控制、机型版本校验等）；

**先来一个简单的从获取基本请求信息的工具类：**

package com.AA.common.utils;
    
    import com.AA.ApplicationConstants;
    import lombok.extern.slf4j.Slf4j;
    import org.apache.commons.collections.MapUtils;
    import org.apache.commons.lang3.ArrayUtils;
    import org.apache.commons.lang3.StringUtils;
    
    import javax.servlet.http.HttpServletRequest;
    import java.net.InetAddress;
    import java.net.UnknownHostException;
    import java.util.Enumeration;
    import java.util.LinkedHashMap;
    import java.util.Map;
    import java.util.regex.Matcher;
    import java.util.regex.Pattern;
    
    /**
     * @author AA
     * @description RequestUtil
     * @date 2021/3/15 14:58
     */
    @Slf4j
    public class RequestUtil {
    
        private static Pattern IP_PATTERN = Pattern.compile("(\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}\\.\\d{1,3})");
        private static Pattern MOBILE_PATTERN = Pattern.compile("^1[3-9]\\d{9}$");
    
        /**
         * @param req
         * @return 返回客户的真实IP地址
         */
        public static String getClientIP(HttpServletRequest req) {
            String ips = getClientIPs(req);
            return getFirstIPFromIPs(ips);
        }
    
        /**
         * 判断ipv4是否是私有ip：10/8, 172.16/12 and 192.168/16, 127.0.0.1
         *
         * @param ipAddress
         * @return
         */
        public static boolean isLocalIp(String ipAddress) {
            if (StringUtils.isEmpty(ipAddress)) {
                return false;
            }
            try {
                InetAddress netAddress = InetAddress.getByName(ipAddress);
                return netAddress.isSiteLocalAddress() || netAddress.isLoopbackAddress();
            } catch (UnknownHostException e) {
                log.warn("parse ip fail! [ipAddress={}] e.getMessage:{} me:{}", ipAddress, e.getMessage(), e);
                return false;
            }
        }
    
        /**
         * 获取客户端的IP地址，若经过代理或负载均衡服务器处理
         * IP可能会多个，形式如：ip1,ip2,ip3
         * 第一个非unknown串是真实的client ip
         *
         * @param req
         * @return String 形式如：ip1,ip2,ip3
         */
        public static String getClientIPs(HttpServletRequest req) {
            String ip = req.getHeader("x-forwarded-for");
            if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
                ip = req.getHeader("Proxy-Client-IP");
            }
            if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
                ip = req.getHeader("WL-Proxy-Client-IP");
            }
            if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
                ip = req.getRemoteAddr();
            }
            return ip;
        }
    
        protected static String getFirstIPFromIPs(String ips) {
            String firstIP;
            Matcher ipMat = IP_PATTERN.matcher(ips);
            if (ipMat.find()) {
                firstIP = ipMat.group(1);
            } else {
                firstIP = ips;
            }
            return firstIP;
        }
    
        public static boolean isMobileNumber(String mobile) {
            Matcher mat = MOBILE_PATTERN.matcher(mobile);
            if (mat.find()) {
                return true;
            } else {
                return false;
            }
        }
    
        public static Map<String, String> getParameterMap(HttpServletRequest request) {
            Map<String, String> params = new LinkedHashMap<String, String>();
            Map<String, String[]> parameterMap = request.getParameterMap();
            if (MapUtils.isNotEmpty(parameterMap)) {
                parameterMap.entrySet().stream().forEach(
                        r -> {
                            String key = r.getKey();
                            String[] values = r.getValue();
                            if (ArrayUtils.isEmpty(values)) {
                                params.put(key, StringUtils.EMPTY);
                            } else {
                                params.put(key, values[0]);
                            }
                        }
                );
            }
            return params;
        }
    
        public static String getXforwardForHeader(HttpServletRequest request) {
            if (request.getHeader("x-forwarded-for") == null) {
                return request.getRemoteAddr();
            }
            return request.getHeader("x-forwarded-for");
        }
    
        public static String getClientType(HttpServletRequest request) {
            String clientType = request.getHeader("Client-Type");
            if (StringUtils.isEmpty(clientType)) {
                // default pc
                clientType = ApplicationConstants.PC_CLIENT;
            }
            if (!clientType.equals(ApplicationConstants.WAP_CLIENT) && !clientType.equals(ApplicationConstants.PC_CLIENT)) {
                // default pc
                clientType = ApplicationConstants.PC_CLIENT;
            }
            return clientType;
        }
    
        /**
         * 打印请求头信息
         *
         * @param request
         */
        public static void displayAllHeaders(HttpServletRequest request) {
            StringBuilder buf = new StringBuilder();
            Enumeration<String> headerNames = request.getHeaderNames();
            while (headerNames.hasMoreElements()) {
                String headerName = headerNames.nextElement();
                buf.append(headerName);
                buf.append(":");
                buf.append(request.getHeader(headerName));
                buf.append(", ");
            }
            log.info("request header is [header={}]", buf.toString());
        }
    }

**定义客户端请求：**

import lombok.Getter;
    import lombok.Setter;
    import lombok.ToString;
    
    /**
     * @author AA
     * @description APP请求封装
     */
    @Setter
    @Getter
    @ToString
    public class AppRequest {
    
        /**
         * imei码
         */
        private String imei;
    
        /**
         * 机型，外部机型
         */
        private String model;
    
        /**
         * 设备开机时间
         */
        private String elapsedtime;
    
        /**
         * 版本号
         */
        private String appVersion;
    
        /**
         * 屏幕像素密度
         */
        private double pixel;
    
        /**
         * 是否支持增量更新 0不支持 1 支持
         */
        private boolean patchSup;
    
        /**
         * 账户登录令牌
         */
        private String token;
    
        /**
         * 账户唯一标识
         */
        private String userId;
    
        /**
         * 数字签名
         */
        private String sign;
    
        /**
         * emmcid
         */
        private String emmcid;
    
        /**
         * 安卓版本号
         */
        private String androidVersion;
    
        private boolean supportWebp;
    
        /**
         * 用户请求ip
         */
        private String userIp;
    
        /**
         * 应用包名
         */
        private String packageName;
    
        /**
         * 用户代理
         */
        private String userAgent;
    
        /**
         * HTTP头参数
         */
        private String referer;
    
        /**
         * HTTP头参数
         */
        private String xForwardedFor;
    
        private String domain;
    
        private String uri;
    
        public String getLogInfo() {
            StringBuilder builder = new StringBuilder();
            builder.append("imei=").append(imei).append(",").append("emmcid=").append(emmcid).append(",").append("userId=").append(userId)
                    .append(",").append("ip=").append(userIp);
            return builder.toString();
        }
    }

**封装客户端请求工具类：**

import com.AA.common.model.AppRequest;
    import com.AAConfigManager;
    import org.apache.commons.lang3.StringUtils;
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    
    import javax.servlet.http.HttpServletRequest;
    
    /**
     * 客户端请求参数辅助类
     */
    public class AppRequestUtil {
    
    	private static final Logger logger = LoggerFactory.getLogger(AppRequestUtil.class);
    
    	private AppRequestUtil() {
    		throw new IllegalStateException("Utility class");
    	}
    
    	/**
    	 * 从http request中拿到基础的数据
    	 *
    	 * @param request 请求
    	 * @return AppRequest
    	 */
    	public static AppRequest assemble(HttpServletRequest request) {
    		AppRequest p = new AppRequest();
    		// 读取web、wap 端cookie中的账号登录信息
    		String openidCookie = UserUtil.getUserCookie(request, UserUtil.ACCOUNT_APP_COOKIE_OPENID);
    		// 客户端往cookie中放置openid有问题会放入明文的null，所以要加null明文判断
    		if (StringUtils.isNotBlank(openidCookie) && !"null".equals(openidCookie)) {
    			p.setUserId(openidCookie);
    		}
    		String tokenCookie = UserUtil.getUserCookie(request, UserUtil.ACCOUNT_APP_COOKIE_AUTHTOKEN);
    		if (StringUtils.isNotBlank(tokenCookie)) {
    			p.setToken(tokenCookie);
    		}
    
    		// 开发或测试环境支持直接透传userId参数
    		String env = System.getProperty("app.env");
    		if (StringUtils.equalsIgnoreCase(env, "test") || StringUtils.equalsIgnoreCase(env, "dev")) {
    			if (StringUtils.isBlank(p.getUserId()) && StringUtils.isNotBlank(request.getParameter("userId"))) {
    				p.setUserId(request.getParameter("userId"));
    			}
    		}
    
    		// 从cookie中读取设备信息
    		String imeiCookie = UserUtil.getUserCookie(request, UserUtil.ACCOUNT_APP_COOKIE_IMEI);
    		String patternStr = ConfigManager.getString("imei.exclude.pattern", "^([0]+)$|^(123456789012345)$");
    		if (StringUtils.isNotBlank(imeiCookie)) {
    			if (imeiCookie.matches(patternStr)) {
    				logger.warn("imei is need exclude[openid={} imei={}]", p.getUserId(), imeiCookie);
    			} else {
    				p.setImei(imeiCookie);
    			}
    		}
    		String emmcidCookie = UserUtil.getUserCookie(request, UserUtil.ACCOUNT_APP_COOKIE_EMMCID);
    		if (StringUtils.isNotBlank(emmcidCookie)) {
    			p.setEmmcid(emmcidCookie);
    		}
    		String modelCookie = UserUtil.getUserCookie(request, UserUtil.ACCOUNT_APP_COOKIE_MODEL);
    		if (StringUtils.isNotBlank(modelCookie)) {
    			p.setModel(StringUtils.replace(modelCookie, "+", " "));
    		}
    		String androidVersionCookie = UserUtil.getUserCookie(request, UserUtil.ACCOUNT_APP_COOKIE_ANDROID_VERSION);
    		if (StringUtils.isNotBlank(androidVersionCookie)) {
    			p.setAndroidVersion(androidVersionCookie);
    		}
    		String appVersionCookie = UserUtil.getUserCookie(request, UserUtil.ACCOUNT_APP_COOKIE_APP_VERSION);
    		if (StringUtils.isNotBlank(appVersionCookie)) {
    			p.setAppVersion(appVersionCookie);
    		}
    		// 应用包名
    		String packageNameCookie = UserUtil.getUserCookie(request, UserUtil.ACCOUNT_APP_COOKIE_PACKAGE_NAME);
    		if (StringUtils.isNotBlank(packageNameCookie)) {
    			p.setPackageName(packageNameCookie);
    		}
    
    		// 读取网络信息
    		p.setUserIp(RequestUtil.getClientIP(request));
    		p.setXForwardedFor(request.getHeader("x-forwarded-for"));
    		p.setUserAgent(request.getHeader("User-Agent"));
    		p.setReferer(request.getHeader("Referer"));
    		p.setDomain(request.getServerName());
    		p.setUri(request.getRequestURI());
    		return p;
    	}
    }

#### **应用——用户登录态校验：** ####

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)
    public @interface AccountCheck {
    }

package com.AA.service.help;
    
    import com.AA.common.enums.ResultCodeEnum;
    import com.AA.common.exception.BusinessException;
    import com.AA.common.model.AppRequest;
    import com.AA.common.utils.AppRequestUtil;
    import com.AA.facade.account.facade.AccountFacade;
    import com.AA.facade.common.model.FacadeDefaultDTO;
    import org.apache.commons.lang3.StringUtils;
    import org.apache.dubbo.config.annotation.DubboReference;
    import org.aspectj.lang.ProceedingJoinPoint;
    import org.aspectj.lang.annotation.Around;
    import org.aspectj.lang.annotation.Aspect;
    import org.springframework.stereotype.Component;
    import org.springframework.web.context.request.RequestContextHolder;
    import org.springframework.web.context.request.ServletRequestAttributes;
    
    import javax.servlet.http.HttpServletRequest;
    
    /**
     * 登录态校验切面
     */
    @Aspect
    @Component
    public class AccountValidateAspect {
    
        @DubboReference
        private AccountFacade accountFacade;
    
        @Around(value = "@annotation(com.AA.service.help.annotation.AccountCheck) && @annotation(accountCheck)")
        public Object paramValidate(ProceedingJoinPoint joinPoint, com.AA.service.help.annotation.AccountCheck accountCheck) throws Throwable {
            HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();
            AppRequest appRequest = AppRequestUtil.assemble(request);
            String token = appRequest.gettoken();
            String openId = appRequest.getUserId();
            if (StringUtils.isBlank(openId) || StringUtils.isBlank(token)) {
                throw new BusinessException(ResultCodeEnum.NOT_FIND_OPEN_ID);
            }
            FacadeDefaultDTO<Boolean> facadeResult = accountFacade.authLogin(openId, token);
            if (!facadeResult.isSuccess() || facadeResult.getData() != true) {
                throw new BusinessException(ResultCodeEnum.UN_LOGIN);
            }
            return joinPoint.proceed();
        }
    }

import org.springframework.validation.annotation.Validated;
    import org.springframework.web.bind.annotation.*;
    
    import javax.annotation.Resource;
    import javax.servlet.http.HttpServletRequest;
    import javax.validation.constraints.NotNull;
    
    /**
     * @author AA
     * @description 用户福利
     * @date 2020/2/10
     */
    @RestController
    @RequestMapping("/api/member")
    @Validated
    public class WelfareController {
    
    	// {....}
    	
        @AccountCheck
        @SentinelResource(value = "welfareRcvDetail")
        @RequestMapping(value = "welfareRcvDetail", method = RequestMethod.GET)
        @ResponseBody
        public DefaultResponseDTO<welfareRcvRecordDTO> welfareRcvRecords(@NotNull Long welfareId, HttpServletRequest request, Integer productBizType) {
            AppRequest appRequest = AppRequestUtil.assemble(request);
           	// {....}
            return DefaultResponseDTO.success(records);
        }
    	
    	// {....}
    }