Mybatis源码分析（五）SqlSession的创建

已于 2023-09-02 15:57:07 修改
阅读量1.6k 收藏
点赞数
分类专栏： # Mybatis源码分析 文章标签： mybatis java 数据库 源码分析 学习
于 2023-01-12 17:01:06 首次发布
小林
本文链接：https://blog.csdn.net/weixin_44451022/article/details/128663031
版权

目录

系列文章：

文章状态时间描述
（一）Mybatis 基本使用已复习2022-12-14对Mybtais的基本使用，能够开发
（二）Mybatis-config.xml的初始化已复习2023-02-10对我们编写的mybatis配置文件的解析
（三）SqlSessionFactory的初始化已复习2023-02-11SqlSession会话工厂的初始化
（四）Mapper文件的解析已复习2023-02-12主要对我们编写的Mapper.xml进行解析
（五）SqlSession的创建已复习2023-02-13主要介绍构建DefaultSqlSessionFactory
（六）Mapper的接口代理已复习2023-02-14如何通过动态代理来执行我们编写的方法
（七）MapperMethod的INSERT分析已复习2023-02-15通过代理对象来执行Insert语句，返回结果
（八）MapperMethod的Select分析已复习2023-02-16通过代理对象来执行Select语句，返回结果
（九）Mybatis的PreparedStatement已复习2023-02-17预处理语句的常见，以及与数据库打交道
（十）Mybatis的结果隐射已复习2023-02-18数据库结果与实体类对象的转换
（十一）Mybatis中的缓存计划中–Mybatis中一级缓存与二级缓存
（十二）Mybatis中的插件开发计划中–Mybatis中的插件运行机制与开发
（十三）Mybatis中的四大组件梳理计划中–Mybatis中的四大组件的梳理
（十四）Mybatis中的设计模式梳理计划中–Mybatis中设计模式的整理
（十五）Spring-Mybatis整理计划中–Spring与Mybatis整合
（十六）Mybatis疑惑总结计划中–我遇到的疑惑与问题

使用 MyBatis 的主要 Java 接口就是 SqlSession。你可以通过这个接口来执行命令，获取映射器实例和管理事务。在介绍 SqlSession 接口之前，我们先来了解如何获取一个 SqlSession 实例。SqlSessions 是由 SqlSessionFactory 实例创建的。SqlSessionFactory 对象包含创建 SqlSession 实例的各种方法。而 SqlSessionFactory 本身是由 SqlSessionFactoryBuilder 创建的，它可以从 XML、注解或 Java 配置代码来创建 SqlSessionFactory。

一 SqlSession的创建

@Test
    void contextLoads() {
        // 第一阶段：MyBatis的初始化阶段
        String resource = "mybatis-config.xml";
        // 得到配置文件的输入流
        InputStream inputStream = null;
        try {
            inputStream = Resources.getResourceAsStream(resource);
        } catch (IOException e) {
            e.printStackTrace();
        }

        // 得到SqlSessionFactory
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);

        // 第二阶段：数据读写阶段
        try (SqlSession session = sqlSessionFactory.openSession()) {
            // 找到接口对应的实现
            UserMapper userMapper = session.getMapper(UserMapper.class);
            // 组建查询参数
            User userParam = new User();
            userParam.setSchoolname("Sunny School");
            // 调用接口展开数据库操作
            List<User> userList =  userMapper.queryAllByLimit(userParam);
            // 打印查询结果
            for (User user : userList) {
                System.out.println("name : " + user.getName() + " ;  email : " + user.getEmail());
            }
        }

    }
  • 我们来看看SqlSession的创建是如何创建的，在上两篇文件中完成配置文件的解析返回SqlSessionFactory
          // 第二阶段：数据读写阶段
        try (SqlSession session = sqlSessionFactory.openSession()) {
  • 可以通过调式看出，我们的SqlSessionFactory的实现是DefaultSqlSessionFactory

DefaultSqlSessionFactory


@Override
  public SqlSession openSession() {
    return openSessionFromDataSource(configuration.getDefaultExecutorType(), null, false);
  }



public enum ExecutorType {

  SIMPLE, // 为每个语句创建新的预处理语句
  REUSE,  // 复用
  BATCH   // 执行批量操作
}


/**
   * 从数据源中获取SqlSession对象
   * @param execType 执行器类型
   * @param level 事务隔离级别
   * @param autoCommit 是否自动提交事务
   * @return SqlSession对象
   */
  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);
      // 创建DefaultSqlSession对象
      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. 首先从configuration获取Environment对象，里面主要包含了DataSource和TransactionFactory对象
  2. 创建TransactionFactory对象
  3. 创建Transaction对象
  4. 从configuration获取Executor
  5. 构造DefaultSqlSession对象

