数据库中间件 Sharding-JDBC 源码分析 —— 事务(一)之BED

基于springboot 2.2.2+sharding+seata实现分布式事务 分布式事务,是在微服务环境下一个很重要的支持框架。看了很多博文都无法能很好的把分布式事务有效的解决,要么在搭建的过程中遇到各种错误,要么就是根本搭建不起来,要么就是没有良好的解决方案。 本文使用sharding和seata集成,进行分布式事务管理,涉及相关技术框架pring boot 2.2.2、mybatis2.1.3、druid1.1.10、sharding4.1.0、mysql5.7、idgenerator1.4.2、eureka2.2.1、openfeign2.2.1、seata1.2 阅读详情

摘要: 原创出处 http://www.iocoder.cn/Sharding-JDBC/transaction-bed/ 「芋道源码」欢迎转载,保留摘要,谢谢!

本文主要基于 Sharding-JDBC 1.5.0 正式版


������关注微信公众号:【芋道源码】有福利:
1. RocketMQ / MyCAT / Sharding-JDBC 所有源码分析文章列表
2. RocketMQ / MyCAT / Sharding-JDBC 中文注释源码 GitHub 地址
3. 您对于源码的疑问每条留言都将得到认真回复。甚至不知道如何读源码也可以请教噢。
4. 新的源码解析文章实时收到通知。每周更新一篇左右。
5. 认真的源码交流微信群。


1. 概述

数据库表分库后,业务场景下的单库本地事务可能变成跨库分布式事务。虽然我们可以通过合适的分库规则让操作的数据在同库下,继续保证单库本地事务,这也是非常推崇的,但不是所有场景下都能适用。如果这些场景对事务的一致性有要求,我们就不得不解决分布式事务的“麻烦”。

分布式事务是个很大的话题,我们来看看 Sharding-JDBC 对她的权衡:

Sharding-JDBC由于性能方面的考量,决定不支持强一致性分布式事务。我们已明确规划线路图,未来会支持最终一致性的柔性事务。

Sharding-JDBC 提供了两种 柔性事务:

  • 最大努力送达型 BED :已经实现
  • 事务补偿型 TCC :计划中

本文分享 最大努力送达型 的实现。建议前置阅读:《Sharding-JDBC 源码分析 —— SQL 执行》。

**Sharding-JDBC 正在收集使用公司名单:传送门。
�� 你的登记,会让更多人参与和使用 Sharding-JDBC。传送门
Sharding-JDBC 也会因此,能够覆盖更多的业务场景。传送门
登记吧,骚年!传送门**

2. 最大努力送达型

概念

在分布式数据库的场景下,相信对于该数据库的操作最终一定可以成功,所以通过最大努力反复尝试送达操作。

从概念看,可能不是很直白的理解是什么意思,本文会最大努力让你干净理解。

架构图

执行过程有 四种 情况:

  1. 【红线】执行成功
  2. 【棕线】执行失败,同步重试成功
  3. 【粉线】执行失败,同步重试失败,异步重试成功
  4. 【绿线】执行失败,同步重试失败,异步重试失败,事务日志保留

整体成漏斗倒三角,上一个阶段失败,交给下一个阶段重试:

整个过程通过如下 组件 完成:

  • 柔性事务管理器
  • 最大努力送达型柔性事务
  • 最大努力送达型事务监听器
  • 事务日志存储器
  • 最大努力送达型异步作业

下面,我们逐节分享每个组件。

3. 柔性事务管理器

3.1 概念

柔性事务管理器,SoftTransactionManager 实现,负责对柔性事务配置( SoftTransactionConfiguration ) 、柔性事务( AbstractSoftTransaction )的管理。

3.2 柔性事务配置

调用 #init() 初始化柔性管理器:

// SoftTransactionManager.java
/**
* 柔性事务配置对象
*/
@Getter
private final SoftTransactionConfiguration transactionConfig;  

// SoftTransactionManager.java
/**
* 初始化事务管理器.
*/
public void init() throws SQLException {
   // 初始化 最大努力送达型事务监听器
   EventBusInstance.getInstance().register(new BestEffortsDeliveryListener());
   // 初始化 事务日志数据库存储表
   if (TransactionLogDataSourceType.RDB == transactionConfig.getStorageType()) {
       Preconditions.checkNotNull(transactionConfig.getTransactionLogDataSource());
       createTable();
   }
   // 初始化 内嵌的最大努力送达型异步作业
   if (transactionConfig.getBestEffortsDeliveryJobConfiguration().isPresent()) {
       new NestedBestEffortsDeliveryJobFactory(transactionConfig).init();
   }
}
  • 将最大努力送达型事务监听器( BestEffortsDeliveryListener )注册到事务总线 ( EventBus )。在『最大努力送达型事务监听器』小节会详细分享
  • 当使用数据库存储事务日志( TransactionLog ) 时,若事务日志表( transaction_log )不存在则进行创建。在『事务日志存储器』小节会详细分享
  • 当配置使用内嵌的最大努力送达型异步作业( NestedBestEffortsDeliveryJob ) 时,进行初始化。在『最大努力送达型异步作业』小节会详细分享

SoftTransactionConfiguration

SoftTransactionConfiguration,柔性事务配置对象。

public class SoftTransactionConfiguration {
    /**
     * 事务管理器管理的数据源.
     */
    @Getter(AccessLevel.NONE)
    private final DataSource targetDataSource;

    /**
     * 同步的事务送达的最大尝试次数.
     */
    private int syncMaxDeliveryTryTimes = 3;

    /**
     * 事务日志存储类型.
     */
    private TransactionLogDataSourceType storageType = RDB;
    /**
     * 存储事务日志的数据源.
     */
    private DataSource transactionLogDataSource;

    /**
     * 内嵌的最大努力送达型异步作业配置对象.
     */
    private Optional<NestedBestEffortsDeliveryJobConfiguration> bestEffortsDeliveryJobConfiguration = Optional.absent();
}

3.3 柔性事务

在 Sharding-JDBC 里,目前柔性事务分成两种:

  • BEDSoftTransaction :最大努力送达型柔性事务
  • TCCSoftTransaction :TCC型柔性事务

继承 AbstractSoftTransaction

