架构师手写代码：分享数据库原子性与一致性实现方案(不再背概念)

最新推荐文章于 2024-10-02 00:27:17 发布
置顶 最新推荐文章于 2024-10-02 00:27:17 发布
阅读量2k 收藏 14
点赞数 65
分类专栏： Java 数据库 事务 文章标签： 数据库 java 事务
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/alises1314/article/details/140688916
版权
Java 同时被 3 个专栏收录
200 篇文章 0 订阅
订阅专栏
数据库
5 篇文章 0 订阅
订阅专栏
事务
5 篇文章 0 订阅
订阅专栏

在这里插入图片描述

数据库事务的原子性和一致性是数据库管理系统（DBMS）中确保数据完整性和可靠性的两个关键属性。下面是这两个属性的基本概念和实现逻辑：

肖哥弹架构 跟大家“弹弹” 数据库设计技巧，需要代码关注

欢迎 点赞，点赞，点赞。

关注公号Solomon肖哥弹架构获取更多精彩内容

历史热点文章

原子性（Atomicity）

原子性指的是事务中的所有操作要么全部完成，要么全部不完成，不会结束在中间某个点。如果事务中的某个操作失败，整个事务将被回滚到开始状态，就像这个事务从未执行过一样。

实现逻辑：

  1. 日志记录：在事务开始时，数据库会记录一个日志，包括事务的所有操作。这个日志是原子性的，即要么全部写入，要么全部不写入。
  2. 写前日志（Write-Ahead Logging, WAL）：在执行任何修改操作之前，首先将操作记录到日志中。这样，即使在操作过程中发生故障，也可以通过日志来恢复数据。
  3. 回滚操作：如果事务中的某个操作失败，数据库会使用日志中的信息来执行回滚操作，撤销事务中已经执行的所有操作。

一致性（Consistency）

一致性确保数据库从一个一致的状态转移到另一个一致的状态。在事务开始之前和提交之后，所有的数据都应满足预定义的完整性约束。

实现逻辑：

  1. 完整性约束：数据库通过预定义的规则（如主键、外键、检查约束等）来确保数据的一致性。
  2. 事务隔离：通过事务隔离级别来控制多个事务之间的并发访问，防止脏读、不可重复读和幻读，从而保证一致性。
  3. 锁定机制：数据库使用锁（如行锁、表锁）来控制对数据的并发访问，确保在事务执行期间数据的一致性不被破坏。
  4. 恢复机制：在系统故障时，数据库可以使用日志来恢复到一致的状态。例如，如果事务在提交前失败，可以使用日志来回滚事务；如果事务已经提交但在写入磁盘前系统崩溃，可以使用日志来重做事务。

业务案例

银行转账事务，涉及两个账户A和B，A向B转账100元。

  1. 开始事务：记录事务开始的日志。
  2. 检查一致性：确保A账户有足够的余额。
  3. 执行操作：从A账户扣除100元，记录操作到日志。
  4. 记录日志：在B账户增加100元之前，先记录这个操作到日志。
  5. 提交事务：将所有操作应用到数据库，并记录提交日志。
  6. 故障恢复：如果在步骤5之前发生故障，数据库可以使用日志来回滚到事务开始前的状态，确保数据一致性。

区别

  • 关注点不同：原子性关注的是事务作为一个整体的执行结果，而一致性关注的是事务执行后数据的准确性和完整性。
  • 实现机制不同：原子性主要通过日志记录和回滚机制来实现，而一致性则通过完整性约束、事务隔离、锁定机制和恢复机制来实现。
  • 影响范围不同：原子性影响的是单个事务的执行，而一致性影响的是整个数据库的状态和多个事务的执行结果。

原子性（Atomicity）实现

  1. 开始事务：
START TRANSACTION;
  1. 执行一系列数据库操作：
-- 假设我们有两个账户，A和B，A向B转账100元
UPDATE accounts SET balance = balance - 100 WHERE account_id = 1; -- A账户扣款
UPDATE accounts SET balance = balance + 100 WHERE account_id = 2; -- B账户收款
  1. 提交事务（如果所有操作都成功）：
COMMIT;
  1. 回滚事务（如果操作中有任何失败）：