1.1 获取environments配置元素

//配置environment环境
<environments default="development">
    <environment id="development">
        /** 事务配置 type= JDBC、MANAGED 
         *  1.JDBC:这个配置直接简单使用了JDBC的提交和回滚设置。它依赖于从数据源得到的连接来管理事务范围。
         *  2.MANAGED:这个配置几乎没做什么。它从来不提交或回滚一个连接。
         */
        <transactionManager type="JDBC" />
        /** 数据源类型：type = UNPOOLED、POOLED、JNDI 
         *  1.UNPOOLED：这个数据源的实现是每次被请求时简单打开和关闭连接。
         *  2.POOLED：这是JDBC连接对象的数据源连接池的实现。 
         *  3.JNDI：这个数据源的实现是为了使用如Spring或应用服务器这类的容器
         */
        <dataSource type="POOLED">
            <property name="driver" value="com.mysql.jdbc.Driver" />
            <property name="url" value="jdbc:mysql://localhost:3306/xhm" />
            <property name="username" value="root" />
            <property name="password" value="root" />
            //默认连接事务隔离级别
            <property name="defaultTransactionIsolationLevel" value=""/> 
        </dataSource>
    </environment>
</environments>
  • 解析我们配置文件中的environment配置元素，具体解析过程请参考前面的文章。

image.png
XMLConfigBuilder

// 解析我们配置文件中的environment配置元素
private void environmentsElement(XNode context) throws Exception {
    if (context != null) {
        if (environment == null) {
            // 获取 default 属性
            environment = context.getStringAttribute("default");
        }
        for (XNode child : context.getChildren()) {
            // 获取 id 属性
            String id = child.getStringAttribute("id");
            /*
             * 检测当前 environment 节点的 id 与其父节点 environments 的属性 default 
             * 内容是否一致，一致则返回 true，否则返回 false
             * 将其default属性值与子元素environment的id属性值相等的子元素设置为当前使用的Environment对象
             */
            if (isSpecifiedEnvironment(id)) {
                // 将environment中的transactionManager标签转换为TransactionFactory对象
                TransactionFactory txFactory = transactionManagerElement(child.evalNode("transactionManager"));
                // 将environment中的dataSource标签转换为DataSourceFactory对象
                DataSourceFactory dsFactory = dataSourceElement(child.evalNode("dataSource"));
                // 创建 DataSource 对象
                DataSource dataSource = dsFactory.getDataSource();
                Environment.Builder environmentBuilder = new Environment.Builder(id)
                    .transactionFactory(txFactory)
                    .dataSource(dataSource);
                // 构建 Environment 对象，并设置到 configuration 中
                configuration.setEnvironment(environmentBuilder.build());
            }
        }
    }
}

1.2 获取事务工厂

DefaultSqlSessionFactory

 private TransactionFactory getTransactionFactoryFromEnvironment(Environment environment) {
    if (environment == null || environment.getTransactionFactory() == null) {
         // 委托事务工厂
      return new ManagedTransactionFactory();
    }
	// 我们配置的事务工厂JdbcTransactionFactory
    return environment.getTransactionFactory();
  }

image.png

  • JdbcTransaction由JDBC进行事务管理

JdbcTransaction

// 由JDBC进行事务管理
public class JdbcTransaction implements Transaction {

  private static final Log log = LogFactory.getLog(JdbcTransaction.class);

