Spring MVC 视图解析

最新推荐文章于 2022-06-09 16:21:50 发布
最新推荐文章于 2022-06-09 16:21:50 发布
阅读量167 收藏
点赞数
文章标签： spring java mvc springmvc
原文链接：https://www.bilibili.com/video/BV1d4411g7tv?p=176&spm_id_from=pageDriver
版权

SpringMVC解析视图概述

  • 不论控制器返回一个String、ModelAndView、View都会转换为ModelAndView对象，由视图解析器解析视图，然后，进行页面的跳转在这里插入图片描述
  • 视图解析两个重要的接口（View、ViewResolver）
    • view：视图的作用是渲染模型数据，将模型里的数据以某种形式呈现给客户
    public interface View {
	String RESPONSE_STATUS_ATTRIBUTE = View.class.getName() + ".responseStatus";
	String PATH_VARIABLES = View.class.getName() + ".pathVariables";
	String SELECTED_CONTENT_TYPE = View.class.getName() + ".selectedContentType";
	// 如果预先确定，则返回视图的内容类型。可用于预先检查视图的内容类型，即在实际渲染尝试之前。
	default String getContentType() {
		return null;
	}
	// 根据指定的模型渲染视图
	void render(@Nullable Map<String, ?> model, HttpServletRequest request, HttpServletResponse response)
			throws Exception;

}
    • ViewResolver：Spring MVC 借助视图解析器（ViewResolver）得到最终的视图对象（View），最终的视图可以是 JSP ，也可能是 Excel、JFreeChart等各种表现形式的视图
    public interface ViewResolver {
	// 按名称解析给定视图
	@Nullable
	View resolveViewName(String viewName, Locale locale) throws Exception;	
}

视图常用实现类

在这里插入图片描述

视图解析器

在这里插入图片描述

  • SpringMVC 为逻辑视图名的解析提供了不同的策略，可以在 Spring WEB 上下文中配置一种或多种解析策略，并指定他们之间的先后顺序。每一种映射策略对应一个具体的视图解析器实现类。
  • 每个视图解析器都实现了 Ordered 接口并开放出一个 order 属性，可以通过 order 属性指定解析器的优先顺序，order 越小优先级越高。

JstlView

  • 若项目中使用了JSTL，则SpringMVC 会自动把视图由InternalResourceView转为 JstlView

代码如下

大致过程与Java Web原生的国际化过程相同i18n 国际化

  • 导包
    <!-- https://mvnrepository.com/artifact/javax.servlet/jstl -->
<dependency>
    <groupId>javax.servlet</groupId>
    <artifactId>jstl</artifactId>
    <version>1.2</version>
</dependency>
  • 在resources文件夹中，放入i18n的配置文件
  • 在spring-mvc的配置文件中，注册messageSource
    <bean id="messageSource" class="org.springframework.context.support.ResourceBundleMessageSource">
    <property name="basename" value="i18n"/>
    <!-- 支持UTF-8的中文 -->
    <property name="defaultEncoding" value="UTF-8"/>
</bean>
  • 编写一个控制器
      @RequestMapping("/viewAndViewResolverTest")
  public String viewAndViewResolverTest() {
    System.out.println("viewAndViewResolverTest");
    return "success";
  }
  • 与Java Web不同的是，在jsp中无需声明地区以及基础名称basename，可以直接通过message调用，获取配置文件的内容。
    <%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%@taglib prefix="fmt" uri="http://java.sun.com/jsp/jstl/fmt" %>
<html>
<head>
    <title>success</title>
</head>
<body>
<h1>
    <fmt:message key="username"/>
</h1>
<h1>
    <fmt:message key="password"/>
</h1>
</body>
</html>

mvc:view-controller标签

  • 若希望直接响应通过 SpringMVC 渲染的页面，可以使用 mvc:view-controller 标签实现（即省去写Controller的代码，直接调用Spring MVC内部的Controller代码）
  • 在spring-mvc的配置文件中，加入以下代码（页面为success.jsp，url为/success）
    <!-- 直接配置响应的页面：无需经过控制器来执行结果 -->
<mvc:view-controller path="/success" view-name="success"/>
<mvc:annotation-driven/>

    注意，必须添加<mvc:annotation-driven/>这句话，否则除了该页面以外，所有页面都会失效。

