使用ProceedingJoinPoint获取当前请求的方法等参数——spring mvc拦截器

最新推荐文章于 2023-01-12 09:54:57 发布
最新推荐文章于 2023-01-12 09:54:57 发布
阅读量3.5w 收藏 8
点赞数 1
文章标签： spring mvc 拦截器
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/SmuEdward/article/details/54315751
版权

在项目中常常需要顾虑请求参数中的特殊字符，比如+，<，>等

解决方案是可以使用spring mvc 的拦截器，配合aspectJ使用

package com.cpic.core.web;

import java.lang.annotation.Annotation;
import java.lang.reflect.Method;
import java.math.BigDecimal;
import java.util.Date;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;

import javax.servlet.http.HttpServletRequest;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.reflect.MethodSignature;
import org.jfree.util.Log;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.servlet.ModelAndView;

import com.cpic.caf.compon.business.common.entity.CodeEntryEO;
import com.cpic.caf.compon.tech.utils.JsonUtils;
import com.cpic.caf.compon.tech.utils.StringUtils;
import com.cpic.caf.pub.app.context.SpringAppContextUtil;
import com.cpic.caf.pub.security.context.SecurityContext;
import com.cpic.core.cache.DataCacheManager;
import com.cpic.core.filter.FilterUtils;
import com.cpic.core.httpHandler.entity.Response;
import com.cpic.cxyb.entity.LogManager;
import com.cpic.cxyb.entity.RybAuditLog;
import com.cpic.cxyb.service.LogManagerService;
import com.cpic.cxyb.service.RybAuditLogService;
import com.cpic.cxyb.threads.RybAuditLogSyncToDBThread;
import com.cpic.framework.entity.ResponseContent;
import com.cpic.xybx.security.MyUserInfoImpl;
import com.cpic.xybx.tools.CpicmIPUtil;

public class FilterTextSpecialString {
	public static final Logger logger = LoggerFactory.getLogger ( FilterTextSpecialString.class );
	DataCacheManager dataCacheManager;
	LogManagerService logManagerService;
	@Autowired
	RybAuditLogService rybAuditLogService;