  // 数据库连接
  protected Connection connection;
  // 数据源
  protected DataSource dataSource;
  // 事务隔离级别
  protected TransactionIsolationLevel level;
  // 是否自动提交事务
  protected boolean autoCommit;

  public JdbcTransaction(DataSource ds, TransactionIsolationLevel desiredLevel, boolean desiredAutoCommit) {
    dataSource = ds;
    level = desiredLevel;
    autoCommit = desiredAutoCommit;
  }

  public JdbcTransaction(Connection connection) {
    this.connection = connection;
  }

  @Override
  public Connection getConnection() throws SQLException {
    if (connection == null) {
      openConnection();
    }
    return connection;
  }

  /**
   * 提交事务
   * @throws SQLException
   */
  @Override
  public void commit() throws SQLException {
    // 连接存在且不会自动提交事务
    if (connection != null && !connection.getAutoCommit()) {
      if (log.isDebugEnabled()) {
        log.debug("Committing JDBC Connection [" + connection + "]");
      }
      // 调用connection对象的方法提交事务
      connection.commit();
    }
  }

  /**
   * 回滚事务
   * @throws SQLException
   */
  @Override
  public void rollback() throws SQLException {
    if (connection != null && !connection.getAutoCommit()) {
      if (log.isDebugEnabled()) {
        log.debug("Rolling back JDBC Connection [" + connection + "]");
      }
      connection.rollback();
    }
  }

  @Override
  public void close() throws SQLException {
    if (connection != null) {
      resetAutoCommit();
      if (log.isDebugEnabled()) {
        log.debug("Closing JDBC Connection [" + connection + "]");
      }
      connection.close();
    }
  }

  protected void setDesiredAutoCommit(boolean desiredAutoCommit) {
    try {
      if (connection.getAutoCommit() != desiredAutoCommit) {
        if (log.isDebugEnabled()) {
          log.debug("Setting autocommit to " + desiredAutoCommit + " on JDBC Connection [" + connection + "]");
        }
        connection.setAutoCommit(desiredAutoCommit);
      }
    } catch (SQLException e) {
      // Only a very poorly implemented driver would fail here,
      // and there's not much we can do about that.
      throw new TransactionException("Error configuring AutoCommit.  "
          + "Your driver may not support getAutoCommit() or setAutoCommit(). "
          + "Requested setting: " + desiredAutoCommit + ".  Cause: " + e, e);
    }
  }

  protected void resetAutoCommit() {
    try {
      if (!connection.getAutoCommit()) {
        // MyBatis does not call commit/rollback on a connection if just selects were performed.
        // Some databases start transactions with select statements
        // and they mandate a commit/rollback before closing the connection.
        // A workaround is setting the autocommit to true before closing the connection.
        // Sybase throws an exception here.
        if (log.isDebugEnabled()) {
          log.debug("Resetting autocommit to true on JDBC Connection [" + connection + "]");
        }
        connection.setAutoCommit(true);
      }
    } catch (SQLException e) {
      if (log.isDebugEnabled()) {
        log.debug("Error resetting autocommit to true "
            + "before closing the connection.  Cause: " + e);
      }
    }
  }

  protected void openConnection() throws SQLException {
    if (log.isDebugEnabled()) {
      log.debug("Opening JDBC Connection");
    }
    connection = dataSource.getConnection();
    if (level != null) {
      connection.setTransactionIsolation(level.getLevel());
    }
    setDesiredAutoCommit(autoCommit);
  }

  @Override
  public Integer getTimeout() throws SQLException {
    return null;
  }

}

JdbcTransaction主要维护了一个默认autoCommit为false的Connection对象，对事物的提交，回滚，关闭等都是接见通过Connection完成的。

1.3 获取执行器Executor

image.png