自定义视图

  • 自定义视图（需要加入SpringMVC，那么，一定需要实现框架的接口）

简单案例

  • 自己写一个view，发送请求之后返回该view
  • 首先，定义view
    @Component
public class HelloView implements View {
// 返回内容类型
  @Override
  public String getContentType() {
    return "text/html;charset=utf-8";
  }

  @Override
  public void render(Map<String, ?> model, HttpServletRequest request, HttpServletResponse response) throws Exception {
    response.setContentType("text/html;charset=utf-8");  // 必须设置，否则会出现中文乱码现象
    response.getWriter().write("自定义view测试");  // 自定义页面内容
  }
}

    即使存在过滤器CharacterEncodingFilter，仍要在响应中设置该返回类型。因为在过滤器中，只设置了编码格式，没有设置响应类型。详见Spring MVC解决中文乱码问题

  • 在sring-mvc配置文件中，设置BeanNameViewResolver视图解析器。并将优先级设为100（其实多少数字都可以，只要比internalResourceViewResolver的oder小就行）。
    <bean class="org.springframework.web.servlet.view.BeanNameViewResolver">
    <property name="order" value="100"/>
</bean>

<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver" id="internalResourceViewResolver">
    <property name="prefix" value="/WEB-INF/views/"/>
    <property name="suffix" value=".jsp"/>
</bean>
    在InternalResourceViewResolver的父类中，将order设置为private int order = Ordered.LOWEST_PRECEDENCE;（ int LOWEST_PRECEDENCE = 2147483647;）
  • 控制器
    @RequestMapping("/testView")
public String testView(){
	System.out.println("testView...");
	return "helloView"; //与视图Bean对象的id一致
}

重定向

  • 之前都是返回一个字符串，然后视图解析器通过拼接，获取真实资源的位置，并转发到此处。
  • 我们也可以让视图解析器解析为重定向的方式。
    @RequestMapping("redirectTest")
  public String redirectTest() {
    System.out.println("redirectTest");
    return "redirect:/index.jsp";
  }

    使用此方法之后，不会视图解析器不会使用拼接的，而是直接根据url寻找资源。

转发

  • 同理，也可以自己写一个转发的地址，不需要视图解析器帮忙拼接。
    @RequestMapping("forwardTest")
  public String forwardTest() {
    System.out.println("forwardTest");
    return "forward:/index.jsp";
  }

源码分析

  • 在DispatcherServlet中，doDispatch()方法，在接近末尾的地方，有一个processDispatchResult()方法；
  • processDispatchResult()方法调用render()方法渲染；
  • render()方法中，调用resolveViewName()通过View的名字，解析出View对象；并在末尾，调用View的rend()方法，开启重定向或转发
    protected void render(ModelAndView mv, HttpServletRequest request, HttpServletResponse response) throws Exception {
	// Determine locale for request and apply it to the response.
	Locale locale =
			(this.localeResolver != null ? this.localeResolver.resolveLocale(request) : request.getLocale());
	response.setLocale(locale);

	View view;
	String viewName = mv.getViewName();
	if (viewName != null) {
		// 通过viewname解析出view
		view = resolveViewName(viewName, mv.getModelInternal(), locale, request);
		if (view == null) {
			throw new ServletException("Could not resolve view with name '" + mv.getViewName() +
					"' in servlet with name '" + getServletName() + "'");
		}
	}
	else {
		// No need to lookup: the ModelAndView object contains the actual View object.
		view = mv.getView();
		if (view == null) {
			throw new ServletException("ModelAndView [" + mv + "] neither contains a view name nor a " +
					"View object in servlet with name '" + getServletName() + "'");
		}
	}

	// Delegate to the View object for rendering.
	if (logger.isTraceEnabled()) {
		logger.trace("Rendering view [" + view + "] ");
	}
	try {
		if (mv.getStatus() != null) {
			response.setStatus(mv.getStatus().value());
		}
		// 执行view
		view.render(mv.getModelInternal(), request, response);
	}
	catch (Exception ex) {
		if (logger.isDebugEnabled()) {
			logger.debug("Error rendering view [" + view + "]", ex);
		}
		throw ex;
	}
}
  • 在resolveViewName()方法中，遍历所有视图解析器，尝试通过view的名字，解析出结果。一旦解析出来，就返回view。
    @Nullable
