MyBatis中经典的五种设计模式源码剖析，打死都不要忘记！

已于 2024-03-15 17:19:58 修改
阅读量1.2k 收藏 21
点赞数 41
分类专栏： JAVA设计模式 文章标签： mybatis 设计模式 java
于 2024-03-15 17:18:59 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44716935/article/details/136744163
版权

MyBatis 3.5版本中也广泛使用了多种设计模式,下面是其中一些主要使用的设计模式

MyBatis

一、构建器模式

  • XMLConfigBuilder: 用于解析 MyBatis 配置文件
  • XMLMapperBuilder: 用于解析映射文件(Mapper.xml)
  • SqlSourceBuilder: 用于构建不同类型的 SqlSource 实现
  1. XMLConfigBuilder

XMLConfigBuilder 类用于解析 MyBatis 的全局配置文件,它的主要实现在 parse() 方法中。该方法通过 Java 的 SAX (Simple API for XML) 解析器来读取 XML 配置文件,并将配置项构建到 Configuration 对象中。

  1. XMLMapperBuilder

XMLMapperBuilder 类用于解析映射文件(Mapper.xml),它的主要实现在 parse() 方法中。该方法同样使用 SAX 解析器来读取映射文件,并根据不同的节点类型构建出相应的 MappedStatement 对象,最终添加到 Configuration 对象中。

  1. SqlSourceBuilder

SqlSourceBuilder 是一个抽象类,它定义了 parse() 方法的框架,用于解析不同类型的 SQL 节点(如 <select>、<insert>等)。具体的解析工作由其子类 XMLScriptBuilder 和 XMLStaticSqlSource 来完成。

XMLScriptBuilder 用于解析动态 SQL 节点,它会将节点内容构建成 SqlSource 接口的实现类 DynamicSqlSource。

XMLStaticSqlSource 用于解析静态 SQL 节点,它会将节点内容作为字符串直接构建出 StaticSqlSource 实例。

以上这些构建器类通过组合使用,共同完成了对 MyBatis 全局配置文件和映射文件的解析和构建工作。

// 创建 XMLConfigBuilder
XMLConfigBuilder configBuilder = ...
// 解析全局配置文件,构建 Configuration 对象
Configuration config = configBuilder.parse();

// 创建 XMLMapperBuilder
XMLMapperBuilder mapperBuilder = new XMLMapperBuilder(config, ...);
// 解析映射文件,构建 MappedStatement 对象并添加到 Configuration 中
mapperBuilder.parse();

// 创建 SqlSourceBuilder
SqlSourceBuilder sqlSourceBuilder = new XMLScriptBuilder(...);
// 解析 SQL 节点,构建 SqlSource 实现
SqlSource sqlSource = sqlSourceBuilder.parse(...);

二、工厂模式

  • SqlSessionFactory: 用于创建 SqlSession 实例
  • ObjectFactory: 用于创建结果对象的实例
  • TypeHandlerRegistry: 管理 TypeHandler 实例的注册与获取
  1. SqlSessionFactory

SqlSessionFactory 接口定义了 openSession() 方法,用于创建 SqlSession 对象。它的默认实现是 DefaultSqlSessionFactory 类。

在 DefaultSqlSessionFactory 中,通过构造函数或 openSessionFromDataSource() 方法创建 SqlSession 实例。以 openSession() 方法为例:

private SqlSession openSessionFromDataSource(ExecutorType execType, TransactionIsolationLevel level, boolean autoCommit) {
  Transaction tx = null;
  try {
    final Environment environment = configuration.getEnvironment();
    final TransactionFactory transactionFactory = getTransactionFactoryFromEnvironment(environment);
    tx = transactionFactory.newTransaction(environment.getDataSource(), level, autoCommit);
    final Executor executor = configuration.newExecutor(tx, execType);
    return new DefaultSqlSession(configuration, executor, autoCommit);
  } catch (Exception e) {
    closeTransaction(tx); // may have fetched a connection so lets call close()
    throw ExceptionFactory.wrapException("Error opening session.  Cause: " + e, e);
  } finally {
    ErrorContext.instance().reset();
  }
}
  1. ObjectFactory

