自定义参数解析器同一个参数支持多种Content-Type

最新推荐文章于 2024-03-06 16:52:15 发布
最新推荐文章于 2024-03-06 16:52:15 发布
阅读量1.8k 收藏 4
点赞数 1
分类专栏： Spring 文章标签： 同一参数支持多参数解析器 Spring自定义参数解析器
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yichen0429/article/details/108337122
版权

文章目录

一堆废话

事出有因， 原先上线的接口现在被要求用Java重写，按照原暴露出去的文档然后毫无疑问的，按照Java的惯例，
一定是@RequestBody然后去接收application/json;charset=utf-8，然后一通参数接收处理逻辑。

结果测试都通过了，上线的时候，刚把原接口切到新接口上，日志就狂飙application/x-www-form-urlencoded；charset=utf-8 NOT SUPPORT
What?然后就一通问号脸。赶紧把接口切回到老接口，然后跑去问PHP的同事，什么情况，原对接参数不是json吗？
然后才明白，草，原来要同时支持application/json;charset=utf-8和application/x-www-form-urlencoded；charset=utf-8

PHP咱是不懂的，但是Java对这个需求的原生支持却不是很好，印象中没有现成的。
因为一般我们定义对象接收参数，如果使用了@RequestBody接收，那么传参一定要使用post+一个对应的参数解析器一个可读的流，按照现在的情况即application/json;charset=utf-8。
要么是直接一个对象接收，不要加任何注解，这个时候对应的Content-Type是application/x-www-form-urlencoded；charset=utf-8则参数可正常解析。

但是这两种情况是矛盾的，如果一个加了@RequestBody的参数对应的Content-Type是application/x-www-form-urlencoded；charset=utf-8, 则最终无法解析。反过来如果一个未加@RequestBody的参数对应的Content-Type是application/json;charset=utf-8则也无法解析。

那么现在就只能来看一下如何定义一个自定义的参数解析器来完成这个需求了。但是这个自定义的参数解析器还有点不太一样，因为数据格式本身不是我们自定义的，本身就存在对应标准的解析器。只是SpringMVC在根据参数去找对应解析器的时候没有对应起来。我们现在只要让自己的解析器能够让这个参数转发到对应可以解析的参数解析器上就可以了。

探究Springmvc参数解析器工作流程

现在就要不怕麻烦的还看一下原来的参数解析器是如何工作的，毕竟不知道它怎么写的我也不知道怎么抄。

SpringMVC项目，二话不说，直接找到org.springframework.web.servlet.DispatcherServlet#doDispatch这个方法，看整个处理器的流程，这里直接简化找到最终映射到方法后的执行

// Actually invoke the handler.
mv = ha.handle(processedRequest, response, mappedHandler.getHandler());

方法跳转流程如下

public abstract class AbstractHandlerMethodAdapter extends WebContentGenerator implements HandlerAdapter, Ordered {
	@Override
	@Nullable
	public final ModelAndView handle(HttpServletRequest request, HttpServletResponse response, Object handler)
			throws Exception {
		return handleInternal(request, response, (HandlerMethod) handler);
	}
}

我再跳org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter#handleInternal

public class RequestMappingHandlerAdapter extends AbstractHandlerMethodAdapter
		implements BeanFactoryAware, InitializingBean {
	/**
	 * 参数解析器列表
	 */
	@Nullable
	private HandlerMethodArgumentResolverComposite argumentResolvers;
	
	@Override
	protected ModelAndView handleInternal(HttpServletRequest request,
			HttpServletResponse response, HandlerMethod handlerMethod) throws Exception {
		ModelAndView mav;
		checkRequest(request);
		// 这里删除了大量相关判断方法，只关注实际跳转执行方法
		// No synchronization on session demanded at all...
		mav = invokeHandlerMethod(request, response, handlerMethod);	
	}
	
	/**
	 * 上面跳到了这里
	 */
	@Nullable
	protected ModelAndView invokeHandlerMethod(HttpServletRequest request,
			HttpServletResponse response, HandlerMethod handlerMethod) throws Exception {
		// 这里又删除了大量的代码
		ServletInvocableHandlerMethod invocableMethod = createInvocableHandlerMethod(handlerMethod);
		// 将本类自己的参数解析器列表赋值给ServletInvocableHandlerMethod 
		if (this.argumentResolvers != null) {
			invocableMethod.setHandlerMethodArgumentResolvers(this.argumentResolvers);
		}
		if (this.returnValueHandlers != null) {
			invocableMethod.setHandlerMethodReturnValueHandlers(this.returnValueHandlers);
		}
		invocableMethod.setDataBinderFactory(binderFactory);
		invocableMethod.setParameterNameDiscoverer(this.parameterNameDiscoverer);
		// 带着使命继续往下执行
		invocableMethod.invokeAndHandle(webRequest, mavContainer);
	}
}