	public static final String[] APP_METHOD = {"innerServerController.submit,innerServerController.submitContent"};
	public static final String RETURN_TYPE_AJAX = "ResponseContent";
	public static final String RETURN_TYPE_MV = "ModelAndView";
	public static final String RETURN_TYPE_MAP = "Map";
	public static final String RETURN_TYPE_VOID = "void";
	public static final String RETURN_TYPE_STRING = "String";
		//特殊字符的判断
	    public Object doAround(ProceedingJoinPoint pjp) throws Throwable {
	    	this.dataCacheManager = (DataCacheManager)SpringAppContextUtil.getBean("dataCacheManager");
	    	
	    	this.logManagerService = (LogManagerService)SpringAppContextUtil.getBean("logManagerService");
	    	//从数据库获取文本框特殊字符过滤信息
  		 	CodeEntryEO codeEntry = null;
  		 	String speCharactor = "";	
  		 	String method = pjp.getTarget().getClass().getName() + "." + pjp.getSignature().getName();
  		 	//获取映射方法
  		 	try{
  		 		String returnType = pjp.getSignature().toString().split(" ")[0];
        		if(StringUtils.isNotBlank(returnType) && RETURN_TYPE_MV.equals(returnType)){
	  		 		Method targetMethod = ((MethodSignature)(pjp.getSignature())).getMethod();  
	  	  		 	Class<?> classtest = targetMethod.getDeclaringClass();
	  	  		 
	  	  		 	String classAnnotationValue = "";
	  	  		 	String methodAnnotationValue = "";
	  	  		 	Annotation[]  classAnnotation = classtest.getAnnotations();
	  	  		 	for (int i = 0; i < classAnnotation.length; i++) {
	  	  		 		if(classAnnotation[i] instanceof RequestMapping){
	  		  		 		RequestMapping requestmap = (RequestMapping) classAnnotation[i];
	  		  		 		if(requestmap.value()[0] != null){
	  		  		 			classAnnotationValue = (requestmap.value())[0];
	  		  		 		}
	  		  		 		break;
	  	  		 		}
	  				}
	  	  		 	
	  	  		 	if(StringUtils.isNotBlank(classAnnotationValue)){
	  	  		 		Annotation[] methodAnnotation = targetMethod.getAnnotations();
	  	  	  		 	for (int i = 0; i < methodAnnotation.length; i++) {
	  	  	  		 		if(methodAnnotation[i] instanceof RequestMapping){
	  	  	  		 			RequestMapping requestmap = (RequestMapping) methodAnnotation[i];
	  	  	  	  		 		if(requestmap.value()[0] != null){
	  	  	  	  		 			methodAnnotationValue = (requestmap.value())[0];
	  	  	  	  		 		}
	  	  	  	  		 		break;
	  	  	  		 		}
	  	  	  		 		
	  	  				}
	  	  	  		 	
	  	  	  		 	String catalog = classAnnotationValue+"/"+methodAnnotationValue; 
	  	  	  		 	//增加审计日志
	  	  	  		    if(RybAuditLogSyncToDBThread.menuMap.get(catalog) != null){
	  	  	  		    	MyUserInfoImpl user = (MyUserInfoImpl) SecurityContext.getCurrentUser();
	  	  	  		    	//UserDefault user = (UserDefault)servletRequest.getAttribute("user");
	  	  	  				RybAuditLog  auditLog = new RybAuditLog();
	  	  	  				auditLog.setDatetime(new Date());
	  	  	  				auditLog.setInterfacecode(catalog);
	  	  	  				auditLog.setKind("web");
	  	  	  				String requestName = (String) RybAuditLogSyncToDBThread.menuMap.get(catalog);
	  	  	  				if(StringUtils.isNotBlank(requestName))auditLog.setInterfacename(requestName);
	  	  	  				if(user != null){
	  	  	  					String usertype = user.getUserType();
	  	  	  					auditLog.setUnitcode(user.getOrgCode());
	  	  	  					auditLog.setUsercode(user.getUserCode());
	  	  	  					auditLog.setUsername(user.getUsername());
	  	  	  					auditLog.setUsertype(usertype);
	  	  	  					auditLog.setOrgid(user.getOrgId());
	  	  	  					if(StringUtils.isNotBlank(usertype) && "CPICUser".equals(user.getUserType())){
	  	  	  						auditLog.setUnitname((String)(RybAuditLogSyncToDBThread.orgMap).get(user.getOrgCode()));
	  	  	  					}else{
	  	  	  						auditLog.setUnitname((String)(RybAuditLogSyncToDBThread.outsideOrgMap).get(user.getOrgCode()));
	  	  	  					}
	  	  	  					
	  	  	  				}
	  	  	  				this.rybAuditLogService.log(auditLog);
	  	  	  		    }
	  	  		 	}
        		}
  		 	}catch(Exception e){
  		 		Log.error("记录审计日志出错"+e.getMessage());
  		 	}
  		 	
  		 	
  		 	
  		 	boolean appFlag = false;
  		 	//判断是否是app
  		 	for(int i = 0 ; i < APP_METHOD.length ; i++){
  		 		if(method.indexOf(APP_METHOD[i]) >= 0){
  		 			appFlag = true;
  		 			break;
  		 		}
  		 	}
  		    //文本过滤器不过滤类和方法，配置在数据库中为：类名.方法名，类名.方法名
  		    CodeEntryEO codeEntryEO = dataCacheManager.getCodeEntryCacheByName("FilterConfig","TextSpecialCharactersException");
  		 	
  		    
  		    String exception = "";
  		    if(codeEntryEO != null){
  		    	exception = codeEntryEO.getName();
  		 	}
  		    String[] exceptions = exception.split(",");
  		    boolean exec = true;
  		    for(int i = 0 ; i < exceptions.length ; i ++){
  		    	if(method.indexOf(exceptions[i]) >= 0){
  		    		exec = false;
  		 			break;
  		 		}
  		    }
  		    boolean flag = false;//默认为假，有可能该Ctrl为例外或者没有参数则不作校验
  		    if(exec){
		    	if(appFlag ){
	    			codeEntry = dataCacheManager.getCodeEntryCacheByName("FilterConfig","appTextSpecialCharacters");
	        	}else{
	        		codeEntry = dataCacheManager.getCodeEntryCacheByName("FilterConfig","TextSpecialCharacters");
	        	}
	        	if (codeEntry != null){
	        		speCharactor = codeEntry.getName();
	        	}
	        	String[] list = {};
	        	//如果过滤规则为空，则不过滤
	        	if(StringUtils.isNotEmpty(speCharactor)){
	        		//特殊字符串数组
	            	list = speCharactor.split(",");
	        	}
		        if(list.length > 0 && pjp.getArgs() != null && pjp.getArgs().length > 0){
			        for (int i = 0; i < pjp.getArgs().length; i++) {
			        	if(pjp.getArgs()[i] instanceof LinkedHashMap){
			        		Map<String,Object> map = (Map<String,Object>)pjp.getArgs()[i];
			        		flag = typeJudge(map,list,method);
			        	}else if(pjp.getArgs()[i] instanceof HttpServletRequest){
			        		HttpServletRequest req = ((HttpServletRequest)pjp.getArgs()[i]);
			        		Enumeration enu = req.getParameterNames();  
			    			while(enu.hasMoreElements()){  
			    				String paraName=(String)enu.nextElement();  
			    				if(req.getParameter(paraName) != null){
			    					flag = FilterUtils.checkTextStringValue(req.getParameter(paraName).toUpperCase(),list);
			    				}
			    				//包含特殊字符退出循环
			    				if(flag){
			    					logger.info(method + "参数名为："+paraName+" 的值为："+req.getParameter(paraName)+" 中包含特殊字符。");
			    					break;
			    				}
			    			} 
			        	}else if(pjp.getArgs()[i] instanceof String){
			        		flag = FilterUtils.checkTextStringValue(pjp.getArgs()[i].toString().toUpperCase(),list);
			        	}
			        	//包含特殊字符退出循环，不校验下一个参数
	    				if(flag){
	    					break;
	    				}
			        }
		        }
  		    }
	        //没有特殊字符校验通过,调用ctrl方法执行业务
	        Object retVal = null;
	        if(!flag){
	        	try{
	        		retVal = pjp.proceed(); 	
	        	}catch(Exception e){
	        		StackTraceElement stackTraceElement= e.getStackTrace()[e.getStackTrace().length-1];
	        		stackTraceElement.getLineNumber();
	        		logger.error ( "\n=========执行{}方法的{}行异常信息为：=========={}",method,stackTraceElement.getLineNumber(),e.fillInStackTrace ( ).toString ( ) );
	        		//记录错误日志到数据库
	        		LogManager logManager = new LogManager();
	        		logManager.setErrormsg("执行" + method + "方法的" + stackTraceElement.getLineNumber() + "行发生错误：" + e.fillInStackTrace ( ).toString ( ));
	        		logManager.setIp(CpicmIPUtil.getServerIp());
	        		logManager.setCreattime(new Date());
	        		String requestStr = getRequestStr(pjp);
	        		logManager.setRequestmsg(requestStr);
	        		logManager.setResponsemsg("系统异常：请联系系统管理员");
	        		this.logManagerService.log(logManager);
	        		//针对异常的处理
	        		if(appFlag ){
		        		Response response = new Response();
						response.setStatus(Response.STATUS_ERROR);
						response.setErrorCode(Response.ERROR_CODE_SYSTEM);
						response.setErrorMessage("系统异常：请联系系统管理员");
						retVal = response;
		        	}else{
		        		String returnType = pjp.getSignature().toString().split(" ")[0];
		        		if(RETURN_TYPE_AJAX.equals(returnType)){
		        			ResponseContent responseContent = new ResponseContent();
							responseContent.setResultState(false);
							responseContent.setErrorCode("-88888");
							responseContent.setMsg("系统异常：请联系系统管理员");
							retVal = responseContent;
		        		}else if(RETURN_TYPE_MV.equals(returnType)){
		        			//返回管理后台错误页面
			        		ModelAndView mv = new ModelAndView("systemError");
			        		mv.addObject("msg", "系统异常：请联系系统管理员");
			        		retVal = mv;
		        		}else if(RETURN_TYPE_STRING.equals(returnType)){
		        			//返回管理后台错误页面
			        		retVal = "systemError";
		        		}else if(returnType.indexOf(RETURN_TYPE_MAP) >= 0){
		        			Map responseContent = new HashMap();
							responseContent.put("resultState",false);
							responseContent.put("errorCode","-88888");
							responseContent.put("msg","系统异常：请联系系统管理员");
							retVal = responseContent;
		        		}else if(returnType.indexOf(RETURN_TYPE_VOID) >= 0){
		        			//void目前不作处理，如果扫描出问题，则在进行处理，把HttpServletResponse获得到，直接向页面输出以下字符串
//		        			Map responseContent = new HashMap();
//							responseContent.put("resultState",false);
//							responseContent.put("errorCode","-88888");
//							responseContent.put("msg","系统异常：请联系系统管理员");
//							retVal = responseContent;
		        		}
		        	}
	        	}
	        }else{//包含特殊字符
	        	LogManager logManager = new LogManager();
        		logManager.setErrormsg("请求异常：请求参数不合法或请求参数被篡改");
        		logManager.setIp(CpicmIPUtil.getServerIp());
        		logManager.setCreattime(new Date());
        		String requestStr = getRequestStr(pjp);
        		logManager.setRequestmsg(requestStr);
        		logManager.setResponsemsg("请求异常：请求参数不合法或请求参数被篡改");
        		this.logManagerService.log(logManager);
	        	if(appFlag ){
	        		Response response = new Response();
					response.setStatus(Response.STATUS_ERROR);
					response.setErrorCode(Response.ERROR_CODE_SPECIAL_TEXT);
					response.setErrorMessage("请求异常：请求参数不合法或请求参数被篡改");
					retVal = response;
	        	}else{
	        		String returnType = pjp.getSignature().toString().split(" ")[0];
	        		if(returnType.indexOf(RETURN_TYPE_AJAX) >= 0){
	        			ResponseContent responseContent = new ResponseContent();
						responseContent.setResultState(false);
						responseContent.setErrorCode("-88888");
						responseContent.setMsg("请求异常：请求参数不合法或请求参数被篡改");
						retVal = responseContent;
	        		}else if(returnType.indexOf(RETURN_TYPE_MV) >= 0){
	        			//返回管理后台错误页面
		        		ModelAndView mv = new ModelAndView("permissionError");
		        		mv.addObject("msg", "请求异常：请求参数不合法或请求参数被篡改");
		        		retVal = mv;
	        		}else if(RETURN_TYPE_STRING.equals(returnType)){
	        			//返回管理后台错误页面
		        		retVal = "permissionError";
	        		}else if(returnType.indexOf(RETURN_TYPE_MAP) >= 0){
	        			Map responseContent = new HashMap();
						responseContent.put("resultState",false);
						responseContent.put("errorCode","-88888");
						responseContent.put("msg","请求异常：请求参数不合法或请求参数被篡改");
						retVal = responseContent;
	        		}else if(returnType.indexOf(RETURN_TYPE_VOID) >= 0){
	        			//void目前不作处理，如果扫描出问题，则在进行处理，把HttpServletResponse获得到，直接向页面输出以下字符串
//	        			Map responseContent = new HashMap();
//						responseContent.put("resultState",false);
//						responseContent.put("errorCode","-88888");
//						responseContent.put("msg","请求异常：请求参数不合法或请求参数被篡改");
//						retVal = responseContent;
	        		}
	        	}
	        }
	         
	        return retVal;  
	    }  
	    
	    
	    public static boolean checkTextStringValue(String str,String[] list){
			boolean flag = true;
			if(str!=null&&!"".equals(str)){
				for(int i=0;i<list.length;i++){
					if(str.indexOf(list[i])>-1){
						flag = false;
						break;
					}
				}
			}
			return flag;
		}
	    
	    
	    
