Spring之RequestBodyAdvice和ResponseBodyAdvice使用场景和原理

已于 2022-06-02 11:50:58 修改
阅读量2.9k 收藏 36
点赞数 4
分类专栏： java 文章标签： spring
于 2022-06-01 12:08:47 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_30976013/article/details/125081196
版权

背景：

在实际项目中，我们常常需要在Controller请求前后进行一些操作，比如：参数解密/返回结果加密，打印请求参数和返回结果的日志等。

方式一：统一包装返回值

  1. 通常返回结果包含code、message、data，结构如下
  2. 缺点：每个Controller都要修改
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
@Data
@NoArgsConstructor
@AllArgsConstructor
public class ResponseResult<T> {
    private int code;
    private String message;
    private T data;
    public ResponseResult(T data) {
        this.data = data;
        this.code = 0;
        this.message = "success";
    }
}

方式二：使用RequestBodyAdvice和ResponseBodyAdvice对请求前后进行处理

基于ControllerAdvice和HttpMessageConverter实现

注解1：标记不加密处理ExcludeHttpBodyDecrypt

import java.lang.annotation.*;

/**
 * @author yin
 * @create 2022-6-1 14:52
 */
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface ExcludeHttpBodyDecrypt {

}

注解1：标记加密处理ExcludeHttpBodyDecrypt

import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * RequestBodyHandler
 *
 * @Author yin
 * @create 2022-6-1 14:52
 */