接着跳到了org.springframework.web.servlet.mvc.method.annotation.ServletInvocableHandlerMethod#invokeAndHandle

public class ServletInvocableHandlerMethod extends InvocableHandlerMethod {
	public void invokeAndHandle(ServletWebRequest webRequest, ModelAndViewContainer mavContainer,
			Object... providedArgs) throws Exception {
		Object returnValue = invokeForRequest(webRequest, mavContainer, providedArgs);
		// 再删除无关代码
	}

}

这里总算看到了一些关键信息了org.springframework.web.method.support.InvocableHandlerMethod#invokeForRequest

public class InvocableHandlerMethod extends HandlerMethod {
	@Nullable
	public Object invokeForRequest(NativeWebRequest request, @Nullable ModelAndViewContainer mavContainer,
			Object... providedArgs) throws Exception {
		// 这里就是解析参数
		Object[] args = getMethodArgumentValues(request, mavContainer, providedArgs);
		if (logger.isTraceEnabled()) {
			logger.trace("Arguments: " + Arrays.toString(args));
		}
		return doInvoke(args);
	}
	
	/**
	 * 上面方法跳到了这里
	 */
	protected Object[] getMethodArgumentValues(NativeWebRequest request, @Nullable ModelAndViewContainer mavContainer,
			Object... providedArgs) throws Exception {
		// 这里就是获取入参的参数类型，如单个字符串的每个参数，或者是某个对象参数，甚至是HttpServletRequest
		MethodParameter[] parameters = getMethodParameters();
		if (ObjectUtils.isEmpty(parameters)) {
			return EMPTY_ARGS;
		}
		
		Object[] args = new Object[parameters.length];
		// 下面就是遍历每个参数类型，然后挨个解析
		for (int i = 0; i < parameters.length; i++) {
			MethodParameter parameter = parameters[i];
			parameter.initParameterNameDiscovery(this.parameterNameDiscoverer);
			args[i] = findProvidedArgument(parameter, providedArgs);
			if (args[i] != null) {
				continue;
			}
			// org.springframework.web.method.support.HandlerMethodArgumentResolverComposite#supportsParameter
			// 后面就贴出了这个方法的内部，就是遍历所有的参数解析器判断是否能够解析当前参数
			if (!this.resolvers.supportsParameter(parameter)) {
				throw new IllegalStateException(formatArgumentError(parameter, "No suitable resolver"));
			}
			try {
			    // 获取参数解析器，解析当前参数
				args[i] = this.resolvers.resolveArgument(parameter, mavContainer, request, this.dataBinderFactory);
			}
			catch (Exception ex) {
				// Leave stack trace for later, exception may actually be resolved and handled...
				if (logger.isDebugEnabled()) {
					String exMsg = ex.getMessage();
					if (exMsg != null && !exMsg.contains(parameter.getExecutable().toGenericString())) {
						logger.debug(formatArgumentError(parameter, exMsg));
					}
				}
				throw ex;
			}
		}
		return args;
	}
}

上面关于找到参数解析器的关键代码org.springframework.web.method.support.HandlerMethodArgumentResolverComposite

public class HandlerMethodArgumentResolverComposite implements HandlerMethodArgumentResolver {
		private final List<HandlerMethodArgumentResolver> argumentResolvers = new LinkedList<>();

	private final Map<MethodParameter, HandlerMethodArgumentResolver> argumentResolverCache =
			new ConcurrentHashMap<>(256);
	
