一篇文章教你弄懂SpringMvc中的HttpMessageConverter

最新推荐文章于 2024-04-23 15:49:15 发布
置顶 最新推荐文章于 2024-04-23 15:49:15 发布
阅读量1.5k 收藏 2
点赞数 1
分类专栏： java技能提升 文章标签： spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/TreeShu321/article/details/108296052
版权

文章目录

写在前面：
我是「境里婆娑」。我还是从前那个少年，没有一丝丝改变，时间只不过是考验，种在心中信念丝毫未减，眼前这个少年，还是最初那张脸，面前再多艰险不退却。
写博客的目的就是分享给大家一起学习交流，如果您对 Java感兴趣，可以关注我，我们一起学习。

导语：相信使用过Spring的开发人员都用过@RequestBody、@ResponseBody注解，可以直接将输入解析成Json、将输出解析成Json，但HTTP 请求和响应是基于文本的，意味着浏览器和服务器通过交换原始文本进行通信，而这里其实就是HttpMessageConverter发挥着作用。

一、HttpMessageConverter介绍

Http请求响应报文其实都是字符串，当请求报文到java程序会被封装为一个ServletInputStream流，开发人员再读取报文，响应报文则通过ServletOutputStream流，来输出响应报文。

从流中只能读取到原始的字符串报文，同样输出流也是。那么在报文到达SpringMVC / SpringBoot出去，都存在一个字符串到java对象的转化问题。这一过程，在SpringMVC / SpringBoot中，是通过HttpMessageConverter来解决的。

在这里插入图片描述

HttpMessageConverter接口提供了5个方法：

  • canRead：判断该转换器是否能将请求内容转换成Java对象
  • canWrite：判断该转换器是否可以将Java对象转换成返回内容
  • getSupportedMediaTypes：获得该转换器支持的MediaType类型
  • read：读取请求内容并转换成Java对象
  • write：将Java对象转换后写入返回内容
    其中read和write方法的参数分别有有HttpInputMessage和HttpOutputMessage对象，这两个对象分别代表着一次Http通讯中的请求和响应部分，可以通过getBody方法获得对应的输入流和输出流。
    其中read和write方法的参数分别有有HttpInputMessage和HttpOutputMessage对象，这两个对象分别代表着一次Http通讯中的请求和响应部分，可以通过getBody方法获得对应的输入流和输出流。
public interface HttpMessageConverter<T> {
    boolean canRead(Class<?> clazz, MediaType mediaType);
    boolean canWrite(Class<?> clazz, MediaType mediaType);
    List<MediaType> getSupportedMediaTypes();
    T read(Class<? extends T> clazz, HttpInputMessage inputMessage)
            throws IOException, HttpMessageNotReadableException;
    void write(T t, MediaType contentType, HttpOutputMessage outputMessage)
            throws IOException, HttpMessageNotWritableException;
}

缺省配置
平常我们在发送http请求时，没有配置任何 MessageConverter，但是数据前后传递依旧好用，是因为 SpringMVC 启动时会自动配置一些HttpMessageConverter，在 WebMvcConfigurationSupport 类中添加了缺省 MessageConverter：

protected final void addDefaultHttpMessageConverters(List<HttpMessageConverter<?>> messageConverters) {
        StringHttpMessageConverter stringConverter = new StringHttpMessageConverter();
        stringConverter.setWriteAcceptCharset(false);

        messageConverters.add(new ByteArrayHttpMessageConverter());
        messageConverters.add(stringConverter);
        messageConverters.add(new ResourceHttpMessageConverter());
        messageConverters.add(new SourceHttpMessageConverter<Source>());
        messageConverters.add(new AllEncompassingFormHttpMessageConverter());

        if (romePresent) {
            messageConverters.add(new AtomFeedHttpMessageConverter());
            messageConverters.add(new RssChannelHttpMessageConverter());
        }

        if (jackson2XmlPresent) {
            ObjectMapper objectMapper = Jackson2ObjectMapperBuilder.xml().applicationContext(this.applicationContext).build();
            messageConverters.add(new MappingJackson2XmlHttpMessageConverter(objectMapper));
        }
        else if (jaxb2Present) {
            messageConverters.add(new Jaxb2RootElementHttpMessageConverter());
        }

        if (jackson2Present) {
            ObjectMapper objectMapper = Jackson2ObjectMapperBuilder.json().applicationContext(this.applicationContext).build();
            messageConverters.add(new MappingJackson2HttpMessageConverter(objectMapper));
        }
        else if (gsonPresent) {
            messageConverters.add(new GsonHttpMessageConverter());
        }
    }

