http 请求头json 和x-www-form-urlencoded 兼容问题

src/main/java/com/scbfkj/uni/api/GenericApi.java

@@ -4,6 +4,7 @@ import com.scbfkj.uni.library.RequestUtil;
 import com.scbfkj.uni.process.DataBase;
 import com.scbfkj.uni.system.Config;
 import com.scbfkj.uni.system.ProcessUtil;
+import jakarta.servlet.http.HttpServletRequest;
 import org.springframework.http.HttpStatusCode;
 import org.springframework.http.ResponseEntity;
 import org.springframework.web.bind.annotation.*;
@@ -58,7 +59,7 @@ public class GenericApi {
 	 * @throws Exception 如果匹配服务失败则抛出异常
 	 */
 	@PostMapping("/**")
-	public ResponseEntity<Map<String, Object>> matchService(@RequestBody(required = false) @RequestAttribute(required = false) @RequestParam(required = false) Map<String, Object> body) throws Exception {
+	public ResponseEntity<Map<String, Object>> matchService(Map<String, Object> body) throws Exception {
 		if ( body == null ) {
 			return ResponseEntity.ok(Map.of("code", "400", "msg", "请求体不能为空"));
 		}

src/main/java/com/scbfkj/uni/api/LogAop.java

@@ -19,6 +19,7 @@ import org.springframework.stereotype.Component;
 import java.time.LocalDateTime;
 import java.util.*;
 import java.util.concurrent.TimeUnit;
+
 /**
  * 日志切面类，用于拦截指定包下的Api请求，进行日志记录、限流控制、服务状态检查等操作。
  */
@@ -26,203 +27,219 @@ import java.util.concurrent.TimeUnit;
 @Aspect
 public class LogAop {
 
-    // 用于存储限流规则的映射
-    private static final Map<String, RateLimiter> rateLimiterMap = new HashMap<>();
-    // 数据库操作实例
-    private static final DataBase DATA_BASE = new DataBase();
-    // 工具类实例
-    @Resource
-    private Util util;
-
-    /**
-     * 环绕通知，拦截指定包下的Api请求。
-     *
-     * @param joinPoint 切点表达式匹配到的连接点
-     * @return 返回处理后的响应实体
-     * @throws Throwable 抛出异常时处理
-     */
-    @Around(value = "within(com.scbfkj.uni.api.*Api)")
-    public ResponseEntity<Object> invokeAround(ProceedingJoinPoint joinPoint) throws Throwable {
-        LocalDateTime requestTime = LocalDateTime.now();
-        // 获取请求信息
-        String uri = RequestUtil.getUri();
-        Object[] args = joinPoint.getArgs();
-        Map<String, Object> returnData = null;
-        String message = null;
-        Map<String, Object> userInfo = RequestUtil.getUserInfo();
-
-        Optional<String> serviceid = Optional.empty();
-        String userId = RequestUtil.getUserId();
-        // Debug模式下的日志打印
-        if (Config.isDebug()) {
-            System.out.println("请求参数：" + DataFormatUtil.toString(args));
-            System.out.println("请求路径：" + uri);
-            System.out.println("请求session：" + RequestUtil.getSessionId());
-            System.out.println("请求ip：" + RequestUtil.getIpAddr());
-            System.out.println("请求userToken：" + RequestUtil.getUserToken());
-            System.out.println("请求appToken：" + RequestUtil.getAppToken());
-        }
-
-        try {
-            Map<String, Object> body = null;
-            // 检查除特定接口外的服务状态
-            if (args.length > 0 && !uri.startsWith("/controlApi") && !uri.startsWith("/file") && !uri.startsWith("/user") && !uri.startsWith("/foxlibc") && !uri.startsWith("/ws")) {
-                Object arg = args[0];
-                if (arg instanceof Map<?, ?> map) {
-                    body = (Map<String, Object>) map;
-                    Util.addFilter(body, serviceid, uri, true);
-                    serviceid = DataAliasGetUtil.getValue("serviceid", (Map<String, Object>) map);
-                    if (serviceid.isEmpty()) {
-                        List<Map<String, Object>> query = DATA_BASE.query(Config.getCenterConnectionStr(), "select * from serviceinfo where urilist=?", uri);
-                        if (!query.isEmpty()) {
-                            serviceid = DataAliasGetUtil.getValue("serviceid", query.get(0));
-                        }
-                    }
-                    if (serviceid.isPresent()) {
-                        // 检查服务运行状态
-                        List<Map<String, Object>> mapList = DATA_BASE.query(Config.getCenterConnectionStr(), "select runstate from servicestate where stoptime is null and  serviceid=? and containercode = ?", serviceid.get(), Config.getContainerCode());
-                        if (mapList.isEmpty()) {
-                            throw new RuntimeException("服务没有运行或者被熔断");
-                        } else {
-                            Map<String, Object> serviceState = mapList.get(0);
-                            Object o = serviceState.get("runstate");
-                            // 判断服务状态
-                            if (Objects.equals(o.toString(), "0")) {
-                                throw new RuntimeException("服务没有运行或者被熔断");
-                            }
-                        }
-                    }
-                }
-            }
-
-            // 检查是否符合限流规则
-            message = checkratelimitrule(uri);
-            if (Objects.nonNull(message)) {
-                return ResponseEntity.ok(UniReturnUtil.fail(message));
-            }
-
-            // 继续执行原方法逻辑
-            ResponseEntity<Map<String, Object>> responseEntity = (ResponseEntity<Map<String, Object>>) joinPoint.proceed(args);
-            Map<String, Object> responseEntityBody = responseEntity.getBody();
-            if (responseEntity.getStatusCode().is2xxSuccessful()) {
-                if (Config.isDebug()) {
-                    System.out.println("返回值：" + DataFormatUtil.toString(returnData));
-                }
-                // 处理返回数据，如果是调试模式，直接返回
-                if ("0".equals(responseEntityBody.get("code")) && serviceid.isPresent()) {
-                    List<Map<String, Object>> serviceInfoes = DATA_BASE.query(Config.getCenterConnectionStr(), "select * from serviceinfo where serviceid=?", serviceid.get());
-                    if (!serviceInfoes.isEmpty()) {
-                        Map<String, Object> serviceInfo = serviceInfoes.get(0);
-                        Object raw = serviceInfo.get("raw");
-                        if (raw != null && raw.toString().equalsIgnoreCase("1")) {
-                            Object data = responseEntityBody.getOrDefault("returnData", responseEntityBody);
-                            if (data instanceof List<?> d && d.size() == 1) {
-                                data = d.get(0);
-                            }
-                            return ResponseEntity.ok(data);
-                        }
-                    }
-                }
-                return ResponseEntity.ok(responseEntityBody);
-            } else {
-                returnData = responseEntityBody;
-            }
-
-        } catch (Throwable e) {
-            if (Config.isDebug()) {
-                e.printStackTrace();
-            }
-            // 错误处理，生成错误日志消息
-            message = UniReturnUtil.getMessage(e);
-            returnData = UniReturnUtil.fail(message);
-        } finally {
-            // 记录日志
-            HashMap<String, Object> logData = new HashMap<>();
-            logData.put("requesttime", requestTime);
-            logData.put("requestpath", uri);
-            logData.put("requestdata", DataFormatUtil.toString(args));
-            logData.put("sessionid", RequestUtil.getSessionId());
-            logData.put("returndata", DataFormatUtil.toString(returnData));
-            logData.put("returntime", LocalDateTime.now());
-            try {
-                logData.put("applicationid", RequestUtil.getAppId());
-            } catch (Exception e) {
-                if (Config.isDebug()) {
-                    e.printStackTrace();
-                }
-            }
-            LoggerService.log(LoggerService.LogType.INTERFACE, logData);
-        }
-
-        // 处理返回数据，过滤和调整
-        if (Config.isDebug()) {
-            System.out.println("返回值：" + DataFormatUtil.toString(returnData));
-        }
-
-        Object code = returnData.get("code");
-        // 过滤返回数据
-        if (!Config.isDebug() && Objects.nonNull(code) && "0".equals(code.toString()) && Objects.nonNull(userInfo) && !"0".equals(userInfo.get("usergroupid").toString())) {
-            Object returnData1 = returnData.get("returnData");
-            if (returnData1 instanceof List<?> ls) {
-                if (serviceid.isPresent()) {
-                    try {
-                        List<String> columns = DATA_BASE.query(Config.getSecurityConnectionStr(), "select pagecode from pageconfiguration where pageconfigurationid  in (select userpermissions.pageconfigurationid from userpermissions where  userid =? and  serviceid = ?)", userId, serviceid.get()).stream().map(it -> it.get("pagecode").toString()).toList();
-                        List<Object> list = ls.stream().map(it -> {
-                            if (it instanceof Map<?, ?> map) {
-                                HashMap<Object, Object> map1 = new HashMap<>();
-                                columns.forEach(key -> {
-                                    map1.put(key, map.get(key));
-                                });
-                                return map1;
-                            } else {
-                                return it;
-                            }
-                        }).toList();
-                        returnData.put("returnData", list);
-
-                    } catch (Exception e) {
-                        returnData.put("returnData", new ArrayList<>());
-                    }
-
-                }
-            }
-        }
-        return ResponseEntity.ok(returnData);
-    }
-
-    /**
-     * 检查请求是否符合限流规则。
-     *
-     * @param uri 请求的URI
-     * @return 如果请求超过限流规则，则返回提示消息；否则返回null。
-     * @throws Exception 抛出异常时处理
-     */
-    private String checkratelimitrule(String uri) throws Exception {
-        // 从数据库查询限流规则
-        List<Map<String, Object>> ratelimitruleList = DATA_BASE.query(Config.getSecurityConnectionStr(), "select * from ratelimitrule ");
-        Optional<Map<String, Object>> optional = ratelimitruleList.stream().filter(it -> {
-            Object pathMatch = it.get("pathmatch");
-            if (Objects.isNull(pathMatch)) return true;
-            return uri.matches(pathMatch.toString());
-        }).findFirst();
-        if (optional.isPresent()) {
-            Map<String, Object> map = optional.get();
-            String pathMatch = map.get("pathmatch").toString();
-            if (!rateLimiterMap.containsKey(pathMatch)) {
-                // 创建新的限流器
-                String duration = map.getOrDefault("duration", 1).toString();
-                String limitValue = map.getOrDefault("limitvalue", 100).toString();
-                rateLimiterMap.put(pathMatch, RateLimiter.create(Double.parseDouble(limitValue), Integer.parseInt(duration), TimeUnit.SECONDS));
-            }
-            RateLimiter rateLimiter = rateLimiterMap.get(pathMatch);
-            String timeOut = map.getOrDefault("timeout", 1).toString();
-            // 尝试获取许可，如果失败则表示请求超过限流阈值
-            boolean acquire = rateLimiter.tryAcquire(Integer.parseInt(timeOut), TimeUnit.SECONDS);
-            if (!acquire) {
-                return map.getOrDefault("returnmessage", "请求频率过高，请降低请求频率").toString();
-            }
-        }
-        return null;
-    }
+	// 用于存储限流规则的映射
+	private static final Map<String, RateLimiter> rateLimiterMap = new HashMap<>();
+	// 数据库操作实例
+	private static final DataBase DATA_BASE = new DataBase();
+	// 工具类实例
+	@Resource
+	private Util util;
+
+	/**
+	 * 环绕通知，拦截指定包下的Api请求。
+	 *
+	 * @param joinPoint 切点表达式匹配到的连接点
+	 *
+	 * @return 返回处理后的响应实体
+	 *
+	 * @throws Throwable 抛出异常时处理
+	 */
+	@Around(value = "within(com.scbfkj.uni.api.*Api)")
+	public ResponseEntity<Object> invokeAround(ProceedingJoinPoint joinPoint) throws Throwable {
+
+		String methodName = joinPoint.getSignature().getName();
+		String className = joinPoint.getSignature().getDeclaringTypeName();
+
+		if ( "matchService".equals(methodName) && "com.scbfkj.uni.api.GenericApi".equals(className) ) {
+			String requestBody = RequestUtil.getRequestBody();
+			if ( requestBody != null ) {
+				Map<String, Object> body = (Map<String, Object>) DataFormatUtil.toMap(requestBody);
+				joinPoint.getArgs()[0] = body;
+			}
+		}
+
+		LocalDateTime requestTime = LocalDateTime.now();
+		// 获取请求信息
+		String uri = RequestUtil.getUri();
+		Object[] args = joinPoint.getArgs();
+		Map<String, Object> returnData = null;
+		String message = null;
+		Map<String, Object> userInfo = RequestUtil.getUserInfo();
+
+		Optional<String> serviceid = Optional.empty();
+		String userId = RequestUtil.getUserId();
+		// Debug模式下的日志打印
+		if ( Config.isDebug() ) {
+			System.out.println("请求参数：" + DataFormatUtil.toString(args));
+			System.out.println("请求路径：" + uri);
+			System.out.println("请求session：" + RequestUtil.getSessionId());
+			System.out.println("请求ip：" + RequestUtil.getIpAddr());
+			System.out.println("请求userToken：" + RequestUtil.getUserToken());
+			System.out.println("请求appToken：" + RequestUtil.getAppToken());
+		}
+
+		try {
+			Map<String, Object> body = null;
+			// 检查除特定接口外的服务状态
+			if ( args.length > 0 && ! uri.startsWith("/controlApi") && ! uri.startsWith("/file") && ! uri.startsWith("/user") && ! uri.startsWith("/foxlibc") && ! uri.startsWith("/ws") ) {
+				Object arg = args[0];
+				if ( arg instanceof Map<?, ?> map ) {
+					body = (Map<String, Object>) map;
+					Util.addFilter(body, serviceid, uri, true);
+					serviceid = DataAliasGetUtil.getValue("serviceid", (Map<String, Object>) map);
+					if ( serviceid.isEmpty() ) {
+						List<Map<String, Object>> query = DATA_BASE.query(Config.getCenterConnectionStr(), "select * from serviceinfo where urilist=?", uri);
+						if ( ! query.isEmpty() ) {
+							serviceid = DataAliasGetUtil.getValue("serviceid", query.get(0));
+						}
+					}
+					if ( serviceid.isPresent() ) {
+						// 检查服务运行状态
+						List<Map<String, Object>> mapList = DATA_BASE.query(Config.getCenterConnectionStr(), "select runstate from servicestate where stoptime is null and  serviceid=? and containercode = ?", serviceid.get(), Config.getContainerCode());
+						if ( mapList.isEmpty() ) {
+							throw new RuntimeException("服务没有运行或者被熔断");
+						} else {
+							Map<String, Object> serviceState = mapList.get(0);
+							Object o = serviceState.get("runstate");
+							// 判断服务状态
+							if ( Objects.equals(o.toString(), "0") ) {
+								throw new RuntimeException("服务没有运行或者被熔断");
+							}
+						}
+					}
+				}
+			}
+
+			// 检查是否符合限流规则
+			message = checkratelimitrule(uri);
+			if ( Objects.nonNull(message) ) {
+				return ResponseEntity.ok(UniReturnUtil.fail(message));
+			}
+
+			// 继续执行原方法逻辑
+			ResponseEntity<Map<String, Object>> responseEntity = (ResponseEntity<Map<String, Object>>) joinPoint.proceed(args);
+			Map<String, Object> responseEntityBody = responseEntity.getBody();
+			if ( responseEntity.getStatusCode().is2xxSuccessful() ) {
+				if ( Config.isDebug() ) {
+					System.out.println("返回值：" + DataFormatUtil.toString(returnData));
+				}
+				// 处理返回数据，如果是调试模式，直接返回
+				if ( "0".equals(responseEntityBody.get("code")) && serviceid.isPresent() ) {
+					List<Map<String, Object>> serviceInfoes = DATA_BASE.query(Config.getCenterConnectionStr(), "select * from serviceinfo where serviceid=?", serviceid.get());
+					if ( ! serviceInfoes.isEmpty() ) {
+						Map<String, Object> serviceInfo = serviceInfoes.get(0);
+						Object raw = serviceInfo.get("raw");
+						if ( raw != null && raw.toString().equalsIgnoreCase("1") ) {
+							Object data = responseEntityBody.getOrDefault("returnData", responseEntityBody);
+							if ( data instanceof List<?> d && d.size() == 1 ) {
+								data = d.get(0);
+							}
+							return ResponseEntity.ok(data);
+						}
+					}
+				}
+				return ResponseEntity.ok(responseEntityBody);
+			} else {
+				returnData = responseEntityBody;
+			}
+
+		} catch ( Throwable e ) {
+			if ( Config.isDebug() ) {
+				e.printStackTrace();
+			}
+			// 错误处理，生成错误日志消息
+			message = UniReturnUtil.getMessage(e);
+			returnData = UniReturnUtil.fail(message);
+		} finally {
+			// 记录日志
+			HashMap<String, Object> logData = new HashMap<>();
+			logData.put("requesttime", requestTime);
+			logData.put("requestpath", uri);
+			logData.put("requestdata", DataFormatUtil.toString(args));
+			logData.put("sessionid", RequestUtil.getSessionId());
+			logData.put("returndata", DataFormatUtil.toString(returnData));
+			logData.put("returntime", LocalDateTime.now());
+			try {
+				logData.put("applicationid", RequestUtil.getAppId());
+			} catch ( Exception e ) {
+				if ( Config.isDebug() ) {
+					e.printStackTrace();
+				}
+			}
+			LoggerService.log(LoggerService.LogType.INTERFACE, logData);
+		}
+
+		// 处理返回数据，过滤和调整
+		if ( Config.isDebug() ) {
+			System.out.println("返回值：" + DataFormatUtil.toString(returnData));
+		}
+
+		Object code = returnData.get("code");
+		// 过滤返回数据
+		if ( ! Config.isDebug() && Objects.nonNull(code) && "0".equals(code.toString()) && Objects.nonNull(userInfo) && ! "0".equals(userInfo.get("usergroupid").toString()) ) {
+			Object returnData1 = returnData.get("returnData");
+			if ( returnData1 instanceof List<?> ls ) {
+				if ( serviceid.isPresent() ) {
+					try {
+						List<String> columns = DATA_BASE.query(Config.getSecurityConnectionStr(), "select pagecode from pageconfiguration where pageconfigurationid  in (select userpermissions.pageconfigurationid from userpermissions where  userid =? and  serviceid = ?)", userId, serviceid.get()).stream().map(it -> it.get("pagecode").toString()).toList();
+						List<Object> list = ls.stream().map(it -> {
+							if ( it instanceof Map<?, ?> map ) {
+								HashMap<Object, Object> map1 = new HashMap<>();
+								columns.forEach(key -> {
+									map1.put(key, map.get(key));
+								});
+								return map1;
+							} else {
+								return it;
+							}
+						}).toList();
+						returnData.put("returnData", list);
+
+					} catch ( Exception e ) {
+						returnData.put("returnData", new ArrayList<>());
+					}
+
+				}
+			}
+		}
+		return ResponseEntity.ok(returnData);
+	}
+
+	/**
+	 * 检查请求是否符合限流规则。
+	 *
+	 * @param uri 请求的URI
+	 *
+	 * @return 如果请求超过限流规则，则返回提示消息；否则返回null。
+	 *
+	 * @throws Exception 抛出异常时处理
+	 */
+	private String checkratelimitrule(String uri) throws Exception {
+		// 从数据库查询限流规则
+		List<Map<String, Object>> ratelimitruleList = DATA_BASE.query(Config.getSecurityConnectionStr(), "select * from ratelimitrule ");
+		Optional<Map<String, Object>> optional = ratelimitruleList.stream().filter(it -> {
+			Object pathMatch = it.get("pathmatch");
+			if ( Objects.isNull(pathMatch) ) return true;
+			return uri.matches(pathMatch.toString());
+		}).findFirst();
+		if ( optional.isPresent() ) {
+			Map<String, Object> map = optional.get();
+			String pathMatch = map.get("pathmatch").toString();
+			if ( ! rateLimiterMap.containsKey(pathMatch) ) {
+				// 创建新的限流器
+				String duration = map.getOrDefault("duration", 1).toString();
+				String limitValue = map.getOrDefault("limitvalue", 100).toString();
+				rateLimiterMap.put(pathMatch, RateLimiter.create(Double.parseDouble(limitValue), Integer.parseInt(duration), TimeUnit.SECONDS));
+			}
+			RateLimiter rateLimiter = rateLimiterMap.get(pathMatch);
+			String timeOut = map.getOrDefault("timeout", 1).toString();
+			// 尝试获取许可，如果失败则表示请求超过限流阈值
+			boolean acquire = rateLimiter.tryAcquire(Integer.parseInt(timeOut), TimeUnit.SECONDS);
+			if ( ! acquire ) {
+				return map.getOrDefault("returnmessage", "请求频率过高，请降低请求频率").toString();
+			}
+		}
+		return null;
+	}
 }
 

src/main/java/com/scbfkj/uni/library/RequestUtil.java

@@ -1,315 +1,379 @@
 package com.scbfkj.uni.library;
 
+import com.fasterxml.jackson.core.JsonProcessingException;
 import com.scbfkj.uni.process.DataBase;
 import com.scbfkj.uni.system.Config;
+import jakarta.servlet.ServletInputStream;
 import jakarta.servlet.http.HttpServletRequest;
 import org.springframework.web.context.request.RequestContextHolder;
 import org.springframework.web.context.request.ServletRequestAttributes;
 
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
 import java.time.LocalDateTime;
 import java.util.*;
 
 public class RequestUtil {
-    public final static String APP_ID = "appid";
-    private static final DataBase DATABASE = new DataBase();
-
-    private RequestUtil() {
-    }
-
-    /**
-     * 获取客户端IP地址
-     * 该方法首先尝试从HTTP请求头中的"x-forwarded-for"字段获取IP地址，如果该字段不存在或为空，
-     * 则尝试从"Proxy-Client-IP"字段获取，接着是"WL-Proxy-Client-IP"字段，
-     * 如果所有尝试都失败或返回不可识别的值，则返回远程地址。
-     * 注意：这个方法适用于通过代理或负载均衡服务器转发的请求获取真实客户端IP地址的场景。
-     *
-     * @return 客户端的IP地址字符串。如果无法确定客户端IP地址，则返回null。
-     */
-    public static String getIpAddr() {
-        String ip = getHeader("x-forwarded-for"); // 尝试从"x-forwarded-for"头部获取IP地址
-        String unknown = "unknown";
-        if (ip == null || ip.isEmpty() || unknown.equalsIgnoreCase(ip)) {
-            ip = getHeader("Proxy-Client-IP"); // 如果失败，尝试从"Proxy-Client-IP"头部获取
-        }
-        if (ip == null || ip.isEmpty() || unknown.equalsIgnoreCase(ip)) {
-            ip = getHeader("WL-Proxy-Client-IP"); // 如果再次失败，尝试从"WL-Proxy-Client-IP"头部获取
-        }
-        if (ip == null || ip.isEmpty() || unknown.equalsIgnoreCase(ip)) {
-            ip = getRemoteAddr(); // 所有尝试失败，返回远程地址
-        }
-        return ip;
-    }
-
-    /**
-     * 获取当前请求的客户端IP地址。
-     *
-     * 该方法不接受任何参数，它通过检索当前线程绑定的ServletRequestAttributes，
-     * 进而获取HttpServletRequest对象，最后从HttpServletRequest中提取客户端的IP地址。
-     *
-     * @return String 客户端的IP地址。
-     */
-    private static String getRemoteAddr() {
-        // 获取当前请求的属性
-        ServletRequestAttributes requestAttributes = (ServletRequestAttributes) RequestContextHolder.currentRequestAttributes();
-        // 从属性中获取HttpServletRequest对象
-        HttpServletRequest request = requestAttributes.getRequest();
-        // 返回客户端的IP地址
-        return request.getRemoteAddr();
-    }
-
-/**
- * 获取应用令牌。
- * <p>此方法从请求头中获取名为"token"的字段值，并返回其字符串表示形式。
- * 如果找不到该字段或字段值为null，则返回null。</p>
- *
- * @return 如果找到有效的token，则返回其字符串形式；否则返回null。
- */
-public static String getAppToken() {
-    // 从请求头中获取名为"token"的字段值
-    Object appToken = getHeader("token");
-    // 判断appToken是否非空，非空则返回其字符串形式，否则返回null
-    return Objects.nonNull(appToken) ? appToken.toString() : null;
-}
+	public final static String APP_ID = "appid";
+	private static final DataBase DATABASE = new DataBase();
 
+	private RequestUtil() {
+	}
 
-    /**
-     * 获取用户令牌。
-     * <p>
-     * 该方法从请求头中提取名为"usertoken"的字段，并返回其值。
-     * 如果不存在该字段，则返回null。
-     *
-     * @return 用户令牌的字符串表示，如果不存在则返回null。
-     */
-    public static String getUserToken() {
-        // 从请求头中获取名为"usertoken"的字段
-        Object userToken = getHeader("usertoken");
-        // 判断用户令牌是否非空，非空则返回其字符串形式，否则返回null
-        return Objects.nonNull(userToken) ? userToken.toString() : null;
-    }
-
-    /**
-     * 获取当前HTTP请求的指定头信息。
-     *
-     * @param headerName 需要获取的头名称。
-     * @return 返回请求头中指定头名称的值。如果不存在该头，则返回null。
-     */
-    private static String getHeader(String headerName) {
-        // 获取当前请求的属性
-        ServletRequestAttributes requestAttributes = (ServletRequestAttributes) RequestContextHolder.currentRequestAttributes();
-        // 从属性中获取HttpServletRequest对象
-        HttpServletRequest request = requestAttributes.getRequest();
-        // 返回指定头名称的值
-        return request.getHeader(headerName);
-    }
-    /**
-     * 获取当前HTTP请求的所有头信息。
-     *
-     * 该方法不接受任何参数，但需要当前线程绑定的HTTP请求上下文。
-     *
-     * @return 一个包含所有头信息的Map，其中头名称为键，头值为值。
-     */
-    public static Map<String, String> getHeaders() {
-        // 获取当前请求的属性
-        ServletRequestAttributes requestAttributes = (ServletRequestAttributes) RequestContextHolder.currentRequestAttributes();
-        // 从属性中获取HttpServletRequest对象
-        HttpServletRequest request = requestAttributes.getRequest();
-        // 获取所有头名称的枚举
-        Enumeration<String> headerNames = request.getHeaderNames();
-        // 创建一个空的Map来存储头信息
-        Map<String,String> headers = new HashMap<>();
-        // 遍历所有头名称，并将它们及其对应的值添加到Map中
-        while (headerNames.hasMoreElements()) {
-            String element = headerNames.nextElement();
-            headers.put(element,request.getHeader(element));
-        }
-        // 返回包含所有头信息的Map
-        return headers;
-    }
-
-/**
- * 获取应用程序ID。
- * 此方法首先尝试从会话ID中检索应用程序ID。如果会话ID不存在或相关应用程序ID未找到，
- * 则方法将尝试从应用程序实例中获取应用程序ID。
- *
- * @return 返回应用程序ID的字符串表示。如果无法获取有效的应用程序ID，则返回null。
- * @throws Exception 如果在获取会话ID或应用程序ID过程中遇到错误，则抛出异常。
- */
-public static String getAppId() throws Exception {
-    String session = getSessionId(); // 尝试获取会话ID
-    if (session == null) {
-        return null; // 如果会话ID不存在，直接返回null
-    }
-    // 尝试从缓存中获取会话信息
-    Map<String, Object> sessionMap = Config.CACHE.get(session);
-    if (sessionMap == null) {
-        sessionMap = new Hashtable<>(); // 如果会话信息不存在，则创建新的会话信息容器
-        Config.CACHE.put(session, sessionMap); // 将新的会话信息容器放入缓存
-    }
-    // 尝试从会话信息中获取应用程序ID
-    Object appid = sessionMap.get(APP_ID);
-    if (Objects.nonNull(appid)) {
-        return appid.toString(); // 如果找到应用程序ID，返回其字符串形式
-    }
-    // 如果在会话信息中未找到应用程序ID，尝试从应用程序实例中获取并返回
-    return getApplication().get(APP_ID).toString();
-}
+	/**
+	 * 获取客户端IP地址 该方法首先尝试从HTTP请求头中的"x-forwarded-for"字段获取IP地址，如果该字段不存在或为空，
+	 * 则尝试从"Proxy-Client-IP"字段获取，接着是"WL-Proxy-Client-IP"字段， 如果所有尝试都失败或返回不可识别的值，则返回远程地址。
+	 * 注意：这个方法适用于通过代理或负载均衡服务器转发的请求获取真实客户端IP地址的场景。
+	 *
+	 * @return 客户端的IP地址字符串。如果无法确定客户端IP地址，则返回null。
+	 */
+	public static String getIpAddr() {
+		String ip = getHeader("x-forwarded-for"); // 尝试从"x-forwarded-for"头部获取IP地址
+		String unknown = "unknown";
+		if ( ip == null || ip.isEmpty() || unknown.equalsIgnoreCase(ip) ) {
+			ip = getHeader("Proxy-Client-IP"); // 如果失败，尝试从"Proxy-Client-IP"头部获取
+		}
+		if ( ip == null || ip.isEmpty() || unknown.equalsIgnoreCase(ip) ) {
+			ip = getHeader("WL-Proxy-Client-IP"); // 如果再次失败，尝试从"WL-Proxy-Client-IP"头部获取
+		}
+		if ( ip == null || ip.isEmpty() || unknown.equalsIgnoreCase(ip) ) {
+			ip = getRemoteAddr(); // 所有尝试失败，返回远程地址
+		}
+		return ip;
+	}
 
+	/**
+	 * 获取当前请求的客户端IP地址。
+	 * <p>
+	 * 该方法不接受任何参数，它通过检索当前线程绑定的ServletRequestAttributes， 进而获取HttpServletRequest对象，最后从HttpServletRequest中提取客户端的IP地址。
+	 *
+	 * @return String 客户端的IP地址。
+	 */
+	private static String getRemoteAddr() {
+		// 获取当前请求的属性
+		ServletRequestAttributes requestAttributes = (ServletRequestAttributes) RequestContextHolder.currentRequestAttributes();
+		// 从属性中获取HttpServletRequest对象
+		HttpServletRequest request = requestAttributes.getRequest();
+		// 返回客户端的IP地址
+		return request.getRemoteAddr();
+	}
 
-/**
- * 获取当前应用的信息。
- * <p>
- * 这个方法首先会尝试从会话中获取应用信息。如果会话中不存在该信息，则会通过应用令牌和请求IP来查询数据库，
- * 获取应用的详细信息，并将其保存到会话中，供后续使用。
- * </p>
- * @return 一个包含应用信息的Map对象。如果会话不存在或应用未登录，则返回null。
- * @throws Exception 如果查询数据库时发生错误，或者无法获取应用信息，则抛出异常。
- */
-public static Map<String, Object> getApplication() throws Exception {
-
-    String session = getSessionId();
-    String clean = "delete from appconnectlog where expiretime <  ?";
-
-    // 清理数据库中过期的连接日志
-    DATABASE.update(Config.getSecurityConnectionStr(), clean, LocalDateTime.now());
-
-    // 检查会话是否有效
-    if (session == null) {
-        return null;
-    }
-    Map<String, Object> sessionMap = Config.CACHE.get(session);
-    if (sessionMap == null) {
-        sessionMap = new Hashtable<>();
-        Config.CACHE.put(session, sessionMap);
-    }
-    // 尝试从会话映射中获取应用信息
-    Object application = sessionMap.get("application");
-    if (Objects.isNull(application)) {
-        // 如果应用信息不存在，则通过应用令牌和IP地址查询应用连接日志
-        String appToken = getAppToken();
-        String requestIp = getIpAddr();
-        String query = "select appid from appconnectlog where apptoken=? and requestip =? and expiretime >  ?";
-        List<Map<String, Object>> appConnectLogList = DATABASE.query(Config.getSecurityConnectionStr(), query,
-                appToken, requestIp, LocalDateTime.now());
-        // 如果查询结果为空，表示应用未登录
-        if (appConnectLogList.isEmpty()) {
-            throw new RuntimeException("当前连接未登录");
-        }
-        // 获取应用ID
-        Map<String, Object> stringObjectMap = appConnectLogList.get(0);
-        Object applicationid = stringObjectMap.get(APP_ID);
-
-        // 根据应用ID查询应用的详细信息
-        query = """
-                select applicationid,
-                       appid,
-                       appsecret,
-                       appname,
-                       appengname,
-                       appdescribe,
-                       applogo,
-                       smalllogo,
-                       backgroundimage,
-                       apptokeneffective,
-                       securitycoderule,
-                       securitycodeeffective,
-                       multilogin,
-                       passwordrule,
-                       passwordeffective
-                from application
-                where appid = ?""";
-        List<Map<String, Object>> applicationList = DATABASE.query(Config.getSecurityConnectionStr(), query, applicationid);
-        // 如果查询结果为空，表示无法获取应用信息
-        if (applicationList.isEmpty()) {
-            throw new RuntimeException("获取应用失败");
-        }
-        // 保存查询到的应用信息到会话映射中
-        application = applicationList.get(0);
-
-        sessionMap.put("application", application);
-
-    }
-    // 将应用信息转换为Map对象并返回
-    Map<String, Object> applicationMap = (Map<String, Object>) application;
-
-    return applicationMap;
+	/**
+	 * 获取应用令牌。
+	 * <p>此方法从请求头中获取名为"token"的字段值，并返回其字符串表示形式。
+	 * 如果找不到该字段或字段值为null，则返回null。</p>
+	 *
+	 * @return 如果找到有效的token，则返回其字符串形式；否则返回null。
+	 */
+	public static String getAppToken() {
+		// 从请求头中获取名为"token"的字段值
+		Object appToken = getHeader("token");
+		// 判断appToken是否非空，非空则返回其字符串形式，否则返回null
+		return Objects.nonNull(appToken) ? appToken.toString() : null;
+	}
 
+	/**
+	 * 获取用户令牌。
+	 * <p>
+	 * 该方法从请求头中提取名为"usertoken"的字段，并返回其值。 如果不存在该字段，则返回null。
+	 *
+	 * @return 用户令牌的字符串表示，如果不存在则返回null。
+	 */
+	public static String getUserToken() {
+		// 从请求头中获取名为"usertoken"的字段
+		Object userToken = getHeader("usertoken");
+		// 判断用户令牌是否非空，非空则返回其字符串形式，否则返回null
+		return Objects.nonNull(userToken) ? userToken.toString() : null;
+	}
 
-}
+	/**
+	 * 获取当前HTTP请求的指定头信息。
+	 *
+	 * @param headerName 需要获取的头名称。
+	 *
+	 * @return 返回请求头中指定头名称的值。如果不存在该头，则返回null。
+	 */
+	private static String getHeader(String headerName) {
+		// 获取当前请求的属性
+		ServletRequestAttributes requestAttributes = (ServletRequestAttributes) RequestContextHolder.currentRequestAttributes();
+		// 从属性中获取HttpServletRequest对象
+		HttpServletRequest request = requestAttributes.getRequest();
+		// 返回指定头名称的值
+		return request.getHeader(headerName);
+	}
 
+	/**
+	 * 获取当前HTTP请求的所有头信息。
+	 * <p>
+	 * 该方法不接受任何参数，但需要当前线程绑定的HTTP请求上下文。
+	 *
+	 * @return 一个包含所有头信息的Map，其中头名称为键，头值为值。
+	 */
+	public static Map<String, String> getHeaders() {
+		// 获取当前请求的属性
+		ServletRequestAttributes requestAttributes = (ServletRequestAttributes) RequestContextHolder.currentRequestAttributes();
+		// 从属性中获取HttpServletRequest对象
+		HttpServletRequest request = requestAttributes.getRequest();
+		// 获取所有头名称的枚举
+		Enumeration<String> headerNames = request.getHeaderNames();
+		// 创建一个空的Map来存储头信息
+		Map<String, String> headers = new HashMap<>();
+		// 遍历所有头名称，并将它们及其对应的值添加到Map中
+		while ( headerNames.hasMoreElements() ) {
+			String element = headerNames.nextElement();
+			headers.put(element, request.getHeader(element));
+		}
+		// 返回包含所有头信息的Map
+		return headers;
+	}
 
-/**
- * 获取用户ID。
- * <p>此方法不接受任何参数，尝试从外部获取用户信息，并提取其中的用户ID。</p>
- *
- * @return 返回用户ID的字符串形式。如果无法获取用户信息或用户信息中不包含用户ID，则返回null。
- */
-public static String getUserId() {
-
-    // 尝试获取用户信息
-    Map<String, Object> userInfo = getUserInfo();
-    if (Objects.isNull(userInfo)) {
-        return null;
-    } else {
-        // 从用户信息中提取用户ID，并转换为字符串格式
-        Object userid = userInfo.get("userid");
-        return Objects.isNull(userid) ? null : DataFormatUtil.toString(userid);
-    }
-}
+	/**
+	 * 获取应用程序ID。 此方法首先尝试从会话ID中检索应用程序ID。如果会话ID不存在或相关应用程序ID未找到， 则方法将尝试从应用程序实例中获取应用程序ID。
+	 *
+	 * @return 返回应用程序ID的字符串表示。如果无法获取有效的应用程序ID，则返回null。
+	 *
+	 * @throws Exception 如果在获取会话ID或应用程序ID过程中遇到错误，则抛出异常。
+	 */
+	public static String getAppId() throws Exception {
+		String session = getSessionId(); // 尝试获取会话ID
+		if ( session == null ) {
+			return null; // 如果会话ID不存在，直接返回null
+		}
+		// 尝试从缓存中获取会话信息
+		Map<String, Object> sessionMap = Config.CACHE.get(session);
+		if ( sessionMap == null ) {
+			sessionMap = new Hashtable<>(); // 如果会话信息不存在，则创建新的会话信息容器
+			Config.CACHE.put(session, sessionMap); // 将新的会话信息容器放入缓存
+		}
+		// 尝试从会话信息中获取应用程序ID
+		Object appid = sessionMap.get(APP_ID);
+		if ( Objects.nonNull(appid) ) {
+			return appid.toString(); // 如果找到应用程序ID，返回其字符串形式
+		}
+		// 如果在会话信息中未找到应用程序ID，尝试从应用程序实例中获取并返回
+		return getApplication().get(APP_ID).toString();
+	}
+
+	/**
+	 * 获取当前应用的信息。
+	 * <p>
+	 * 这个方法首先会尝试从会话中获取应用信息。如果会话中不存在该信息，则会通过应用令牌和请求IP来查询数据库， 获取应用的详细信息，并将其保存到会话中，供后续使用。
+	 * </p>
+	 *
+	 * @return 一个包含应用信息的Map对象。如果会话不存在或应用未登录，则返回null。
+	 *
+	 * @throws Exception 如果查询数据库时发生错误，或者无法获取应用信息，则抛出异常。
+	 */
+	public static Map<String, Object> getApplication() throws Exception {
+
+		String session = getSessionId();
+		String clean = "delete from appconnectlog where expiretime <  ?";
+
+		// 清理数据库中过期的连接日志
+		DATABASE.update(Config.getSecurityConnectionStr(), clean, LocalDateTime.now());
+
+		// 检查会话是否有效
+		if ( session == null ) {
+			return null;
+		}
+		Map<String, Object> sessionMap = Config.CACHE.get(session);
+		if ( sessionMap == null ) {
+			sessionMap = new Hashtable<>();
+			Config.CACHE.put(session, sessionMap);
+		}
+		// 尝试从会话映射中获取应用信息
+		Object application = sessionMap.get("application");
+		if ( Objects.isNull(application) ) {
+			// 如果应用信息不存在，则通过应用令牌和IP地址查询应用连接日志
+			String appToken = getAppToken();
+			String requestIp = getIpAddr();
+			String query = "select appid from appconnectlog where apptoken=? and requestip =? and expiretime >  ?";
+			List<Map<String, Object>> appConnectLogList = DATABASE.query(Config.getSecurityConnectionStr(), query,
+			                                                             appToken, requestIp, LocalDateTime.now());
+			// 如果查询结果为空，表示应用未登录
+			if ( appConnectLogList.isEmpty() ) {
+				throw new RuntimeException("当前连接未登录");
+			}
+			// 获取应用ID
+			Map<String, Object> stringObjectMap = appConnectLogList.get(0);
+			Object applicationid = stringObjectMap.get(APP_ID);
+
+			// 根据应用ID查询应用的详细信息
+			query = """
+					select applicationid,
+					       appid,
+					       appsecret,
+					       appname,
+					       appengname,
+					       appdescribe,
+					       applogo,
+					       smalllogo,
+					       backgroundimage,
+					       apptokeneffective,
+					       securitycoderule,
+					       securitycodeeffective,
+					       multilogin,
+					       passwordrule,
+					       passwordeffective
+					from application
+					where appid = ?""";
+			List<Map<String, Object>> applicationList = DATABASE.query(Config.getSecurityConnectionStr(), query, applicationid);
+			// 如果查询结果为空，表示无法获取应用信息
+			if ( applicationList.isEmpty() ) {
+				throw new RuntimeException("获取应用失败");
+			}
+			// 保存查询到的应用信息到会话映射中
+			application = applicationList.get(0);
+
+			sessionMap.put("application", application);
+
+		}
+		// 将应用信息转换为Map对象并返回
+		Map<String, Object> applicationMap = (Map<String, Object>) application;
+
+		return applicationMap;
+
+
+	}
+
+	/**
+	 * 获取用户ID。
+	 * <p>此方法不接受任何参数，尝试从外部获取用户信息，并提取其中的用户ID。</p>
+	 *
+	 * @return 返回用户ID的字符串形式。如果无法获取用户信息或用户信息中不包含用户ID，则返回null。
+	 */
+	public static String getUserId() {
+
+		// 尝试获取用户信息
+		Map<String, Object> userInfo = getUserInfo();
+		if ( Objects.isNull(userInfo) ) {
+			return null;
+		} else {
+			// 从用户信息中提取用户ID，并转换为字符串格式
+			Object userid = userInfo.get("userid");
+			return Objects.isNull(userid) ? null : DataFormatUtil.toString(userid);
+		}
+	}
+
+	/**
+	 * 获取用户信息。 此方法会首先尝试从会话ID中获取用户信息，如果不存在，则返回null。 如果会话ID存在但对应用户信息为空，则创建一个新的用户信息容器并返回。
+	 *
+	 * @return Map<String, Object> 如果用户信息存在，则返回一个包含用户信息的Map；否则返回null。
+	 */
+	public static Map<String, Object> getUserInfo() {
+
+		// 获取当前会话ID
+		String session = getSessionId();
+		// 如果会话ID为空，则直接返回null
+		if ( session == null ) {
+			return null;
+		}
+		// 尝试从缓存中获取会话对应的用户信息
+		Map<String, Object> sessionMap = Config.CACHE.get(session);
+		// 如果该会话ID未被缓存，创建一个新的会话信息容器并加入缓存
+		if ( sessionMap == null ) {
+			sessionMap = new Hashtable<>();
+			Config.CACHE.put(session, sessionMap);
+		}
+		// 尝试从会话信息容器中获取用户信息
+		Object userInfo = sessionMap.get("userinfo");
+		// 如果用户信息存在，则返回，否则返回null
+		return Objects.nonNull(userInfo) ? (Map<String, Object>) userInfo : null;
+	}
+
+	/**
+	 * 获取会话ID。
+	 * <p>
+	 * 该方法是一个静态方法，不需要实例化对象即可调用。它通过调用另一个名为getHeader的方法， 并传入参数"sessionid"来获取会话ID。会话ID通常用于追踪和识别用户在应用程序中的会话。
+	 *
+	 * @return 返回一个String类型的会话ID。如果无法获取到会话ID，则可能返回null或空字符串， 具体取决于getHeader方法的实现。
+	 */
+	public static String getSessionId() {
+		return getHeader("sessionid");
+	}
+
+	/**
+	 * 获取当前请求的URI。
+	 * <p>
+	 * 该方法不接受任何参数。
+	 *
+	 * @return 返回当前HTTP请求的URI字符串。
+	 */
+	public static String getUri() {
+		// 获取当前请求的属性
+		ServletRequestAttributes requestAttributes = (ServletRequestAttributes) RequestContextHolder.currentRequestAttributes();
+
+		// 从请求属性中提取并返回请求的URI
+		return requestAttributes.getRequest().getRequestURI();
+	}
+
+	/**
+	 * 获取当前线程中的HttpServletRequest对象。 本方法主要用于在Spring MVC环境下，获取当前请求的HttpServletRequest对象。
+	 * 通过利用Spring提供的RequestContextHolder工具类，可以方便地获取到当前线程绑定的请求属性， 进而获取到HttpServletRequest对象，以便进行后续的请求处理或信息获取操作。
+	 *
+	 * @return 当前线程中的HttpServletRequest对象，如果线程中没有绑定请求属性，则返回null。
+	 */
+	public static HttpServletRequest getRequest() {
+		// 通过RequestContextHolder获取当前线程绑定的请求属性
+		ServletRequestAttributes requestAttributes = (ServletRequestAttributes) RequestContextHolder.currentRequestAttributes();
+
+		// 从请求属性中获取HttpServletRequest对象并返回
+		return requestAttributes.getRequest();
+	}
+
+	/**
+	 * 从HttpServletRequest中获取请求体的内容。
+	 * <p>
+	 * 注意：此操作会消费输入流，确保在调用此方法前未有其他组件读取过请求体
+	 *
+	 * @return 请求体中的字符串内容，如果发生IO异常则返回null。
+	 */
+	public static String getRequestBody() {
+		HttpServletRequest request = getRequest();
+		try {
+			StringBuilder stringBuilder = new StringBuilder();
+			BufferedReader bufferedReader = null;
+
+			// 获取请求的输入流
+			ServletInputStream inputStream = request.getInputStream();
+			if ( inputStream != null ) {
+				bufferedReader = new BufferedReader(new InputStreamReader(inputStream, request.getCharacterEncoding()));
+
+				// 读取请求体内容
+				char[] charBuffer = new char[128];
+				int bytesRead = - 1;
+				while ( (bytesRead = bufferedReader.read(charBuffer)) > 0 ) {
+					stringBuilder.append(charBuffer, 0, bytesRead);
+				}
+			}
+			String body = stringBuilder.toString();
+			try {
+				DataFormatUtil.getObjectMapper().readValue(body, Map.class);
+			} catch ( JsonProcessingException e ) {
+				Map<String, String> temp = new HashMap<>();
+				for ( String s : body.split("&") ) {
+					String[] strings = s.split("=");
+					temp.put(strings[0], strings[1]);
+				}
+				body = DataFormatUtil.toString(temp);
+			}
+
+			if ( ! request.getParameterMap().isEmpty() && stringBuilder.isEmpty() ) {
+				return DataFormatUtil.toString(request.getParameterMap());
+			}
+
+			// 关闭流（如果使用了bufferedReader）
+			if ( bufferedReader != null ) {
+				bufferedReader.close();
+			}
 
+			return body;
+		} catch ( IOException e ) {
+			// 处理读取时的IO异常
+			e.printStackTrace();
+			return null;
+		}
+	}
 
-    /**
-     * 获取用户信息。
-     * 此方法会首先尝试从会话ID中获取用户信息，如果不存在，则返回null。
-     * 如果会话ID存在但对应用户信息为空，则创建一个新的用户信息容器并返回。
-     *
-     * @return Map<String, Object> 如果用户信息存在，则返回一个包含用户信息的Map；否则返回null。
-     */
-    public static Map<String, Object> getUserInfo() {
-
-        // 获取当前会话ID
-        String session = getSessionId();
-        // 如果会话ID为空，则直接返回null
-        if (session == null) {
-            return null;
-        }
-        // 尝试从缓存中获取会话对应的用户信息
-        Map<String, Object> sessionMap = Config.CACHE.get(session);
-        // 如果该会话ID未被缓存，创建一个新的会话信息容器并加入缓存
-        if (sessionMap == null) {
-            sessionMap = new Hashtable<>();
-            Config.CACHE.put(session, sessionMap);
-        }
-        // 尝试从会话信息容器中获取用户信息
-        Object userInfo = sessionMap.get("userinfo");
-        // 如果用户信息存在，则返回，否则返回null
-        return Objects.nonNull(userInfo) ? (Map<String, Object>) userInfo : null;
-    }
-
-    /**
-     * 获取会话ID。
-     *
-     * 该方法是一个静态方法，不需要实例化对象即可调用。它通过调用另一个名为getHeader的方法，
-     * 并传入参数"sessionid"来获取会话ID。会话ID通常用于追踪和识别用户在应用程序中的会话。
-     *
-     * @return 返回一个String类型的会话ID。如果无法获取到会话ID，则可能返回null或空字符串，
-     *         具体取决于getHeader方法的实现。
-     */
-    public static String getSessionId() {
-        return getHeader("sessionid");
-    }
-
-    /**
-     * 获取当前请求的URI。
-     *
-     * 该方法不接受任何参数。
-     *
-     * @return 返回当前HTTP请求的URI字符串。
-     */
-    public static String getUri() {
-        // 获取当前请求的属性
-        ServletRequestAttributes requestAttributes = (ServletRequestAttributes) RequestContextHolder.currentRequestAttributes();
-
-        // 从请求属性中提取并返回请求的URI
-        return requestAttributes.getRequest().getRequestURI();
-    }
 }