	/**
	 * 判断参数是否能够找到对应的参数解析器
	 */
	@Override
	public boolean supportsParameter(MethodParameter parameter) {
		return getArgumentResolver(parameter) != null;
	}
	
	@Nullable
	private HandlerMethodArgumentResolver getArgumentResolver(MethodParameter parameter) {
		// 这里指向一个本地缓存，如果一个参数类型可以被某个参数解析器解析，则缓存下次无须遍历
		HandlerMethodArgumentResolver result = this.argumentResolverCache.get(parameter);
		if (result == null) {
		    // 遍历所有的参数解析器，判断是否支持当前参数类型
			for (HandlerMethodArgumentResolver resolver : this.argumentResolvers) {
				if (resolver.supportsParameter(parameter)) {
					result = resolver;
					// 如果支持则放入本地缓存，下次直接从缓存中取
					this.argumentResolverCache.put(parameter, result);
					break;
				}
			}
		}
		return result;
	}
	
	@Override
	@Nullable
	public Object resolveArgument(MethodParameter parameter, @Nullable ModelAndViewContainer mavContainer,
			NativeWebRequest webRequest, @Nullable WebDataBinderFactory binderFactory) throws Exception {
		// 获取该参数类型对应的参数解析器
		HandlerMethodArgumentResolver resolver = getArgumentResolver(parameter);
		if (resolver == null) {
			throw new IllegalArgumentException("Unsupported parameter type [" +
					parameter.getParameterType().getName() + "]. supportsParameter should be called first.");
		}
		// 解析参数
		return resolver.resolveArgument(parameter, mavContainer, webRequest, binderFactory);
	}
	
}

通过对org.springframework.web.method.support.HandlerMethodArgumentResolverComposite#getArgumentResolver的调试， 我们贴出几张图来说明系统中目前所有的参数解析器，以及我们目前需要的用来解析@RequestBody和application/x-www-form-urlencoded对应的参数解析器

  • application/x-www-form-urlencoded对应的解析器为ServletModelAttributeMethodProcessor
  • @RequestBody application/json对应的解析器为RequestResponseBodyMethodProcessor
    public class RequestResponseBodyMethodProcessor extends AbstractMessageConverterMethodProcessor {
	@Override
	public boolean supportsParameter(MethodParameter parameter) {
	    // 可以看到必须要有RequestBody这个注解，该参数解析器才会工作
		return parameter.hasParameterAnnotation(RequestBody.class);
	}
}

顺便说下为什么我们在controller方法入参的时候写HttpServletRequest和HttpServletResponse也能够入参进来，就是因为有对应的参数解析器，这里也给找出来了

  • org.springframework.web.servlet.mvc.method.annotation.ServletRequestMethodArgumentResolver
  • org.springframework.web.servlet.mvc.method.annotation.ServletResponseMethodArgumentResolver

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

不想看废话的可以直接进结果

  1. 定义一个注解用于标注在参数上，用以标识这个参数希望用我们的参数解析器进行解析
    import java.lang.annotation.*;

/**
 * <p>标识参数可以被多个参数解析器尝试进行参数解析</p >
 *
 * 同一个参数支持application/json和application/x-www-form-urlencoded
 *
 * @see com.company.content.risk.order.common.handle.MultiArgumentResolverMethodProcessor
 * @author Snowball
 * @version 1.0
 * @date 2020/08/31 18:57
 */
@Target(ElementType.PARAMETER)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface MultiArgumentResolver {
}
  2. 实现一个自定义参数解析器，要实现接口org.springframework.web.method.support.HandlerMethodArgumentResolver。在解析方法里我们去判断当前客户端传入的Content-Type， 如果是application/json则将参数解析交给RequestResponseBodyMethodProcessor， 如果是application/x-www-form-urlencoded， 则将参数解析交给ServletModelAttributeMethodProcessor。 HandlerMethodArgumentResolver接口要实现两个方法
    • supportsParameter 判断当前解析器是否支持入参对象
    • resolveArgument 解析逻辑