public abstract class AbstractSoftTransaction {
    /**
     * 分片连接原自动提交状态
     */
    private boolean previousAutoCommit;
    /**
     * 分片连接
     */
    @Getter
    private ShardingConnection connection;
    /**
     * 事务类型
     */
    @Getter
    private SoftTransactionType transactionType;
    /**
     * 事务编号
     */
    @Getter
    private String transactionId;
}

AbstractSoftTransaction 实现了开启柔性事务、关闭柔性事务两个方法提供给子类调用:

  • #beginInternal()

    /**
    * 开启柔性
    *
    * @param conn 分片连接
    * @param type 事务类型
    * @throws SQLException
    */
    protected final void beginInternal(final Connection conn, final SoftTransactionType type) throws SQLException {
       // TODO 判断如果在传统事务中,则抛异常
       Preconditions.checkArgument(conn instanceof ShardingConnection, "Only ShardingConnection can support eventual consistency transaction.");
       // 设置执行错误,不抛出异常
       ExecutorExceptionHandler.setExceptionThrown(false);
       connection = (ShardingConnection) conn;
       transactionType = type;
       // 设置自动提交状态
       previousAutoCommit = connection.getAutoCommit();
       connection.setAutoCommit(true);
       // 生成事务编号
       // TODO 替换UUID为更有效率的id生成器
       transactionId = UUID.randomUUID().toString();
    }
    • 调用 ExecutorExceptionHandler.setExceptionThrown(false) 设置执行 SQL 错误时,也不抛出异常。

      • 对异常处理的代码:ExecutorExceptionHandler#setExceptionThrown()
      • 对于其他 SQL,不会因为 SQL 错误不执行,会继续执行
      • 对于上层业务,不会因为 SQL 错误终止逻辑,会继续执行。这里有一点要注意下,上层业务不能对该 SQL 执行结果有强依赖,因为 SQL 错误需要重试达到数据最终一致性
      • 对于最大努力型事务( TCC暂未实现 ),会对执行错误的 SQL 进行重试
    • 调用 connection.setAutoCommit(true);,设置执行自动提交。使用最大努力型事务时,上层业务执行 SQL 会马上提交,即使调用 Connection#rollback() 也是无法回滚的,这点一定要注意。

  • #end()

    /**
    * 结束柔性事务.
    */
    public final void end() throws SQLException {
      if (connection != null) {
          ExecutorExceptionHandler.setExceptionThrown(true);
          connection.setAutoCommit(previousAutoCommit);
          SoftTransactionManager.closeCurrentTransactionManager();
      }
    }
    
    // SoftTransactionManager.java
    /**
    * 关闭当前的柔性事务管理器.
    */
    static void closeCurrentTransactionManager() {
       ExecutorDataMap.getDataMap().put(TRANSACTION, null);
       ExecutorDataMap.getDataMap().put(TRANSACTION_CONFIG, null);
    }
    • 事务结束后,一定要记得调用 #end() 清理线程变量。否则,下次请求使用到该线程,会继续在这个柔性事务内。

BEDSoftTransaction

BEDSoftTransaction,最大努力送达型柔性事务。

public class BEDSoftTransaction extends AbstractSoftTransaction {

    /**
     * 开启柔性事务.
     * 
     * @param connection 数据库连接对象
     */
    public void begin(final Connection connection) throws SQLException {
        beginInternal(connection, SoftTransactionType.BestEffortsDelivery);
    }
}

TCCSoftTransaction

TCCSoftTransaction,TCC 型柔性事务,暂未实现。实现后,会更新到 《Sharding-JDBC 源码分析 —— 分布式事务(二)之事务补偿型》。


3.3.1 创建柔性事务

通过调用 SoftTransactionManager#getTransaction() 创建柔性事务对象:

/**
* {@link ExecutorDataMap#dataMap} 柔性事务对象 key
*/
private static final String TRANSACTION = "transaction";
/**
* {@link ExecutorDataMap#dataMap} 柔性事务配置 key
*/
private static final String TRANSACTION_CONFIG = "transactionConfig";

// SoftTransactionManager.java
/**
* 创建柔性事务.
* 
* @param type 柔性事务类型
* @return 柔性事务
*/
public AbstractSoftTransaction getTransaction(final SoftTransactionType type) {
   AbstractSoftTransaction result;
   switch (type) {
       case BestEffortsDelivery: 
           result = new BEDSoftTransaction();
           break;
       case TryConfirmCancel:
           result = new TCCSoftTransaction();
           break;
       default: 
           throw new UnsupportedOperationException(type.toString());
   }
   // TODO 目前使用不支持嵌套事务,以后这里需要可配置
   if (getCurrentTransaction().isPresent()) {
       throw new UnsupportedOperationException("Cannot support nested transaction.");
   }
   ExecutorDataMap.getDataMap().put(TRANSACTION, result);
   ExecutorDataMap.getDataMap().put(TRANSACTION_CONFIG, transactionConfig);
   return result;
}
  • 后续可以从 ExecutorDataMap 中获取当前线程的柔性事务和柔性事务配置:

    // SoftTransactionManager.java
    /**
    * 获取当前线程的柔性事务配置.
    * 
    * @return 当前线程的柔性事务配置
    */
    public static Optional<SoftTransactionConfiguration> getCurrentTransactionConfiguration() {
       Object transactionConfig = ExecutorDataMap.getDataMap().get(TRANSACTION_CONFIG);
       return (null == transactionConfig)
               ? Optional.<SoftTransactionConfiguration>absent()
               : Optional.of((SoftTransactionConfiguration) transactionConfig);
    }
    
    /**
    * 获取当前的柔性事务.
    * 
    * @return 当前的柔性事务
    */
    public static Optional<AbstractSoftTransaction> getCurrentTransaction() {
       Object transaction = ExecutorDataMap.getDataMap().get(TRANSACTION);
       return (null == transaction)
               ? Optional.<AbstractSoftTransaction>absent()
               : Optional.of((AbstractSoftTransaction) transaction);
    }

4. 事务日志存储器

柔性事务执行过程中,会通过事务日志( TransactionLog ) 记录每条 SQL 执行状态:

  • SQL 执行前,记录一条事务日志
  • SQL 执行成功,移除对应的事务日志