protected View resolveViewName(String viewName, @Nullable Map<String, Object> model,
		Locale locale, HttpServletRequest request) throws Exception {

	if (this.viewResolvers != null) {
		// 遍历所有视图解析器
		for (ViewResolver viewResolver : this.viewResolvers) {
			View view = viewResolver.resolveViewName(viewName, locale);
			if (view != null) {
				return view;
			}
		}
	}
	return null;
}

InternalResourceViewResolver

  • 继承关系
    在这里插入图片描述
  • 所有ViewResolver都需要实现resolveViewName()方法
AbstractCachingViewResolver
  • AbstractCachingViewResolver首先实现了这个方法，在此其中，最重要的是createView()方法，用于创造View；而该方法又调用一个loadView()的方法（该方法是一个抽象方法）。
    @Override
@Nullable
public View resolveViewName(String viewName, Locale locale) throws Exception {
	if (!isCache()) {
		// 创造View
		return createView(viewName, locale);
	}
	else {
		Object cacheKey = getCacheKey(viewName, locale);
		View view = this.viewAccessCache.get(cacheKey);
		if (view == null) {
			synchronized (this.viewCreationCache) {
				view = this.viewCreationCache.get(cacheKey);
				if (view == null) {
					// Ask the subclass to create the View object.
					view = createView(viewName, locale);
					if (view == null && this.cacheUnresolved) {
						view = UNRESOLVED_VIEW;
					}
					if (view != null && this.cacheFilter.filter(view, viewName, locale)) {
						this.viewAccessCache.put(cacheKey, view);
						this.viewCreationCache.put(cacheKey, view);
					}
				}
			}
		}
		else {
			if (logger.isTraceEnabled()) {
				logger.trace(formatKey(cacheKey) + "served from cache");
			}
		}
		return (view != UNRESOLVED_VIEW ? view : null);
	}
}

    @Nullable
protected View createView(String viewName, Locale locale) throws Exception {
	return loadView(viewName, locale);
}
UrlBasedResolver
  • 子类UrlBasedResolver实现了loadView()方法，该方法又调用一个buildView()方法实现。
    @Override
protected View loadView(String viewName, Locale locale) throws Exception {
	AbstractUrlBasedView view = buildView(viewName);
	View result = applyLifecycleMethods(viewName, view);
	return (view.checkResource(locale) ? result : null);
}
  • buildView()是最重要的实现方法。通过BeanUtils.instantiateClass()方法实例化一个view对象，通过各类get和set方法，给view注入多个参数（基本上响应有什么，就注入什么）。
    protected AbstractUrlBasedView buildView(String viewName) throws Exception {
	Class<?> viewClass = getViewClass();
	Assert.state(viewClass != null, "No view class");
	// 实例化一个view
	AbstractUrlBasedView view = (AbstractUrlBasedView) BeanUtils.instantiateClass(viewClass);
	view.setUrl(getPrefix() + viewName + getSuffix());
	view.setAttributesMap(getAttributesMap());

	String contentType = getContentType();
	if (contentType != null) {
		view.setContentType(contentType);
	}

	String requestContextAttribute = getRequestContextAttribute();
	if (requestContextAttribute != null) {
		view.setRequestContextAttribute(requestContextAttribute);
	}

	Boolean exposePathVariables = getExposePathVariables();
	if (exposePathVariables != null) {
		view.setExposePathVariables(exposePathVariables);
	}
	Boolean exposeContextBeansAsAttributes = getExposeContextBeansAsAttributes();
	if (exposeContextBeansAsAttributes != null) {
		view.setExposeContextBeansAsAttributes(exposeContextBeansAsAttributes);
	}
	String[] exposedContextBeanNames = getExposedContextBeanNames();
	if (exposedContextBeanNames != null) {
		view.setExposedContextBeanNames(exposedContextBeanNames);
	}

	return view;
}
  • 值得一提的是，该类还重写了父类的createView()方法，加入了viewName的判断
    @Override