ObjectFactory 接口定义了创建结果对象实例的方法。默认实现是 DefaultObjectFactory 类,它使用反射机制创建对象实例。

public <T> T create(Class<T> type) {
  return create(type, null, null);
}

public <T> T create(Class<T> type, List<Class<?>> constructorArgTypes, List<Object> constructorArgs) {
  Class<?> classToCreate = resolveInterface(type);
  // we know types are assignable
  return (T) createInstance(classToCreate, constructorArgTypes, constructorArgs);
}
  1. TypeHandlerRegistry

TypeHandlerRegistry 类用于管理 TypeHandler 实例的注册和获取。它维护了一个 TypeHandler 的注册表,开发者也可以通过 register() 方法注册自定义的 TypeHandler。

public <T> void register(TypeInfo<T> typeInfo, TypeHandler<? extends T> typeHandler) {
    register(MappedTypes.forTypeInfo(typeInfo), typeHandler);
}

private <T> void register(MappedTypes<T> mappedTypes, TypeHandler<? extends T> typeHandler) {
    if (mappedTypes.hasUnknownType()) {
        throw new IllegalArgumentException("Cannot add handlers for unknown types.");
    }
    bundlers.put(mappedTypes, typeHandler);
}

public <T> TypeHandler<T> getTypeHandler(Class<T> type) {
    return getTypeHandler((Type) type, null);
}

public <T> TypeHandler<T> getTypeHandler(Type type, TypeHandlerRegistry instance) {
    if (instance == null) {
        instance = this;
    }
    final Map<TypeInfo<?>, TypeHandler<?>> typeHandlers = instance.getTypeHandlers();
    TypeHandler<?> handler = typeHandlers.get(TypeParameterSetter.resolveType(type));
    if (handler == null) {
        handler = typeHandlers.get(MappedTypes.forType(type, null));
    }
    @SuppressWarnings("unchecked")
    // This cast should be safe as we'll only get handlers of the expected type
    TypeHandler<T> cachedHandler = (TypeHandler<T>) handler;
    return cachedHandler;
}

三、代理模式

  • MapperProxy: 基于 JDK 动态代理创建 Mapper 接口的代理实例
  • ConnectionProxy: 为 Connection 对象创建代理
    MyBatis 3.5版本中使用了 JDK 动态代理来实现代理模式,下面是关键源码分析:
  1. MapperProxy

MapperProxy 实现了 InvocationHandler 接口,用于创建 Mapper 接口的代理实例。关键代码如下:

public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
  try {
    // 如果是 Object 类中定义的方法,直接调用
    if (Object.class.equals(method.getDeclaringClass())) {
      return method.invoke(this, args);
    // 忽略一些方法
    } else if (isDefaultMethod(method)) {
      return invokeDefaultMethod(proxy, method, args);
    }
  } catch (Throwable t) {
    throw ExceptionUtil.unwrapThrowable(t);
  }
  // 创建 MapperMethod 实例,它定义了如何执行映射语句
  final MapperMethod mapperMethod = cachedMapperMethod(method);
  return mapperMethod.execute(sqlSession, args);
}

MapperProxy 会缓存 MapperMethod 实例,在执行 Mapper 接口方法时,会调用对应 MapperMethod 的 execute 方法,该方法内部会进一步调用 SqlSession 的方法执行映射语句。

  1. ConnectionProxy

ConnectionProxy 实现了 InvocationHandler 接口,用于为 Connection 对象创建代理。关键代码如下:

public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
  try {
    // 忽略 Object 类定义的方法
    if (Object.class.equals(method.getDeclaringClass())) {
      return method.invoke(this, args);
    // 忽略一些方法
    } else if (CLOSE.hashCode() == method.getName().hashCode() && CLOSE.equals(method.getName())) {
      return null;
    }
  } catch (Throwable t) {
    throw ExceptionUtil.unwrapThrowable(t);
  }
  // 如果是其他方法,执行原始 Connection 对象的对应方法
  try {
    return method.invoke(connection, args);
  } catch (Throwable t) {
    throw ExceptionUtil.unwrapThrowable(t);
  }
}