通过实现事务日志存储器接口( TransactionLogStorage ),提供存储功能。目前有两种实现:

  • MemoryTransactionLogStorage :基于内存的事务日志存储器。主要用于开发测试,生产环境下不要使用。
  • RdbTransactionLogStorage :基于数据库的事务日志存储器。

本节只分析 RdbTransactionLogStorage。对 MemoryTransactionLogStorage 感兴趣的同学可以点击链接传送到达。

TransactionLogStorage 有五个接口方法,下文每个小标题都是一个方法。

4.1 #add()

// TransactionLogStorage.java
/**
* 存储事务日志.
* 
* @param transactionLog 事务日志
*/
void add(TransactionLog transactionLog);

// RdbTransactionLogStorage.java
@Override
public void add(final TransactionLog transactionLog) {
   String sql = "INSERT INTO `transaction_log` (`id`, `transaction_type`, `data_source`, `sql`, `parameters`, `creation_time`) VALUES (?, ?, ?, ?, ?, ?);";
   try (
    // ... 省略你熟悉的代码
   } catch (final SQLException ex) {
       throw new TransactionLogStorageException(ex);
   }
}
  • 注意:如果插入事务日志失败,SQL 会继续执行,如果此时 SQL 执行失败,则该 SQL 会不见了。建议:#add() 和下文的 #remove() 异常时,都打印下异常日志都文件系统

TransactionLog (transaction_log) 数据库表结构如下:

字段名字数据库类型备注
id事件编号VARCHAR(40)EventBus 事件编号,非事务编号
transaction_type柔性事务类型VARCHAR(30)
data_source真实数据源名VARCHAR(255)
sql执行 SQLTEXT已经改写过的 SQL
parameters占位符参数TEXTJSON 字符串存储
creation_time记录时间LONG
async_delivery_try_times已异步重试次数INT

4.2 #remove()

// TransactionLogStorage.java
/**
* 根据主键删除事务日志.
* 
* @param id 事务日志主键
*/
void remove(String id);

// RdbTransactionLogStorage.java    
@Override
public void remove(final String id) {
   String sql = "DELETE FROM `transaction_log` WHERE `id`=?;";
   try (
          // ... 省略你熟悉的代码
   } catch (final SQLException ex) {
       throw new TransactionLogStorageException(ex);
   }
}

4.3 #findEligibleTransactionLogs()

// TransactionLogStorage.java
/**
* 读取需要处理的事务日志.
* 
* <p>需要处理的事务日志为: </p>
* <p>1. 异步处理次数小于最大处理次数.</p>
* <p>2. 异步处理的事务日志早于异步处理的间隔时间.</p>
* 
* @param size 获取日志的数量
* @param maxDeliveryTryTimes 事务送达的最大尝试次数
* @param maxDeliveryTryDelayMillis 执行送达事务的延迟毫秒数.
*/
List<TransactionLog> findEligibleTransactionLogs(int size, int maxDeliveryTryTimes, long maxDeliveryTryDelayMillis);

// RdbTransactionLogStorage.java
@Override
public List<TransactionLog> findEligibleTransactionLogs(final int size, final int maxDeliveryTryTimes, final long maxDeliveryTryDelayMillis) {
   List<TransactionLog> result = new ArrayList<>(size);
   String sql = "SELECT `id`, `transaction_type`, `data_source`, `sql`, `parameters`, `creation_time`, `async_delivery_try_times` "
       + "FROM `transaction_log` WHERE `async_delivery_try_times`<? AND `transaction_type`=? AND `creation_time`<? LIMIT ?;";
   try (Connection conn = dataSource.getConnection()) {
       // ... 省略你熟悉的代码
   } catch (final SQLException ex) {
       throw new TransactionLogStorageException(ex);
   }
   return result;
}

4.4 #increaseAsyncDeliveryTryTimes()

// TransactionLogStorage.java
/**
* 增加事务日志异步重试次数.
* 
* @param id 事务主键
*/
void increaseAsyncDeliveryTryTimes(String id);

// RdbTransactionLogStorage.java
@Override
public void increaseAsyncDeliveryTryTimes(final String id) {
   String sql = "UPDATE `transaction_log` SET `async_delivery_try_times`=`async_delivery_try_times`+1 WHERE `id`=?;";
   try (
       // ... 省略你熟悉的代码
   } catch (final SQLException ex) {
       throw new TransactionLogStorageException(ex);
   }
}

4.5 #processData()

// TransactionLogStorage.java
/**
* 处理事务数据.
*
* @param connection 业务数据库连接
* @param transactionLog 事务日志
* @param maxDeliveryTryTimes 事务送达的最大尝试次数
*/
boolean processData(Connection connection, TransactionLog transactionLog, int maxDeliveryTryTimes);

// RdbTransactionLogStorage.java
@Override
public boolean processData(final Connection connection, final TransactionLog transactionLog, final int maxDeliveryTryTimes) {
   // 重试执行失败 SQL
   try (
       Connection conn = connection;
       PreparedStatement preparedStatement = conn.prepareStatement(transactionLog.getSql())) {
       for (int parameterIndex = 0; parameterIndex < transactionLog.getParameters().size(); parameterIndex++) {
           preparedStatement.setObject(parameterIndex + 1, transactionLog.getParameters().get(parameterIndex));
       }
       preparedStatement.executeUpdate();
   } catch (final SQLException ex) {
       // 重试失败,更新事务日志,增加已异步重试次数
       increaseAsyncDeliveryTryTimes(transactionLog.getId());
       throw new TransactionCompensationException(ex);
   }
   // 移除重试执行成功 SQL 对应的事务日志
   remove(transactionLog.getId());
   return true;
}
  • 不同于前四个增删改查接口方法的实现,#processData() 是带有一些逻辑的。根据事务日志( TransactionLog )重试执行失败的 SQL,若成功,移除事务日志;若失败,更新事务日志,增加已异步重试次数
  • 该方法会被最大努力送达型异步作业调用到

5. 最大努力送达型事务监听器

最大努力送达型事务监听器,BestEffortsDeliveryListener,负责记录事务日志、同步重试执行失败 SQL。

