利用@RequestBody和@ResponseBody处理参数校验

最新推荐文章于 2024-04-23 18:52:22 发布
最新推荐文章于 2024-04-23 18:52:22 发布
阅读量1.1k 收藏 1
点赞数 1
分类专栏： spring 文章标签： java spring mvc
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/clapAlong/article/details/129709680
版权
是的，今天继续聊@RequestBody和@ResponseBody。

上次通过@RequestMapping注解了解到了RequestMappingHandlerMapping和RequestMappingHandlerAdaptor。
这两兄弟在处理请求的过程中，RequestMappingHandlerMapping帮忙做了url与方法的具体映射，RequestMappingHandlerAdaptor帮忙做了查找具体的处理程序和查找具体的将返回值处理为一个ModelAndView实例的程序。
今天主要来聊他们两兄弟的其他功能。

写一个简单的接口，用@RequestBody修饰方法参数，然后打断点看调用链。

还是在上篇文章中关注的这一行，现在需要关注的是变量ha，发现他的类型是RequestMappingHandlerAdapter。
在这里插入图片描述
发现这个处理器也是通过mappedHandler确定的。
现在看一下具体逻辑。
在这里插入图片描述
其中的handlerAdapters，则是在Spring容器初始化的过程中填充的。
在这里插入图片描述
以上是RequestMappingHandlerAdapter的加载过程，现在找它的应用代码。
在这里插入图片描述
在invokeHandlerMethod中，会设置两个参数，argumentResolvers和returnValueHandlers，如同变量名，一个负责解析参数，一个负责处理返回值。
解析参数的过程中，第一次进入的请求将会进入if代码块，其余请求将直接从缓存获取参数解析器。

这里的解析器，在现在的程序中，就是指将请求参数反序列化为对象的请求参数处理程序和将对象序列化为流的返回参数处理程序。

在这里插入图片描述

这里可以看到，Spring自带了27种解析器，而@RequestBody和@ResponseBody的解析器就是图中标出的RequestResponseBodyMethodProcessor。
在这里插入图片描述

在图中可以看到，判断的依据就是是否使用@RequestBody和@ResponseBody修饰过。
在这里插入图片描述
在程序启动后的第一个@RequestBody的请求进入时，将缓存处理程序。
如图所示，下一次进入时就不需要轮训程序列表了，可以直接从Map中读取，效率有保障。
在这里插入图片描述
resolveArgument方法是处理参数的方法，如图所示，这是一个反序列化的方法，将流转换为对象。
在这里插入图片描述
转换完成后，将进入我们程序中的@Controller类，然后再经过RequestResponseBodyMethodProcessor的handleReturnValue方法将对象序列化为流，返回给浏览器。

以上是@RequestBody和@ResponseBody的处理流程。那么我们写的程序可以利用这一点做什么呢？

在RequestResponseBodyMethodProcessor的父类AbstractMessageConverterMethodArgumentResolver中，Spring贴心的保留了一个供开发者利用的窗口。
在这里插入图片描述
通过使用@RestControllerAdvice注解可以在请求参数的进出处改写它，这种操作在处理大量参数的校验时挺好用。
以下代码是个人在处理大量参数的合法校验时使用的处理程序，如果有帮助就点个赞吧

@RestControllerAdvice
@Slf4j
public class RequestResponseBodyAdvice implements RequestBodyAdvice, ResponseBodyAdvice<Object> {
    @Override
    public boolean supports(MethodParameter methodParameter, Type targetType, Class<? extends HttpMessageConverter<?>> converterType) {
        return methodParameter.hasParameterAnnotation(RequestBody.class);
    }

    @Override
    public HttpInputMessage beforeBodyRead(HttpInputMessage inputMessage, MethodParameter parameter, Type targetType, Class<? extends HttpMessageConverter<?>> converterType) {
        return inputMessage;
    }