@Target({ElementType.METHOD, ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface HttpBodyDecrypt {
}

测试Controller接口

@RestController
@RequestMapping("/UniversityManagement")
public class BsBuUniversityInfoController {
    @HttpBodyDecrypt
    @PostMapping(value = "/BsBuUniversityInfo/testNoLogin", name = "测试接口")
    public Object test(@RequestBody BsBuUniversityInfoModel model) {
        BsBuUniversityInfo buUniversityInfo = new BsBuUniversityInfo();
        buUniversityInfo.setUniversityCode("00000");
        return buUniversityInfo;
    }
}

通过RequestBodyAdvice，拦截Controller对request解密，签名验证处理

/**
 * @author yin
 * @create 2022-6-1 10:09
 */

import cn.gewut.business.common.Annotation.ExcludeHttpBodyDecrypt;
import cn.gewut.business.common.Annotation.HttpBodyDecrypt;
import cn.gewut.business.common.Util.AESUtils;
import org.springframework.core.MethodParameter;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpInputMessage;
import org.springframework.http.converter.HttpMessageConverter;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.servlet.mvc.method.annotation.RequestBodyAdvice;

import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.lang.reflect.Type;

@ControllerAdvice
public class RequestAdvisor implements RequestBodyAdvice {

    @Override
    public boolean supports(MethodParameter methodParameter, Type targetType, Class<? extends HttpMessageConverter<?>> converterType) {
        System.out.println("supports");
        //排除解密注解--包含@ExcludeHttpBodyDecrypt 返回false不执行
        boolean methodHasExcludeHttpBodyDecrypt = methodParameter.hasMethodAnnotation(ExcludeHttpBodyDecrypt.class);
        if (methodHasExcludeHttpBodyDecrypt) {
            return false;
        }
        //解密注解--包含@HttpBodyDecrypt 返回true 需要执行
        boolean methodHasHttpBodyDecrypt = methodParameter.hasMethodAnnotation(HttpBodyDecrypt.class);
        if (methodHasHttpBodyDecrypt) {
            return true;
        }
        //排除解密注解--声明类是否包含@ExcludeHttpBodyDecrypt 返回false不执行
        boolean classHasExcludeHttpBodyDecrypt = methodParameter.getDeclaringClass().getAnnotation(ExcludeHttpBodyDecrypt.class) != null;
        if (classHasExcludeHttpBodyDecrypt) {
            return false;
        }
        boolean classHasHttpBodyDecrypt = methodParameter.getDeclaringClass().getAnnotation(HttpBodyDecrypt.class) != null;
        if (classHasHttpBodyDecrypt) {
            return true;
        }
        return false;
    }

    @Override
    public HttpInputMessage beforeBodyRead(HttpInputMessage inputMessage, MethodParameter parameter, Type targetType, Class<? extends HttpMessageConverter<?>> converterType) throws IOException {
        System.out.println("beforeBodyRead");

        if (inputMessage.getBody().available() <= 0) {
            return inputMessage;
        }
        byte[] requestDataByte = new byte[inputMessage.getBody().available()];
        inputMessage.getBody().read(requestDataByte);
        byte[] requestDataByteNew = null;
        try {
            // 解密
            requestDataByteNew  = AESUtils.decryptHandler(requestDataByte);
        } catch (Exception e) {
            e.printStackTrace();
        }
        // 使用解密后的数据，构造新的读取流
        InputStream rawInputStream = new ByteArrayInputStream(requestDataByteNew);
        return new HttpInputMessage() {
            @Override
            public HttpHeaders getHeaders() {
                return inputMessage.getHeaders();
            }

            @Override
            public InputStream getBody() throws IOException {
                return rawInputStream;
            }
        };
    }

    @Override
    public Object afterBodyRead(Object body, HttpInputMessage inputMessage, MethodParameter parameter, Type targetType, Class<? extends HttpMessageConverter<?>> converterType) {
        System.out.println("afterBodyRead");
        return body;
    }

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

}

通过ResponseBodyAdvice，拦截Controller对Response封装，统一返回对象

/**
 * @author yin
 * @create 2022-6-1 10:09
 */

import cn.gewut.business.common.Util.ResponseResult;
import org.springframework.core.MethodParameter;
import org.springframework.http.MediaType;
import org.springframework.http.converter.HttpMessageConverter;
import org.springframework.http.server.ServerHttpRequest;
import org.springframework.http.server.ServerHttpResponse;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.servlet.mvc.method.annotation.ResponseBodyAdvice;

@ControllerAdvice
public class ResponseAdvisor implements ResponseBodyAdvice<Object> {
    @Override
    public boolean supports(MethodParameter methodParameter, Class<? extends HttpMessageConverter<?>> aClass) {
        return true;
    }

    @Override
    public Object beforeBodyWrite(Object o, MethodParameter methodParameter, MediaType mediaType,
                                  Class<? extends HttpMessageConverter<?>> aClass, ServerHttpRequest serverHttpRequest,
                                  ServerHttpResponse serverHttpResponse) {
        System.out.println(methodParameter.toString());

        return o;
//        if (o instanceof ResponseResult) {
//            return o;
//        }
//        return new ResponseResult<>(o);
    }
}

用到的 AES加密，签名工具类

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;

import javax.crypto.Cipher;
import javax.crypto.spec.SecretKeySpec;
import java.nio.charset.StandardCharsets;
import java.util.Base64;

/**
 * @author yin
 * @create 2022-6-1 10:09
 */

public class AESUtils {

    public static final String AESKey = "key1234567890key";

    public static final String signKey = "123456";

    // 加密
    public static String Encrypt(String sSrc, String sKey) throws Exception {
        if (sKey == null) {
            System.out.print("Key为空null");
            return null;
        }
        // 判断Key是否为16位
        if (sKey.length() != 16) {
            System.out.print("Key长度不是16位");
            return null;
        }
        byte[] raw = sKey.getBytes("utf-8");
        SecretKeySpec skeySpec = new SecretKeySpec(raw, "AES");
        Cipher cipher = Cipher.getInstance("AES/ECB/PKCS5Padding");//"算法/模式/补码方式"
        cipher.init(Cipher.ENCRYPT_MODE, skeySpec);
        byte[] encrypted = cipher.doFinal(sSrc.getBytes("utf-8"));
        return Base64.getEncoder().encodeToString(encrypted);//此处使用BASE64做转码功能，同时能起到2次加密的作用。
    }

    // 解密
    public static String Decrypt(String sSrc, String sKey) throws Exception {
        try {
            // 判断Key是否正确
            if (sKey == null) {
                System.out.print("Key为空null");
                return null;
            }
            // 判断Key是否为16位
            if (sKey.length() != 16) {
                System.out.print("Key长度不是16位");
                return null;
            }
            byte[] raw = sKey.getBytes("utf-8");
            SecretKeySpec skeySpec = new SecretKeySpec(raw, "AES");
            Cipher cipher = Cipher.getInstance("AES/ECB/PKCS5Padding");
            cipher.init(Cipher.DECRYPT_MODE, skeySpec);
            byte[] encrypted1 = Base64.getDecoder().decode(sSrc);//先用base64解密
            try {
                byte[] original = cipher.doFinal(encrypted1);
                String originalString = new String(original, "utf-8");
                return originalString;
            } catch (Exception e) {
                System.out.println(e.toString());
                return null;
            }
        } catch (Exception ex) {
            System.out.println(ex.toString());
            return null;
        }
    }

    /**
     * AES解密 加MD5签名验证。
     *
     * @param requestBytes
     * @return
     */
    public static byte[] decryptHandler(byte[] requestBytes) throws Exception {
        if (requestBytes.length <= 0) {
            return new byte[0];
        }
        String requestData = new String(requestBytes, StandardCharsets.UTF_8);
        JSONObject jsonobj = JSON.parseObject(requestData);

        System.out.println("收到的加密数据：" + jsonobj);
        String encrypt = jsonobj.get("encrypt") == null ? "" : jsonobj.get("encrypt").toString();
        String decrypt = "";
        if (encrypt.length() > 0) {
            //解密参数
            decrypt = AESUtils.Decrypt(encrypt, AESKey);
            if (decrypt == null) {
                //解密失败，返回异常
                throw new IllegalArgumentException("解密失败");
            }
        }
        System.out.println("解密后的数据：" + decrypt);
        //获取并验证签名。
        String sign = jsonobj.get("sign") == null ? "" : jsonobj.get("sign").toString();
        String md5Data = Md5Utils.md5Digest(decrypt + signKey);
        if (!sign.equals(md5Data)) {
            //验签失败
            throw new IllegalArgumentException("验证签名失败");
        }
        //验证通过，返回解密后的参数
        return decrypt.getBytes(StandardCharsets.UTF_8);
    }


    /**
     * AES加密 加MD5签名验证。
     *
     * @param requestBytes
     * @return
     */
    public byte[] encryptHandler(byte[] requestBytes) throws Exception {
        if (requestBytes.length <= 0) {
            return new byte[0];
        }
        String requestData = new String(requestBytes, StandardCharsets.UTF_8);
        String encrypt = "";
        if (requestData.length() > 0) {
            //加密密文
            encrypt = AESUtils.Encrypt(requestData, AESKey);
            if (encrypt == null) {
                //加密失败，返回异常
                throw new IllegalArgumentException("加密失败");
            }
        }

        JSONObject jsonObj = new JSONObject();
        jsonObj.put("encrypt", encrypt);//加密数据
        jsonObj.put("sign", Md5Utils.md5Digest(requestData + signKey));//签名

        System.out.println("加密签名后数据：" + jsonObj);
        //验证通过，返回解密后的参数
        return jsonObj.toJSONString().getBytes(StandardCharsets.UTF_8);
    }

	//测试AES加密
    public static void main(String[] args) throws Exception {
        /*
         * 此处使用AES-128-ECB加密模式，key需要为16位。
         */
        String cKey = "key1234567890key";
        // 需要加密的字串
        String cSrc = "www.yin.com";
        System.out.println(cSrc);
        // 加密
        String enString = Encrypt(cSrc, cKey);
        System.out.println("加密后的字串是：" + enString);

        // 解密
        String DeString = Decrypt(enString, cKey);
        System.out.println("解密后的字串是：" + DeString);
        System.out.println("*******************************************");

        JSONObject jsonObject = new JSONObject();
        jsonObject.put("name", "小米");
        jsonObject.put("universityCode", "00000");
        System.out.println("发送的接口数据:" + jsonObject);


        AESUtils aesUtils = new AESUtils();
        //加密
        byte[] bytes = aesUtils.encryptHandler(jsonObject.toJSONString().getBytes());

        //解密
        byte[] bytes1 = aesUtils.decryptHandler(bytes);
    }
}

原理

RequestResponseBodyAdviceChain

1. 启动执行RequestResponseBodyAdviceChain()初始化

把RequestBodyAdvice，ResponseBodyAdvice实现类都加到RequestResponseBodyAdviceChain；

2. 每次请求执行beforeBodyRead(),

源码可以看出循环所有实现类，然后先执行advice.supports(parameter, targetType, converterType) 为true后，执行request = advice.beforeBodyRead(request, parameter, targetType, converterType);

3. 再执行afterBodyRead()

源码可以看出循环所有实现类，然后先执行advice.supports(parameter, targetType, converterType) 为true后，执行body = advice.afterBodyRead(body, inputMessage, parameter, targetType, converterType);

class RequestResponseBodyAdviceChain implements RequestBodyAdvice, ResponseBodyAdvice<Object> {

	private final List<Object> requestBodyAdvice = new ArrayList<>(4);

	private final List<Object> responseBodyAdvice = new ArrayList<>(4);


	/**
	 * Create an instance from a list of objects that are either of type
	 * {@code ControllerAdviceBean} or {@code RequestBodyAdvice}.
	 */
	public RequestResponseBodyAdviceChain(@Nullable List<Object> requestResponseBodyAdvice) {
		this.requestBodyAdvice.addAll(getAdviceByType(requestResponseBodyAdvice, RequestBodyAdvice.class));
		this.responseBodyAdvice.addAll(getAdviceByType(requestResponseBodyAdvice, ResponseBodyAdvice.class));
	}

	@SuppressWarnings("unchecked")
	static <T> List<T> getAdviceByType(@Nullable List<Object> requestResponseBodyAdvice, Class<T> adviceType) {
		if (requestResponseBodyAdvice != null) {
			List<T> result = new ArrayList<>();
			for (Object advice : requestResponseBodyAdvice) {
				Class<?> beanType = (advice instanceof ControllerAdviceBean ?
						((ControllerAdviceBean) advice).getBeanType() : advice.getClass());
				if (beanType != null && adviceType.isAssignableFrom(beanType)) {
					result.add((T) advice);
				}
			}
			return result;
		}
		return Collections.emptyList();
	}


	@Override
	public boolean supports(MethodParameter param, Type type, Class<? extends HttpMessageConverter<?>> converterType) {
		throw new UnsupportedOperationException("Not implemented");
	}

	@Override
	public boolean supports(MethodParameter returnType, Class<? extends HttpMessageConverter<?>> converterType) {
		throw new UnsupportedOperationException("Not implemented");
	}

	@Override
	public HttpInputMessage beforeBodyRead(HttpInputMessage request, MethodParameter parameter,
			Type targetType, Class<? extends HttpMessageConverter<?>> converterType) throws IOException {

		for (RequestBodyAdvice advice : getMatchingAdvice(parameter, RequestBodyAdvice.class)) {
			if (advice.supports(parameter, targetType, converterType)) {
				request = advice.beforeBodyRead(request, parameter, targetType, converterType);
			}
		}
		return request;
	}

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

		for (RequestBodyAdvice advice : getMatchingAdvice(parameter, RequestBodyAdvice.class)) {
			if (advice.supports(parameter, targetType, converterType)) {
				body = advice.afterBodyRead(body, inputMessage, parameter, targetType, converterType);
			}
		}
		return body;
	}

	@Override
	@Nullable
	public Object beforeBodyWrite(@Nullable Object body, MethodParameter returnType, MediaType contentType,
			Class<? extends HttpMessageConverter<?>> converterType,
			ServerHttpRequest request, ServerHttpResponse response) {

		return processBody(body, returnType, contentType, converterType, request, response);
	}

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

		for (RequestBodyAdvice advice : getMatchingAdvice(parameter, RequestBodyAdvice.class)) {
			if (advice.supports(parameter, targetType, converterType)) {
				body = advice.handleEmptyBody(body, inputMessage, parameter, targetType, converterType);
			}
		}
		return body;
	}


	@SuppressWarnings("unchecked")
	@Nullable
	private <T> Object processBody(@Nullable Object body, MethodParameter returnType, MediaType contentType,
			Class<? extends HttpMessageConverter<?>> converterType,
			ServerHttpRequest request, ServerHttpResponse response) {

		for (ResponseBodyAdvice<?> advice : getMatchingAdvice(returnType, ResponseBodyAdvice.class)) {
			if (advice.supports(returnType, converterType)) {
				body = ((ResponseBodyAdvice<T>) advice).beforeBodyWrite((T) body, returnType,
						contentType, converterType, request, response);
			}
		}
		return body;
	}

	@SuppressWarnings("unchecked")
	private <A> List<A> getMatchingAdvice(MethodParameter parameter, Class<? extends A> adviceType) {
		List<Object> availableAdvice = getAdvice(adviceType);
		if (CollectionUtils.isEmpty(availableAdvice)) {
			return Collections.emptyList();
		}
		List<A> result = new ArrayList<>(availableAdvice.size());
		for (Object advice : availableAdvice) {
			if (advice instanceof ControllerAdviceBean) {
				ControllerAdviceBean adviceBean = (ControllerAdviceBean) advice;
				if (!adviceBean.isApplicableToBeanType(parameter.getContainingClass())) {
					continue;
				}
				advice = adviceBean.resolveBean();
			}
			if (adviceType.isAssignableFrom(advice.getClass())) {
				result.add((A) advice);
			}
		}
		return result;
	}

	private List<Object> getAdvice(Class<?> adviceType) {
		if (RequestBodyAdvice.class == adviceType) {
			return this.requestBodyAdvice;
		}
		else if (ResponseBodyAdvice.class == adviceType) {
			return this.responseBodyAdvice;
		}
		else {
			throw new IllegalArgumentException("Unexpected adviceType: " + adviceType);
		}
	}

}
殷乾Lakers
关注
  • 4
    点赞
  • 踩
  • 36
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spring Cache的基本使用与实现原理详解
08-27
缓存是实际工作中非经常常使用的一种提高性能的方法, 我们会在很多场景下来...下面这篇文章主要给大家介绍了关于Spring Cache的基本使用与实现原理的相关资料，文中通过示例代码介绍的非常详细，需要的朋友可以参考下
Hibernate、Spring和Struts工作原理及使用理由
06-03
【标题】：“Hibernate、Spring和Struts工作原理及使用理由” 【内容】： Hibernate是一个流行的Java持久化框架，它的核心工作原理主要包括以下步骤： 1. **读取并解析配置文件**：Hibernate通过读取hibernate....
Spring boot ResponseBodyAdvice接口全局统一返回控制，Api返回值是String 类型时异常
Crystalqy的博客
03-01 3487
在大部分前后端分离项目中，后端的返回值基本都需要包装成一个GlobalResponse，其中属性有code、message、data等，来供前端使用。这样就导致大部分Api写完后都需要手动构建一个GlobalResponse对象并填充属性返回，也就造成了大量的重复代码。这类代码其实有很方便的处理方式，就是使用spring提供的responseBodyAdvice接口
统一异常处理导致ResponseBodyAdvice失效
AE86的博客
07-26 4461
微服务架构下准备将一些基础功能抽出到公共Jar包中，包括统一异常处理、JwtToken校验、统一请求响应处理等，抽完以后发现，当出现异常时，走了统一异常捕获的逻辑，但是项目中的所有自定义的ResponseBodyAdvice都没有执行，决定一步步DEBUG定位下原因，项目是Springboot 2.3.7.RELEASE版本。...
微服务巧用Aop，使用RequestBodyAdvice对请求参数加密，项目全局增强Api接口安全性
最新发布
大猩猩的专栏
05-16 555
假如有特殊的请求，我们可以进行方法变通。在我们日常开发中，通常不会考虑到Api的安全性，但是在运维部署时，如果是小公司，大可能的配置ssl文件是免费的，安全性并不是很高，市场上有很多的工具可以简单的进行破解，HttpInputMessage 它代表了一个 HTTP 输入消息，通常用于读取 HTTP 请求的正文，这个接口提供了对 HTTP 请求头和请求体的访问。如果不管不问，我们的Api接口就像在互联网上裸奔一样，专业破解方就像看我们的API没穿裤衩子一样，随意的更改我们的请求与回放。
【Java】SpringMVC ResponseBodyAdvice详解
weixin_45734473的博客
09-27 1630
【Java】SpringMVC ResponseBodyAdvice详解
RequestBodyAdvice和ResponseBodyAdvice
多看多听多总结
11-07 1369
1、类层次结构
Spring解密之RequestBodyAdvice、ResponseBodyAdvice、HttpMessageConverter
lw_yang的博客
10-18 1421
Author： lwyang SpringBoot：2.1.9.RELEASE 概述 RequestBodyAdvice Allows customizing the request before its body is read and converted into an Object and also allows for processing of the resulting Objec...
springMVC之RequestBodyAdvice和ResponseBodyAdvice
原之殇
11-28 787
首先，关于这两个类怎么用，我看了一篇博客觉得还不错，Springboot中RequestBody-Advice与ResponseBodyAdvice的正确使用。这里我主要是想探究一下它们是如何工作的。 作用范围 RequestBodyAdvice 当使用HttpEntity作为请求参数或者使用@RequestBody / @RequestPart注解时，它允许你在请求消息体读取并将其转换成对象的前后作出处理。 ResponseBodyAdvice 当使用ResponseEntity作为响应参数或者使用
Springaop原理及各种应用场景
01-27
AOP是...实现的关键就在于AOP框架自动创建的AOP代理，AOP代理则可分为静态代理和动态代理两大类，其中静态代理是指使用 AOP框架提供的命令进行编译，从而在编译阶段就可生成AOP代理类，因此也称为编译
springboot基本使用和内部原理
03-22
springboot基本使用和内部原理，看后大部分原理都能知道是怎么回事
Spring事务处理流程和原理详解
08-25
主要介绍了Spring事务处理流程和原理详解,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
使用 @ControllerAdvice 和 实现ResponseBodyAdvice接口， 拦截Controller方法默认返回参数，统一处理返回值/响应体
凌焰
11-04 731
ControllerResponseAdvice实现ResponseBodyAdvice接口。在supports方法中处理，凡是有注解的都跳过封装，不进入beforeBodyWrite方法。对于不想封装的返回如何处理？
RequestBodyAdvice和ResponseBodyAdvice原理详解
ZhangASen的博客
04-11 989
RequestResponseBodyAdviceChain的afterBodyRead方法：调用getMatchingAdvice方法，获取RequestBodyAdvice类型的advice其中：class RequestResponseBodyAdviceChain implements RequestBodyAdvice, ResponseBodyAdvice。HandlerAdapter字面上的意思就是处理适配器，它的作用用一句话概括就是调用具体的方法对用户发来的请求来进行处理。
RequestBodyAdvice和ResponseBodyAdvice优化请求、响应格式
m0_60742341的博客
10-12 225
RequestBodyAdvice和ResponseBodyAdvice优化请求、响应格式
关于Spring中ResponseBodyAdvice的使用
ABestRookie的博客
10-27 2582
关于Spring中ResponseBodyAdvice的使用1 ResponseBodyAdvice的简介2 ResponseBodyAdvice的使用1 准备一个SpringBoot项目环境2 添加一个响应拦截类3 添加一个返回包装类4 添加控制类5 接口测试 ResponseBodyAdvice可以在注解@ResponseBody将返回值处理成相应格式之前操作返回值。实现这个接口即可完成相应操作。可用于对response 数据的一些统一封装或者加密等操作 1 ResponseBodyAdvice的简
ResponseBodyAdvice和HttpMessageConverter应用浅析
stay foolish
03-27 732
目录 1 使用ResponseBodyAdvice 2 使用HttpMessageConverter 3 源码跟踪 此文的目的是想要对@ResponseBody修饰的方法的返回值，从大写下划线转成小写驼峰，而突然发现官方文档表示“HandlerInterceptor的postHandle() 不支持@ResponseBody、@ResponseEntity修饰方法输出结果的处理，应该使用@ResponseBodyAdvice”。 同时官方文档SpringWebMvc一章中1.10MvcConfig
springmvc源码学习（八）RequestMappingHandlerAdapter
码易的博客
07-25 2135
目录前言一、getHandler( )二、使用步骤1.引入库2.读入数据总结 前言 。 前面分析过RequestMappingHandlerMapping的初始化过程，解析了@Controller等注解信息，将Controller访问路径与方法信息缓存起来，下面分析一下获取过程。 一、getHandler( ) （1） getHandler( ) 示例：pandas 是基于NumPy 的一种工具，该工具是为了解决数据分析任务而创建的。 二、使用步骤 1.引入库 代码如下（示例）： import n..
spring的ioc和aop使用场景
06-06
Spring的IOC和AOP使用场景如下： 1. IOC（控制反转）：适用于需要动态管理对象依赖关系的场景，例如在一个大型的Web应用中，需要管理多个Service对象之间的依赖关系，使用IOC可以将对象的创建和依赖关系的管理交给Spring容器来完成，从而简化代码，提高可维护性和可扩展性。 2. AOP（面向切面编程）：适用于需要在多个模块中实现相同功能的场景，例如在一个Web应用中，需要记录日志、权限控制、事务管理等功能，使用AOP可以将这些功能抽象出来，以切面的方式进行统一管理，从而提高代码的复用性和可维护性。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值