HttpMessageConverter匹配过程
当使用 @RequestBody和 @ResponseBody注解时，RequestMappingHandlerAdapter就使用它们来进行读取或者写入相应格式的数据。

@RequestBody 据Request对象header部分的Content-Type类型，逐一匹配合适的HttpMessageConverter来读取数据。 底层调用的是RequestResponseBodyMethodProcessor readWithMessageConverters方法

protected <T> Object readWithMessageConverters(HttpInputMessage inputMessage, MethodParameter parameter,
			Type targetType) throws IOException, HttpMediaTypeNotSupportedException, HttpMessageNotReadableException {

		MediaType contentType;
		boolean noContentType = false;
		try {
			contentType = inputMessage.getHeaders().getContentType();
		}
		catch (InvalidMediaTypeException ex) {
			throw new HttpMediaTypeNotSupportedException(ex.getMessage());
		}
		if (contentType == null) {
			noContentType = true;
			contentType = MediaType.APPLICATION_OCTET_STREAM;
		}

		Class<?> contextClass = parameter.getContainingClass();
		Class<T> targetClass = (targetType instanceof Class ? (Class<T>) targetType : null);
		if (targetClass == null) {
			ResolvableType resolvableType = ResolvableType.forMethodParameter(parameter);
			targetClass = (Class<T>) resolvableType.resolve();
		}

		HttpMethod httpMethod = (inputMessage instanceof HttpRequest ? ((HttpRequest) inputMessage).getMethod() : null);
		Object body = NO_VALUE;

		EmptyBodyCheckingHttpInputMessage message;
		try {
			message = new EmptyBodyCheckingHttpInputMessage(inputMessage);

			for (HttpMessageConverter<?> converter : this.messageConverters) {
				Class<HttpMessageConverter<?>> converterType = (Class<HttpMessageConverter<?>>) converter.getClass();
				GenericHttpMessageConverter<?> genericConverter =
						(converter instanceof GenericHttpMessageConverter ? (GenericHttpMessageConverter<?>) converter : null);
				if (genericConverter != null ? genericConverter.canRead(targetType, contextClass, contentType) :
						(targetClass != null && converter.canRead(targetClass, contentType))) {
					if (message.hasBody()) {
						HttpInputMessage msgToUse =
								getAdvice().beforeBodyRead(message, parameter, targetType, converterType);
						body = (genericConverter != null ? genericConverter.read(targetType, contextClass, msgToUse) :
								((HttpMessageConverter<T>) converter).read(targetClass, msgToUse));
						body = getAdvice().afterBodyRead(body, msgToUse, parameter, targetType, converterType);
					}
					else {
						body = getAdvice().handleEmptyBody(null, message, parameter, targetType, converterType);
					}
					break;
				}
			}
		}
		catch (IOException ex) {
			throw new HttpMessageNotReadableException("I/O error while reading input message", ex, inputMessage);
		}

		if (body == NO_VALUE) {
			if (httpMethod == null || !SUPPORTED_METHODS.contains(httpMethod) ||
					(noContentType && !message.hasBody())) {
				return null;
			}
			throw new HttpMediaTypeNotSupportedException(contentType, this.allSupportedMediaTypes);
		}

		MediaType selectedContentType = contentType;
		Object theBody = body;
		LogFormatUtils.traceDebug(logger, traceOn -> {
			String formatted = LogFormatUtils.formatValue(theBody, !traceOn);
			return "Read \"" + selectedContentType + "\" to [" + formatted + "]";
		});

		return body;
	}

@ResponseBody 底层调用的AbstractMessageConverterMethodProcessor

