mybatis 后台分页实现

最新推荐文章于 2021-11-28 12:50:48 发布
最新推荐文章于 2021-11-28 12:50:48 发布
阅读量386 收藏
点赞数
文章标签： java 后端 数据库
原文链接：https://my.oschina.net/zhenghuazhi/blog/199113
版权 
package page;

public interface Dialect {
    
    public boolean supportsLimit();

    public String getLimitString(String sql, boolean hasOffset);

    public String getLimitString(String sql, int offset, int limit);

	public boolean supportsLimitOffset();
}

 

package page;

public class MySQLDialect implements Dialect {

	protected static final String SQL_END_DELIMITER = ";";

	public String getLimitString(String sql, boolean hasOffset) {
		return new StringBuffer(sql.length() + 20).append(trim(sql))
				.append(hasOffset ? " limit ?,?" : " limit ?")
				.append(SQL_END_DELIMITER).toString();
	}

	public String getLimitString(String sql, int offset, int limit) {
		sql = trim(sql);
		StringBuffer sb = new StringBuffer(sql.length() + 20);
		sb.append(sql);
		if (offset > 0) {
			sb.append(" limit ").append(offset).append(',').append(limit)
					.append(SQL_END_DELIMITER);
		} else {
			sb.append(" limit ").append(limit).append(SQL_END_DELIMITER);
		}
		return sb.toString();
	}

	public boolean supportsLimit() {
		return true;
	}

	private String trim(String sql) {
		sql = sql.trim();
		if (sql.endsWith(SQL_END_DELIMITER)) {
			sql = sql.substring(0,
					sql.length() - 1 - SQL_END_DELIMITER.length());
		}
		return sql;
	}

	public boolean supportsLimitOffset() {
		// TODO Auto-generated method stub
		return true;
	}

}

 

package page;

import java.util.Properties;

import org.apache.ibatis.executor.Executor;
import org.apache.ibatis.mapping.BoundSql;
import org.apache.ibatis.mapping.MappedStatement;
import org.apache.ibatis.mapping.MappedStatement.Builder;
import org.apache.ibatis.mapping.SqlSource;
import org.apache.ibatis.plugin.Interceptor;
import org.apache.ibatis.plugin.Intercepts;
import org.apache.ibatis.plugin.Invocation;
import org.apache.ibatis.plugin.Plugin;
import org.apache.ibatis.plugin.Signature;
import org.apache.ibatis.session.ResultHandler;
import org.apache.ibatis.session.RowBounds;

@Intercepts({ @Signature(type = Executor.class, method = "query", args = {
		MappedStatement.class, Object.class, RowBounds.class,
		ResultHandler.class }) })
public class OffsetLimitInterceptor implements Interceptor {
	static int MAPPED_STATEMENT_INDEX = 0;
	static int PARAMETER_INDEX = 1;
	static int ROWBOUNDS_INDEX = 2;
	static int RESULT_HANDLER_INDEX = 3;

	Dialect dialect;

	public Object intercept(Invocation invocation) throws Throwable {
		processIntercept(invocation.getArgs());
		return invocation.proceed();
	}

	void processIntercept(final Object[] queryArgs) {
		// queryArgs = query(MappedStatement ms, Object parameter, RowBounds
		// rowBounds, ResultHandler resultHandler)
		MappedStatement ms = (MappedStatement) queryArgs[MAPPED_STATEMENT_INDEX];
		Object parameter = queryArgs[PARAMETER_INDEX];
		final RowBounds rowBounds = (RowBounds) queryArgs[ROWBOUNDS_INDEX];
		int offset = rowBounds.getOffset();
		int limit = rowBounds.getLimit();

		if (dialect.supportsLimit()
				&& (offset != RowBounds.NO_ROW_OFFSET || limit != RowBounds.NO_ROW_LIMIT)) {
			BoundSql boundSql = ms.getBoundSql(parameter);
			String sql = boundSql.getSql().trim();
			if (dialect.supportsLimitOffset()) {
				sql = dialect.getLimitString(sql, offset, limit);
				offset = RowBounds.NO_ROW_OFFSET;
			} else {
				sql = dialect.getLimitString(sql, 0, limit);
			}
			limit = RowBounds.NO_ROW_LIMIT;

			queryArgs[ROWBOUNDS_INDEX] = new RowBounds(offset, limit);
			BoundSql newBoundSql = new BoundSql(ms.getConfiguration(), sql,
					boundSql.getParameterMappings(),
					boundSql.getParameterObject());
			MappedStatement newMs = copyFromMappedStatement(ms,
					new BoundSqlSqlSource(newBoundSql));
			queryArgs[MAPPED_STATEMENT_INDEX] = newMs;
		}
	}

