Mybatis缓存和事务管理-模板模式

本文详细介绍了模板方法模式的概念及其在MyBatis中的具体应用,如缓存管理和事务管理执行器。通过模板方法模式,MyBatis实现了算法的骨架和部分步骤的分离,提高了代码的可扩展性和可维护性。在BaseExecutor类中定义了模板方法,子类SimpleExecutor实现了具体的执行逻辑,展示了如何利用多态性和开放-封闭原则来设计灵活的系统。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

**背景**:某个方法要实现的算法需要多个步骤,但其中有一些步骤是固定不变的,而另一些步骤则是不固定的。为了提高代码的可扩展性和可维护性,模板方法模式在这种场景下就派上了用场。
在模板方法模式中,一个算法可以分为多个步骤,这些步骤的执行次序在一个被称为“模板方法”的方法中定义,而算法的每个步骤都对应着一个方法,这些方法被称为“基本方法”。模板方法按照它定义的顺序依次调用多个基本方法,从而实现整个算法流程。在模板方法模式中,会将模板方法的实现以及那些固定不变的基本方法的实现放在子类中,而那些不固定的基本方法在父类中只是抽象方法,其真正的实现代码会被延迟到子类中完成。

在这里插入图片描述
template()方法是模板方法,oper3()是固定不变的方法,oper1(),oper2(),oper4()都是固定不变的基本方法,所以在AbstractClass中都定义为抽象方法,而ConcreteClass1和ConcreteClass2需要实现这些方法。
模板方法可以将模板方法以及固定不变的基本方法统一封装到父类中,而这些变化的部分封装到子类中实现,这样就由父类控制整个算法的流程,而子类实现算法的某些细节,实现这两方面的解耦。当需要修改算法的行为时,开发人员可以通过添加子类的方式实现,这符合“开放-封闭”原则。
模板方法不仅可以服用已有的代码,还可以充分利用面向对象的多态性,系统可以在运行时选择一种具体子类实现的完整的算法,这样可以提高系统的灵活性和可扩展性。

mybatis中的应用:缓存管理和事务管理执行器
在这里插入图片描述

/**
 *    Copyright 2009-2020 the original author or authors.
 *
 *    Licensed under the Apache License, Version 2.0 (the "License");
 *    you may not use this file except in compliance with the License.
 *    You may obtain a copy of the License at
 *
 *       http://www.apache.org/licenses/LICENSE-2.0
 *
 *    Unless required by applicable law or agreed to in writing, software
 *    distributed under the License is distributed on an "AS IS" BASIS,
 *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *    See the License for the specific language governing permissions and
 *    limitations under the License.
 */
package org.apache.ibatis.executor;

import static org.apache.ibatis.executor.ExecutionPlaceholder.EXECUTION_PLACEHOLDER;

import java.sql.Connection;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.List;
import java.util.concurrent.ConcurrentLinkedQueue;

import org.apache.ibatis.cache.CacheKey;
import org.apache.ibatis.cache.impl.PerpetualCache;
import org.apache.ibatis.cursor.Cursor;
import org.apache.ibatis.executor.statement.StatementUtil;
import org.apache.ibatis.logging.Log;
import org.apache.ibatis.logging.LogFactory;
import org.apache.ibatis.logging.jdbc.ConnectionLogger;
import org.apache.ibatis.mapping.BoundSql;
import org.apache.ibatis.mapping.MappedStatement;
import org.apache.ibatis.mapping.ParameterMapping;
import org.apache.ibatis.mapping.ParameterMode;
import org.apache.ibatis.mapping.StatementType;
import org.apache.ibatis.reflection.MetaObject;
import org.apache.ibatis.reflection.factory.ObjectFactory;
import org.apache.ibatis.session.Configuration;
import org.apache.ibatis.session.LocalCacheScope;
import org.apache.ibatis.session.ResultHandler;
import org.apache.ibatis.session.RowBounds;
import org.apache.ibatis.transaction.Transaction;
import org.apache.ibatis.type.TypeHandlerRegistry;

/**
 * @author Clinton Begin
 */
public abstract class BaseExecutor implements Executor {

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

