SpringMVC对自定义controller入参预处理方式

package org.springframework.web.method.support;

import org.springframework.core.MethodParameter;

import org.springframework.web.bind.WebDataBinder;

import org.springframework.web.bind.support.WebDataBinderFactory;

import org.springframework.web.context.request.NativeWebRequest;

public interface HandlerMethodArgumentResolver {

     //用于判定是否需要处理该参数分解，返回true为需要，并会去调用下面的方法resolveArgument。

     boolean supportsParameter(MethodParameter parameter);

     //真正用于处理参数分解的方法，返回的Object就是controller方法上的形参对象。

     Object resolveArgument(MethodParameter parameter, ModelAndViewContainer mavContainer,

             NativeWebRequest webRequest, WebDataBinderFactory binderFactory) throws Exception;

}

package com.demo.controller;

import javax.servlet.http.HttpServletRequest;

import org.springframework.web.bind.annotation.RequestMapping;

import org.springframework.web.bind.annotation.RequestMethod;

import org.springframework.web.bind.annotation.RestController;

import com.demo.domain.Person;

import com.demo.mvc.annotation.MultiPerson;

import lombok.extern.slf4j.Slf4j;

@Slf4j

@Controller

@RequestMapping ( "demo1" )

public class HandlerMethodArgumentResolverDemoController {

     @ResponseBody

     @RequestMapping (method = RequestMethod.POST)

     public String addPerson(HttpServletRequest request) {

         String firstName = request.getParameter( "first_name" );

         String lastName = request.getParameter( "last_name" );

         Person person = new Person(firstName, lastName);

         log.info(person.toString());

         return person.toString();

     }

}

@RequestMapping (method = RequestMethod.POST)

public String addPerson(Person person) {

   log.info(person.toString());

   return person.toString();

}

package com.demo.mvc测试数据ponent;

import org.springframework.core.MethodParameter;

import org.springframework.web.bind.support.WebDataBinderFactory;

import org.springframework.web.context.request.NativeWebRequest;

import org.springframework.web.method.support.HandlerMethodArgumentResolver;

import org.springframework.web.method.support.ModelAndViewContainer;

import com.demo.domain.Person;

public class PersonArgumentResolver implements HandlerMethodArgumentResolver {

     @Override

     public boolean supportsParameter(MethodParameter parameter) {

         return parameter.getParameterType().equals(Person. class );

     }

     @Override

     public Object resolveArgument(MethodParameter parameter, ModelAndViewContainer mavContainer, NativeWebRequest webRequest, WebDataBinderFactory binderFactory) throws Exception {

         String firstName = webRequest.getParameter( "first_name" );

         String lastName = webRequest.getParameter( "last_name" );

         return new Person(firstName, lastName);

     }

}

< mvc:annotation-driven >

       < mvc:argument-resolvers >

         < bean class = "com.demo.mvc测试数据ponent.PersonArgumentResolver" />

       </ mvc:argument-resolvers >

</ mvc:annotation-driven >

< bean class = "org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter" >

     < property name = "customArgumentResolvers" >

           < bean class = "com.demo.mvc测试数据ponent.PersonArgumentResolver" />

     </ property >

</ bean >

public class WebConfig extends WebMvcConfigurerAdapter{

     @Override

     public void addArgumentResolvers(List<HandlerMethodArgumentResolver> argumentResolvers) {

         argumentResolvers.add( new CustomeArgumentResolver());

     }

}

// ----------------------------------------- Controller层

@RestController

@RequestMapping ( "/a" )

public class AController {

  @Resource (name = "aService" )

  private AService aService;

  @PostMapping (value = "/a" )

  public ResponseBean<String> a(HttpServletRequest request, HttpServletResponse response) {

   final String name = WebUtils.findParameterValue(request, "name" );

   return ResponseBean.of(aService.invoke(name));

  }

}

// ----------------------------------------- 前端访问路径

// {{rootPath}}/a/a.do

// 这里之所以是 /lq , 而不是 /* ; 是因为 AntPathMatcher测试数据bine 方法中进行合并时的处理, 导致 前一个 /* 丢失