	    /**
		 * 类型判断
		 * @param map
		 * @return
		 */
	    public boolean typeJudge(Map<String, Object> map,String[] list,String method) {
	    	boolean flag = false;
	    	for (String key : map.keySet()) {
    			try{
	    			if(map.get(key) instanceof Integer){
	    				continue;
	        		}else if(map.get(key) instanceof Long){
	        			continue;
	        		}else if(map.get(key) instanceof String){
	        			flag = FilterUtils.checkTextStringValue(map.get(key).toString().toUpperCase(),list);
	        			if(flag){
	        				logger.info(method + "|参数名为："+key+" 的值为："+map.get(key).toString()+" 中包含特殊字符。");
	        				break;
	        			}
	            	}else if(map.get(key) instanceof Date){
	            		continue;
	            	}else if(map.get(key) instanceof BigDecimal){
	            		continue;
	            	}else if(map.get(key) instanceof List){//类型为list
	            		continue;
	                }else if(map.get(key) instanceof Map){//类型为map
	            		try{
	            			if(map.get(key) != null && !"".equals ( map.get(key) )){
	            				flag = typeJudge((Map<String,Object>)map.get(key),list,method);
	            				if(flag){
	            					logger.info(method + "|参数名为："+key+" 的值为："+map.get(key).toString()+" 中包含特殊字符。");
	    	        				break;
	    	        			}
	            			}
	            		}catch (Exception e) {
	            			logger.error ( "\n=========异常信息为：==========\n{}",e.fillInStackTrace ( ).toString ( ) );
						}
	            	}
    			}catch(Exception e){
    				logger.error ( "\n=========异常信息为：==========\n{}",e.fillInStackTrace ( ).toString ( ) );
    			}
    		}
	    	return flag;
	    }
	    