import com.company.content.risk.order.common.annotation.MultiArgumentResolver;
import com.google.common.collect.ImmutableList;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.core.MethodParameter;
import org.springframework.web.HttpMediaTypeNotSupportedException;
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.HandlerMethodArgumentResolverComposite;
import org.springframework.web.method.support.ModelAndViewContainer;
import org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter;
import org.springframework.web.servlet.mvc.method.annotation.RequestResponseBodyMethodProcessor;
import org.springframework.web.servlet.mvc.method.annotation.ServletModelAttributeMethodProcessor;

import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

/**
 * 自定义参数解析器用以支持同一个参数支持application/json和application/x-www-form-urlencoded解析
 *
 * @see MultiArgumentResolver
 * @author Snowball
 * @version 1.0
 * @date 2020/08/31 19:00
 */
public class MultiArgumentResolverMethodProcessor implements HandlerMethodArgumentResolver  {

    @Autowired
    private RequestMappingHandlerAdapter requestMappingHandlerAdapter;

    private static final String CONTENT_TYPE_JSON = "application/json";

    private static final String CONTENT_TYPE_FORM_URLENCODED = "application/x-www-form-urlencoded";


    /**
     * 支持的content_type
     */
    private static final ImmutableList<String> SUPPORT_CONTENT_TYPE_LIST = ImmutableList.of(CONTENT_TYPE_JSON, CONTENT_TYPE_FORM_URLENCODED);

    /**
     * 参考这个写法， 同一个类型的参数解析后缓存对应的参数解析器，不过这里的key改为了Content-Type
     * @see HandlerMethodArgumentResolverComposite#argumentResolverCache
     */
    private final Map<String, HandlerMethodArgumentResolver> argumentResolverCache =
            new ConcurrentHashMap<>(8);


    @Override
    public boolean supportsParameter(MethodParameter parameter) {
        return parameter.getParameter().isAnnotationPresent(MultiArgumentResolver.class);
    }

    /**
     * 解析参数
     */
    @Override
    public Object resolveArgument(MethodParameter parameter, ModelAndViewContainer mavContainer, NativeWebRequest webRequest, WebDataBinderFactory binderFactory) throws Exception {
        String contentType = webRequest.getHeader("Content-Type");
        isSupport(contentType);
        List<HandlerMethodArgumentResolver> argumentResolvers = requestMappingHandlerAdapter.getArgumentResolvers();
        HandlerMethodArgumentResolver handlerMethodArgumentResolver = argumentResolverCache.get(contentType);
        if (handlerMethodArgumentResolver != null) {
            return handlerMethodArgumentResolver.resolveArgument(parameter, mavContainer, webRequest, binderFactory);
        }
        for (HandlerMethodArgumentResolver argumentResolver : argumentResolvers) {
            if (isJson(contentType) && argumentResolver instanceof RequestResponseBodyMethodProcessor) {
                argumentResolverCache.put(contentType, argumentResolver);
                return argumentResolver.resolveArgument(parameter, mavContainer, webRequest, binderFactory);
            } else if (isFormUrlEncoded(contentType) && argumentResolver instanceof ServletModelAttributeMethodProcessor) {
                argumentResolverCache.put(contentType, argumentResolver);
                return argumentResolver.resolveArgument(parameter, mavContainer, webRequest, binderFactory);
            }
        }
        return null;
    }

    private boolean isJson(String contentType) {
        return contentType.contains(CONTENT_TYPE_JSON);
    }

    private boolean isFormUrlEncoded(String contentType) {
        return contentType.contains(CONTENT_TYPE_FORM_URLENCODED);
    }

    /**
     * 判断当前参数解析器是否支持解析当前的Content-Type
     * @param contentType
     * @return
     * @throws HttpMediaTypeNotSupportedException
     */
    private boolean isSupport(String contentType) throws HttpMediaTypeNotSupportedException {
        if (contentType == null) {
            throw new HttpMediaTypeNotSupportedException("contentType不能为空");
        }
        boolean isMatch = false;
        for (String item : SUPPORT_CONTENT_TYPE_LIST) {
            if (contentType.contains(item)) {
                isMatch = true;
                break;
            }
        }
        if (!isMatch) {
            throw new HttpMediaTypeNotSupportedException("支持Content-Type" + SUPPORT_CONTENT_TYPE_LIST.toString());
        }
        return true;
    }
  1. 将参数解析器注册成bean，添加到系统参数解析器列表即可
    import com.company.content.risk.order.common.handle.MultiArgumentResolverMethodProcessor;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.annotation.Order;
import org.springframework.web.method.support.HandlerMethodArgumentResolver;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

import java.util.List;

/**
 * <p>web核心配置</p >
 *
 * @author Snowball
 * @version 1.0
 * @date 2020/08/31 18:57
 */
@Configuration
@Order
public class CoreWebConfig implements WebMvcConfigurer {