	private MappedStatement copyFromMappedStatement(MappedStatement ms,
			SqlSource newSqlSource) {
		Builder builder = new MappedStatement.Builder(ms.getConfiguration(),
				ms.getId(), newSqlSource, ms.getSqlCommandType());
		builder.resource(ms.getResource());
		builder.fetchSize(ms.getFetchSize());
		builder.statementType(ms.getStatementType());
		builder.keyGenerator(ms.getKeyGenerator());
		builder.keyProperty(ms.getKeyProperty());
		builder.timeout(ms.getTimeout());
		builder.parameterMap(ms.getParameterMap());
		builder.resultMaps(ms.getResultMaps());
		builder.cache(ms.getCache());
		MappedStatement newMs = builder.build();
		return newMs;
	}

	public Object plugin(Object target) {
		return Plugin.wrap(target, this);
	}

	public void setProperties(Properties properties) {
		String dialectClass = new PropertiesHelper(properties)
				.getRequiredString("dialectClass");
		try {
			dialect = (Dialect) Class.forName(dialectClass).newInstance();
		} catch (Exception e) {
			throw new RuntimeException(
					"cannot create dialect instance by dialectClass:"
							+ dialectClass, e);
		}
		System.out.println(OffsetLimitInterceptor.class.getSimpleName()
				+ ".dialect=" + dialectClass);
	}

	public static class BoundSqlSqlSource implements SqlSource {
		BoundSql boundSql;

		public BoundSqlSqlSource(BoundSql boundSql) {
			this.boundSql = boundSql;
		}

		public BoundSql getBoundSql(Object parameterObject) {
			return boundSql;
		}
	}

}

 

package page;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintStream;
import java.io.PrintWriter;
import java.util.Collection;
import java.util.Enumeration;
import java.util.InvalidPropertiesFormatException;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Properties;
import java.util.Set;

public class PropertiesHelper {
	/** Never check system properties. */
	public static final int SYSTEM_PROPERTIES_MODE_NEVER = 0;
	/**
	 * * Check system properties if not resolvable in the specified properties.
	 * * This is the default.
	 */
	public static final int SYSTEM_PROPERTIES_MODE_FALLBACK = 1;
	/**
	 * * Check system properties first, before trying the specified properties.
	 * * This allows system properties to override any other property source.
	 */
	public static final int SYSTEM_PROPERTIES_MODE_OVERRIDE = 2;
	Properties p;
	private int systemPropertiesMode = SYSTEM_PROPERTIES_MODE_NEVER;

	public PropertiesHelper(Properties p) {
		setProperties(p);
	}

	public PropertiesHelper(Properties p, int systemPropertiesMode) {
		setProperties(p);
		if (systemPropertiesMode != SYSTEM_PROPERTIES_MODE_NEVER
				&& systemPropertiesMode != SYSTEM_PROPERTIES_MODE_FALLBACK
				&& systemPropertiesMode != SYSTEM_PROPERTIES_MODE_OVERRIDE) {
			throw new IllegalArgumentException(
					"error systemPropertiesMode mode:" + systemPropertiesMode);
		}
		this.systemPropertiesMode = systemPropertiesMode;
	}

	public Properties getProperties() {
		return p;
	}

	public void setProperties(Properties props) {
		if (props == null)
			throw new IllegalArgumentException("properties must be not null");
		this.p = props;
	}

	public String getRequiredString(String key) {
		String value = getProperty(key);
		if (isBlankString(value)) {
			throw new IllegalStateException(
					"required property is blank by key=" + key);
		}
		return value;
	}