// BestEffortsDeliveryListener.java
@Subscribe
@AllowConcurrentEvents
public void listen(final DMLExecutionEvent event) {
   if (!isProcessContinuously()) {
       return;
   }
   SoftTransactionConfiguration transactionConfig = SoftTransactionManager.getCurrentTransactionConfiguration().get();
   TransactionLogStorage transactionLogStorage = TransactionLogStorageFactory.createTransactionLogStorage(transactionConfig.buildTransactionLogDataSource());
   BEDSoftTransaction bedSoftTransaction = (BEDSoftTransaction) SoftTransactionManager.getCurrentTransaction().get();
   switch (event.getEventExecutionType()) {
       case BEFORE_EXECUTE: // 执行前,插入事务日志
           //TODO 对于批量执行的SQL需要解析成两层列表
           transactionLogStorage.add(new TransactionLog(event.getId(), bedSoftTransaction.getTransactionId(), bedSoftTransaction.getTransactionType(), 
                   event.getDataSource(), event.getSql(), event.getParameters(), System.currentTimeMillis(), 0));
           return;
       case EXECUTE_SUCCESS: // 执行成功,移除事务日志
           transactionLogStorage.remove(event.getId());
           return;
       case EXECUTE_FAILURE: // 执行失败,同步重试
           boolean deliverySuccess = false;
           for (int i = 0; i < transactionConfig.getSyncMaxDeliveryTryTimes(); i++) { // 同步【多次】重试
               if (deliverySuccess) {
                   return;
               }
               boolean isNewConnection = false;
               Connection conn = null;
               PreparedStatement preparedStatement = null;
               try {
                   // 获得数据库连接
                   conn = bedSoftTransaction.getConnection().getConnection(event.getDataSource(), SQLType.DML);
                   if (!isValidConnection(conn)) { // 因为可能执行失败是数据库连接异常,所以判断一次,如果无效,重新获取数据库连接
                       bedSoftTransaction.getConnection().release(conn);
                       conn = bedSoftTransaction.getConnection().getConnection(event.getDataSource(), SQLType.DML);
                       isNewConnection = true;
                   }
                   preparedStatement = conn.prepareStatement(event.getSql());
                   // 同步重试
                   //TODO 对于批量事件需要解析成两层列表
                   for (int parameterIndex = 0; parameterIndex < event.getParameters().size(); parameterIndex++) {
                       preparedStatement.setObject(parameterIndex + 1, event.getParameters().get(parameterIndex));
                   }
                   preparedStatement.executeUpdate();
                   deliverySuccess = true;
                   // 同步重试成功,移除事务日志
                   transactionLogStorage.remove(event.getId());
               } catch (final SQLException ex) {
                   log.error(String.format("Delivery times %s error, max try times is %s", i + 1, transactionConfig.getSyncMaxDeliveryTryTimes()), ex);
               } finally {
                   close(isNewConnection, conn, preparedStatement);
               }
           }
           return;
       default: 
           throw new UnsupportedOperationException(event.getEventExecutionType().toString());
   }
}
  • BestEffortsDeliveryListener 通过 EventBus 实现监听 SQL 的执行。Sharding-JDBC 如何实现 EventBus 的,请看《Sharding-JDBC 源码分析 —— SQL 执行》
  • 调用 #isProcessContinuously() 方法判断是否处于最大努力送达型事务中,当且仅当处于该状态才进行监听事件处理
  • SQL 执行前,插入事务日志
  • SQL 执行成功,移除事务日志
  • SQL 执行失败,根据柔性事务配置( SoftTransactionConfiguration )同步的事务送达的最大尝试次数( syncMaxDeliveryTryTimes )进行多次重试直到成功。总体逻辑和 RdbTransactionLogStorage#processData() 方法逻辑类似,区别在于获取分片数据库连接的特殊处理:此处调用失败,数据库连接可能是异常无效的,因此调用了 #isValidConnection() 判断连接的有效性。若无效,则重新获取分片数据库连接。另外,若是重新获取分片数据库连接,需要进行关闭释放 (Connection#close()):

    // BestEffortsDeliveryListener.java
    /**
    * 通过 SELECT 1 校验数据库连接是否有效
    *
    * @param conn 数据库连接
    * @return 是否有效
    */
    private boolean isValidConnection(final Connection conn) {
       try (PreparedStatement preparedStatement = conn.prepareStatement("SELECT 1")) {
           try (ResultSet rs = preparedStatement.executeQuery()) {
               return rs.next() && 1 == rs.getInt("1");
           }
       } catch (final SQLException ex) {
           return false;
       }
    }
    
    /**
    * 关闭释放预编译SQL对象和数据库连接
    *
    * @param isNewConnection 是否新创建的数据库连接,是的情况下才释放
    * @param conn 数据库连接
    * @param preparedStatement 预编译SQL
    */
    private void close(final boolean isNewConnection, final Connection conn, final PreparedStatement preparedStatement) {
       if (null != preparedStatement) {
           try {
               preparedStatement.close();
           } catch (final SQLException ex) {
               log.error("PreparedStatement closed error:", ex);
           }
       }
       if (isNewConnection && null != conn) {
           try {
               conn.close();
           } catch (final SQLException ex) {
               log.error("Connection closed error:", ex);
           }
       }
    }

6. 最大努力送达型异步作业

当最大努力送达型事务监听器( BestEffortsDeliveryListener )多次同步重试失败后,交给最大努力送达型异步作业进行多次异步重试,并且多次执行有固定间隔。

Sharding-JDBC 提供了两个最大努力送达型异步作业实现:

  • NestedBestEffortsDeliveryJob :内嵌的最大努力送达型异步作业
  • BestEffortsDeliveryJob :最大努力送达型异步作业

两者实现代码逻辑基本一致。前者相比后者,用于开发测试,去除对 Zookeeper 依赖,无法实现高可用,因此生产环境下不适合使用。

6.1 BestEffortsDeliveryJob

BestEffortsDeliveryJob 所在 Maven 项目为 sharding-jdbc-transaction-async-job,基于当当开源的 Elastic-Job 实现。如下是官方对该 Maven 项目的简要说明:

由于柔性事务采用异步尝试,需要部署独立的作业和Zookeeper。sharding-jdbc-transaction采用elastic-job实现的sharding-jdbc-transaction-async-job,通过简单配置即可启动高可用作业异步送达柔性事务,启动脚本为start.sh。