protected <T> void writeWithMessageConverters(@Nullable T value, MethodParameter returnType,
			ServletServerHttpRequest inputMessage, ServletServerHttpResponse outputMessage)
			throws IOException, HttpMediaTypeNotAcceptableException, HttpMessageNotWritableException {

		Object body;
		Class<?> valueType;
		Type targetType;

		if (value instanceof CharSequence) {
			body = value.toString();
			valueType = String.class;
			targetType = String.class;
		}
		else {
			body = value;
			valueType = getReturnValueType(body, returnType);
			targetType = GenericTypeResolver.resolveType(getGenericType(returnType), returnType.getContainingClass());
		}

		if (isResourceType(value, returnType)) {
			outputMessage.getHeaders().set(HttpHeaders.ACCEPT_RANGES, "bytes");
			if (value != null && inputMessage.getHeaders().getFirst(HttpHeaders.RANGE) != null &&
					outputMessage.getServletResponse().getStatus() == 200) {
				Resource resource = (Resource) value;
				try {
					List<HttpRange> httpRanges = inputMessage.getHeaders().getRange();
					outputMessage.getServletResponse().setStatus(HttpStatus.PARTIAL_CONTENT.value());
					body = HttpRange.toResourceRegions(httpRanges, resource);
					valueType = body.getClass();
					targetType = RESOURCE_REGION_LIST_TYPE;
				}
				catch (IllegalArgumentException ex) {
					outputMessage.getHeaders().set(HttpHeaders.CONTENT_RANGE, "bytes */" + resource.contentLength());
					outputMessage.getServletResponse().setStatus(HttpStatus.REQUESTED_RANGE_NOT_SATISFIABLE.value());
				}
			}
		}

		MediaType selectedMediaType = null;
		MediaType contentType = outputMessage.getHeaders().getContentType();
		if (contentType != null && contentType.isConcrete()) {
			if (logger.isDebugEnabled()) {
				logger.debug("Found 'Content-Type:" + contentType + "' in response");
			}
			selectedMediaType = contentType;
		}
		else {
			HttpServletRequest request = inputMessage.getServletRequest();
			List<MediaType> acceptableTypes = getAcceptableMediaTypes(request);
			List<MediaType> producibleTypes = getProducibleMediaTypes(request, valueType, targetType);

			if (body != null && producibleTypes.isEmpty()) {
				throw new HttpMessageNotWritableException(
						"No converter found for return value of type: " + valueType);
			}
			List<MediaType> mediaTypesToUse = new ArrayList<>();
			for (MediaType requestedType : acceptableTypes) {
				for (MediaType producibleType : producibleTypes) {
					if (requestedType.isCompatibleWith(producibleType)) {
						mediaTypesToUse.add(getMostSpecificMediaType(requestedType, producibleType));
					}
				}
			}
			if (mediaTypesToUse.isEmpty()) {
				if (body != null) {
					throw new HttpMediaTypeNotAcceptableException(producibleTypes);
				}
				if (logger.isDebugEnabled()) {
					logger.debug("No match for " + acceptableTypes + ", supported: " + producibleTypes);
				}
				return;
			}

			MediaType.sortBySpecificityAndQuality(mediaTypesToUse);

			for (MediaType mediaType : mediaTypesToUse) {
				if (mediaType.isConcrete()) {
					selectedMediaType = mediaType;
					break;
				}
				else if (mediaType.isPresentIn(ALL_APPLICATION_MEDIA_TYPES)) {
					selectedMediaType = MediaType.APPLICATION_OCTET_STREAM;
					break;
				}
			}

			if (logger.isDebugEnabled()) {
				logger.debug("Using '" + selectedMediaType + "', given " +
						acceptableTypes + " and supported " + producibleTypes);
			}
		}

		if (selectedMediaType != null) {
			selectedMediaType = selectedMediaType.removeQualityValue();
			for (HttpMessageConverter<?> converter : this.messageConverters) {
				GenericHttpMessageConverter genericConverter = (converter instanceof GenericHttpMessageConverter ?
						(GenericHttpMessageConverter<?>) converter : null);
				if (genericConverter != null ?
						((GenericHttpMessageConverter) converter).canWrite(targetType, valueType, selectedMediaType) :
						converter.canWrite(valueType, selectedMediaType)) {
					body = getAdvice().beforeBodyWrite(body, returnType, selectedMediaType,
							(Class<? extends HttpMessageConverter<?>>) converter.getClass(),
							inputMessage, outputMessage);
					if (body != null) {
						Object theBody = body;
						LogFormatUtils.traceDebug(logger, traceOn ->
								"Writing [" + LogFormatUtils.formatValue(theBody, !traceOn) + "]");
						addContentDispositionHeader(inputMessage, outputMessage);
						if (genericConverter != null) {
							genericConverter.write(body, targetType, selectedMediaType, outputMessage);
						}
						else {
							((HttpMessageConverter) converter).write(body, selectedMediaType, outputMessage);
						}
					}
					else {
						if (logger.isDebugEnabled()) {
							logger.debug("Nothing to write: null body");
						}
					}
					return;
				}
			}
		}

		if (body != null) {
			throw new HttpMediaTypeNotAcceptableException(this.allSupportedMediaTypes);
		}
	}