protected View createView(String viewName, Locale locale) throws Exception {
	// If this resolver is not supposed to handle the given view,
	// return null to pass on to the next resolver in the chain.
	if (!canHandle(viewName, locale)) {
		return null;
	}

	// Check for special "redirect:" prefix. 判断是否以redirect开头
	if (viewName.startsWith(REDIRECT_URL_PREFIX)) {
		String redirectUrl = viewName.substring(REDIRECT_URL_PREFIX.length());
		RedirectView view = new RedirectView(redirectUrl,
				isRedirectContextRelative(), isRedirectHttp10Compatible());
		String[] hosts = getRedirectHosts();
		if (hosts != null) {
			view.setHosts(hosts);
		}
		return applyLifecycleMethods(REDIRECT_URL_PREFIX, view);
	}

	// Check for special "forward:" prefix.判断是否以forward开头
	if (viewName.startsWith(FORWARD_URL_PREFIX)) {
		String forwardUrl = viewName.substring(FORWARD_URL_PREFIX.length());
		InternalResourceView view = new InternalResourceView(forwardUrl);
		return applyLifecycleMethods(FORWARD_URL_PREFIX, view);
	}

	// Else fall back to superclass implementation: calling loadView.
	return super.createView(viewName, locale);
}
InternalResourceViewResolver
  • 在真正的ViewResolver中，就简单地调用父类的buildView()方法，即可实现功能。
    @Override
protected AbstractUrlBasedView buildView(String viewName) throws Exception {
	InternalResourceView view = (InternalResourceView) super.buildView(viewName);  //调用父类的方法实现
	if (this.alwaysInclude != null) {
		view.setAlwaysInclude(this.alwaysInclude);
	}
	view.setPreventDispatchLoop(true);
	return view;
}

BeanNameViewResolver

  • 继承关系
    在这里插入图片描述
  • 该类相较于上面庞大的类来说，简单得多。基本上就是将整个view实例化一遍，然后还回去。
    public class BeanNameViewResolver extends WebApplicationObjectSupport implements ViewResolver, Ordered {

	private int order = Ordered.LOWEST_PRECEDENCE;  // default: same as non-Ordered
	/**
	 * Specify the order value for this ViewResolver bean.
	 * <p>The default value is {@code Ordered.LOWEST_PRECEDENCE}, meaning non-ordered.
	 * @see org.springframework.core.Ordered#getOrder()
	 */
	public void setOrder(int order) {
		this.order = order;
	}

	@Override
	public int getOrder() {
		return this.order;
	}


	@Override
	@Nullable
	public View resolveViewName(String viewName, Locale locale) throws BeansException {
		ApplicationContext context = obtainApplicationContext();
		if (!context.containsBean(viewName)) {
			// Allow for ViewResolver chaining...
			return null;
		}
		if (!context.isTypeMatch(viewName, View.class)) {
			if (logger.isDebugEnabled()) {
				logger.debug("Found bean named '" + viewName + "' but it does not implement View");
			}
			// Since we're looking into the general ApplicationContext here,
			// let's accept this as a non-match and allow for chaining as well...
			return null;
		}
		return context.getBean(viewName, View.class);
	}

}

InternalResourceView

  • 继承关系
    在这里插入图片描述
AbstractView
  • 该类首先实现了rend()方法，并调用了抽象方法renderMergedOutputModel()
    @Override
public void render(@Nullable Map<String, ?> model, HttpServletRequest request,
		HttpServletResponse response) throws Exception {

	if (logger.isDebugEnabled()) {
		logger.debug("View " + formatViewName() +
				", model " + (model != null ? model : Collections.emptyMap()) +
				(this.staticAttributes.isEmpty() ? "" : ", static attributes " + this.staticAttributes));
	}

	Map<String, Object> mergedModel = createMergedOutputModel(model, request, response);
	prepareResponse(request, response);
	renderMergedOutputModel(mergedModel, getRequestToExpose(request), response);
}
InternalResourceView
  • 该类就直接实现了renderMergedOutputModel()方法，并将大部分model的信息，都保存在request中。
  • 最后获取Dispatcher，并forward到指定的url中。
    @Override