BestEffortsDeliveryJob

public class BestEffortsDeliveryJob extends AbstractIndividualThroughputDataFlowElasticJob<TransactionLog> {

    /**
     * 最大努力送达型异步作业配置对象
     */
    @Setter
    private BestEffortsDeliveryConfiguration bedConfig;
    /**
     * 事务日志存储器对象
     */
    @Setter
    private TransactionLogStorage transactionLogStorage;

    @Override
    public List<TransactionLog> fetchData(final JobExecutionMultipleShardingContext context) {
        return transactionLogStorage.findEligibleTransactionLogs(context.getFetchDataCount(),
            bedConfig.getJobConfig().getMaxDeliveryTryTimes(), bedConfig.getJobConfig().getMaxDeliveryTryDelayMillis());
    }

    @Override
    public boolean processData(final JobExecutionMultipleShardingContext context, final TransactionLog data) {
        try (
            Connection conn = bedConfig.getTargetDataSource(data.getDataSource()).getConnection()) {
            transactionLogStorage.processData(conn, data, bedConfig.getJobConfig().getMaxDeliveryTryTimes());
        } catch (final SQLException | TransactionCompensationException ex) {
            log.error(String.format("Async delivery times %s error, max try times is %s, exception is %s", data.getAsyncDeliveryTryTimes() + 1, 
                bedConfig.getJobConfig().getMaxDeliveryTryTimes(), ex.getMessage()));
            return false;
        }
        return true;
    }

    @Override
    public boolean isStreamingProcess() {
        return false;
    }
}
  • 调用 #fetchData() 方法获取需要处理的事务日志 (TransactionLog),内部调用了 TransactionLogStorage#findEligibleTransactionLogs() 方法
  • 调用 #processData() 方法处理事务日志,重试执行失败的 SQL,内部调用了 TransactionLogStorage#processData()
  • #fetchData() 和 #processData() 调用是 Elastic-Job 控制的。每一轮定时调度,每条事务日志只执行一次。当超过最大异步调用次数后,该条事务日志不再处理,所以生产使用时,最好增加下相应监控超过最大异步重试次数的事务日志。

6.2 AsyncSoftTransactionJobConfiguration

AsyncSoftTransactionJobConfiguration,异步柔性事务作业配置对象。

public class AsyncSoftTransactionJobConfiguration {

    /**
     * 作业名称.
     */
    private String name = "bestEffortsDeliveryJob";

    /**
     * 触发作业的cron表达式.
     */
    private String cron = "0/5 * * * * ?";

    /**
     * 每次作业获取的事务日志最大数量.
     */
    private int transactionLogFetchDataCount = 100;

    /**
     * 事务送达的最大尝试次数.
     */
    private int maxDeliveryTryTimes = 3;

    /**
     * 执行事务的延迟毫秒数.
     *
     * <p>早于此间隔时间的入库事务才会被作业执行.</p>
     */
    private long maxDeliveryTryDelayMillis = 60  * 1000L;
}

6.3 Elastic-Job 是否必须?

Sharding-JDBC 提供的最大努力送达型异步作业实现( BestEffortsDeliveryJob ),通过与 Elastic-Job 集成,可以很便捷并且有质量保证的高可用、高性能使用。一部分团队,可能已经引入或自研了类似 Elastic-Job 的分布式作业中间件解决方案,每多一个中间件,就是多一个学习与运维成本。那么是否可以使用自己的分布式作业解决方案?答案是,可以的。参考 BestEffortsDeliveryJob 的实现,通过调用 TransactionLogStorage 来实现:

// 伪代码(不考虑性能、异常)
List<TransactionLog> transactionLogs = transactionLogStorage.findEligibleTransactionLogs(....);
for (TransactionLog transactionLog : transactionLogs) {
       transactionLogStorage.processData(conn, log, maxDeliveryTryTimes);
}

当然,个人还是很推荐 Elastic-Job。

�� 笔者要开始写《Elastic-Job 源码分析》。


另外,如果有支持事务消息的分布式队列系统,可以通过 TransactionLogStorage 实现存储事务消息存储成消息。为什么要支持事务消息?如果 SQL 执行是成功的,需要回滚(删除)事务消息。

7. 适用场景

见《官方文档 - 事务支持》。

8. 开发指南 & 开发示例

见《官方文档 - 事务支持》。

666. 彩蛋

哈哈哈

算是坚持把这个系列写完了,给自己 32 個赞。

满足!

《Elastic-Job 源码分析》 走起!不 High 不结束!

大牛都在用的sharding-JDBC,来看这里,教你啊 Sharding-JDBC Sharding-JDBC是ShardingSphere中的一个独立产品,定位为轻量级Java框架,在Java的JDBC层提供的额外服务。 它使用客户端直连数据库,以jar包形式提供服务,无需额外部署和依赖,可理解为增强版的JDBC驱动,完全兼容JDBC和各种ORM框架。ShardingSphere是一套开源的分布式数据库中间件解决方案组成的生态圈,它由Sharding-JDBC、Sharding-Proxy和Sharding-Sidecar(计划中)这3款相互独立的产品组成。 阅读详情

相关推荐

我是如何探索Sharding-JDBC源码的?sharding源码学习从0到1

一文理清sharding-JDBC主脉络本文主旨一条sql 引起的反思寻找Sharding-JDBC 主脉络1.从sharding源码包结构寻找线索2)shrding-jdbc-core 提供的对于jdbc规范的重写3)sql路由3)sql路由3)sql路由3)sql路由2.debug关键节点验证执行流程 本文主旨 本文尝试,以自上而下的方式,从整体脉络、从大方向上阐释sharding-jdbc在...

D_19901719576的博客 1544

ShardingSphere分库分表核心原理精讲第十一节 分布式事务详解

27 分布式事务:如何理解 ShardingSphere 中对分布式事务的抽象过程? 从今天开始,我们将进入一个全新模块,即ShardingSphere 分布式事务。这是一个非常重要的主题,我们将通过三个课时来全面介绍 ShardingSphere 的事务实现机制。 ShardingTransactionManagerEngine 在第 18 课时和第 19 课时的“分布式事务:如何使用强一致事务与柔性事务?”中,我们已经对分布式事务的基本概念做了介绍。 在了解完一些基本概念之后,我们来看 Shardin