    /**
     * 注册自定义参数解析器
     * @return
     */
    @Bean
    public MultiArgumentResolverMethodProcessor multiArgumentResolverMethodProcessor() {
        return new MultiArgumentResolverMethodProcessor();
    }

    /**
     * 添加自定义参数解析器
     * @param resolvers
     */
    @Override
    public void addArgumentResolvers(List<HandlerMethodArgumentResolver> resolvers) {
        resolvers.add(0, multiArgumentResolverMethodProcessor());
    }
}
  2. 使用，将@MultiArgumentResolver标识在controller方法的某个入参对象即可
    @PostMapping(value = "text/submit")
public OutApiResponse<OutTextResponseBody> submitText(@MultiArgumentResolver OutTextRequest outTextRequest) {

}

补充

在上面自定义参数解析器的类中，注入了一个bean，类为RequestMappingHandlerAdapter, 目的是为了从这个类中获取到目前系统中已有的参数解析器列表。那么如何知道这个类里面包含了哪些参数解析器呢？摘录相关代码如下。这个类实现了接口InitializingBean，在bean初始化完成后调用afterPropertiesSet，然后在里面判断加入了默认的参数解析器列表

public class RequestMappingHandlerAdapter extends AbstractHandlerMethodAdapter
		implements BeanFactoryAware, InitializingBean {
	@Nullable
	private HandlerMethodArgumentResolverComposite argumentResolvers;
	
	@Override
	public void afterPropertiesSet() {
		// Do this first, it may add ResponseBody advice beans
		initControllerAdviceCache();

		if (this.argumentResolvers == null) {
			List<HandlerMethodArgumentResolver> resolvers = getDefaultArgumentResolvers();
			this.argumentResolvers = new HandlerMethodArgumentResolverComposite().addResolvers(resolvers);
		}
	}

	private List<HandlerMethodArgumentResolver> getDefaultArgumentResolvers() {
		List<HandlerMethodArgumentResolver> resolvers = new ArrayList<>();

		// Annotation-based argument resolution
		resolvers.add(new RequestParamMethodArgumentResolver(getBeanFactory(), false));
		resolvers.add(new RequestParamMapMethodArgumentResolver());
		resolvers.add(new PathVariableMethodArgumentResolver());
		resolvers.add(new PathVariableMapMethodArgumentResolver());
		resolvers.add(new MatrixVariableMethodArgumentResolver());
		resolvers.add(new MatrixVariableMapMethodArgumentResolver());
		resolvers.add(new ServletModelAttributeMethodProcessor(false));
		resolvers.add(new RequestResponseBodyMethodProcessor(getMessageConverters(), this.requestResponseBodyAdvice));
		resolvers.add(new RequestPartMethodArgumentResolver(getMessageConverters(), this.requestResponseBodyAdvice));
		resolvers.add(new RequestHeaderMethodArgumentResolver(getBeanFactory()));
		resolvers.add(new RequestHeaderMapMethodArgumentResolver());
		resolvers.add(new ServletCookieValueMethodArgumentResolver(getBeanFactory()));
		resolvers.add(new ExpressionValueMethodArgumentResolver(getBeanFactory()));
		resolvers.add(new SessionAttributeMethodArgumentResolver());
		resolvers.add(new RequestAttributeMethodArgumentResolver());

		// Type-based argument resolution
		resolvers.add(new ServletRequestMethodArgumentResolver());
		resolvers.add(new ServletResponseMethodArgumentResolver());
		resolvers.add(new HttpEntityMethodProcessor(getMessageConverters(), this.requestResponseBodyAdvice));
		resolvers.add(new RedirectAttributesMethodArgumentResolver());
		resolvers.add(new ModelMethodProcessor());
		resolvers.add(new MapMethodProcessor());
		resolvers.add(new ErrorsMethodArgumentResolver());
		resolvers.add(new SessionStatusMethodArgumentResolver());
		resolvers.add(new UriComponentsBuilderMethodArgumentResolver());

		// Custom arguments
		if (getCustomArgumentResolvers() != null) {
			resolvers.addAll(getCustomArgumentResolvers());
		}

		// Catch-all
		resolvers.add(new RequestParamMethodArgumentResolver(getBeanFactory(), true));
		resolvers.add(new ServletModelAttributeMethodProcessor(true));

		return resolvers;
	}
}
DDF_YiChen
关注
  • 1
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 11
    评论
专栏目录
Go-依赖Content-Typeheader自动地解析request.Body
08-14
在Go的标准库中，并没有直接提供一个自动解析`Body`的方法，但我们可以根据`Content-Type`来选择合适的解析策略。例如，如果`Content-Type`是`application/json`，我们可以使用`encoding/json`包来解码JSON数据；...
SpringBoot如何解析参数的深入理解
08-26
例如，如果一个参数同时出现在URL查询字符串和请求体中，RequestBodyMethodArgumentResolver会优先处理。 对于`@RequestParam`，你可以指定参数是否必须存在，以及默认值。例如： ```java @GetMapping("/example") ...
支持多种Content-Type类型的方法(衍生到Header的设置)
weixin_34005042的博客
07-30 3023
刚才看到一个问题，他的同事(我的同事系列...)在使用@RequestMapping时，他的请求头Content-Type需要application/json,application/x-www-form-urlencoded只支持这两个类型，即只有请求头中Content-Type为这两种类型时才会映射，对于这种情况，可以使用以下...
SpringBoot—多种Content-Type同时进行参数绑定的处理方法
daegis的博客
01-16 8797
一、背景 SpringBoot版本2.1.1-RELEASE。在工作中遇到了这样一个特殊的需求：需要接收前台传入的参数，接收参数并封装对象之后进行后续的处理。根据现有逻辑，前台请求http接口的Content-Type有两种，application/json和application/x-www-form-urlencoded。现要求两种请求方式都能够进行参数绑定。想到通过自定义一个Handler...
前台多种contentType方式请求及后台响应过程分析
atu1111的博客
11-25 1435
这里写自定义目录标题前台多种请求contentType方式及后台响应过程分析前端使用post提交请求欢迎使用Markdown编辑器新的改变功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，...
http请求上传多个文件时content-type的设置
热门推荐
fuck487的博客
11-20 1万+
http请求上传多个文件时，content-type设置为 multipart/form-data; boundary=----WebKitFormBoundaryAnydWsQ1ajKuGoCd multipart/form-data 为上传文件 boundary为声明文件之间的边界...
SpringMvc 同一个接口接收不同的 Content-Type
qiu7213的博客
01-05 1012
前端传参中，请求头中的 Content-Type 会有多种形式，这里只列举两种 application/json application/x-www-form-urlencoded 同一个接口，来接收不同的Content-Type 类型，代码如下。通过判断不同的Content-Type，使用不同的方式读取数据。 请求是 Post 请求： @PostMapping("Pay") @ApiOperation(value = "支付接口", response = ScanPayPassi.
为Retrofit统一添加post请求的默认参数的方法
01-20
1. 首先，创建一个自定义的OkHttp拦截器，该拦截器会在请求被发送前检查其`Content-Type`，如果为`application/json`，则添加默认参数： ```java public class DefaultJsonInterceptor implements Interceptor { @...
multipart-data-parser:多部分表单数据解析器
05-11
**multipart-data-parser: 多部分表单数据解析器** 在Web开发中，当我们需要上传文件或者处理包含文本和二进制数据的复杂表单时，通常会使用`multipart/form-data`编码格式。`multipart-data-parser`是一个专门针对...
jsonld-rdfa-parser:要使用jsonld.js registerRDFParser方法注册的自定义RDFa解析器（基于green-turtle）
05-05
jsonld-rdfa-parser 要使用jsonld.js registerRDFParser方法注册的自定义RDFa解析器（基于 ...// register the parser for content type text/htmljsonld . registerRDFParser ( 'text/html' , jsonldRdfaParser ) ;//
Content-type详解
最新发布
qq_44741577的博客
03-06 9637
Content-Type（MediaType），即是Internet Media Type，互联网媒体类型，也叫做MIME类型。在互联网中有成百上千中不同的数据类型，HTTP在传输数据对象时会为他们打上称为MIME的数据格式标签，用于区分数据类型。最初MIME是用于电子邮件系统的，后来HTTP也采用了这一方案。在HTTP协议消息头中，使用来表示请求和响应中的媒体类型信息。它用来告诉服务端如何处理请求的数据，以及告诉客户端（一般是浏览器）如何解析响应的数据，比如显示图片，解析并展示html等等。
解决非法出现多次出现的‘contentType‘具有不同的值
MsWRight的博客
08-09 1089
服务器500错误： Page指令：非法出现多次出现的'contentType'具有不同的值（old：[text/html; charset=UTF-8]，new：[text/html;charset=UTF-8]）
axios处理不同的contentType
qq_35119405的博客
08-08 680
如果需要传递表单类型：application/x-www-form-urlencoded。vue 中的 axios 默认的 content-type是。get请求默认发送application/json。使用qs序列化传参即可，此时的载荷如图。
前端知识~Content-Type和Accept
JackChan
09-12 1390
前端知识~Content-Type和Accept
Content-Type
jiandan1127的博客
04-11 2447
Content-Type 存在于请求和响应的头部，用于标识数据的类型。(通俗地说就是 , 你想要后台返回给你什么数据类型, 后台需要你发送什么样的数据类型给他) 1. Response Headers 在响应中，Content-Type 告诉客户端实际返回的内容的类型。比如要通常接口会返回 JSON 格式的数据，那么需要将 Content-Type 设置为application/js...
Request Headers和Response Headers中的Content-Type以及ResponseType
Harley567
03-23 4006
Request Headers和Response Headers中的Content-Type以及ResponseType
Content-Type的类型详解/前后端对于不同Content-type数据类型的处理
Roxlu7的博客
11-21 9842
Content-Type头部是在客户端向服务器发送请求时，指定请求体的媒体类型。服务器据此判断请求体的格式，从而正确解析数据。这是一种用于发送表单数据的类型，它会将数据以键值对的形式编码，例如。键和值都会进行URL编码，以避免特殊字符的影响。这种类型的优点是可以发送任何类型的字符，但缺点是不能发送二进制数据，如文件上传，而且URL编码会增加数据的长度，可能会超过服务器的限制。
html5多文件上传 java_Java Web使用Html5 FormData实现多文件上传功能
weixin_36469638的博客
02-13 208
前一阵子,迭代一个线上的项目,其中有一个图片上传的功能,之前用的ajaxfileupload.js来实现上传的,不过由于ajaxfileupload.js,默认是单文件上传(虽然可以通过修改源码的方法来实现多文件上传),又加上是在移动端做的,所以就打算采用html5的FormData实现多文件上传首先html页面定义有两种:Html1>Html2项目中我采用了Html2的方式再看看上传的JS...
SpringBoot 一个接口同时支持 form 表单、form-data、json 的优雅写法
AI研习社
06-25 342
开发者（KaiFaX）面向全栈工程师的开发者专注于前端、Java/Python/Go/PHP的技术社区来源：juejin.cn/post/7054441239839506446网上很多代码都是千篇一律的 cvs，相信我只要你认真看完我写的这篇，你就可以完全掌握这个知识点，这篇文章不适合直接 cvs，一定要先理解。最近重写个项目遇到个比较棘手的问题，老项目是 PHP 接口，...
feign无法解析text/x-json类型的返回参数
06-07
Feign 默认使用的是 Jackson 库来进行 JSON 数据的解析，而 Jackson 对于 Content-Type 为 application/json 的数据格式可以自动进行解析，但对于 Content-Type 为 text/x-json 的数据格式不支持。 有两种解决方法...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值