	public String getNullIfBlank(String key) {
		String value = getProperty(key);
		if (isBlankString(value)) {
			return null;
		}
		return value;
	}

	public String getNullIfEmpty(String key) {
		String value = getProperty(key);
		if (value == null || "".equals(value)) {
			return null;
		}
		return value;
	}

	/** * 尝试从System.getProperty(key)及System.getenv(key)得到值 * @return */
	public String getAndTryFromSystem(String key) {
		String value = getProperty(key);
		if (isBlankString(value)) {
			value = getSystemProperty(key);
		}
		return value;
	}

	private String getSystemProperty(String key) {
		String value;
		value = System.getProperty(key);
		if (isBlankString(value)) {
			value = System.getenv(key);
		}
		return value;
	}

	public Integer getInteger(String key) {
		String v = getProperty(key);
		if (v == null) {
			return null;
		}
		return Integer.parseInt(v);
	}

	public int getInt(String key, int defaultValue) {
		if (getProperty(key) == null) {
			return defaultValue;
		}
		return Integer.parseInt(getRequiredString(key));
	}

	public int getRequiredInt(String key) {
		return Integer.parseInt(getRequiredString(key));
	}

	public Long getLong(String key) {
		if (getProperty(key) == null) {
			return null;
		}
		return Long.parseLong(getRequiredString(key));
	}

	public long getLong(String key, long defaultValue) {
		if (getProperty(key) == null) {
			return defaultValue;
		}
		return Long.parseLong(getRequiredString(key));
	}

	public Long getRequiredLong(String key) {
		return Long.parseLong(getRequiredString(key));
	}

	public Boolean getBoolean(String key) {
		if (getProperty(key) == null) {
			return null;
		}
		return Boolean.parseBoolean(getRequiredString(key));
	}

	public boolean getBoolean(String key, boolean defaultValue) {
		if (getProperty(key) == null) {
			return defaultValue;
		}
		return Boolean.parseBoolean(getRequiredString(key));
	}

	public boolean getRequiredBoolean(String key) {
		return Boolean.parseBoolean(getRequiredString(key));
	}

	public Float getFloat(String key) {
		if (getProperty(key) == null) {
			return null;
		}
		return Float.parseFloat(getRequiredString(key));
	}

	public float getFloat(String key, float defaultValue) {
		if (getProperty(key) == null) {
			return defaultValue;
		}
		return Float.parseFloat(getRequiredString(key));
	}

	public Float getRequiredFloat(String key) {
		return Float.parseFloat(getRequiredString(key));
	}

	public Double getDouble(String key) {
		if (getProperty(key) == null) {
			return null;
		}
		return Double.parseDouble(getRequiredString(key));
	}

	public double getDouble(String key, double defaultValue) {
		if (getProperty(key) == null) {
			return defaultValue;
		}
		return Double.parseDouble(getRequiredString(key));
	}

	public Double getRequiredDouble(String key) {
		return Double.parseDouble(getRequiredString(key));
	}

	/** setProperty(String key,int value) ... start */
	public Object setProperty(String key, int value) {
		return setProperty(key, String.valueOf(value));
	}

	public Object setProperty(String key, long value) {
		return setProperty(key, String.valueOf(value));
	}

	public Object setProperty(String key, float value) {
		return setProperty(key, String.valueOf(value));
	}

	public Object setProperty(String key, double value) {
		return setProperty(key, String.valueOf(value));
	}

	public Object setProperty(String key, boolean value) {
		return setProperty(key, String.valueOf(value));
	}

	/** delegate method start */
	public String getProperty(String key, String defaultValue) {
		return p.getProperty(key, defaultValue);
	}

	public String getProperty(String key) {
		String propVal = null;
		if (systemPropertiesMode == SYSTEM_PROPERTIES_MODE_OVERRIDE) {
			propVal = getSystemProperty(key);
		}
		if (propVal == null) {
			propVal = p.getProperty(key);
		}
		if (propVal == null
				&& systemPropertiesMode == SYSTEM_PROPERTIES_MODE_FALLBACK) {
			propVal = getSystemProperty(key);
		}
		return propVal;
	}