二、自定义HttpMessageConverter

一般springboot会有默认的消息管理器，StringHttpMessageConverter(字符串转换器),FastJsonHttpMessageConverter ,MappingJackson2HttpMessageConverter等等。

今天我要说的是如何自定义消息管理器-FastJsonHttpMessageConverter
1.引用fastjson依赖

<dependency>
   <groupId>com.alibaba</groupId>
   <artifactId>fastjson</artifactId>
   <version>1.2.58</version>
</dependency>

2. 创建配置文件JsonHttpMessageConfiguration.java

@Configuration
public class MyJsonHttpMessageConfiguration {

    @Bean
    @ConditionalOnMissingBean(FastJsonHttpMessageConverter.class)
    public FastJsonHttpMessageConverter fastJsonHttpMessageConverter() {
        //1.需要定义一个convert转换消息的对象
        FastJsonHttpMessageConverter fastJsonHttpMessageConverter = new FastJsonHttpMessageConverter();
        //2.添加fastJson的配置信息;
        FastJsonConfig config = new FastJsonConfig();
        //添加配置-config.setSerializerFeatures()  方法中可以添加多个配置（以，分开）
        config.setSerializerFeatures(SerializerFeature.WriteMapNullValue,SerializerFeature.DisableCircularReferenceDetect);
        //添加配置-config.setSerializerFeatures()  方法中可以添加多个配置（以，分开）
        config.setSerializerFeatures(SerializerFeature.WriteMapNullValue,SerializerFeature.DisableCircularReferenceDetect);
        fastJsonHttpMessageConverter.setFastJsonConfig(config);
        fastJsonHttpMessageConverter.setSupportedMediaTypes(getSupportedMediaTypes());
        fastJsonHttpMessageConverter.setDefaultCharset(Charset.forName("UTF-8"));
        return fastJsonHttpMessageConverter;
    }
    /**
     *  配置全局支持的媒体类型
     */
    private List<MediaType> getSupportedMediaTypes() {
        List<MediaType> supportedMediaTypes = new ArrayList<>();
        supportedMediaTypes.add(MediaType.APPLICATION_JSON);
        supportedMediaTypes.add(MediaType.APPLICATION_ATOM_XML);
        supportedMediaTypes.add(MediaType.APPLICATION_FORM_URLENCODED);
        supportedMediaTypes.add(MediaType.APPLICATION_OCTET_STREAM);
        supportedMediaTypes.add(MediaType.APPLICATION_PDF);
        supportedMediaTypes.add(MediaType.APPLICATION_RSS_XML);
        supportedMediaTypes.add(MediaType.APPLICATION_XHTML_XML);
        supportedMediaTypes.add(MediaType.APPLICATION_XML);
        supportedMediaTypes.add(MediaType.IMAGE_GIF);
        supportedMediaTypes.add(MediaType.IMAGE_JPEG);
        supportedMediaTypes.add(MediaType.IMAGE_PNG);
        supportedMediaTypes.add(MediaType.TEXT_EVENT_STREAM);
        supportedMediaTypes.add(MediaType.TEXT_HTML);
        supportedMediaTypes.add(MediaType.TEXT_MARKDOWN);
        supportedMediaTypes.add(MediaType.TEXT_PLAIN);
        supportedMediaTypes.add(MediaType.TEXT_XML);
        return supportedMediaTypes;
    }
}

SerializerFeature配置的属性解释