ROLLBACK;
java实现
Connection conn = null;
try {
    // 获取数据库连接
    conn = dataSource.getConnection();
    // 开始事务
    conn.setAutoCommit(false);

    // 执行一系列数据库操作
    conn.prepareStatement("UPDATE accounts SET balance = balance - 100 WHERE account_id = 1").executeUpdate();
    conn.prepareStatement("UPDATE accounts SET balance = balance + 100 WHERE account_id = 2").executeUpdate();

    // 提交事务
    conn.commit();
} catch (SQLException e) {
    // 发生异常时回滚事务
    if (conn != null) {
        try {
            conn.rollback();
        } catch (SQLException ex) {
            // 记录回滚时的异常
            ex.printStackTrace();
        }
    }
    // 处理或抛出异常
    throw new RuntimeException("Transaction failed", e);
} finally {
    // 关闭数据库连接
    if (conn != null) {
        try {
            conn.close();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

一致性（Consistency）实现

  1. 设置完整性约束（在创建表时定义）：
CREATE TABLE accounts (
    account_id INT PRIMARY KEY,
    balance DECIMAL(10, 2) CHECK (balance >= 0) -- 确保余额非负
);
  1. 使用事务隔离级别（在开始事务时设置）：
-- 以MySQL为例，设置隔离级别为可重复读
START TRANSACTION WITH CONSISTENCY;
  1. 使用锁定机制（在SQL语句中显式加锁）：
-- 对A账户进行排它锁
SELECT * FROM accounts WHERE account_id = 1 FOR UPDATE;
  1. 检查一致性条件（在事务逻辑中实现）：
-- 检查A账户余额是否足够
SELECT balance FROM accounts WHERE account_id = 1;
-- 如果余额不足，可以执行ROLLBACK来回滚事务
  1. 执行操作并提交事务：
-- 执行转账操作
UPDATE accounts SET balance = balance - 100 WHERE account_id = 1;
UPDATE accounts SET balance = balance + 100 WHERE account_id = 2;
COMMIT;
Java实现
Connection conn = null;
try {
    // 获取数据库连接
    conn = dataSource.getConnection();
    // 开始事务
    conn.setAutoCommit(false);

    // 执行一系列数据库操作
    conn.prepareStatement("UPDATE accounts SET balance = balance - 100 WHERE account_id = 1").executeUpdate();
    conn.prepareStatement("UPDATE accounts SET balance = balance + 100 WHERE account_id = 2").executeUpdate();

    // 提交事务
    conn.commit();
} catch (SQLException e) {
    // 发生异常时回滚事务
    if (conn != null) {
        try {
            conn.rollback();
        } catch (SQLException ex) {
            // 记录回滚时的异常
            ex.printStackTrace();
        }
    }
    // 处理或抛出异常
    throw new RuntimeException("Transaction failed", e);
} finally {
    // 关闭数据库连接
    if (conn != null) {
        try {
            conn.close();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

综合案例

综合展示如何在一个事务中实现原子性和一致性：

sql
-- 开始事务
BEGIN TRANSACTION;

-- 检查A账户余额是否足够
SELECT balance FROM accounts WHERE account_id = 1;

-- 如果余额不足，回滚事务
IF balance < 100 THEN
    ROLLBACK TRANSACTION;
ELSE
    -- 执行转账操作
    UPDATE accounts SET balance = balance - 100 WHERE account_id = 1;
    UPDATE accounts SET balance = balance + 100 WHERE account_id = 2;

    -- 提交事务
    COMMIT TRANSACTION;
END IF;

手写原子性与一致性案例1

Java来实现这个简单的数据库系统(主要让大家理解原子性与一致性的逻辑,并非实现一个真实的数据库的能力)。这个系统将包括以下功能：

  1. 原子性：通过事务来保证操作的原子性，如果事务中的任何操作失败，整个事务将被回滚。
  2. 一致性：通过一致性检查来确保数据在事务前后满足预定义的规则。
import java.util.*;
import java.util.concurrent.locks.*;

public class SimpleDatabase {
    // 存储数据的内存结构
    private final Map<String, Integer> storage = new HashMap<>();
    // 用于控制并发访问的读写锁
    private final Lock writeLock = new ReentrantLock();
    private final Lock readLock = new ReentrantLock();

    // 执行事务
    public void executeTransaction(List<DatabaseOperation> operations) {
        writeLock.lock();
        try {
            // 首先进行预检查，确保事务可以执行
            for (DatabaseOperation op : operations) {
                if (!isConsistent(op)) {
                    throw new IllegalStateException("Inconsistent operation detected");
                }
            }
            
            // 执行所有操作
            for (DatabaseOperation op : operations) {
                applyOperation(op);
            }
        } finally {
            writeLock.unlock();
        }
    }

    // 一致性检查
    private boolean isConsistent(DatabaseOperation operation) {
        // 这里可以添加具体的一致性检查逻辑
        // 检查账户余额是否足够
        if (operation.getType() == DatabaseOperation.Type.DEBIT && storage.getOrDefault(operation.getKey(), 0) < operation.getValue()) {
            return false;
        }
        return true;
    }

    // 应用操作
    private void applyOperation(DatabaseOperation operation) {
        switch (operation.getType()) {
            case CREDIT:
                storage.merge(operation.getKey(), operation.getValue(), Integer::sum);
                break;
            case DEBIT:
                storage.compute(operation.getKey(), (k, v) -> v - operation.getValue());
                break;
            default:
                throw new IllegalArgumentException("Unknown operation type");
        }
    }

    // 定义操作类型
    enum OperationType {
        CREDIT, DEBIT
    }

    // 数据库操作封装
    static class DatabaseOperation {
        private final String key;
        private final int value;
        private final OperationType type;

        public DatabaseOperation(String key, int value, OperationType type) {
            this.key = key;
            this.value = value;
            this.type = type;
        }

        public String getKey() {
            return key;
        }

        public int getValue() {
            return value;
        }

        public OperationType getType() {
            return type;
        }
    }

    // 测试
    public static void main(String[] args) {
        SimpleDatabase db = new SimpleDatabase();

        // 创建事务
        List<DatabaseOperation> transaction = new ArrayList<>();
        transaction.add(new DatabaseOperation("account1", 100, OperationType.CREDIT));
        transaction.add(new DatabaseOperation("account2", 50, OperationType.DEBIT));

        // 执行事务
        db.executeTransaction(transaction);

        // 打印结果
        System.out.println(db.storage);
    }
}

SimpleDatabase 类提供了一个简单的内存数据库实现。我们定义了一个DatabaseOperation 类来封装数据库操作，包括键、值和操作类型（借记或贷记）。executeTransaction 方法用于执行一个事务，它首先进行一致性检查，然后应用所有操作。如果任何操作不一致，事务将抛出异常并回滚。展示了如何在内存中以编程方式实现原子性和一致性，但它并不是一个真正的数据库系统。真正的数据库系统需要处理更多的复杂性，如持久化、并发控制、恢复机制等

简单的银行账户管理系统，它将包括以下特性：

  1. 原子性：通过事务机制保证操作的原子性，如果事务中的任何一步失败，整个事务将回滚。
  2. 一致性：通过业务逻辑检查保证数据的一致性，例如，账户余额不能为负。

我们将使用Java的ConcurrentHashMap来保证线程安全，使用ReentrantReadWriteLock来实现读写锁，以提高并发性能。

手写原子性与一致性案例2

银行账户管理系统实现

import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

public class BankAccountSystem {
    // 使用线程安全的HashMap来存储账户数据
    private final ConcurrentHashMap<String, Account> accounts = new ConcurrentHashMap<>();
    private final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
    private final Lock readLock = lock.readLock();
    private final Lock writeLock = lock.writeLock();

    // 账户类
    private static class Account {
        int balance;

        public Account(int initialBalance) {
            this.balance = initialBalance;
        }
    }

    // 创建新账户
    public void createAccount(String accountId, int initialBalance) {
        writeLock.lock();
        try {
            accounts.compute(accountId, (k, v) -> {
                if (v == null) {
                    return new Account(initialBalance);
                }
                throw new IllegalStateException("Account already exists");
            });
        } finally {
            writeLock.unlock();
        }
    }

    // 存款操作
    public void deposit(String accountId, int amount) {
        writeLock.lock();
        try {
            Account account = accounts.get(accountId);
            if (account == null) {
                throw new IllegalArgumentException("Account does not exist");
            }
            account.balance += amount;
        } finally {
            writeLock.unlock();
        }
    }

    // 取款操作
    public void withdraw(String accountId, int amount) throws InsufficientFundsException {
        writeLock.lock();
        try {
            Account account = accounts.get(accountId);
            if (account == null) {
                throw new IllegalArgumentException("Account does not exist");
            }
            if (account.balance < amount) {
                throw new InsufficientFundsException("Insufficient funds for account: " + accountId);
            }
            account.balance -= amount;
        } finally {
            writeLock.unlock();
        }
    }

    // 检查账户余额
    public int getBalance(String accountId) {
        readLock.lock();
        try {
            Account account = accounts.get(accountId);
            return account != null ? account.balance : 0;
        } finally {
            readLock.unlock();
        }
    }

    // 自定义异常：资金不足异常
    public static class InsufficientFundsException extends Exception {
        public InsufficientFundsException(String message) {
            super(message);
        }
    }

    // 测试
    public static void main(String[] args) {
        BankAccountSystem bankSystem = new BankAccountSystem();
        bankSystem.createAccount("001", 1000);
        try {
            bankSystem.deposit("001", 500);
            bankSystem.withdraw("001", 1600); // 这将抛出异常，因为余额不足
        } catch (InsufficientFundsException e) {
            System.out.println(e.getMessage());
        }
        System.out.println("Balance after transactions: " + bankSystem.getBalance("001"));
    }
}

此案例定义了一个BankAccountSystem类，它使用ConcurrentHashMap来存储账户信息，并使用ReentrantReadWriteLock来保证读写操作的线程安全。我们提供了createAccount、deposit、withdraw和getBalance方法来执行账户操作。withdraw方法在余额不足时会抛出InsufficientFundsException异常，这是一致性检查的一部分

结论

原子性和一致性是数据库事务不可或缺的特性，它们共同维护了数据的完整性和可靠性。作为架构师或开发者，理解这些概念并掌握其实现细节对于设计和维护高效、稳定的数据库系统至关重要。

Solomon_肖哥弹架构
关注
专栏目录
【软件架构思想系列】分层架构
AI天才研究院
01-19 1万+
- 分层架构 -今天谈下架构设计中的分层思想和分层模型。架构思维概述对于架构思维本身仍然是类似系统思维，结构化思维，编程思维等诸多思维模式的一个合集。由于架构的核心作用是在业务现实世界和抽象的IT实现之间建立起一道桥梁，因此架构思维最核心的就是要：理解到业务驱动技术，技术为最终的业务服务。要真正通过架构设计来完成业务和技术，需求和实现，软件和硬件，静态和动态，成本和收益等多方面的平...
网易Java面试必问：10年阿里开发架构师经验分享
m0_57286679的博客
05-14 106
前言： 求职季在即，技巧千万条，硬实力才是关键，听说今年疫情大环境不好，更要好好准备才行。MySQL是Java程序员面向高级的必备技能，很多朋友在面试时经常在这里折戟沉沙，饮恨不已。熟练掌握MySQL知识，在实践中具有很强的操作性，尤其是在互联网行业，不仅要写好代码、实现功能，而且还要在高并发的情况下能够正常运转。 这篇文章总结了许多关于MySQL方面的知识总结，以及面试多家总结出来的常问面试题，希望对大家有所帮助。 微服务的发展 微服务倡导将复杂的单体应用拆分为若干个功能简单、松耦合的服务，这样可以降
Java架构师必备技术：javaweb面试问题大全及答案大全
m0_57066131的博客
07-04 295
01 阿里中间件（四面，Java岗） 1.1 Java中间件一面 技术一面考察范围 重点问了Java线程锁：synchronized 和ReentrantLock相关的底层实现 线程池的底层实现以及常见的参数 数据结构基本都问了一遍：链表、队列等 Java内存模型：常问的JVM分代模型，以及JDK1.8后的区别，最后还问了JVM相关的调优参数 分布式锁的实现比较技术 一面题目 自我介绍 擅长哪方面的技术？ java有哪些锁中类？（乐观锁&悲观锁、可重入锁&Synchroni
阿里P8架构师谈：成为架构师必须学好的七大知识点（含面试题）
m0_54854484的博客
05-27 629
不想当将军的兵不是好兵，就程序猿不想当架构师就不是好的程序员！ Java架构师主要需要做哪些工作呢？ 1、负责设计和搭建软件系统架构（平台、数据库、接口和应用架构等），解决开发中各种系统架构问题。 2、优化现有系统的性能，解决软件系统平台关键技术问题攻关、核心功能模块设计、核心代码开发。 3、在项目需求不断细化的工程中校正整体的架构设计，以及详细模块拆分设计。 4、营造技术学习氛围，带领团队不断完善开发开发方法及流程，提升开发效率与质量，加强技术标准及规范。 5、带领团队攻克例如大数据量、高并发、高稳定性等
Java架构师知识体系汇总
程序新视界
07-19 3188
源码分析 常用设计模式 Proxy代理模式 Factory工厂模式 Singleton单例模式 Delegate委派模式 Strategy策略模式 Prototype原型模式 Template模板模式 Spring5 beans 接口实例化 代理Bean操作 Context Ioc容器设计原理及高级特性 Aop设计原理 Factorybean与Beanfac...
阿里P8架构师谈：成为架构师必须入手的七大知识点（含面试题）
jiey0407的博客
05-16 372
不想当将军的兵不是好兵，就程序猿不想当架构师就不是好的程序员！ Java架构师主要需要做哪些工作呢？ 1、负责设计和搭建软件系统架构（平台、数据库、接口和应用架构等），解决开发中各种系统架构问题。 2、优化现有系统的性能，解决软件系统平台关键技术问题攻关、核心功能模块设计、核心代码开发。 3、在项目需求不断细化的工程中校正整体的架构设计，以及详细模块拆分设计。 4、营造技术学习氛围，带领团队不断完善开发开发方法及流程，提升开发效率与质量，加强技术标准及规范。 5、带领团队攻克例如大数据量、高并发、高稳定性等
手写Spring事务框架，阿里架构师一文详解Spring-SpringAOP原理
Java_supermanNO1的博客
01-03 654
本文转载自：手写Spring事务框架，阿里架构师一文详解Spring-SpringAOP原理 一、Spring核心知识 Spring是一个开源框架，Spring是于2003年兴起的一个轻量级的Java开发框架，由Rod Johnson在其著作Expert One-On-One J2EE Development and Design中阐述的部分理念和原型衍生而来。它是为了解决企业应用开发的复杂性...
.NET架构师面试题(1)
wo4641771的博客
05-20 1134
1.C#中的委托是什么？事件是不是一种委托？ 委托是一种引用类型，表示对具有特定参数列表和返回类型的方法的引用。委托用于将方法作为参数传递给其他方法。事件就是通过委托调用的方法。 2.聊聊.NET的管道和.NET Core的中间件 .NET的管道：在管道模型运行开始前，首先HTTP的请求被被传递到HttpRuntime类的一个实例中，然后这个实例对象检测请求并找到被接受的那个应用程序，接下来管道模型就使用HttpApplicationFactory对象来创建一个HttpApplication对象来处理
C/C++ Linux后台服务器开发高级架构师学习知识点路线总结（2021架构师篇完整版）
Linuxhus的博客
12-28 7650
C/C++ Linux后台服务器开发高级架构师学习知识点路线总结（2021架构师篇完整版） 前言： 小编之前有跟大家分享过一篇架构师体系知识点总结的文章，今天在原来的基础上有所改变更新（2021版）。 相信大家也知道，想要成为一名架构师肯定是需要一定的时间经验累积，才可以达到架构师的水平，今天分享的是成为架构师需要掌握的技术知识点，尽量的完善，目前对标的是知名企业腾讯、阿里等等后端开发岗位。 今天更新的内容是从Linux高级互联网架构师知识点说起，基础的知识点今天在这里就不写出来了，有需要了解的朋友
Java后端架构技术面试汇总：基础+设计模式+MySQL+分布式+微服务等
javaAnPou的博客
08-03 716
下述整理的180道Java后端常问的面试体系汇总，有整理出一份知识点复习笔记和Java后端高频知识考点专题文档答案免费分享给大家！由于篇幅原因，在这只把部分的题目列举出来
MySQL之复合查询与内外连接
zdlynj的博客
09-30 1209
前面我们讲解的mysql表的查询都是对一张表进行查询，即数据的查询都是在某一时刻对一个表进行操作的。而在实际开发中，我们往往还需要对多个表同时进行查询。我们这里使用的测试表，为雇员信息表(来自Oracle 9i的经典测试表)：EMP员工表，DEPT部门表，SALGRADE工资等级表。
点评项目-2-完善注册登录业务
m0_75138009的博客
09-29 564
需要处理的业务：在网页发送 /user/code 路径下的 post 请求后，我们需要检验手机号后，向合法的手机号发送一个随机生成的电话号。
World of Warcraft [CLASSIC][80][Grandel] Call to Arms: Victory in Wintergrasp
最新发布
qq 117791303
10-02 276
Wintergrasp 冬拥湖 120 VS 120
Spring的热部署工具和数据库密码加盐操作
2301_77053417的博客
09-28 771
加密过程：用户输入的密码+盐值 --> 字符串1，然后使用md5对字符串1加密得到字符串2，然后字符串2+盐值 --> 字符串3，这个字符串3就是存储在数据库中的密文。背景：如果我们的密码明文存储在数据库中，要是被窃取了是非常的危险的，所以我们在数据库中存储的密码不能是明文的，需要进行加密后存储，也就是数据库中存储的是密文。解密过程：取出数据库中的盐值和用户输入的密码得到字符串1，使用md5对字符串1加密得到字符串2，然后验证字符串2和数据库中的密文即可。做好以上的步骤，你项目中的热部署就已经做好了。
Redis事务
zhzjn的博客
09-30 357
Redis事务可以通过MULTI、EXEC、WATCH和DISCARD指令来实现。1. MULTI指令：表示事务的开始，之后的所有指令都会被逐一记录，但不会立即执行。2. EXEC指令：表示事务的执行，会按照记录的指令逐一执行。3. WATCH指令：可以监视一个或多个键的变化，如果在事务执行期间被其他客户端修改，事务会被回滚。4. DISCARD指令：表示事务的撤销，可以放弃之前记录的指令。
【RocketMQ】RocketMQ应用难点
记录一名在读研究生的学习笔记、感悟、开发产物
09-30 875
本文探讨了RocketMQ中消息重复消费的问题及其解决方案，尤其是在CLUSTERING模式下的扩容影响。文章分析了重复消费的原因，如广播模式、负载均衡模式下的多consumerGroup消费、消费者组内的动态变化及网络延迟等，并提出了利用唯一标识进行去重的方法。此外，还讨论了如何选择合适的存储机制以高效处理大量消息标识，如HashMap、MySQL、Redis以及推荐的布隆过滤器等方案。对于防止消息堆积与确保消息不丢失，也给出了相应的策略和技术措施。
IT基础监控范围和对象
MXsoft618的博客
09-29 585
综上所述，监控易的监控范围非常广泛，几乎涵盖了所有主流的IT基础设施以及相关的设备和系统。通过全面、实时、准确的监控功能，监控易为运维团队提供了强大的支持，帮助他们及时发现并解决潜在的问题，确保业务系统的稳定运行和高效运维。除了上述监控范围外，监控易还支持其他扩展监控功能，如被动式设备监控、自定义脚本监控、高级监测点监控等。监控易作为一款由美信时代独立自主研发的分布式一体化集中监控平台，其监控范围极为广泛，几乎涵盖了所有主流的IT基础设施以及相关的设备和系统。
JAVA架构师全方位学习：并发、数据库、Linux与框架解析
"此资源包含全面的JAVA架构师学习材料，包括视频课程和相关代码，涵盖了互联网并发编程、数据库设计与优化、Linux系统知识、JAVA虚拟机深入理解、互联网框架应用、中间件架构设计、网络通信编程以及分布式项目的实战...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

Solomon_肖哥弹架构

你的欣赏就是我最大的动力

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

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

打赏作者

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

抵扣说明：

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

余额充值