  protected Transaction transaction;
  protected Executor wrapper;

  protected ConcurrentLinkedQueue<DeferredLoad> deferredLoads;
  protected PerpetualCache localCache;
  protected PerpetualCache localOutputParameterCache;
  protected Configuration configuration;

  protected int queryStack;
  private boolean closed;

  protected BaseExecutor(Configuration configuration, Transaction transaction) {
    this.transaction = transaction;
    this.deferredLoads = new ConcurrentLinkedQueue<>();
    this.localCache = new PerpetualCache("LocalCache");
    this.localOutputParameterCache = new PerpetualCache("LocalOutputParameterCache");
    this.closed = false;
    this.configuration = configuration;
    this.wrapper = this;
  }

  @Override
  public Transaction getTransaction() {
    if (closed) {
      throw new ExecutorException("Executor was closed.");
    }
    return transaction;
  }

  @Override
  public void close(boolean forceRollback) {
    try {
      try {
        rollback(forceRollback);
      } finally {
        if (transaction != null) {
          transaction.close();
        }
      }
    } catch (SQLException e) {
      // Ignore. There's nothing that can be done at this point.
      log.warn("Unexpected exception on closing transaction.  Cause: " + e);
    } finally {
      transaction = null;
      deferredLoads = null;
      localCache = null;
      localOutputParameterCache = null;
      closed = true;
    }
  }

  @Override
  public boolean isClosed() {
    return closed;
  }

  @Override
  public int update(MappedStatement ms, Object parameter) throws SQLException {
    ErrorContext.instance().resource(ms.getResource()).activity("executing an update").object(ms.getId());
    if (closed) {
      throw new ExecutorException("Executor was closed.");
    }
    clearLocalCache();
    return doUpdate(ms, parameter);
  }

  @Override
  public List<BatchResult> flushStatements() throws SQLException {
    return flushStatements(false);
  }

  public List<BatchResult> flushStatements(boolean isRollBack) throws SQLException {
    if (closed) {
      throw new ExecutorException("Executor was closed.");
    }
    return doFlushStatements(isRollBack);
  }