fegus的博客 1840

MLX90640 热成像 STM32

MLX90640 热成像

zhaocundang's blog 5008

(高级)ShardingSphere源码分析如何实现分布式事务

在分析事务之前,需要先明白事务与链接的关系,一个事务可以包含多个链接(如读写分离的实现),一个链接也可以对应多个事务(如链接池化技术)。 ShardingTransactionManagerEngine shardingsphere与事务相关的工程有以下几个。 从命名上,我们不难看出 sharding-transaction-core 应该包含了分布式事务相关的一些基础核心类,而 sharding-transaction-2pc 和 sharding-transaction-base 分别基于强一致性.

gonghaiyu的博客 1672

SAP采购订单行项目增强实战:用BADI ME_GUI_PO_CUST添加自定义字段(避坑指南)

本文详细解析了如何通过BADI ME_GUI_PO_CUST在SAP采购订单行项目中添加自定义字段,包括技术架构理解、字段扩展步骤、自定义函数组创建及BADI实现。文章特别强调了避开官方文档未提及的陷阱,如字段映射限制和屏幕显示问题,并提供了高级优化技巧和性能建议。

weixin_30402343的博客 596

3DMax高效建模与人工智能:一场颠覆传统创作的效率革命

AI与3DMax的结合,不仅是工具效率的升级,更是一场创作范式的革命。从“手动雕刻”到“智能共生”,设计师的角色正从执行者转向决策者。正如网友所言:“AI不是替代人类,而是赋予凡人以神笔。”在这场变革中,唯有拥抱技术、深耕创意,方能在数字艺术的浪潮中立于潮头。参考文献与工具推荐技术原理:火星时代资讯《人工智能和三维建模》工具实测:哔哩哔哩《tyDiffusion 3dsMax应用》9、Tripo AI官网教育案例:原创论文《人工智能技术介入三维动画课程建设》

m0_46478534的博客 3021

分库分表之ShardingSphere 支持分布式事务 源码分析

1. 事务相关配置 @EnableTransactionManagement // 支持spring事务 @SpringBootApplication(scanBasePackages = "com.example.shard") public class ShardJdbcApplication { ..... } @ShardingTransactionType(T...

u010627840的专栏 676

OpenCv案例(七): 基于OpenCvSharp计算图像的清晰度(自动对焦)

自动对焦,其实是对相机成像的清晰值得计算,若对焦不清晰,成像的清晰度低,视觉效果模糊。若是在工业检测行业,对焦不准确,可能会造成严重后果;对焦准确的图像,其清晰度高,对比度鲜明,层次明显。

qq_37835727的博客 7115

万字长文详解Shardingsphere对XA分布式事务的支持

点击上方蓝色“程序猿DD”,选择“设为星标”回复“资源”获取独家整理的学习资料!万字长文详解Shardingsphere对XA分布式事务的支持Apache ShardingSphere ...

程序猿DD 1302

AI系统架构设计实战:AI应用架构师的深度指南

核心概念:AI系统架构是指设计和组织人工智能系统各个组件(包括数据、算法、计算资源、集成接口等)的结构框架,以及这些组件之间的交互方式和原则。它为AI应用提供了技术蓝图,决定了系统的性能、可扩展性、可维护性和可靠性。数据的本质:数据是对客观事物的符号表示,是可识别的、抽象的符号。在AI系统中,数据不仅是输入,也是系统学习和改进的基础。数据就像AI系统的"燃料",其质量和数量直接决定了AI系统的能力边界。

AI天才研究院 1203

AIGC实战——多模态模型DALL.E 2

DALL.E 2 是 OpenAI 提出的一个大规模文本生成图像模型,可以根据文本提示生成各种风格的逼真图像。它通过将预训练模型 CLIP 与 GLIDE 中的扩散模型架构相结合完成任务。它还具有其他应用,例如通过文本提示编辑图像和提供给定图像的变体。虽然它也有一些局限性,例如不一致的文本渲染和属性绑定,但 DALL.E 2 是仍然一个非常强大的AI模型,推动了生成模型的发展。

盼小辉丶的博客 1万+

【源码】Sharding-JDBC源码分析之Sql解析的原理

本文从源码的角度分析Sharding-JDBC中SQL解析的实现原理。以MySQL数据库的Select查询语句为例,分享了Sharding-JDBC中通过Antlr工具进行SQL解析的流程。重点分享了MySQLStatementSQLVisitor的源码。

JingAi_jia917的博客 1934

K8s(十二):监控与报警(163邮箱+钉钉)-Prometheus + Grafana + Alertmanager(超详细)

🔴 K8s(十二):监控与报警(163邮箱+钉钉)-Prometheus + Grafana + Alertmanager(超详细)

✨ 欢迎来到【Seal ^_^ 的优快云博客】!✨ 3万+

Sharding-JDBC 源码分析 —— 分布式事务(一)之最大努力型

1. 概述 数据库表分库后,业务场景下的单库本地事务可能变成跨库分布式事务。虽然我们可以通过合适的分库规则让操作的数据在同库下,继续保证单库本地事务,这也是非常推崇的,但不是所有场景下都能适用。如果这些场景对事务的一致性有要求,我们就不得不解决分布式事务的“麻烦”。 分布式事务是个很大的话题,我们来看看 Sharding-JDBC 对她的权衡: Sharding-JDBC由于性能方面的考量,决定不支持强一致性分布式事务。我们已明确规划线路图,未来会支持最终一致性的柔性事务。 Sharding-J

weixin_42073629的博客 1400

IMSL CNL 7.0.0 (x86-64)Crack

IMSL CNL 7.0.0 (x86-64)Crack intel的算法库破解文件,这是C++版本的破解文件

数学建模模型总结

这是本人在两年内准备参加数学建模竞赛搜集到的模型资料,已经经过了本人的筛选和整理,希望能够对准备参加数学建模竞赛的学弟学妹们提供一些帮助!

Sharding-JDBC 源码分析 —— 为什么阅读 Sharding-JDBC 源码?