protected void renderMergedOutputModel(
	Map<String, Object> model, HttpServletRequest request, HttpServletResponse response) throws Exception {

	// Expose the model object as request attributes.
	exposeModelAsRequestAttributes(model, request);

	// Expose helpers as request attributes, if any.
	exposeHelpers(request);

	// Determine the path for the request dispatcher.
	String dispatcherPath = prepareForRendering(request, response);

	// Obtain a RequestDispatcher for the target resource (typically a JSP).
	RequestDispatcher rd = getRequestDispatcher(request, dispatcherPath);
	if (rd == null) {
		throw new ServletException("Could not get RequestDispatcher for [" + getUrl() +
				"]: Check that the corresponding file exists within your web application archive!");
	}

	// If already included or response already committed, perform include, else forward.
	if (useInclude(request, response)) {
		response.setContentType(getContentType());
		if (logger.isDebugEnabled()) {
			logger.debug("Including [" + getUrl() + "]");
		}
		rd.include(request, response);
	}

	else {
		// Note: The forwarded resource is supposed to determine the content type itself.
		if (logger.isDebugEnabled()) {
			logger.debug("Forwarding to [" + getUrl() + "]");
		}
		rd.forward(request, response);
	}
}
掂过碌蔗呀
关注
【SpringMVC笔记05】SpringMVC中的视图解析器
✅ Java 开发工程师，从事 Web 应用程序的研发，擅长 Spring、SpringBoot 等技术。 ✅ 热爱编程，业余时间学习新知识，通过 CSDN 记录学习心得和笔记内容。
06-18 2381
这篇文章主要介绍了SpringMVC中几种常用的视图解析器。
Spring MVC使用篇（四）—— 视图解析器
王喆峰的博客
11-01 926
文章目录1、视图解析器简介2、演示案例环境搭建3、AbstractCa chingViewResolver4、UrlBasedViewResolver5、InternalResourceViewResolver6、XmlViewResolver7、BeanNameViewResolver8、ResourceBundleViewResolver9、FreeMarkerViewResolver与Vel...
Spring Mvc 视图解析
weixin_33842328的博客
02-20 161
2019独角兽企业重金招聘Python工程师标准>>> ...
5. SpringMVC视图解析
weixin_45267102的博客
06-01 336
文章目录SpringMVC视图解析过程1. 视图解析器2. 视图`☆` SpringMVC视图解析过程 首先我们需要明白–不论控制器（就是我们使用@Controller注解标记的类）返回的是String,ModelAndView,View数据SpringMVC都会转换为ModelAndView对象，ModelAndView对象(包含了逻辑名和模型对象的视图)由视图解析器解析成视图对象，然后解析，进行页面的跳转。 另外我们还需要知道两个接口 ViewResolver即视图解析器的顶级接口 View视图对象的
SpringMvc视图解析
记忆碎片
05-01 374
首先来看一下视图的概念: 视图的作用是渲染模型数据,将模型里的数据以某种形式呈现给客户。为了实现视图模型和具体实现技术的解耦,Spring 在org.springframework.web.servlet 包中定义了一个高度抽象的 View接口. 视图对象由视图解析器负责实例化。由于视图是无状态的,所以他们不会有线程安全的问题. 下面是SpringMvc解析视图的一个示意图:
SpringMVC之视图解析
OceanStar的博客
11-09 616
SpringMVC如何解析视图
Spring MVC视图解析器（ViewResolver）
洛卡JAVA架构师每日分享Java架构师知识
05-20 1346
视图解析器（ViewResolver）是 Spring MVC 的重要组成部分，负责将逻辑视图名解析为具体的视图对象。 Spring MVC 提供了很多视图解析类，其中每一项都对应 Java Web 应用中特定的某些视图技术。下面介绍一些常用的视图解析类。 URLBasedViewResolver UrlBasedViewResolver 是对 ViewResolver 的一种简单实现，主要提供了一种拼接 URL 的方式来解析视图。 UrlBasedViewResolver 通过 prefix 属性指定前缀
spring mvc html 404,SpringMVC视图解析器配置导致访问404的问题
weixin_36467992的博客
06-19 805
最近在学习SpringMVC，先跟着教程demo在类方法上使用RequestMapping()注解，完成了页面的跳转，先上代码吧。HelloController类：package com.itcast.zxw.controller;import org.springframework.stereotype.Controller;import org.springframework.web.bind...
spring MVC视图解析器
热门推荐
杰哥一号号的博客
11-20 1万+
在这篇博客中介绍一下SpringMVC视图解析器。当我们对SpringMVC控制的资源发起请求时，这些请求都会被SpringMVC的DispatcherServlet处理，接着spring会分析看哪一个HandlerMapping定义的所有请求映射中存在对该请求的最合理的映射。然后通过该HandlerMapping取得其对应的Handler，接着再通过相应的HandlerAdapter处理该Han
SpringMVC-5 视图和视图解析器
03-25
理解视图和视图解析器的解析流程、使用常用的InternalResourceView和JstlView、实现自定义视图、实现重定向操作
SpringMVC源码阅读：视图解析器
Jinyao的博客
02-07 976
SpringMVC源码阅读：视图解析器 1.前言 SpringMVC是目前J2EE平台的主流Web框架，不熟悉的园友可以看SpringMVC源码阅读入门,它交代了SpringMVC的基础知识和源码阅读的技巧 本文将通过源码(基于Spring4.3.7)分析，弄清楚SpringMVC如何完成视图解析的 2.源码分析 在SpringMVC源码阅...
Spring MVC之视图解析
u011277123的博客
01-09 322
谈谈IT 2017-01-06 22:19 什么是视图解析 我计划完成 50 到 100 篇有关 Spring 的文章，这是第十七篇。如果您对Spring和编程感兴趣，欢迎订阅我的头条号，也欢迎关注我的个人独立IT博客：谈谈IT,网址就是tantanit.com哦。 浏览器只识别静态的html文件。MVC中，controller并不直接生成html文件，而只负责为model填充数
SpringMVC视图解析
naumy的博客
05-21 268
视图解析 1. SpringMVC如何解析视图概述 ① 不论控制器返回一个String,ModelAndView,View都会转换为ModelAndView对象，由视图解析器解析视图，然后，进行页面的跳转。 ② 视图解析源码分析：重要的两个接口 ③ 断点调试源码 ④ 流程图 2. 视图和视图解析器 请求处理方法执行完成后，最终返回一个 ModelAndView 对象。 对于那些返回 String，View 或 ModeMap 等类型的处理方法，Spring MVC 也会在内部将它们装配成一个 Mo
SpringMVC的视图解析器
qq_29860591的博客
04-08 395
视图和视图解析器 请求处理方法执行完成后，最终返回一个 ModelAndView 对象。对于那些返回 String，View 或 ModeMap 等类型的处理方法，Spring MVC 也会在内部将它们装配成一个 ModelAndView 对象，它包含了逻辑名和模型对象的视图 Spring MVC 借助视图解析器(ViewResolver)得到最终的视图对象(View)，最终的视图可以是...
springmvc视图解析器_SpringMVC详细
weixin_35404745的博客
01-24 152
#「闪光时刻」主题征文 二期# MVC是什么？mvc是模型(model)- 视图(view)- 控制器(controller)的缩写，它是一个设计模式。这三个部分以最少的耦合协同工作，从提高应用的可扩展性及可维护性mvc的特点·多个视图可以对应一个模型。按mvc设计模式，一个模型对应多个视图，可以减少代码的复制及代码的维护量，这样，一旦模型发生改变，也易于维护。·模型返回的数据与显示逻辑分离。模型...
Spring MVC如何解析视图
code_fighter 博客
01-28 402
请求处理方法执行完成后，最终返回一个 ModelAndView 对象。对于那些返回 String，View 或 ModeMap 等类型的处理方法，Spring MVC 也会在内部将它们装配成一个ModelAndView 对象，它包含了逻辑名和模型对象的视图 视图: 的作用是渲染模型数据，将模型里的数据以某种形式呈现给客户。为了实现视图模型和具体实现技术的解耦， Spring 在
springmvc视图解析器详解
Eaeyson的博客
06-09 9726
springmvc视图解析器详解
Spring MVC视图解析深度解析
在Spring MVC框架中，视图解析是实现模型和视图之间转换的关键环节。本教程将深入探讨Spring MVC的视图解析机制，帮助开发者理解如何通过视图解析器（ViewResolver）将逻辑视图名转换为实际的视图资源，并完成页面...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值