	public Object setProperty(String key, String value) {
		return p.setProperty(key, value);
	}

	public void clear() {
		p.clear();
	}

	public Set<Entry<Object, Object>> entrySet() {
		return p.entrySet();
	}

	public Enumeration<?> propertyNames() {
		return p.propertyNames();
	}

	public boolean contains(Object value) {
		return p.contains(value);
	}

	public boolean containsKey(Object key) {
		return p.containsKey(key);
	}

	public boolean containsValue(Object value) {
		return p.containsValue(value);
	}

	public Enumeration<Object> elements() {
		return p.elements();
	}

	public Object get(Object key) {
		return p.get(key);
	}

	public boolean isEmpty() {
		return p.isEmpty();
	}

	public Enumeration<Object> keys() {
		return p.keys();
	}

	public Set<Object> keySet() {
		return p.keySet();
	}

	public void list(PrintStream out) {
		p.list(out);
	}

	public void list(PrintWriter out) {
		p.list(out);
	}

	public void load(InputStream inStream) throws IOException {
		p.load(inStream);
	}

	public void loadFromXML(InputStream in) throws IOException,
			InvalidPropertiesFormatException {
		p.loadFromXML(in);
	}

	public Object put(Object key, Object value) {
		return p.put(key, value);
	}

	public void putAll(Map<? extends Object, ? extends Object> t) {
		p.putAll(t);
	}

	public Object remove(Object key) {
		return p.remove(key);
	}

	/** @deprecated */
	public void save(OutputStream out, String comments) {
		p.save(out, comments);
	}

	public int size() {
		return p.size();
	}

	public void store(OutputStream out, String comments) throws IOException {
		p.store(out, comments);
	}

	public void storeToXML(OutputStream os, String comment, String encoding)
			throws IOException {
		p.storeToXML(os, comment, encoding);
	}

	public void storeToXML(OutputStream os, String comment) throws IOException {
		p.storeToXML(os, comment);
	}

	public Collection<Object> values() {
		return p.values();
	}

	public String toString() {
		return p.toString();
	}

	private static boolean isBlankString(String value) {
		return value == null || "".equals(value.trim());
	}
}

 

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE configuration
PUBLIC "-//ibatis.apache.org//DTD Config 3.0//EN"
"http://ibatis.apache.org/dtd/ibatis-3-config.dtd">
<configuration>
<plugins>  

	<plugin interceptor="page.OffsetLimitInterceptor">
		<property name="dialectClass"
			value="page.MySQLDialect" />
	</plugin>
</plugins>

	<environments default="development">
		<environment id="development">
			<transactionManager type="JDBC" />
			<dataSource type="POOLED">
				<property name="driver" value="com.mysql.jdbc.Driver" />
				<property name="url"
					value="jdbc:mysql://localhost:3306/test?useUnicode=true&amp;characterEncoding=UTF-8" />
				<property name="username" value="root" />
				<property name="password" value="sa" />
			</dataSource>
		</environment>
	</environments>
	<mappers>
		<mapper resource="com/company/project/model/mapper/UserInfoMapper.xml" />
	</mappers>
</configuration>

 

import java.io.Reader;
import java.util.List;

import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.RowBounds;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;

import com.company.project.model.UserInfo;
/**
 * @author badqiu
 */
public class Ibatis3DemoMain {
	
	public static void main(String[] args) throws Exception {
		
		Reader reader = Resources.getResourceAsReader("Configuration.xml");
		SqlSessionFactory sessionFactory = new SqlSessionFactoryBuilder().build(reader);
		SqlSession session = sessionFactory.openSession();
		
		testCrud(session);
	}

	private static void testCrud(SqlSession session) {
		
		
		
		// test select
//		Long count = (Long)session.selectOne("UserInfo.count",user);
//		assertTrue(1 == count);
		List<UserInfo> list = session.selectList("UserInfo.pageSelect",user,new RowBounds(0, 2));
		
		for (UserInfo info : list) {
			System.out.println(info.toString());
		}
//		SqlSession.selectList(statement, parameter, new RowBounds(offset,limit))即可使用物理分页

//		fromDb = (UserInfo)list.get(0);
	}
	
}

 由于版本问题，BoundSql类在ibatis3的版本中构造函数新增了一个参数，