/**
   * 创建一个执行器
   * @param transaction 事务
   * @param executorType 数据库操作类型
   * @return 执行器
   */
  public Executor newExecutor(Transaction transaction, ExecutorType executorType) {
    executorType = executorType == null ? defaultExecutorType : executorType;
    executorType = executorType == null ? ExecutorType.SIMPLE : executorType;
    Executor executor;
    // 根据数据操作类型创建实际执行器
    if (ExecutorType.BATCH == executorType) {
        // 批处理执行器
      executor = new BatchExecutor(this, transaction);
    } else if (ExecutorType.REUSE == executorType) {
        // 可以重用执行器
      executor = new ReuseExecutor(this, transaction);
    } else {
        //一个简单的执行器
      executor = new SimpleExecutor(this, transaction);
    }
    // 根据配置文件中settings节点cacheEnabled配置项确定是否启用缓存
    if (cacheEnabled) { // 如果配置启用缓存
      // 使用CachingExecutor装饰实际执行器
      executor = new CachingExecutor(executor);
    }
    // 为执行器增加拦截器（插件），以启用各个拦截器的功能
    executor = (Executor) interceptorChain.pluginAll(executor);
    return executor;
  }
  • 执行器的类型，我们来看看执行器的接口信息

image.png
Executor

public interface Executor {

  ResultHandler NO_RESULT_HANDLER = null;

  // 数据更新操作，其中数据的增加、删除、更新均可由该方法实现
  int update(MappedStatement ms, Object parameter) throws SQLException;
  // 数据查询操作，返回结果为列表形式
  <E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, CacheKey cacheKey, BoundSql boundSql) throws SQLException;
  // 数据查询操作，返回结果为列表形式
  /**
   * 执行查询操作
   * @param ms 映射语句对象
   * @param parameter 参数对象
   * @param rowBounds 翻页限制
   * @param resultHandler 结果处理器
   * @param <E> 输出结果类型
   * @return 查询结果
   * @throws SQLException
   */
  <E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler) throws SQLException;
  // 数据查询操作，返回结果为游标形式
  <E> Cursor<E> queryCursor(MappedStatement ms, Object parameter, RowBounds rowBounds) throws SQLException;
  // 清理缓存
  List<BatchResult> flushStatements() throws SQLException;
  // 提交事务
  void commit(boolean required) throws SQLException;
  // 回滚事务
  void rollback(boolean required) throws SQLException;
  // 创建当前查询的缓存键值
  CacheKey createCacheKey(MappedStatement ms, Object parameterObject, RowBounds rowBounds, BoundSql boundSql);
  // 本地缓存是否有指定值
  boolean isCached(MappedStatement ms, CacheKey key);
  // 清理本地缓存
  void clearLocalCache();
  // 懒加载
  void deferLoad(MappedStatement ms, MetaObject resultObject, String property, CacheKey key, Class<?> targetType);
  // 获取事务
  Transaction getTransaction();
  // 关闭执行器
  void close(boolean forceRollback);
  // 判断执行器是否关闭
  boolean isClosed();
  // 设置执行器包装
  void setExecutorWrapper(Executor executor);

}

executor包含了Configuration和刚刚创建的Transaction，默认的执行器为SimpleExecutor，如果开启了二级缓存(默认开启)，则CachingExecutor会包装SimpleExecutor，然后依次调用拦截器的plugin方法返回一个被代理过的Executor对象，记住这个地方，后面Sql语句具体的执行是交给执行器来进行处理的。

1.4 构建DefaultSqlSession

 return new DefaultSqlSession(configuration, executor, autoCommit);

public class DefaultSqlSession implements SqlSession {
  // 配置信息
  private final Configuration configuration;
  // 执行器
  private final Executor executor;
  // 是否自动提交
  private final boolean autoCommit;
  // 缓存是否已经被污染
  private boolean dirty;
  // 游标列表
  private List<Cursor<?>> cursorList;

  public DefaultSqlSession(Configuration configuration, Executor executor, boolean autoCommit) {
    this.configuration = configuration;
    this.executor = executor;
    this.dirty = false;
    this.autoCommit = autoCommit;
  }

}

image.png
SqlSession的所有查询接口最后都归结位Exector的方法调用。后面文章我们来分析其调用流程。