    @Override
    public Object afterBodyRead(Object body, HttpInputMessage inputMessage, MethodParameter parameter, Type targetType, Class<? extends HttpMessageConverter<?>> converterType) {
        try {
            return handlerRequestBody(body);
        } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException | InstantiationException e) {
            log.error("afterBodyRead", e);
        }
        return body;
    }

    @Override
    public Object handleEmptyBody(Object body, HttpInputMessage inputMessage, MethodParameter parameter, Type targetType, Class<? extends HttpMessageConverter<?>> converterType) {
        return body;
    }


    @Override
    public boolean supports(MethodParameter returnType, Class converterType) {
        return returnType.hasMethodAnnotation(ApiOperation.class);
    }

    @Override
    public Object beforeBodyWrite(Object body, MethodParameter returnType, MediaType selectedContentType, Class selectedConverterType, ServerHttpRequest request, ServerHttpResponse response) {
        try {
            return handlerResponseBody(body);
        } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException | InstantiationException e) {
            log.error("beforeBodyWrite", e);
        }
        return body;
    }

    private Object handlerRequestBody(Object argument) throws IllegalAccessException, NoSuchMethodException, InvocationTargetException, InstantiationException {
        // 新增
        Class<?> argumentClass = argument.getClass();
        Field[] fields = argumentClass.getDeclaredFields();
        handlerRequestDefaultValue(fields, argument, argumentClass);
        Class<?> superclass = argumentClass.getSuperclass();
        while (null != superclass) {
            Field[] superFields = superclass.getDeclaredFields();
            handlerRequestDefaultValue(superFields, argument, superclass);
            superclass = superclass.getSuperclass();
        }
        return argument;
    }

    private void handlerRequestDefaultValue(Field[] fields, Object argument, Class<?> argClass) throws InvocationTargetException, IllegalAccessException, NoSuchMethodException, InstantiationException {

        for (Field field : fields) {
            field.setAccessible(true);
            if (null != field.getAnnotation(ApiModelProperty.class)) {
                String fieldName = toUpperFirstOne(field.getName());
                Method getMethod = argClass.getDeclaredMethod("get" + fieldName);
                getMethod.setAccessible(true);
                Object o = getMethod.invoke(argument);
                Class<?> type = field.getType();
                if (null == o) {
                    String value = field.getAnnotation(ApiModelProperty.class).defaultValue();
                    String[] dict = field.getAnnotation(ApiModelProperty.class).dict();
                    boolean isEnums = dict.length > 1;
                    boolean isContains = Arrays.asList(dict).contains(value);
                    Method setMethod = argClass.getDeclaredMethod("set" + fieldName, type);
                    setMethod.setAccessible(true);
                    if (type.equals(String.class)) {
                        if (isEnums && isContains) {
                            setMethod.invoke(argument, value);
                        }else if(isEnums && StringUtils.hasText(value)){
                            setMethod.invoke(argument, dict[0].split(":")[0]);
                        }else
                        if (StringUtils.hasText(value)) {
                            setMethod.invoke(argument, value);
                        }
                    } else if (type.equals(Integer.class)) {
                        /*if (isEnums && isContains) {
                            setMethod.invoke(argument, Integer.valueOf(value));
                        }else if(isEnums && StringUtils.isNotBlank(value)){
                            setMethod.invoke(argument, Integer.valueOf(dict[0].split(":")[0]));
                        }else*/
                        if (StringUtils.hasText(value)) {
                            setMethod.invoke(argument, Integer.valueOf(value));
                        }
                    } else if (type.equals(Boolean.class)) {
                        /*if (isEnums && isContains) {
                            setMethod.invoke(argument, "1".equals(value));
                        }else if(isEnums && StringUtils.isNotBlank(value)){
                            setMethod.invoke(argument, "1".equals(dict[0].split(":")[0]));
                        }else*/
                        if (StringUtils.hasText(value)) {
                            setMethod.invoke(argument, "1".equals(value));
                        }
                    }
                }
            }
        }
    }

    private Object handlerResponseBody(Object argument) throws IllegalAccessException, NoSuchMethodException, InvocationTargetException, InstantiationException {
        // 新增
        Class<?> argumentClass = argument.getClass();
        Field[] fields = argumentClass.getDeclaredFields();
        handlerResponseDefaultValue(fields, argument, argumentClass);
        Class<?> superclass = argumentClass.getSuperclass();
        while (null != superclass) {
            Field[] superFields = superclass.getDeclaredFields();
            handlerResponseDefaultValue(superFields, argument, superclass);
            superclass = superclass.getSuperclass();
        }
        return argument;
    }

    private void handlerResponseDefaultValue(Field[] fields, Object argument, Class<?> argClass) throws InvocationTargetException, IllegalAccessException, NoSuchMethodException, InstantiationException {

        for (Field field : fields) {
            field.setAccessible(true);
            if (null != field.getAnnotation(ApiModelProperty.class)) {
                String fieldName = toUpperFirstOne(field.getName());
                Method getMethod = argClass.getDeclaredMethod("get" + fieldName);
                getMethod.setAccessible(true);
                Object o = getMethod.invoke(argument);
                Class<?> type = field.getType();
                if (null == o) {
                    String value = field.getAnnotation(ApiModelProperty.class).defaultValue();
                    Method setMethod = argClass.getDeclaredMethod("set" + fieldName, type);
                    setMethod.setAccessible(true);
                    if (type.equals(String.class) && StringUtils.hasText(value)) {
                        setMethod.invoke(argument, value);
                    } else if (type.equals(Integer.class) && StringUtils.hasText(value)) {
                        if (StringUtils.hasText(value)) {
                            setMethod.invoke(argument, Integer.valueOf(value));
                        }
                    } else if (type.equals(Boolean.class) && StringUtils.hasText(value)) {
                        setMethod.invoke(argument, "1".equals(value));
                    } else if (type.equals(List.class)) {
//                        Type genericType = field.getGenericType();
//                        if (genericType instanceof ParameterizedType) {
//                            ParameterizedType pt = (ParameterizedType) genericType;
//                            Class<?> genericClazz = (Class<?>) pt.getActualTypeArguments()[0];
//                            if (isPrimitive(genericClazz)) {
//                                setMethod.invoke(argument, new ArrayList<>());
//                                continue;
//                            }
//                            Object o1 = genericClazz.newInstance();
//                            Field[] argufields = genericClazz.getDeclaredFields();
//                            handlerResponseDefaultValue(argufields, o1, genericClazz);
//                            setMethod.invoke(argument, Collections.singletonList(o1));
//                        } else {
                        setMethod.invoke(argument, new ArrayList<>());
//                        }
                    } else if (!isPrimitive(type)) {
                        Field[] argufields = type.getDeclaredFields();
                        Object o1 = type.newInstance();
                        handlerResponseDefaultValue(argufields, o1, type);
                        setMethod.invoke(argument, o1);
                        //setMethod.invoke(argument, new Object());
                    }
                }
            }
        }
    }

    private String toUpperFirstOne(String s) {
        if (Character.isUpperCase(s.charAt(0))) {
            return s;
        } else {
            return Character.toUpperCase(s.charAt(0)) +
                    s.substring(1);
        }
    }

    private boolean isPrimitive(Class<?> clazz) {
        return clazz.equals(Integer.class) ||
                clazz.equals(Byte.class) ||
                clazz.equals(Long.class) ||
                clazz.equals(Double.class) ||
                clazz.equals(Float.class) ||
                clazz.equals(Character.class) ||
                clazz.equals(Short.class) ||
                clazz.equals(Boolean.class);
    }
}
等会儿咱吃啥
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spring MVC参数校验详解（关于`@RequestBody`返回`400`）
08-29
主要介绍了Spring MVC参数校验的相关资料，主要是针对`@RequestBody`返回`400`的问题，文中通过示例代码介绍的非常详细，对大家具有一定的参考学习价值，需要的朋友们下面跟着小编来一起学习学习吧。
Spring MVC打印@RequestBody、@Response日志的方法
08-26
主要介绍了Spring MVC打印@RequestBody、@Response日志的方法，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
swagger界面 @RequestBody 参数类错误，变成了其他参数类
你当像鸟飞往你的山~~
03-18 2672
遇到一个问题：swagger界面 @RequestBody 参数类错误，变成了其他参数类，不是相应的类，看类写的没错，属性都没错，检查半天 结果原因是：有两个类的注解值一样的，这种问题一般是复制问题，或多人开发写的问题 两个注解值写的一样，导致一直是前者的属性字段， ...
@ResponseBody 注解 的详解
代妈炼金术师
02-07 648
的方法时，Spring MVC会调用MessageConverter对象（如MappingJackson2HttpMessageConverter、StringHttpMessageConverter等）来将方法返回的对象转换成适合HTTP响应的数据格式。是Spring MVC框架中的一个注解，它用于方法级别或控制器类级别。当我们在处理HTTP请求的方法上使用此注解时，意味着该方法的返回值将直接写入HTTP响应体中，并转换为对应的响应内容类型（如JSON、XML、纯文本等）。
【Spring】MVC：HandlerAdapter 适配与执行的过程
菜鸡也有大佬梦
02-23 482
前言 三个核心接口 HttpMessageConverter SpringMVC处理请求和响应时，支持多种类型的请求参数和返回类型，而此种功能的实现就需要对HTTP消息体和参数及返回值进行转换，为此SpringMVC提供了大量的转换类，所有转换类都实现了HttpMessageConverter接口。 HttpMessageConverter接口定义了5个方法，用于将HTTP请求报文转换为java对象，以及将java对象转换为HTTP响应报文。对应到SpringMVC的Controller方法，read方法
@ResponseBody注解作用与原理
qq_62042780的博客
10-29 7642
@ResponseBody注解的作用
@RequestBody 接收参数接收不到的原因
tianyuConqueror的博客
08-08 1万+
因为之前的知识有些遗忘，所以犯了一个大错。 @RequestBody 用来接收json对应的对象里的字段有大写，所以接收不到，谨记
@ResponseBody用法详解
weixin_47609799的博客
05-18 3万+
概念性理解 @ResponseBody 注解的作用是将Controller的方法返回的对象，通过适当的转换器转换为指定的格式之后，写入到response对象的body区，通常用来返回JSON数据或者是XML数据。 本质 @ResponseBody的作用其实是将java对象转为json格式的数据，然后直接写入HTTP response 的body中；一般在异步获取数据时使用 注意 在使用此注解之后不会再走视图处理器，而是直接将数据写入到输入流中，他的效果等同于通过response对象输出指定格式的数据。 @
@ResponseBody注解的作用
Evan's Blog ٩(๑❛ᴗ❛๑)۶
11-20 4万+
  1、 　　@ResponseBody注解的作用是将controller的方法返回的对象 通过适当的转换器 转换为指定的格式之后，写入到response对象的body区（响应体中），通常用来返回JSON数据或者是XML。 　　数据，需要注意的呢，在使用此注解之后不会再走视图处理器，而是直接将数据写入到输入流中，它的效果等同于通过response对象输出指定格式的数据。        这里...