摘要:本文深入解析Sharding-JDBC源码阅读的价值与方法。作为分布式数据库中间件,Sharding-JDBC实现SQL解析、路由、改写、执行和归并五大核心流程。阅读源码可带来六大收益:掌握分库分表原理、提升问题排查能力、学习优秀架构设计、获得定制开发能力、夯实Java基础、增强技术影响力。文章详细拆解各模块实现,并给出四步阅读路线:从测试用例入手,跟踪SQL生命周期,分模块击破,带着问题探索。通过源码阅读,开发者可完成从"使用者"到"贡献者"的蜕变,构建分布式

油墨香^-^的博客 1280

计算机控制技术及应用

《计算机控制技术及应用》通过总结作者的科研成果和吸收国内外的先进理论、方法和技术,以计算机控制系统的网络化、开放化、智能化和集成化发展趋势为主线索,主要介绍计算机控制系统的基本概念和计算机控制系统的典型形式,计算机控制系统的数学描述与基本分析方法,以及数字PID控制器、最少拍控制系统、达林算法、状态变量设计法等设计方法及其各种改进算法。重点突出计算机控制系统输入输出通道接口的设计方法和典型控制系统的设计案例与实现方法等。

【源码】Sharding-JDBC源码分析之ShardingSphereConnection的创建原理

本篇从源码角度,分析了ShardingSphere框架中ShardingSphereConnection的实现原理。一个ShardingSphereConnection对应多个真实的Connection。重点分析了ShardingSphereConnection、ConnectionManager的源码。

JingAi_jia917的博客 1128

深度学习工具包 DeepLearningToolbox