长安不及十里
关注
专栏目录
六、SqlSession 的创建过程以及 Executor 执行 SQL 过程详解
戴泽王的博客
05-11 430
源码地址：https://github.com/RononoaZoro/mybatis-book/tree/master 的 mybatis-book ( mybatis-chapter04 ) 文章内容出自《Mybatis 3 源码深度解析》第五章 1、XPath 方式解析 XML 文件 users.xml <?xml version="1.0" encoding="UTF-8" ?> <users> <user id = "1"> <.
MyBatis源码分析：SqlSession获取过程
天之冰的博客
07-24 1322
public static void main(String[] args) throws IOException { String resource = "mybatis-config.xml"; InputStream inputStream = Resources.getResourceAsStream(resource); //SqlSess...
Java API
zhulei12345的专栏
02-23 611
Java API 既然你已经知道如何配置 MyBatis 和创建映射文件,你就已经准备好来提升技能了。 MyBatis 的 Java API 就是你收获你所做的努力的地方。正如你即将看到的,和 JDBC 相比, MyBatis 很大程度简化了你的代码而且保持简洁,很容易理解和维护。MyBatis 3 已经引入 了很多重要的改进来使得 SQL 映射更加优秀。 应用目录结构 在我
关于MyBatis的缓存详解
最新发布
威哥爱编程，CSDN 博客专家、全栈领域新星创作者、华为 HDE，愿交天下 IT 技术爱好者
07-24 779
局部的 session 缓存：MyBatis 默认开启的缓存是局部的 session 缓存，这意味着每个 MyBatis session 都会有自己的缓存，这个缓存仅在当前 session 内有效。它主要用于处理循环依赖和提升性能。MyBatis 的缓存机制非常灵活，可以通过简单的配置来满足不同的性能需求。合理地使用缓存可以显著提高应用程序的性能，尤其是在处理大量数据库查询时。然而，开发者需要注意缓存的一致性和并发问题，特别是在使用可读写缓存时。
mybatis session创建过程（2）
weixin_34149796的博客
07-05 169
session创建过程  在mybatis的常规用法当中，通过sqlSessionFactory.openSession()来创建SqlSession对象，这里的sqlSessionFactory就是在解析配置后生成的SqlSession的工厂。 public class MyBatisTest { ...
Mybatis源码分析——SqlSession的创建过程
lost_gost的博客
04-19 908
我们可以通过SqlSession实例完成对数据库的增删改查操作。研读MyBatis源码，可以从MyBatis最顶层API入手。本章我们就来了解一下SqlSession实例的创建过程。
MyBatis浅谈
Gane_Cheng的博客
10-07 8042
MyBatis 是支持定制化 SQL、存储过程以及高级映射的优秀的持久层框架。MyBatis 避免了几乎所有的 JDBC 代码和手动设置参数以及获取结果集。MyBatis 可以对配置和原生Map使用简单的 XML 或注解，将接口和 Java 的 POJOs(Plain Old Java Objects,普通的 Java对象)映射成数据库中的记录。
MyBatis 源码分析 之SqlSession接口和Executor类
08-31
MyBatis是一个流行的Java持久层框架，它简化了数据库操作，允许开发者将SQL查询与Java代码直接集成。...在源码分析中，对这两个组件的深入理解可以帮助开发者优化性能，排查问题，以及自定义扩展MyBatis的功能。
MyBatis源码分析.pdf
05-23
MyBatis源码分析 MyBatis是一款流行的Java持久层框架，提供了强大的数据库访问能力，本文将对MyBatis的源码进行深入分析，从而帮助读者更好地理解MyBatis的工作机理。 1. MyBatis入门 MyBatis是一款基于Java的...
Mybatis源码分析.pdf
08-30
总结起来，MyBatis源码分析涵盖了从配置加载到数据库操作的全过程，涉及到了配置解析、SQL执行、结果映射等多个关键环节，以及Executor、StatementHandler等核心组件。通过深入学习MyBatis的源码，开发者不仅可以...
mybatis源码分析视频
02-19
本资源“mybatis源码分析视频”是针对MyBatis框架进行深入剖析的教程，通过视频和文档的形式帮助学习者理解其内部工作机制。 1. **MyBatis简介** MyBatis消除了几乎所有的JDBC代码和手动设置参数以及获取结果集。...
MyBatis常用对象SqlSessionFactory和SqlSession介绍和运用
热门推荐
DemoTransfer
06-23 22万+
前言:学习框架一个比较好的路径阅读源码.本文介绍的SqlSessionFactory和SqlSession.可以通过了解SqlSessionFactory接口和SqlSession接口以及两个的实现类入手,去看源码了解实现过程.最好能把项目下载到本地,慢慢分析实现过程.Myabtis官网：http://www.mybatis.org/ github地址：https://github.com/myb
Mybatis-SqlSession的创建过程
星光之子的博客
09-09 877
XPath方式解析XML文件概述XPath方式解析XML文件 概述 SqlSession对象 表示 MyBaits框架 与 数据库 建立的会话 可以通过SqlSession实例 完成 对数据库的增删改查操作 为了简化流程描述，将SqlSession的创建过程拆解为3个阶段 Configuration实例的创建过程 SqlSessionFactory实例的创建过程 SqlSession实例化的过程 XPath方式解析XML文件 MyBatis的主配置文件和Mapper配置都使用的是XML格式 MyBati
Mybatis之 SqlSession简介
dingd1234的博客
02-27 6368
SqlSession 的创建需要借助于 SqlSessionFactory。SqlSessionFactory 是 Mybatis 的关键对象。每个基于 MyBatis 的应用都是以一个 SqlSessionFactory 的实例为核心的。SqlSessionFactory 的实例可以通过 SqlSessionFactoryBuilder 获得。如下图所示： SqlSessionFactory 可以理解为是创建 SqlSession 的工厂，SqlSessionFactory 是线程安全的，一旦被创建，应
MyBatis 入门到精通(一) 了解MyBatis获取SqlSession
行行
02-05 181
MyBatis是什么？ MyBatis是一款一流的支持自定义SQL、存储过程和高级映射的持久化框架。MyBatis几乎消除了所有的JDBC代码，也基本不需要手工去设置参数和获取检索结果。MyBatis能够使用简单的XML格式或者注解进行来配置，能够映射基本数据元素、Map接口和POJOs（普通java对象）到数据库中的记录。   简介   每个MyBatis应用程序主要都是使用Sql...
Mybatis中的SqlSession
weixin_44903465的博客
03-02 3546
mybatis简介: 它是一个优秀的持久层框架,底层基于JDBC实现与数据库的交互,并且在JDBC操作的基础上做了封装和优化, 它借助灵活的SQL定制,参数以及结果集的映射方式,更好的适应了当前互联网技术的发展. Mybatis优点: 1.稳定,灵活(动态sql),功能强大(池,日志,缓存) 2.学习以及使用成本低 3.解耦,SQL的可维护性,可复用性比较高 Mybatis中的SqlSessio...
mybatis--sqlsession
cheyun0833的博客
09-26 189
sqlsession代表与数据库一次回话，访问一次数据库就是一次回话，sqlsession底层封装了对数据库curd的操作实现. SqlSession提供select/insert/update/delete方法，在旧版本中使用使用SqlSession接口的这些方法，但是新版的Mybatis...
MyBatis 之 SqlSession
weixin_42867178的博客
09-04 721
MyBatis 之 SqlSession
mybatis之sqlSession
zy190903的博客
03-20 301
主要实现都在DefaultSqlSession中 DefaultSqlSession中包含两个关键引用: private Configuration configuration; private Executor executor; DefaultSqlSession定义了一系列的方法来满足需求增删改查，但是最终执行sql语句都是由executor来完成的。 一.select ...
mybatis 源码分析
08-14
总之，Mybatis的源码分析需要深入了解其核心组件和原理，包括SqlSessionFactory、SqlSession、Executor、StatementHandler、ParameterHandler和ResultSetHandler等。通过分析这些组件的工作原理和协作关系，可以更好...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

长安不及十里

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

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

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

打赏作者

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

抵扣说明：

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

余额充值