  @Override
  public <E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler) throws SQLException {
    BoundSql boundSql = ms.getBoundSql(parameter);
    CacheKey key = createCacheKey(ms, parameter, rowBounds, boundSql);
    return query(ms, parameter, rowBounds, resultHandler, key, boundSql);
  }

  @SuppressWarnings("unchecked")
  @Override
  public <E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql) throws SQLException {
    ErrorContext.instance().resource(ms.getResource()).activity("executing a query").object(ms.getId());
    if (closed) {
      throw new ExecutorException("Executor was closed.");
    }
    if (queryStack == 0 && ms.isFlushCacheRequired()) {
      clearLocalCache();
    }
    List<E> list;
    try {
      queryStack++;
      list = resultHandler == null ? (List<E>) localCache.getObject(key) : null;
      if (list != null) {
        handleLocallyCachedOutputParameters(ms, key, parameter, boundSql);
      } else {
        list = queryFromDatabase(ms, parameter, rowBounds, resultHandler, key, boundSql);
      }
    } finally {
      queryStack--;
    }
    if (queryStack == 0) {
      for (DeferredLoad deferredLoad : deferredLoads) {
        deferredLoad.load();
      }
      // issue #601
      deferredLoads.clear();
      if (configuration.getLocalCacheScope() == LocalCacheScope.STATEMENT) {
        // issue #482
        clearLocalCache();
      }
    }
    return list;
  }

  @Override
  public <E> Cursor<E> queryCursor(MappedStatement ms, Object parameter, RowBounds rowBounds) throws SQLException {
    BoundSql boundSql = ms.getBoundSql(parameter);
    return doQueryCursor(ms, parameter, rowBounds, boundSql);
  }

  @Override
  public void deferLoad(MappedStatement ms, MetaObject resultObject, String property, CacheKey key, Class<?> targetType) {
    if (closed) {
      throw new ExecutorException("Executor was closed.");
    }
    DeferredLoad deferredLoad = new DeferredLoad(resultObject, property, key, localCache, configuration, targetType);
    if (deferredLoad.canLoad()) {
      deferredLoad.load();
    } else {
      deferredLoads.add(new DeferredLoad(resultObject, property, key, localCache, configuration, targetType));
    }
  }

  @Override
  public CacheKey createCacheKey(MappedStatement ms, Object parameterObject, RowBounds rowBounds, BoundSql boundSql) {
    if (closed) {
      throw new ExecutorException("Executor was closed.");
    }
    CacheKey cacheKey = new CacheKey();
    cacheKey.update(ms.getId());
    cacheKey.update(rowBounds.getOffset());
    cacheKey.update(rowBounds.getLimit());
    cacheKey.update(boundSql.getSql());
    List<ParameterMapping> parameterMappings = boundSql.getParameterMappings();
    TypeHandlerRegistry typeHandlerRegistry = ms.getConfiguration().getTypeHandlerRegistry();
    // mimic DefaultParameterHandler logic
    for (ParameterMapping parameterMapping : parameterMappings) {
      if (parameterMapping.getMode() != ParameterMode.OUT) {
        Object value;
        String propertyName = parameterMapping.getProperty();
        if (boundSql.hasAdditionalParameter(propertyName)) {
          value = boundSql.getAdditionalParameter(propertyName);
        } else if (parameterObject == null) {
          value = null;
        } else if (typeHandlerRegistry.hasTypeHandler(parameterObject.getClass())) {
          value = parameterObject;
        } else {
          MetaObject metaObject = configuration.newMetaObject(parameterObject);
          value = metaObject.getValue(propertyName);
        }
        cacheKey.update(value);
      }
    }
    if (configuration.getEnvironment() != null) {
      // issue #176
      cacheKey.update(configuration.getEnvironment().getId());
    }
    return cacheKey;
  }

  @Override
  public boolean isCached(MappedStatement ms, CacheKey key) {
    return localCache.getObject(key) != null;
  }

  @Override
  public void commit(boolean required) throws SQLException {
    if (closed) {
      throw new ExecutorException("Cannot commit, transaction is already closed");
    }
    clearLocalCache();
    flushStatements();
    if (required) {
      transaction.commit();
    }
  }

  @Override
  public void rollback(boolean required) throws SQLException {
    if (!closed) {
      try {
        clearLocalCache();
        flushStatements(true);
      } finally {
        if (required) {
          transaction.rollback();
        }
      }
    }
  }

  @Override
  public void clearLocalCache() {
    if (!closed) {
      localCache.clear();
      localOutputParameterCache.clear();
    }
  }

  protected abstract int doUpdate(MappedStatement ms, Object parameter) throws SQLException;

  protected abstract List<BatchResult> doFlushStatements(boolean isRollback) throws SQLException;

  protected abstract <E> List<E> doQuery(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql)
      throws SQLException;

  protected abstract <E> Cursor<E> doQueryCursor(MappedStatement ms, Object parameter, RowBounds rowBounds, BoundSql boundSql)
      throws SQLException;

  protected void closeStatement(Statement statement) {
    if (statement != null) {
      try {
        statement.close();
      } catch (SQLException e) {
        // ignore
      }
    }
  }

  /**
   * Apply a transaction timeout.
   *
   * @param statement
   *          a current statement
   * @throws SQLException
   *           if a database access error occurs, this method is called on a closed <code>Statement</code>
   * @since 3.4.0
   * @see StatementUtil#applyTransactionTimeout(Statement, Integer, Integer)
   */
  protected void applyTransactionTimeout(Statement statement) throws SQLException {
    StatementUtil.applyTransactionTimeout(statement, statement.getQueryTimeout(), transaction.getTimeout());
  }

  private void handleLocallyCachedOutputParameters(MappedStatement ms, CacheKey key, Object parameter, BoundSql boundSql) {
    if (ms.getStatementType() == StatementType.CALLABLE) {
      final Object cachedParameter = localOutputParameterCache.getObject(key);
      if (cachedParameter != null && parameter != null) {
        final MetaObject metaCachedParameter = configuration.newMetaObject(cachedParameter);
        final MetaObject metaParameter = configuration.newMetaObject(parameter);
        for (ParameterMapping parameterMapping : boundSql.getParameterMappings()) {
          if (parameterMapping.getMode() != ParameterMode.IN) {
            final String parameterName = parameterMapping.getProperty();
            final Object cachedValue = metaCachedParameter.getValue(parameterName);
            metaParameter.setValue(parameterName, cachedValue);
          }
        }
      }
    }
  }

  private <E> List<E> queryFromDatabase(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql) throws SQLException {
    List<E> list;
    localCache.putObject(key, EXECUTION_PLACEHOLDER);
    try {
      list = doQuery(ms, parameter, rowBounds, resultHandler, boundSql);
    } finally {
      localCache.removeObject(key);
    }
    localCache.putObject(key, list);
    if (ms.getStatementType() == StatementType.CALLABLE) {
      localOutputParameterCache.putObject(key, parameter);
    }
    return list;
  }

  protected Connection getConnection(Log statementLog) throws SQLException {
    Connection connection = transaction.getConnection();
    if (statementLog.isDebugEnabled()) {
      return ConnectionLogger.newInstance(connection, statementLog, queryStack);
    } else {
      return connection;
    }
  }

  @Override
  public void setExecutorWrapper(Executor wrapper) {
    this.wrapper = wrapper;
  }

  private static class DeferredLoad {

    private final MetaObject resultObject;
    private final String property;
    private final Class<?> targetType;
    private final CacheKey key;
    private final PerpetualCache localCache;
    private final ObjectFactory objectFactory;
    private final ResultExtractor resultExtractor;

    // issue #781
    public DeferredLoad(MetaObject resultObject,
                        String property,
                        CacheKey key,
                        PerpetualCache localCache,
                        Configuration configuration,
                        Class<?> targetType) {
      this.resultObject = resultObject;
      this.property = property;
      this.key = key;
      this.localCache = localCache;
      this.objectFactory = configuration.getObjectFactory();
      this.resultExtractor = new ResultExtractor(configuration, objectFactory);
      this.targetType = targetType;
    }

    public boolean canLoad() {
      return localCache.getObject(key) != null && localCache.getObject(key) != EXECUTION_PLACEHOLDER;
    }

    public void load() {
      @SuppressWarnings("unchecked")
      // we suppose we get back a List
      List<Object> list = (List<Object>) localCache.getObject(key);
      Object value = resultExtractor.extractObjectFromList(list, targetType);
      resultObject.setValue(property, value);
    }

  }

}