属性名称含义
QuoteFieldNames输出key时是否使用双引号,默认为true
UseSingleQuotes使用单引号而不是双引号,默认为false
WriteMapNullValue是否输出值为null的字段,默认为false应用场景：前端必须需要所有字段
UseISO8601DateFormatDate使用ISO8601格式输出，默认为false
WriteNullListAsEmptyList字段如果为null,输出为[],而不是null
WriteNullStringAsEmpty字符类型字段如果为null,输出为"",而不是null
WriteNullNumberAsZero数值字段如果为null,输出为0,而非null
WriteNullBooleanAsFalseBoolean字段如果为null,输出为false,而非null
SkipTransientField如果是true，类中的Get方法对应的Field是transient，序列化时将会被忽略。默认为true
SortField按字段名称排序后输出。默认为false

到此SpringMvc中的HttpMessageConverter介绍完毕。如果还有不明白的可以留言。
—————————————————————————————————
由于本人水平有限，难免有不足，恳请各位大佬不吝赐教！

境里婆娑
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
HttpMessageConverter（消息转换器）原理和使用方式
私は悪い人ですか的博客
10-31 4222
我跟你讲这个东西暂时就两种使用一个是加@ResponseBody注解（异步请求），一个是ResponseEntity<T>作为返回值（文件的下载） HttpMessageConverter原理 HttpMessageConverter<T> HttpMessageConverter<T>是 Spring3.0 新添加的一个接口，负责将请求信息转换...
坑记（HttpInputMessage）
splendid_java的专栏
01-10 1077
实现接口报文的监听和处理操作。在监听时，需分别实现相关的Advice类，以帮助完成自己的逻辑实现。这就厉害了，不阻塞，但是可能丢包…所以如果使用上述方法，读取请求body时，数据并不完整，会导致后续逻辑出现异常。如我们使用以上方式，读取请求报文数据时，可能产生。在实现接口的加密处理过程中， 我们一般选择使用。今天我们谈谈使用过程中可能遇到的问题。多看、多学、多试，总会找到解决的办法和途径。
HttpMessageConverter
最新发布
小钟不想敲代码
04-23 989
HttpMessageConverter
详解 SpringMVC 的 HttpMessageConverter
莫等闲 白了少年头 空悲切
11-06 5854
HttpMessageConverter是Spring Framework中的一个接口，用于处理HTTP请求和响应的消息转换。在Spring MVC中，HttpMessageConverter主要用于将HTTP请求的输入内容转换为指定的Java对象，以及将Java对象转换为HTTP响应的输出内容。它负责处理请求和响应的数据格式转换，例如将请求的JSON或XML数据转换为Java对象，并将Java对象转换为JSON或XML格式的响应数据。
SpringMVC 学习（七）之报文信息转换器 HttpMessageConverter
zjs246813的博客
02-26 1116
HttpMessageConverter 报文信息转换器，将请求报文（如JSON、XML、HTML等）转换为 Java 对象，或将 Java 对象转换为响应报文。HttpMessageConverter 接口定义了将 Java 对象转换为 HTTP 响应的报文信息和将 HTTP 请求中的报文信息转换为 Java 对象的方法。SpringMVC 提供了多个内置的 HttpMessageConverter 实现，以支持不同的数据格式和数据类型。
HttpMessageConverter解析
weixin_43808717的博客
06-03 1903
1、前言 主要分析HttpMessageConverter接口、@RequestMapping中的一些属性、@ResponseBody注解、@RequestBody注解以及Json的收发，通过ajax了解这些东西如何在一起使用；如何搭配使用、分别有什么作用、担任什么职责… @RequestMapping注解：请求映射专家，主要负责URI到Controller的映射，以及一些响应的方式、数据格式等的设置… @ResponseBody注解：在Controller响应方法上加入该注解，就会跳过视图解析器；
SpringMVC 中HttpMessageConverter简介和Http请求415 的问题
09-02
在SpringMVC中，如果使用`@RequestBody`注解来接收POST请求中的参数，那么Spring会依赖于已配置的HttpMessageConverter来解析请求体。当你收到415错误时，这通常意味着服务器找不到合适的HttpMessageConverter来处理...
springmvc中RequestMappingHandlerAdapter与HttpMessageConverter的装配讲解
08-26
在这个过程中，`RequestMappingHandlerAdapter`和`HttpMessageConverter`两个组件起着至关重要的作用。 `RequestMappingHandlerAdapter`是Spring MVC中的一个适配器，它的主要职责是将请求映射到处理器方法...
SpringMVC源码解析之消息转换器HttpMessageConverter
08-28
HttpMessageConverter是SpringMVC中的一个核心机制，它提供了一个灵活的消息转换机制，能够自动将请求报文转换为对象，和将对象转换为响应报文。该机制的实现是通过使用@RequestBody和@ResponseBody两个注解，分别...
这一次搞懂SpringMVC原理说明
09-07
在本文中，我们将探讨SpringMVC如何处理请求、解析参数、映射返回值以及中间件的使用。 首先，当前端发送HTTP请求到后端接口时，请求会经过Servlet容器，如Tomcat或Jetty。Servlet生命周期中的四个关键阶段包括实例...
阿里P7大牛一对一教你如何手写SpringMVC框架
10-10
看后不过瘾？想学更多架构技术知识？那么请联系我
Spring——HttpMessageConverter
chenxingxingxing的博客
04-21 1277
文章目录HttpMessageConverter简介1、@RequestBody2、RequestEntity3、@ResponseBody（1）响应普通类型（2）响应json对象4、ResponseEntity（1）文件的下载（3）文件上传 HttpMessageConverter简介 Http:http协议；Message：消息；Converter:转换器，合起来就是报文消息转换器，它可以将请求报文转化为java对象，也可以将java对象转换为响应报文信息。HttpMessageConverter有两个
Spring MVC 之 HttpMessageConverter
爱老婆爱生活~
03-31 683
Spring MVC 为开发者提供了方便的开发方式和丰富的功能。其中，HttpMessageConverter 是Spring MVC中非常重要的一个组件，它负责准换客户端提交的请求数据
SpringMvc-HttpMessageConverter
文天大人
09-25 115
怀念二抱三抱
HttpMessageConverter是这样转换数据的
Crystalqy的博客
03-03 1165
Java Web 人员经常要设计 RESTful API（如何设计好的RESTful API），通过 json 数据进行交互。那么前端传入的 json 数据如何被解析成 Java 对象作为 API入参，API 返回结果又如何将 Java 对象解析成 json 格式数据返回给前端？ 其实在整个数据流转过程中，HttpMessageConverter起到了重要作...
FastJsonHttpMessageConverter 类的作用与使用详解
qq_28754027的博客
04-03 4587
FastJson是一种高性能的Java JSON解析库，它采用类似于Jackson和Gson的JSON序列化和反序列化机制，但是速度更快。FastJson支持Java对象到JSON的序列化和JSON到Java对象的反序列化，同时支持对JSON字符串的高效解析。
Java如何实现对应用系统进行请求加密、响应加密处理(SpringBoot、SpringCloud)
热门推荐
一恍过去
05-30 2万+
😊 @ 作者： 一恍过去 💖 @ 主页： https://blog.csdn.net/zhuocailing3390 🎉 @ 主题： Java如何实现对应用系统进行请求加密、响应加密处理(SpringBoot、SpringCloud) ⏱️ @ 创作时间： 2022年05月30日 Java如何实现对应用系统进行请求加密、响应加密处理(SpringBoot、SpringCloud)...
SpringMVC(四)Message Converters
ThinkMore
01-24 1956
字符串信息转换 获取简单字符串 @RequestMapping(value="/string", method=RequestMethod.POST) public @ResponseBody String readString(@RequestBody String string) { return "Read string '" + string + "'"; } 这里的
HttpMessageConverter逻辑梳理
xiaoming的博客
06-15 1099
本文目录结构： 一、快速了解的机制二、结合解读解析请求报文机制三、结合解读解析响应报文机制四、创建自定义HttpMessageConverter实现参数加解密一、快速了解的机制 快速过一遍相关代码（这里只摘取核心的代码，并注释方法作用，其余代码使用【…】省略，感兴趣的话可以自行查看源码） 其实核心流程就是根据parameter去匹配resolver，然后将具体的参数解析工作交给匹配到的resolver，resolver再将解析工作委托给converter 二、结合解读解析请求报文机制 根据paramet
初识SpringMVC以及springmvc基本应用入门案例彩色PPT版本.pptx
05-29
"该资源为一个关于初识SpringMVC及其基本应用的入门教程，采用彩色PPT形式，旨在帮助学习者理解并掌握SpringMVC框架。内容包括SpringMVC的概述、使用SpringMVC与Servlet开发web程序的流程、案例工作流程分析以及...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

境里婆娑

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值