深度学习工具包Deprecation notice.-----This toolbox is outdated and no longer maintained.There are much better tools available for deep learning than this toolbox, e.g. [Theano](http://deeplearning.net/software/theano/), [torch](http://torch.ch/) or [tensorflow](http://www.tensorflow.org/)I would suggest you use one of the tools mentioned above rather than use this toolbox.Best, Rasmus.DeepLearnToolbox================A Matlab toolbox for Deep Learning.Deep Learning is a new subfield of machine learning that focuses on learning deep hierarchical models of data.It is inspired by the human brain's apparent deep (layered, hierarchical) architecture.A good overview of the theory of Deep Learning theory is[Learning Deep Architectures for AI](http://www.iro.umontreal.ca/~bengioy/papers/ftml_book.pdf)For a more informal introduction, see the following videos by Geoffrey Hinton and Andrew Ng.* [The Next Generation of Neural Networks](http://www.youtube.com/watch?v=AyzOUbkUf3M) (Hinton, 2007)* [Recent Developments in Deep Learning](http://www.youtube.com/watch?v=VdIURAu1-aU) (Hinton, 2010)* [Unsupervised Feature Learning and Deep Learning](http://www.youtube.com/watch?v=ZmNOAtZIgIk) (Ng, 2011)If you use this toolbox in your research please cite [Prediction as a candidate for learning deep hierarchical models of data](http://www2.imm.dtu.dk/pubdb/views/publication_details.php?id=6284)```@MASTERSTHESIS\{IMM2012-06284, author = "R. B. Palm", title = "Prediction as a candidate for learning deep hierarchical models of data", year = "2012",}```Contact: rasmusbergpalm at gmail dot comDirectories included in the toolbox-----------------------------------`NN/` - A library for Feedforward Backpropagation Neural Networks`CNN/` - A library for Convolutional Neural Networks`DBN/` - A library for Deep Belief Networks`SAE/` - A library for Stacked Auto-Encoders`CAE/` - A library for Convolutional Auto-Encoders`util/` - Utility functions used by the libraries`data/` - Data used by the examples`tests/` - unit tests to verify toolbox is workingFor references on each library check REFS.mdSetup-----1. Download.2. addpath(genpath('DeepLearnToolbox'));Example: Deep Belief Network---------------------```matlabfunction test_example_DBNload mnist_uint8;train_x = double(train_x) / 255;test_x = double(test_x) / 255;train_y = double(train_y);test_y = double(test_y);%% ex1 train a 100 hidden unit RBM and visualize its weightsrand('state',0)dbn.sizes = [100];opts.numepochs = 1;opts.batchsize = 100;opts.momentum = 0;opts.alpha = 1;dbn = dbnsetup(dbn, train_x, opts);dbn = dbntrain(dbn, train_x, opts);figure; visualize(dbn.rbm{1}.W'); % Visualize the RBM weights%% ex2 train a 100-100 hidden unit DBN and use its weights to initialize a NNrand('state',0)%train dbndbn.sizes = [100 100];opts.numepochs = 1;opts.batchsize = 100;opts.momentum = 0;opts.alpha = 1;dbn = dbnsetup(dbn, train_x, opts);dbn = dbntrain(dbn, train_x, opts);%unfold dbn to nnnn = dbnunfoldtonn(dbn, 10);nn.activation_function = 'sigm';%train nnopts.numepochs = 1;opts.batchsize = 100;nn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.10, 'Too big error');```Example: Stacked Auto-Encoders---------------------```matlabfunction test_example_SAEload mnist_uint8;train_x = double(train_x)/255;test_x = double(test_x)/255;train_y = double(train_y);test_y = double(test_y);%% ex1 train a 100 hidden unit SDAE and use it to initialize a FFNN% Setup and train a stacked denoising autoencoder (SDAE)rand('state',0)sae = saesetup([784 100]);sae.ae{1}.activation_function = 'sigm';sae.ae{1}.learningRate = 1;sae.ae{1}.inputZeroMaskedFraction = 0.5;opts.numepochs = 1;opts.batchsize = 100;sae = saetrain(sae, train_x, opts);visualize(sae.ae{1}.W{1}(:,2:end)')% Use the SDAE to initialize a FFNNnn = nnsetup([784 100 10]);nn.activation_function = 'sigm';nn.learningRate = 1;nn.W{1} = sae.ae{1}.W{1};% Train the FFNNopts.numepochs = 1;opts.batchsize = 100;nn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.16, 'Too big error');```Example: Convolutional Neural Nets---------------------```matlabfunction test_example_CNNload mnist_uint8;train_x = double(reshape(train_x',28,28,60000))/255;test_x = double(reshape(test_x',28,28,10000))/255;train_y = double(train_y');test_y = double(test_y');%% ex1 Train a 6c-2s-12c-2s Convolutional neural network %will run 1 epoch in about 200 second and get around 11% error. %With 100 epochs you'll get around 1.2% errorrand('state',0)cnn.layers = { struct('type', 'i') %input layer struct('type', 'c', 'outputmaps', 6, 'kernelsize', 5) %convolution layer struct('type', 's', 'scale', 2) %sub sampling layer struct('type', 'c', 'outputmaps', 12, 'kernelsize', 5) %convolution layer struct('type', 's', 'scale', 2) %subsampling layer};cnn = cnnsetup(cnn, train_x, train_y);opts.alpha = 1;opts.batchsize = 50;opts.numepochs = 1;cnn = cnntrain(cnn, train_x, train_y, opts);[er, bad] = cnntest(cnn, test_x, test_y);%plot mean squared errorfigure; plot(cnn.rL);assert(er<0.12, 'Too big error');```Example: Neural Networks---------------------```matlabfunction test_example_NNload mnist_uint8;train_x = double(train_x) / 255;test_x = double(test_x) / 255;train_y = double(train_y);test_y = double(test_y);% normalize[train_x, mu, sigma] = zscore(train_x);test_x = normalize(test_x, mu, sigma);%% ex1 vanilla neural netrand('state',0)nn = nnsetup([784 100 10]);opts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samples[nn, L] = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.08, 'Too big error');%% ex2 neural net with L2 weight decayrand('state',0)nn = nnsetup([784 100 10]);nn.weightPenaltyL2 = 1e-4; % L2 weight decayopts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex3 neural net with dropoutrand('state',0)nn = nnsetup([784 100 10]);nn.dropoutFraction = 0.5; % Dropout fraction opts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex4 neural net with sigmoid activation functionrand('state',0)nn = nnsetup([784 100 10]);nn.activation_function = 'sigm'; % Sigmoid activation functionnn.learningRate = 1; % Sigm require a lower learning rateopts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex5 plotting functionalityrand('state',0)nn = nnsetup([784 20 10]);opts.numepochs = 5; % Number of full sweeps through datann.output = 'softmax'; % use softmax outputopts.batchsize = 1000; % Take a mean gradient step over this many samplesopts.plot = 1; % enable plottingnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex6 neural net with sigmoid activation and plotting of validation and training error% split training data into training and validation datavx = train_x(1:10000,:);tx = train_x(10001:end,:);vy = train_y(1:10000,:);ty = train_y(10001:end,:);rand('state',0)nn = nnsetup([784 20 10]); nn.output = 'softmax'; % use softmax outputopts.numepochs = 5; % Number of full sweeps through dataopts.batchsize = 1000; % Take a mean gradient step over this many samplesopts.plot = 1; % enable plottingnn = nntrain(nn, tx, ty, opts, vx, vy); % nntrain takes validation set as last two arguments (optionally)[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');```[![Bitdeli Badge](https://d2weczhvl823v0.cloudfront.net/rasmusbergpalm/deeplearntoolbox/trend.png)](https://bitdeli.com/free "Bitdeli Badge")

【源码】Sharding-JDBC源码分析之SPI机制

本篇先介绍了Java SPI机制实现,而后介绍了ShardingSphere框架中最核心的TypedSPI、RequiredSPI、OrderdSPI、OptionalSPI的实现源码。

JingAi_jia917的博客 1478

数据库中间件 Sharding-JDBC 和 MyCAT 源码解析合集

Sharding-JDBC 目录如下:Sharding-JDBC 源码分析 —— SQL 解析(一)之词法解析Sharding-JDBC 源码分析 —— SQL 解析(二...

芋道源码 1074

数据库中间件 Sharding-JDBC 源码分析 —— SQL 解析(一)之语法解析

**SQL 解析引擎**,数据库中间件必备的功能和流程。Sharding-JDBC 在 `1.5.0.M1` 正式发布时,将 SQL 解析引擎从 Druid 替换成了自研的。**新引擎仅解析分片上下文,对于 SQL 采用"半理解"理念,进一步提升性能和兼容性,同时降低了代码复杂度**(不理解没关系,我们后续会更新文章解释该优点)。 国内另一款数据库中间件 MyCAT SQL 解析引擎也是 Druid,目前也在开发属于

芋艿V 1251

数据库中间件 Sharding-JDBC 源码分析 —— 结果归并

摘要: 原创出处 http://www.iocoder.cn/Sharding-JDBC/result-merger/ 「芋道源码」欢迎转载,保留摘要,谢谢!本文主要基于 Sharding-JDBC 1.5.0 正式版 1. 概述 2. MergeEngine 2.1 SelectStatement#setIndexForItems() 2.2 ResultSetMerger 2.2.1 A

芋艿V 1373

【源码】Sharding-JDBC源码分析之配置数据库定义的表的元数据解析原理

本篇从源码角度,分析了Sharding JDBC通过SchemaBuilder解析获取表的元数据的实现原理。元数据包括表、字段、主键、约束。重点分析了GenericSchemaBuilder、SystemSchemaBuilder的源码实现。

JingAi_jia917的博客 1087

【源码】Sharding-JDBC源码分析之ContextManager创建中ShardingSphereDatabase的创建原理

本篇从源码的角度,分析了ShardingSphereDatabase的创建过程。重点分析了MetaDataContextsFactory、ShardingSphereDatabasesFactory、ShardingSphereDatabase的源码实现。

JingAi_jia917的博客 2382

Sharding-JDBC 源码之启动流程分析

Sharding-JDBC 是 ShardingSphere 开源的分布式数据库中间件产品之一,提供标准化的数据分片、分布式事务和数据库治理功能,可适用于如Java同构、异构语言、云原生等各种多样化的应用场景。 Sharding-JDBC 在 Java 的 JDBC 层提供额外服务,它使用客户端直连数据库,以jar包形式提供服务,无需额外部署和依赖,可理解为增强版的JDBC驱动,完全兼容JDBC和各种ORM框架 接下来,让我们由简入繁,逐渐拉来 Sharding-JDBC 的序幕。 首先基于 Sprin.

朝花夕拾 2252
上一篇: Dubbo 源码解析 —— Directory
下一篇: 【死磕Java并发】—–深入分析volatile的实现原理
公众号-芋道源码
博客等级 码龄10年 1639粉丝 377原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值