/**
 *    Copyright 2009-2019 the original author or authors.
 *
 *    Licensed under the Apache License, Version 2.0 (the "License");
 *    you may not use this file except in compliance with the License.
 *    You may obtain a copy of the License at
 *
 *       http://www.apache.org/licenses/LICENSE-2.0
 *
 *    Unless required by applicable law or agreed to in writing, software
 *    distributed under the License is distributed on an "AS IS" BASIS,
 *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *    See the License for the specific language governing permissions and
 *    limitations under the License.
 */
package org.apache.ibatis.executor;

import java.sql.Connection;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.Collections;
import java.util.List;

import org.apache.ibatis.cursor.Cursor;
import org.apache.ibatis.executor.statement.StatementHandler;
import org.apache.ibatis.logging.Log;
import org.apache.ibatis.mapping.BoundSql;
import org.apache.ibatis.mapping.MappedStatement;
import org.apache.ibatis.session.Configuration;
import org.apache.ibatis.session.ResultHandler;
import org.apache.ibatis.session.RowBounds;
import org.apache.ibatis.transaction.Transaction;

/**
 * @author Clinton Begin
 */
public class SimpleExecutor extends BaseExecutor {

  public SimpleExecutor(Configuration configuration, Transaction transaction) {
    super(configuration, transaction);
  }

  @Override
  public int doUpdate(MappedStatement ms, Object parameter) throws SQLException {
    Statement stmt = null;
    try {
      Configuration configuration = ms.getConfiguration();
      StatementHandler handler = configuration.newStatementHandler(this, ms, parameter, RowBounds.DEFAULT, null, null);
      stmt = prepareStatement(handler, ms.getStatementLog());
      return handler.update(stmt);
    } finally {
      closeStatement(stmt);
    }
  }