ConnectionProxy 的主要作用是拦截 Connection 的 close 方法,防止连接被过早关闭,其他方法调用都会转发给原始的 Connection 对象执行。通过代理模式,MyBatis 可以在原有功能的基础上添加一些额外的处理逻辑,如 SQL 缓存、延迟加载等,从而提高性能和扩展性。

四、 模板方法模式

  • BaseExecutor: 提供了 update、query 等模板方法
  • SimpleExecutor、ReuseExecutor 等继承并实现具体逻辑

下面我们来看 BaseExecutor 中 query 方法的实现:

public <E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) throws SQLException {
  // 获取缓存键
  CacheKey cacheKey = createCacheKey(ms, parameter, rowBounds, boundSql);
  return query(ms, parameter, rowBounds, resultHandler, cacheKey, boundSql);
}

private <E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, CacheKey cacheKey, BoundSql boundSql) throws SQLException {
  // 从二级缓存中获取结果
  List<E> list = resultHandlerCacheCtrl.getList(cacheKey, boundSql, resultHandler);
  if (list != null) {
    return list;
  }
  // 执行查询
  list = delegateExecute(ms, parameter, rowBounds, resultHandler, cacheKey, boundSql);
  // 存入二级缓存
  resultHandlerCacheCtrl.storeList(cacheKey, list);
  return list;
}

private <E> List<E> delegateExecute(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, CacheKey cacheKey, BoundSql boundSql) throws SQLException {
  // 由具体的执行器实现查询逻辑
  return delegate.execute(ms, parameter, rowBounds, resultHandler, boundSql);
}

在 query 方法中,先根据传入的参数创建缓存键,然后尝试从二级缓存中获取结果。如果缓存中没有,就调用 delegateExecute 方法执行具体的查询逻辑。查询结果会被存入二级缓存中。

delegateExecute 方法只是一个模板方法,它将具体的查询逻辑委托给了子类的 execute 方法去实现。

下面以 SimpleExecutor 为例,看一下它是如何实现 execute 方法的:

public <E> List<E> execute(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) throws SQLException {
  Configuration configuration = ms.getConfiguration();
  StatementHandler handler = configuration.newStatementHandler(wrapper, ms, parameter, rowBounds, resultHandler, boundSql);
  stmt = handler.prepare(statement, transaction.getTimeout());
  return handler.query(stmt, resultHandler);
}

SimpleExecutor 的 execute 方法首先创建了一个 StatementHandler 对象,然后调用它的 prepare 方法创建 Statement。最后,再调用 StatementHandler 的 query 方法执行查询,并返回结果。

通过这种模板方法模式的设计,BaseExecutor 定义了一个算法的框架,而具体的执行步骤由子类去实现

五、装饰器模式

  • Cache decorators: 为缓存提供装饰器扩展功能
  • ResultLoaderMap: 延迟加载的实现使用了装饰器模式
    在 MyBatis 3.5 版本中,装饰器模式主要应用在缓存和延迟加载功能上。下面分别对这两个部分的源码实现进行分析:
  1. Cache decorators: 为缓存提供装饰器扩展功能

MyBatis 使用装饰器模式为缓存功能提供了可扩展性,主要通过 CacheDecorator 抽象类和多个具体的装饰器类实现。

// CacheDecorator 是一个抽象装饰器类
public abstract class CacheDecorator implements Cache {
  // 持有被装饰的缓存对象
  protected final Cache delegate;

  // 构造函数将被装饰对象传入
  public CacheDecorator(Cache delegate) {
    this.delegate = delegate;
  }

  // 其他方法的实现都会调用被装饰对象的相应方法
  @Override
  public String getId() {
    return delegate.getId();
  }
  // ...
}

CacheDecorator 持有一个被装饰的 Cache 对象,并在其方法实现中调用该对象的相应方法。