public BoundSql(Configuration configuration, String sql, List<ParameterMapping> parameterMappings, Object parameterObject) {
    this.sql = sql;
    this.parameterMappings = parameterMappings;
    this.parameterObject = parameterObject;
    this.additionalParameters = new HashMap<String, Object>();
    this.metaParameters = configuration.newMetaObject(additionalParameters);
  }

 所以，必须要先获得configuration，configuration可以通过MappedStatement获得。

转载于:https://my.oschina.net/zhenghuazhi/blog/199113

chengyu0485
关注
MyBatis使用篇（十一）—— MyBatis实现分页
王喆峰的博客
01-08 2927
文章目录1、搭建演示环境1.1 创建数据表1.2 创建实体类1.3 创建接口Dao1.4 创建SQL映射文件1.5 创建测试类2、通过List结果集实现分页2.1 添加接口方法2.2 添加SQL标签2.3 添加测试方法3、通过SQL参数实现分页3.1 添加接口方法3.2 添加SQL标签3.3 添加测试方法4、通过RowBounds实现分页4.1 添加接口方法4.2 添加SQL标签4.3 添加测试方...
springboot+mybatis实现分页
七和
01-18 3481
分页成果展示：www.qihea.xyz 1.整合mybatis框架 1.数据库准备好数据：我网站中的数据时通过python爬虫，直接保存到数据库中的。图片直接保存的豆瓣的url。 2.整合mybatis依赖和mybatis分页插件： 根据此教程完成初步操作：Kotlin+IDEA+SpringBoot+MyBatis+MySQL+Gradle项目（不要选择kotlin即可） 然后添...
Spring&boot;mybatis;增删改查前后端分离分页demo
11-07
Spring&boot;&mybatis;增删改查&前后端分离&分页&demo;
mybatis后端分页查询
weixin_42592992的博客
03-11 267
第一个参数的意思为：当前页数，第二个参数的意思为：每页显示多少条记录 获取参数后执行 PageHelper.startPage(pageNum,pageSize); 只对紧跟其后的 第一条SQL语句有效 xxxxxxxxxxxxxxxxxxxxxxxxxxxx （它返回的数据，只能返回Page或者是List，Page实际上也是List，所以要用pageinfo来接收） PageInfo page = new PageInfo(selectview,5);//传入连续显示的页数5 ...
Mysql+Mybatis+spring 后台分页
热门推荐
ppt0501的专栏
10-29 2万+
一、mybatis分页是基于mybatis plugin，用拦截器实现，上代码。 1、生产sql语句： package com.csair.interceptor; import java.sql.Connection; import java.util.HashMap; import java.util.Properties; import org.apache.ibatis.execu
mybatis 实现分页和过滤模糊查询
zzvar的博客
05-12 2963
基于 mybatis 的分页和过滤查询学习内容：分页设计1、分页需传递的参数2、分页需展示的数据3、分页需展示的数据的来源3.1、结果总数与结果集（分页原理）3.2、总页数、上一页和下一页4、分页实现源码（只写重要部分）4.1、编写 PageResult.java4.2、编写 QueryObject.java4.3、编写 ProductQueryObject .java4.4、编写 ProductMapper.xml4.5、编写 ProductDAOImpl.java4.6、编写 ProductServic
mybatis分页jar
12-04
PageHelper插件的核心是通过对SQL语句进行智能解析，自动添加分页条件，从而实现数据库的高效分页查询。在本例中，我们涉及到的版本是PageHelper 5.1.8，它应该包含了对各种数据库的良好支持和优化。 PageHelper...
Mybatis实现分页
weixin_41438466的博客
09-28 1186
0. 什么时候会用到分页 在web开发过程中涉及到表格时，例如dataTable，就会产生分页的需求，通常我们将分页方式分为两种：前端分页和后端分页。 前端分页 一次性请求数据表格中的所有记录(ajax)，然后在前端缓存并且计算count和分页逻辑，一般前端组件(例如dataTable)会提供分页动作。 特点是：简单，很适合小规模的web平台；当数据量大的时候会产生性能问题，在查询和网络传输的...
springboot+mybatis+limit代码实现分页、web前端到后台、crud、搜索关键字、完整实例项目
01-11
java后台springboot技术的小实例项目,浏览器地址访问http://localhost:8080/dialog/selectAllLaw
Mybatis后台物理分页查询
weixin_44231698的博客
11-02 161
　　分页查询在日常开发中是非常常见的，往往分为逻辑分页、物理分页。如果数据量较大，对内存、网络传输的消耗非常大的时候选择物理分页。 本章节我们主要讲物理分页查询，以一个例子展开，把B库的user表每次查询100条循环查询并批量插入A库的user表中。 　　我们的项目框架是jeesite，首先我们为项目配置A库，B库数据源，见配置多数据源文章。下面我们将列举此功能的代码： 1.Contro...
后端框架的学习----mybatis框架（5、分页）
日常笔记 | 干货分享 | 毕设源码 | 毕设指导 | 答辩指导
11-28 375
七、分页 简单使用 1、在要使用Log4j的类中，导入包import org.apache.log4j.Logger; 2、日志对象，参数为当前类的class static Logger logger = Logger.getLogger(UserDaoTest.class); 3、日志级别 logger.info("info:进入了testlog4"); logger.debug("debug:进入了debug"); logger.error("e
SpringBoot+Mybatis实现后台分页
weixin_42370891的博客
12-09 2608
SpringBoot+Mybatis实现后台分页 1.首先我们新建一个springboot工程 在pom.xml中引用分页插件，千万不要引用错了。 &lt;!--分页插件--&gt; &lt;dependency&gt; &lt;groupId&gt;com.github.pagehelper&lt;/groupId&gt; &lt;artifactId&gt;pagehelper...
mybatis pagehelper插件实现后端分页
hahaowenGG的博客
04-15 247
pagehelp分页实现 前段部分： 通过JS实现 <script language="javascript"> function pagebtn(obj,url,pages,pagenumber) { var temp="<div>" +"<ul class='pagination'>&l...
第18章—后端分页（Mybatis）
weixin_30337157的博客
01-28 114
spring boot 系列学习记录：http://www.cnblogs.com/jinxiaohang/p/8111057.html 码云源码地址：https://gitee.com/jinxiaohang/springboot 　　本次练习在之前第04章—整合Mybatis基础上进行，也算是Bootstrap-Table基础上进行扩展。 在使用mybatis时，我会将实体类属...
真分页后端实现--Mybatis
灵活的小胖子
07-22 534
首先，我们要真分页查询文件 然后，由于文件数据很多，我们设计了根据文件名称模糊查询文件的功能 由于采取了分页，需要根据查询出来的总的文件数来判断到底有几页 根据上面的几个需求，我们写了三个接口： 1.真分页查询每一页的数据 2.根据文件名真分页模糊查询 3.查询文件总数 优化： 三个合成一个 实现： 定义一个基础分页类basePage（好处：任何需要分页的地方只要继承这个基础分页类即可）： //@Data可以为类提供读写功能，从而不用写get、set方法;他还会为类提供 equa..
利用Mybatis来实现前后端数据的分页
NULL
02-19 1187
1, 在spring的配置文件创建 SqlMapConfig.xml &lt;?xml version="1.0" encoding="UTF-8" ?&gt; &lt;!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN" "http://mybatis.org/dtd/mybatis-3-config.dtd"&
让mybatis sql注解支持 IN 多参数传递
简单之美
06-02 1万+
import java.util.List; import java.util.Map; import org.apache.ibatis.annotations.Param; import org.apache.ibatis.annotations.Select; import org.springframework.stereotype.Repository; /** * */ @Re
Mybatis PageHelper分页插件与后台静态页面管理实践
总结来说，本文详细介绍了如何在后台管理系统中使用分页插件PageHelper来实现数据库查询的分页功能，以及如何配置静态资源映射和Mybatis插件，这对于构建高效、易用的后台管理系统具有重要意义。开发者在实际开发...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值