  @Override
  public <E> List<E> doQuery(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) throws SQLException {
    Statement stmt = null;
    try {
      Configuration configuration = ms.getConfiguration();
      StatementHandler handler = configuration.newStatementHandler(wrapper, ms, parameter, rowBounds, resultHandler, boundSql);
      stmt = prepareStatement(handler, ms.getStatementLog());
      return handler.query(stmt, resultHandler);
    } finally {
      closeStatement(stmt);
    }
  }

  @Override
  protected <E> Cursor<E> doQueryCursor(MappedStatement ms, Object parameter, RowBounds rowBounds, BoundSql boundSql) throws SQLException {
    Configuration configuration = ms.getConfiguration();
    StatementHandler handler = configuration.newStatementHandler(wrapper, ms, parameter, rowBounds, null, boundSql);
    Statement stmt = prepareStatement(handler, ms.getStatementLog());
    Cursor<E> cursor = handler.queryCursor(stmt);
    stmt.closeOnCompletion();
    return cursor;
  }

  @Override
  public List<BatchResult> doFlushStatements(boolean isRollback) {
    return Collections.emptyList();
  }

  private Statement prepareStatement(StatementHandler handler, Log statementLog) throws SQLException {
    Statement stmt;
    Connection connection = getConnection(statementLog);
    stmt = handler.prepare(connection, transaction.getTimeout());
    handler.parameterize(stmt);
    return stmt;
  }

}