具体的装饰器类继承自 CacheDecorator并添加了额外的功能,例如:

  • LruCache(最近最少使用缓存): 添加了维护缓存大小的功能
  • ScheduledCache(定时刷新缓存): 添加了定时刷新线程清理缓存的功能
  • SerializedCache(序列化缓存): 添加了缓存对象序列化功能
  • LoggingCache(日志缓存): 添加了缓存操作日志输出功能

通过装饰器模式的设计,MyBatis 可以很方便地扩展缓存的功能,只需要新增一个装饰器类就可以了。

  1. ResultLoaderMap: 延迟加载的实现使用了装饰器模式

MyBatis 使用 ResultLoaderMap 装饰器类为映射结果集提供了延迟加载功能。

public class ResultLoaderMap extends AbstractObjectDecorator {

  // 持有被装饰对象的元数据信息
  private final MetaObject metaResultObject;
  // ...

  public ResultLoaderMap(Object mapResult, Configuration configuration) {
    // 将被装饰对象传入父类
    super(mapResult);
    metaResultObject = configuration.newMetaObject(mapResult);
  }

  // 重写 setValue 方法,实现延迟加载
  @Override
  public void setValue(Object prop, Object value) {
    if (prop instanceof String) {
      // 调用父类 setValue 设置属性值
      super.setValue(prop, value);
    } else {
      // 通过 MetaObject 设置值,实现延迟加载
      metaResultObject.setValue(prop, value);
    }
  }
}

ResultLoaderMap 继承自 AbstractObjectDecorator，在构造函数中将被装饰对象传递给父类。
setValue 方法被重写,如果属性是 String 类型,则直接调用父类的 setValue 方法设置值;否则通过 MetaObject 设置值,实现延迟加载的逻辑。

六、代理模式

  1. 插件运行原理基于观察者模式

MyBatis 中有四大对象: Executor、ParameterHandler、ResultSetHandler 和 StatementHandler。插件可以选择性地监听这四个对象的方法,并在方法执行前后进行拦截和处理。

这个过程是通过动态代理实现的,MyBatis 会为目标对象创建一个代理对象,插件可以在代理对象的方法执行前后注入自己的逻辑。

public Object plugin(Object target) {
    // 生成代理对象
    return Plugin.wrap(target, this);
}

public static Object wrap(Object target, Interceptor interceptor) {
    // 获取目标对象的类
    Class<?> type = target.getClass();
    // 获取所有接口
    Class<?>[] interfaces = getAllInterfaces(type, null);
    if (interfaces.length > 0) {
        // 创建代理对象
        return Proxy.newProxyInstance(
            type.getClassLoader(),
            interfaces,
            new Plugin(target, interceptor));
    }
    return target;
}

在 Plugin 的 wrap 方法中,通过 JDK 动态代理创建了一个目标对象的代理对象,代理对象的所有方法调用都会被 Plugin 实例的 invoke 方法拦截。

  1. 插件通过监听四大对象的方法调用来实现自身逻辑

以 Executor 插件为例,它需要实现 Interceptor 接口,并重写 intercept 方法:

@Intercepts({@Signature(type = Executor.class, method = "update", args = {...})})
public class ExamplePlugin implements Interceptor {
    
    @Override
    public Object intercept(Invocation invocation) throws Throwable {
        // 执行被拦截方法之前进行的处理
        ...
        
        // 执行被拦截方法
        Object result = invocation.proceed();
        
        // 执行被拦截方法之后进行的处理
        ...
        
        return result;
    }
    
    @Override
    public Object plugin(Object target) {
        // 返回目标对象的代理对象
        return Plugin.wrap(target, this);
    }
}

在 intercept 方法中,插件可以在执行被拦截方法之前和之后注入自己的逻辑。插件通过 invocation.proceed() 调用执行被拦截方法。

插件需要在 plugin 方法中返回目标对象的代理对象,这样 MyBatis 在使用目标对象时就会使用这个代理对象,从而实现了插件逻辑的注入。