/**

  * <p> 直接以前端传递来的Serivce名+方法名去调用Service层的同名方法; Controller层不再需要写任何代码

  * <p> 例子

  * <pre>

  *   前端: /lq/thirdService/queryTaskList.do

  *   Service层相应的方法签名:  Object queryTaskList(Map<String, Object> parameterMap)

  *   相应的Service注册到Spring容器中的id : thirdServiceService

  * </pre>

  * @author LQ

  *

  */

@RestController

@RequestMapping ( "/lq" )

public class CommonController {

  private static final Logger LOG = LoggerFactory.getLogger(ThirdServiceController. class );

  @PostMapping (value = "/{serviceName}/{serviceMethodName}" )

  public void common( @PathVariable String serviceName, @PathVariable final String serviceMethodName, HttpServletRequest request, HttpServletResponse response) {

   // 收集前台传递来的参数, 并作预处理

   final Map<String, String> parameterMap = HtmlUtils.getParameterMap(request);

   final Map<String, Object> paramsCopy = preDealOutParam(parameterMap);

   // 获取本次的调度服务名和相应的方法名

   //final List<String> serviceAndMethod = parseServiceAndMethod(request);

   //final String serviceName = serviceAndMethod.get(0) + "Service";

   //final String serivceMethodName = serviceAndMethod.get(1);

   // 直接使用Spring3.x新加入的@PathVariable注解; 代替上面的自定义操作

   serviceName = serviceName + "Service" ;

   final String fullServiceMethodName = StringUtil.format( "{}.{}" , serviceName, serivceMethodName);

   // 输出日志, 方便回溯

   LOG.debug( "### current request method is [ {} ] ,  parameters is [ {} ]" , fullServiceMethodName, parameterMap);

   // 获取Spring中注册的Service Bean

   final Object serviceBean = SpringBeanFactory.getBean(serviceName);

   Object rv;

   try {

    // 调用Service层的方法

    rv = ReflectUtil.invoke(serviceBean, serivceMethodName, paramsCopy);

    // 若用户返回一个主动构建的FriendlyException

    if (rv instanceof FriendlyException) {

     rv = handlerException(fullServiceMethodName, (FriendlyException) rv);

    } else {

     rv = returnVal(rv);

    }

   } catch (Exception e) {

    rv = handlerException(fullServiceMethodName, e);

   }

   LOG.debug( "### current request method [ {} ] has dealed,  rv is [ {} ]" , fullServiceMethodName, rv);

   HtmlUtils.writerJson(response, rv);

  }

  /**

   * 解析出Service和相应的方法名

   * @param request

   * @return

   */

  private List<String> parseServiceAndMethod(HttpServletRequest request) {

   // /lq/thirdService/queryTaskList.do 解析出 [ thirdService, queryTaskList ]

   final String serviceAndMethod = StringUtil.subBefore(request.getServletPath(), "." , false );

   List<String> split = StringUtil.split(serviceAndMethod, '/' , true , true );

   return split.subList( 1 , split.size());

  }

  // 将传递来的JSON字符串转换为相应的Map, List等

  private Map<String, Object> preDealOutParam( final Map<String, String> parameterMap) {

   final Map<String, Object> outParams = new HashMap<String, Object>(parameterMap.size());

   for (Map.Entry<String, String> entry : parameterMap.entrySet()) {

    outParams.put(entry.getKey(), entry.getValue());

   }

   for (Map.Entry<String, Object> entry : outParams.entrySet()) {

    final String value = (String) entry.getValue();

    if (StringUtil.isEmpty(value)) {

     entry.setValue( "" );

     continue ;

    }

    Object parsedObj = JSONUtil.tryParse(value);

    // 不是JSON字符串格式

    if ( null == parsedObj) {

     continue ;

    }

    entry.setValue(parsedObj);

   }

   return outParams;

  }

  // 构建成功执行后的返回值

  private Object returnVal(Object data) {

   return MapUtil.newMapBuilder().put( "data" , data).put( "status" , 200 ).put( "msg" , "success" ).build();

  }

  // 构建执行失败后的返回值

  private Object handlerException(String distributeMethod, Throwable e) {

   final String logInfo = StringUtil.format( "[ {} ] fail" , distributeMethod);

   LOG.error(logInfo, ExceptionUtil.getRootCause(e));

   return MapUtil.newMapBuilder().put( "data" , "" ).put( "status" , 500 )

     .put( "msg" , ExceptionUtil.getRootCause(e).getMessage()).build();

  }

}