	    private String getRequestStr(ProceedingJoinPoint pjp){
	    	String requestStr = "";
    		if(pjp.getArgs() != null && pjp.getArgs().length > 0){
		        for (int i = 0; i < pjp.getArgs().length; i++) {
		        	if(pjp.getArgs()[i] instanceof LinkedHashMap){
		        		Map<String,Object> map = (Map<String,Object>)pjp.getArgs()[i];
		        		requestStr += "Map参数值为：" + JsonUtils.objToJson(map) + "|";
		        	}else if(pjp.getArgs()[i] instanceof HttpServletRequest){
		        		HttpServletRequest req = ((HttpServletRequest)pjp.getArgs()[i]);
		        		Enumeration enu = req.getParameterNames();  
		        		requestStr += "HttpServletRequest参数值为：" + JsonUtils.objToJson(enu) + "|";
		        	}else if(pjp.getArgs()[i] instanceof String){
		        		requestStr += "HttpServletRequest参数值为：" + pjp.getArgs()[i].toString() + "|";
		        	}
		        }
	        }
    		return requestStr;
	    }
}


SmuEdward
关注
  • 1
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
AOP中ProceedingJoinPoint获取目标方法，参数，注解
u013259361的博客
11-05 2万+
private void saveLog(ProceedingJoinPoint jp,long time)throws Throwable { //1.获取用户行为日志(ip,username,operation,method,params,time,createdTime) //获取类的字节码对象，通过字节码对象获取方法信息 Class<?> ...
Spring Mvc AOP通过注解方式拦截controller等实现日志管理
08-18
// 获取被拦截方法的简单名称 String methodName = joinPoint.getSignature().getName(); // 记录方法开始信息 logger.info("开始执行方法：" + methodName); // 调用被拦截的方法 Object result = ...
org.aspectj.lang.ProceedingJoinPoint获取返回类型、参数名称/值等
DN金猿的博客
07-13 6548
1、参数值 Object[] args = joinPoint.getArgs(); 2、参数名称 Signature signature = joinPoint.getSignature(); if (signature instanceof MethodSignature) { MethodSignature methodSignature = (MethodSignature) signature; String[] properties = methodSignature.
通过proceedingJoinPoint获取切入方法的参数名及参数值
weixin_43913362的博客
11-26 1万+
通过proceedingJoinPoint获取切入方法的参数名及参数值 函数封装如下： //获取参数名和参数值 public String getParam(ProceedingJoinPoint proceedingJoinPoint) { Map<String, Object> map = new HashMap<String, Object>(); Object[] values = proceedingJoinPoint.getArgs(); String[] names =
【springboot】org.aspectj.lang.ProceedingJoinPoint获取返回类型、参数名称/值等
新技术革命
02-25 5216
1、参数值 Object[] args = joinPoint.getArgs(); 2、参数名称 Signature signature = joinPoint.getSignature(); if (signature instanceof MethodSignature) { MethodSignature methodSignature = (MethodSignature) signature; String[] properties = methodSignature.getP
Spring MVC 获取请求参数
zengxianxue的博客
11-14 492
Spring MVC 获取请求参数
Spring boot拦截器实现IP黑名单的完整步骤
08-19
在上面的代码中，我们使用@Around注解来拦截请求，并且使用ProceedingJoinPoint参数来获取当前请求的信息。 获取请求主机IP地址 在拦截器实现中，我们需要获取请求主机IP地址以便检查是否在黑名单中。我们可以使用...
spring boot如何使用spring AOP实现拦截器
08-30
5. **ProceedingJoinPoint**：在`Interceptor`方法中，`pjp`是一个`ProceedingJoinPoint`实例，它提供了访问被拦截方法的信息，比如方法签名、参数等，并且允许我们在适当的时候调用`proceed()`方法来执行原方法。...
在自定义spring aop中使用el获取拦截方法的变量值。
04-26
标题中的“在自定义Spring AOP中使用EL获取拦截方法的变量值”指的是在Spring的面向切面编程（AOP）中，通过Expression Language（EL，表达式语言）来访问被拦截方法的局部变量值。这通常涉及到Spring的代理机制、...
Spring AOP访问目标方法的参数操作示例
08-25
我们可以使用`jp.getArgs()`方法来获取目标方法的参数，然后对其进行修改或其他操作。 在最后，我们可以看到，Around增强处理还可以修改目标方法的返回值。在我们的示例中，我们可以看到，如果返回值是Integer类型...
JAVA开发（AOP之ProceedingJoinPoint）
JAVA领域优质创作者，基于分片网络查询方法专利发明者。
01-12 6075
我们在开发过程中经常使用到自定义注解来实现在一些类或者方法执行过程中切面，统一实现某些业务操作。例如自定义注解
切面 Aspect ProceedingJoinPoint 获取当前类、方法等属性API
热门推荐
龙池小生
04-16 6万+
切面配置类，获取切面上的各种属性： 示例 @Aspect @Component public class ProceedingJoinPointDemo { @Pointcut("execution(public * com.demo.controller.*.*.*(..))") public void allControllerMethod() { } ...
Java反射-解析ProceedingJoinPoint的方法参数及参数值
luckyman98的博客
02-14 2955
import org.aspectj.lang.ProceedingJoinPoint; import org.aspectj.lang.reflect.CodeSignature; import java.util.HashMap; import java.util.Map; public class AspectjUtils { /** * 获取某个Method的参数名称...
SpringBoot在AOP中获取HttpServletRequest信息
Mr.Xie的博客
08-05 1万+
AOP中获取HttpServletRequest信息 //获取当前登录人信息 //Subject subject = SecurityUtils.getSubject(); //SysUser user = (SysUser)subject.getPrincipal(); //获取RequestAttributes ...
SpringAOP中的JointPoint和ProceedingJoinPoint使用总结
huluwa10526的博客
12-09 4553
一、Joint Point JointPoint是程序运行过程中可识别的点，这个点可以用来作为AOP切入点。JointPoint对象则包含了和切入相关的很多信息。比如切入点的对象，方法，属性等。我们可以通过反射的方式获取这些点的状态和信息，用于追踪tracing和记录logging应用信息。 二、Pointcut pointcut 是一种程序结构和规则，它用于选取join point并收集这些point的上下文信息。 pointcut通常包含了一系列的Joint Point，我们可以通过pointcut来同
ProceedingJoinPoint获取不到参数问题
Angus的博客
09-04 2745
ProceedingJoinPoint获取不到参数问题 这几天刚开始学Spring Boot 边看书，边跟着书打代码 学到AOP的时候，书中有这么一段代码 @Around("@within(org.springframework.stereotype.Controller)") public Object simpleAop(final ProceedingJoinPoint pjp) throws Throwable { try{ Object[] args
Spring AOP中获取request,response
ChlatZed的博客
06-08 7591
注意将其写在方法里HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();ServletWebRequest servletWebRequest=new ServletWebRequest(request); HttpServl
ProceedingJoinPoint获取get请求和post请求的参数
最新发布
02-02
- 也可以使用Spring的RequestBody注解来获取请求体中的参数，例如： ```java public void beforeAdvice(ProceedingJoinPoint joinPoint, @RequestBody MyRequestObject requestObject) { // 处理请求体中的参数....

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值