@ResponseBody详解
热门推荐
originations的博客
04-24 45万+
@ResponseBody的作用其实是将java对象转为json格式的数据。 @responseBody注解的作用是将controller的方法返回的对象通过适当的转换器转换为指定的格式之后，写入到response对象的body区，通常用来返回JSON数据或者是XML数据。 注意：在使用此注解之后不会再走视图处理器，而是直接将数据写入到输入流中，他的效果等同于通过response对象输出指定格式...
@ResponseBody注解使用简介
weixin_43708793的博客
05-19 5624
1、@ResponseBody注解简介： @ResponseBody注解： 主要做两件事：1、将返回值转换成JSON，如果返回值是String或者其他基本数据类型则不满足key-value形式，不能转换成json类型，则返回字符串 2、设置响应头为application/json;charset=utf-8；返回值为字符串，则不能转换成json格式的则响应头设置为text/html， 为防止中文乱码，因此需要使用@RequestMapping(,produces = “text/html;ch
@ResponseBody详解：用于响应体响应数据
那仰望的人，心底的孤独和叹息
12-01 1275
@ResponseBody 响应体响应数据。RestFul风格或者是web阶段接触过的异步请求，都需要把数据转换成Json放入响应体中。可以加在类上和方法上，加在类上可以写成，其的作用等同于；使得该类中的所有方法的返回类型都转为。@ResponseBody可以加在类上和方法上，加在类上可以写成@RestController，其的作用等同于@Controller + @ResponseBody；使得该类中的所有方法的返回类型都转为json。很多时候都会创建一个公共返回对象，包含状态码，消息，数据。在后端处理请
@ResponseBody 和 @RequestBody 注解的区别
08-31
主要介绍了@ResponseBody 和 @RequestBody 注解的区别的相关资料,需要的朋友可以参考下
springMvc注解之@ResponseBody和@RequestBody详解
08-30
本篇文章主要介绍了springMvc注解之@ResponseBody和@RequestBody详解，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
Spring 注解学习手札（七） 补遗——@ResponseBody，@RequestBody，@PathVariable
04-09
NULL 博文链接：https://snowolf.iteye.com/blog/1628861
mybatisPlus使用MetaObjectHandler对字段进行更新
最新发布
m0_56356631的博客
04-23 260
都是符合我们的预期的。
string模拟实现
m0_73969414的博客
04-23 1385
c++中string的模拟实现，面试必会知识点
实现自定义注解、实现自定义幂等性注解
qq_44721738的博客
04-23 515
添加 Spring AOP 依赖。创建自定义注解。创建一个新的 Java 注解类，通过@interface关键字来定义，并可以添加元注解以及属性。@Target(ElementType.METHOD) //表示作用于方法上@Retention(RetentionPolicy.RUNTIME) // 表示这个注解在运行时是可见的，这样 AOP 代理才能在运行时读取到这个注解编写 AOP 拦截（自定义注解）的逻辑代码。@Aspect@Component// 方法执行前的处理。
javaweb-SpringBoot基础
kussm_的博客
04-20 1287
Spring的官网(Spring的简介：Spring makes Java simple。Spring Boot 可以帮助我们非常快速的构建应用程序、简化开发、提高效率。创建一个子包controller。
在springboot用@Controller @ResponseBody@Autowired @PostMapping@Service@Mapper@Data实现用户登录案例
05-21
好的，下面是一个基于 Spring Boot 的用户登录案例： 1. 创建 User 实体类 ```java @Data public class User { private String username; private String password; } ``` 2. 创建 UserService 接口和实现类 ```java public interface UserService { User login(String username, String password); } @Service public class UserServiceImpl implements UserService { @Override public User login(String username, String password) { // 在这里校验用户名和密码是否正确，省略实现 return new User(username, password); } } ``` 3. 创建 UserController 控制器 ```java @Controller public class UserController { @Autowired private UserService userService; @PostMapping("/login") @ResponseBody public String login(@RequestBody User user) { User loginUser = userService.login(user.getUsername(), user.getPassword()); if (loginUser != null) { return "登录成功"; } else { return "用户名或密码错误"; } } } ``` 4. 配置 mybatis 和数据库信息 在 application.properties 文件中添加以下配置： ``` spring.datasource.driver-class-name=com.mysql.jdbc.Driver spring.datasource.url=jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=UTF-8&autoReconnect=true&failOverReadOnly=false&maxReconnects=10 spring.datasource.username=root spring.datasource.password=root mybatis.mapper-locations=classpath:mapper/*.xml ``` 5. 创建 UserMapper 接口和 XML 映射文件 ```java @Mapper public interface UserMapper { User selectByUsernameAndPassword(@Param("username") String username, @Param("password") String password); } ``` 在 mapper 文件夹下创建 UserMapper.xml 文件，编写 SQL 语句： ```xml <mapper namespace="com.example.demo.mapper.UserMapper"> <resultMap id="BaseResultMap" type="com.example.demo.entity.User"> <id column="username" property="username" /> <result column="password" property="password" /> </resultMap> <select id="selectByUsernameAndPassword" resultMap="BaseResultMap"> select * from user where username=#{username} and password=#{password} </select> </mapper> ``` 6. 编写测试代码 ```java @RunWith(SpringRunner.class) @SpringBootTest public class UserControllerTests { @Autowired private UserController userController; @Test public void testLogin() { User user = new User(); user.setUsername("admin"); user.setPassword("123456"); String result = userController.login(user); assertEquals("登录成功", result); } } ``` 以上就是一个基于 Spring Boot 的用户登录案例的实现过程，希望对你有所帮助。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值