<think>好的,用户现在用的是瑞芯微的RV1126硬件平台,想要开发摄像头驱动ISP驱动。首先,我需要回忆一下RV1126的相关资料。RV1126是一款针对视觉处理的芯片,通常用于摄像头、智能安防等领域,所以摄像头驱动ISP确实是关键部分。 用户可能有一定的嵌入式开发经验,但可能对RV1126的具体开发流程不太熟悉。需要先确定他们的开发环境是否已经搭建好了,比如SDK、交叉编译工具链等。如果用户已经完成了这些基础工作,接下来就是具体的驱动开发步骤。 摄像头驱动方面,RV1126通常支持MIPI CSI-2接口的摄像头模块。需要确认用户使用的摄像头型号是否兼容,或者是否需要自己适配。可能需要修改设备树(Device Tree)来配置MIPI接口参数,比如时钟频率、数据通道数等。还有I2C通信,用于配置摄像头传感器的寄存器,这部分可能需要编写或调整驱动代码。 然后是ISP驱动,RV1126内置了ISP模块,处理图像数据如降噪、HDR等。用户可能需要配置ISP的参数,或者根据具体需求调整图像处理流程。瑞芯微的SDK里可能有相关的文档示例代码,需要引导用户参考这些资料,比如如何通过mediactl或v4l2工具进行配置。 另外,用户可能会遇到调试问题,比如图像不显示、颜色异常等。这时候可能需要检查设备树配置是否正确,时钟信号是否稳定,或者I2C通信是否正常。还有可能是电源管理的问题,摄像头模块的供电是否充足。 用户可能还不太清楚如何测试驱动是否正常工作,可能需要指导他们使用工具如v4l2-ctl来捕获图像,或者使用瑞芯微提供的调试工具。另外,ISP的调试可能需要通过参数调整来优化图像质量,这部分可能需要反复试验。 需要提醒用户注意内核版本SDK的兼容性,不同版本的SDK可能在驱动支持上有差异。如果用户遇到编译错误或驱动加载失败,建议检查内核配置驱动模块的依赖关系。 最后,考虑到用户的具体需求,可能需要推荐他们查阅RV1126的官方文档,加入开发者社区或论坛,获取更多的支持案例分享。如果有具体的错误信息或日志,分析起来会更有效率。</think>开发摄像头驱动ISP驱动在RV1126平台上的实现可以分为以下几个关键步骤,以下是基于瑞芯微平台的开发要点总结: --- ### **一、RV1126视觉开发基础** 1. **硬件特性认知** - 双核NPU(2Tops算力)支持INT8/INT16量化 - 内置第三代ISP(支持HDR、3DNR等图像增强算法) - 支持MIPI CSI-2/DVP等摄像头接口 2. **开发环境搭建** ```bash # 官方推荐工具链(需联系瑞芯微获取) tar xvf rv1126_toolchain.tar.gz export PATH=$PATH:/opt/rv1126/gcc-arm-8.3-2019.11-x86_64-arm-linux-gnueabihf/bin ``` --- ### **二、摄像头驱动开发流程** #### **1. 设备树配置** ```dts // kernel/arch/arm/boot/dts/rv1126-ipc.dtsi &i2c1 { status = "okay"; camera0: camera-module@10 { compatible = "sony,imx415"; // 替换实际传感器型号 reg = <0x10>; clocks = <&cru CLK_MIPICSI_OUT>; clock-names = "xvclk"; port { camera_out: endpoint { remote-endpoint = <&mipi_in_ucam0>; data-lanes = <1 2 3 4>; // MIPI通道配置 link-frequencies = /bits/ 64 <594000000>; }; }; }; }; &mipi_csi2 { status = "okay"; ports { port@0 { mipi_in_ucam0: endpoint@1 { remote-endpoint = <&camera_out>; data-lanes = <1 2 3 4>; }; }; }; }; ``` #### **2. V4L2驱动框架适配** - 实现`struct v4l2_subdev_ops`操作集 - 注册I2C驱动: ```c static struct i2c_driver imx415_i2c_driver = { .driver = { .name = "imx415", .of_match_table = imx415_of_match, }, .probe = imx415_probe, .remove = imx415_remove, }; module_i2c_driver(imx415_i2c_driver); ``` --- ### **三、ISP驱动开发要点** #### **1. ISP管线配置** 通过`media-ctl`工具验证数据流: ```bash media-ctl -p -d /dev/media0 # 预期输出应包含实体链路: # "imx415 1-0010" -> "rkisp1_isp" ``` #### **2. 图像调优参数设置** 通过`v4l2-ctl`调整ISP参数: ```bash v4l2-ctl -d /dev/v4l-subdev0 \ --set-ctrl brightness=128 \ --set-ctrl contrast=90 \ --set-ctrl saturation=100 ``` #### **3. HDR模式启用(以IMX415为例)** ```c // 通过I2C发送传感器配置命令 static int imx415_set_hdr(struct i2c_client *client, u32 mode) { u8 reg_val[3]; reg_val[0] = 0x30; // HDR控制寄存器地址 reg_val[1] = (mode & 0x0F) << 4; i2c_master_send(client, reg_val, 2); return 0; } ``` --- ### **四、典型问题排查** 1. **图像无输出** - 检查供电:`cat /sys/class/regulator/regulator.9/voltage` - 验证时钟信号:示波器测量XCLK引脚(正常应输出24MHz) 2. **颜色异常** ```bash # 确认Bayer格式匹配 v4l2-ctl --get-fmt-video # 输出应为:'RG10' (对于IMX415) ``` 3. **ISP超时错误** ```dmesg [ 256.390241] rkisp1: timeout waiting for isp config lock! ``` 需检查时钟频率配置: ```dts &cru { assigned-clocks = <&cru CLK_MIPICSIOUT_RX>; assigned-clock-rates = <594000000>; // 需与传感器输出匹配 }; ``` --- ### **五、开发资源推荐** 1. **官方文档** - 《RV1126 TRM》第12章ISP子系统 - 《Rockchip_Developer_Guide_ISP3.x_CN》 2. **调试工具** ```bash # ISP3D调试工具(需配套SDK) isp_demo --sensor=imx415 --action=test ``` 建议通过瑞芯微官方GitHub获取最新内核补丁(注意分支选择): ``` git clone -b rv1126_linux_release https://github.com/rockchip-linux/kernel.git ``` 开发过程中若遇到具体硬件兼容性问题,建议直接联系瑞芯微FAE获取传感器适配支持包(Sensor Driver Adaptation Kit)。
评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值