Java语录精选
关注
  • 41
    点赞
  • 踩
  • 21
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Mybatis 框架源码10种设计模式分析.pdf
09-12
Mybatis 框架源码10种设计模式分析.pdf
89丨开源实战五（下）：总结MyBatis框架中用到的10种设计模式1
08-04
有了前面这么多讲的学习和训练，我想你现在应该已经具备了一定的研究和分析能力，能够自己做查缺补漏，把提到的所有源码都搞清楚。所以，在今天的课程中，如果有哪里有疑问
基于Springboot+MyBatis-Plus实现多租户动态数据源模式源码（高分毕业设计）.zip
11-06
基于Springboot+MyBatis-Plus实现多租户动态数据源模式源码（高分毕业设计）.zip已获导师指导并通过的高分毕业设计项目，也可作为课程设计和期末大作业，下载即用无需修改，项目完整确保可以运行。 【备注】 主要针对计算机相关专业的正在做毕设的学生和需要项目实战的Java学习者。 也可作为课程设计、期末大作业。包含：项目源码、数据库脚本、项目说明等，该项目可以直接作为毕设使用。也可以用来学习参考借鉴！ 基于Springboot+MyBatis-Plus实现多租户动态数据源模式源码（高分毕业设计）.zip已获导师指导并通过的高分毕业设计项目，也可作为课程设计和期末大作业，下载即用无需修改，项目完整确保可以运行。 【备注】 主要针对计算机相关专业的正在做毕设的学生和需要项目实战的Java学习者。 也可作为课程设计、期末大作业。包含：项目源码、数据库脚本、项目说明等，该项目可以直接作为毕设使用。也可以用来学习参考借鉴！ 基于Springboot+MyBatis-Plus实现多租户动态数据源模式源码（高分毕业设计）.zip已获导师指导并通过的高分毕业设计项目，也可作为课程设计
基于SpringBoot和Mybatis的网上鲜花交易平台设计源码
04-09
本资源提供了一套基于SpringBoot和Mybatis开发的网上鲜花交易平台设计源码。该项目包含了163个SVG文件、155个JavaScript文件、135个Java源文件、80个GIF动画文件、63个JPG图像文件、50个Vue文件、47个HTML文件、46个CSS文件、43个PNG图像文件以及22个XML配置文件，共871个文件。系统实现了网上鲜花交易的功能，适合需要开发网上鲜花交易平台的开发者学习和使用。
设计模式在mybatis中的应用
08-08
设计模式在mybatis中的应用
腊月一十八，聊聊 MyBatis 中的设计模式.docx
11-19
腊月一十八，聊聊 MyBatis 中的设计模式
设计模式（十）：装饰者模式
wenqi1992的博客
04-29 440
装饰者模式的介绍
C++11 设计模式6. 建造者模式，也叫做生成器模式
hunandede的博客
04-29 711
建造者模式（也被成为⽣成器模式），是⼀种创建型设计模式，软件开发过程中有的时候需要创建很复杂的对象，⽽建造者模式的主要思想是将对象的构建过程分为多个步骤，并为每个步骤定义⼀个抽象的接⼝。，构建过程相对复杂，⽽我们使⽤建造者模式将计算机的构建过程封装在⼀个具体的建造者类中，⽽指导者类则负责指导构建的步骤和顺序。每个具体的建造者类可以负责构建不同型号或配置的计算机，客户端代码可以通过选择不同的建造者来创建不同类型的计算机，这样就可以根据需要构建不同表示的复杂对象，更加灵活。
23种设计模式
weixin_72256328的博客
05-01 979
23种设计模式
c++设计模式
qq_27344469的博客
04-28 289
uniontech: 赵良云问题: 23种设计模式，你知道多少....，KL:大话数据结构、大话设计模式、人人都是产品经理，编程之美。ChinaSoft:数据结构，类模板与模板类，回调函数。加班复加班，加班何其多，事事待加班，项目成蹉跎；单一职责原则、开放封闭原则、依赖倒转原则。业务逻辑与界面分开，让它们之间的耦合度下降。面向对象思想(维护性 扩展性 复用性)Hollysys:深拷贝与浅拷贝。编程是一门技术，更加是一门艺术。这是看到的一篇博主写的文章，努力一次把事情做好。
Java 设计模式（行为型）
心若有所向往，何惧道阻且长。
04-28 1218
Java 设计模式（行为型）
设计模式的原则与分类
孟孟的博客
04-30 369
单一职责原则是接口隔离原则的基础，单一职责原则注重职责的划分，从职责角度进行类和接口的划分；迪米特法则 又叫做最少知道原则，一个类对于其他类知道得越少越好，简单来说就是只暴露方法入口，而实现细节不需要暴露给调用者。如果要修改一个功能，不是直接进行内部的代码修改，而是使用扩展的方式进行。结构型模式，更加注重类或对象的结合方式，将类或对象进行结合，形成一个更大的结构，在该结构下，不同的组件扮演不同的角色。一个类只需要负责一种职责即可，一个类发生变化的原因，必然是所负责的职责发生变化。
Java 设计模式（结构型）
心若有所向往，何惧道阻且长。
04-29 1121
Java 设计模式（结构型）
23种设计模式之建造者模式
JAVA开发区的博客
04-28 1101
将一个复杂对象的构造与它的表示分离，使同样的建造过程可以创建不同的表示，这样的设计模式被称为建造者模式。它是一个负责的对象分解为多个简单的对象，然后一步步构建而成。它将变与不变相分离，即产品的组成部分是不变的，但每一部分是可以灵活选择的。
【设计模式】17、iterator 迭代器模式
最新发布
呆呆的猫的博客
05-02 474
为了集合数据的安全性, 或方便迭代, 可以用迭代器接口. 屏蔽复杂的内部逻辑, 外部只能使用迭代器遍历
设计模式：工厂模式
choice~的博客
04-29 2101
在这篇文章中，我将解释为什么工厂是有用的，然后我将用来自著名Java框架或Java API的真实示例来介绍每种类型。我将使用Java代码来实现工厂，但如果你不了解Java，你仍然能够理解这个想法。此外，我将使用 UML 来正式描述模式。虽然本文是关于工厂模式的，但仅仅为了使用模式而使用模式比从不使用模式更糟糕。这种行为是一种反模式。实际上，大多数模式使代码更难以理解。大多数时候，我不使用工厂。例如：我一直认为工厂是它们的优势（将在下一部分中看到它们）与代码的可读性和理解性之间的权衡。工厂的主要目标是实例化对
【设计模式】简单工厂模式（Simple Factory Pattern）
无休居士的博客
04-29 547
简单工厂模式是一种类创建型设计模式，它提供一个静态方法来创建对象。
Python设计模式(二)
weixin_37901366的博客
04-28 354
【代码】Python设计模式(二)
设计模式-组合模式
weixin_51832365的博客
04-28 1158
组合（Composite Pattern）模式的定义：有时又叫作整体-部分（Part-Whole）模式，它是一种将对象组合成树状的层次结构的模式，用来表示“整体-部分”的关系，使用户对单个对象和组合对象具有一致的访问性，属于结构型设计模式。组合模式一般用来描述整体与部分的关系，它将对象组织到树形结构中，顶层的节点被称为根节点，根节点下面可以包含树枝节点和叶子节点，树枝节点下面又可以包含树枝节点和叶子节点，树形结构图如下。由上图可以看出，其实根节点和树枝节点本质上属于同一种数据类型，可以作为容器使用；
mybatis中常用的设计模式
06-07
在 MyBatis 中，常用的设计模式包括： 1. 工厂模式：MyBatis 中的 SqlSessionFactory 和 SqlSession 都是...总之，MyBatis 中采用了多种设计模式，这些设计模式都有助于提高 MyBatis 的灵活性、可扩展性和可维护性。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

Java语录精选

你的鼓励是我坚持下去的动力

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

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

打赏作者

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

抵扣说明：

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

余额充值