redis中使用事务保护数据完整性

news2024/11/19 16:33:01

事务是指一个执行过程，要么全部执行成功，要么失败什么都不改变。不会存在一部分成功一部分失败的情况，也就是事务的ACID四大特性（原子性、一致性、隔离性、持久性）。但是redis中的事务并不是严格意义上的事务，它只是保证了多个命令执行是按照顺序执行，在执行过程中不会插入其他的命令，并不会保证所有命令都成功。也就是说在命令执行过程中，某些命令的失败不会回滚前面已经执行成功的命令，也不会影响后面命令的执行。
redis中的事务跟pipeline很类似，但pipeline是批量提交命令到服务器，服务器执行命令过程中是一条一条执行的，在执行过程中是可以插入其他的命令。而事务是把这些命令批量提交到服务器，服务器执行命令过程也是一条一条执行的，但是在执行这一批命令时是不能插入执行其他的命令，必须等这一批命令执行完成后才能执行其他的命令。

1、事务基本结构

与数据库事务执行过程类似，redis事务是由multi、exec、discard三个关键字组成，对比数据库事务的begin、commit、rollback三个关键字。
命令行示例如下：

127.0.0.1:6379> set key1 value111
OK
127.0.0.1:6379> set key2 value222
OK
127.0.0.1:6379> mget key1 key2
1) "value111"
2) "value222"
127.0.0.1:6379> 

# 第一个事务
127.0.0.1:6379> multi
OK
127.0.0.1:6379(TX)> set key1 value-111
QUEUED
127.0.0.1:6379(TX)> setm key2 value-222
(error) ERR unknown command `setm`, with args beginning with: `key2`, `value-222`, 
127.0.0.1:6379(TX)> exec
(error) EXECABORT Transaction discarded because of previous errors.
127.0.0.1:6379> 
127.0.0.1:6379> mget key1 key2
1) "value111"
2) "value222"
127.0.0.1:6379> 

# 第二个事务
127.0.0.1:6379> multi
OK
127.0.0.1:6379(TX)> set key1 value-111
QUEUED
127.0.0.1:6379(TX)> set key2 value-222
QUEUED
127.0.0.1:6379(TX)> discard
OK
127.0.0.1:6379> 
127.0.0.1:6379> mget key1 key2
1) "value111"
2) "value222"
127.0.0.1:6379> 

# 第三个事务
127.0.0.1:6379> multi
OK
127.0.0.1:6379(TX)> set key1 value-111
QUEUED
127.0.0.1:6379(TX)> set key3 value-333 vddd
QUEUED
127.0.0.1:6379(TX)> set key2 value-222
QUEUED
127.0.0.1:6379(TX)> exec
1) OK
2) (error) ERR syntax error
3) OK
127.0.0.1:6379> 
127.0.0.1:6379> mget key1 key2 key3
1) "value-111"
2) "value-222"
3) (nil)
127.0.0.1:6379>

在上面的示例过程中，第一个事务执行时输入了一个错误的命令，在提交事务时整个命令都没有执行；第二个事务提交了多个命令，但是最后回滚了事务，整个事务也不会执行；第三个事务在提交命令时，故意设置一个执行失败的命令，会发现这个失败的命令并不会影响其他命令的成功。

2、事务的执行步骤

redis中的事务是分两步执行的：第一步命令排队，也就是将所有要执行的命令添加到一个队列中，在这一步中命令不会真正执行；第二步命令执行或取消，在这一步中真正处理队列中的命令，如果是exec命令，就执行这些命令；如果是discard命令，就取消执行命令。这里需要注意，如果在排队中某些命令解析出错，即使调用了exec命令，整个队列中的命令也不会执行；但是如果在执行过程中出现了错误，它并不会影响其他命令的正常执行，一般使用封装好的客户端不会出现这种命令错误情况。

3、并发事务

多线程的项目就会有并发问题，并发问题就会存在数据不一致，数据库中解决并发问题是通过锁来实现的，在操作数据前加锁，保证数据在整个执行过程中不被其他程序修改。这种方式加锁是悲观锁，每次更新操作都认为数据会被其他程序修改，导致程序的并发性能不好；还有一种加锁方式是乐观锁，每次直到真正更新数据时才判断数据是否被更新了，如果数据被更新就放弃操作，对于读多写少的场景非常适合，一般实现乐观锁是通过版本号机制。
redis中就支持这种乐观锁机制，它的实现是通过watch命令，在开始执行事务前先通过watch监控被更新的key，如果在事务执行时发现这些key被修改了，那么就不执行事务中的命令。
下面演示的是扣费场景：在进行扣费前，先判断用户的余额，如果余额够扣，就扣减用户的账号余额；如果余额不足，就不能扣减账号余额。

  1. watch某个key后，如果数据没有被其他客户端修改，事务将成功执行：
127.0.0.1:6379> set user:balance:1 100
OK
127.0.0.1:6379> watch user:balance:1
OK
127.0.0.1:6379> get user:balance:1
"100"
127.0.0.1:6379> multi
OK
127.0.0.1:6379(TX)> incrby user:balance:1 -100
QUEUED
127.0.0.1:6379(TX)> exec
1) (integer) 0
127.0.0.1:6379> get user:balance:1
"0"
127.0.0.1:6379>

  1. watch某个key后，如果key对应的值被其他程序修改了，执行事务将不成功；如果不用watch命令，事务会成功执行。
    下图展示了在两个客户端验证事务：
    1、首先在下面的客户端设置键的值为100；
    2、然后设置 watch 该值，并且开启事务；
    3、执行减100的命令；
    4、在上面的客户端中修改这个键的值，减3；
    5、下面的客户端执行 exec 命令提交事务。
    这几个步骤执行完成后，发现数据没有修改成功，表示 watch 命令监控到数据变动没有执行事务中的命令。
    watch事务演示
    下面演示步骤与上面一样，只不过在事务前没有 watch 命令，发现数据被修改了。
    没有watch事务演示

  2. watch命令只对当前客户端中的 multi / exec 之间的命令有影响，不在它们之间的命令不受影响，可以正常执行：

127.0.0.1:6379> set user:balance:1 100
OK
127.0.0.1:6379> watch user:balance:1
OK
127.0.0.1:6379> incrby user:balance:1 -3
(integer) 97
127.0.0.1:6379> multi
OK
127.0.0.1:6379(TX)> incrby user:balance:1 -100
QUEUED
127.0.0.1:6379(TX)> set watchkey aaa
QUEUED
127.0.0.1:6379(TX)> exec
(nil)
127.0.0.1:6379> mget user:balance:1 watchkey
1) "97"
2) (nil)
127.0.0.1:6379>

上面这段代码在watch命令后对键的值进行了修改，发现更新成功；watch的key对应值被修改了，导致事务内的命令不执行，所以后面mget命令没有获取到新的值。

  1. 与watch对应有一个unwatch命令，它表示watch某个key后可以通过unwatch取消监控；如果watch某个key后有 exec 或 discard 命令执行，程序会自动取消监控，不必再使用unwatch取消监控：
127.0.0.1:6379> watch user:balance:1
OK
127.0.0.1:6379> unwatch
OK
127.0.0.1:6379>
4、代码中使用
  1. 使用jedis实现扣费逻辑

首先还是先使用jedis测试上面提出扣费场景：
引入依赖：

<dependency>
    <groupId>redis.clients</groupId>
    <artifactId>jedis</artifactId>
    <version>4.3.0</version>
</dependency>

主要代码逻辑如下：

import redis.clients.jedis.*;
import java.time.Duration;
import java.util.List;

public class JedisUtil {

    /**
     * 连接池
     */
    private JedisPool jedisPool;

    /**
     * 连接初始化
     * @param host
     * @param port
     * @param password
     */
    public JedisUtil(String host, int port, String password) {
        JedisPoolConfig config = new JedisPoolConfig();
        config.setMaxTotal(256);
        config.setMaxIdle(256);
        config.setMinIdle(1);
        config.setMaxWait(Duration.ofMillis(300));

        if(password != null && !"".equals(password)) {
            jedisPool = new JedisPool(config, host, port, 500, password);
        } else {
            jedisPool = new JedisPool(config, host, port, 500);
        }
    }

    /**
     * 关闭连接池
     */
    public void close() {
        if(jedisPool != null && !jedisPool.isClosed()) {
            jedisPool.clear();
            jedisPool.close();
        }
    }

    /**
     * 获取连接
     * @return
     */
    public Jedis getJedis() {
        if(jedisPool != null && !jedisPool.isClosed()) {
            return jedisPool.getResource();
        }
        return null;
    }

    /**
     * 归还jedis对象
     * @param jedis
     */
    public void returnJedis(Jedis jedis) {
        if(jedis != null) {
            jedis.close();
        }
    }

    public static void main(String[] args) {
        // 获取jedis连接
        JedisUtil util = new JedisUtil("192.168.56.101", 6379, "");
        // 键
        String key = "user:balance:1";
        util.deduct(key, 100);
    }

    /**
     * 扣减金额
     */
    public void deduct(String key, int money) {
        Jedis jedis = this.getJedis();
        // 监控键对应值的变化
        jedis.watch(key);

        // 获取账户余额，当余额足够时扣减金额
        String val = jedis.get(key);
        if(val != null && Integer.parseInt(val) >= money) {
            // 开启事务
            Transaction multi = jedis.multi();
            try {
                // 事务中的命令
                multi.incrBy(key, -money);
                System.out.println("run in multi!");

                // 执行事务
                List<Object> exec = multi.exec();
                System.out.println("run exec : " + exec);
            } catch (Exception e) {
                // 放弃事务
                multi.discard();
                e.printStackTrace();
            } finally {
                this.returnJedis(jedis);
            }
        } else {
            // 取消监控
            jedis.unwatch();
            System.out.println("余额不足...");
        }
    }
}

在上面代码中执行事务部分添加断点，并通过其他客户端更新watch对应key的值，发现事务并不执行，这就达到了数据逻辑的一致性，不会因为其他客户端扣减金额后，该客户端继续扣减余额导致剩余金额为负数的情况。

  1. redisTemplate使用事务

在redisTemplate中使用事务，有三种方式，下面的代码是实现上面扣费逻辑的过程：
（1）使用SessionCallback实现：

public void runTransaction(final String key, final String value) {
    List<Object> exec = redisTemplate.execute(new SessionCallback<List<Object>>() {
        @Override
        public <K, V> List<Object> execute(RedisOperations<K, V> operations) throws DataAccessException {
            List<Object> exec = null;
            // 监控键对应值的变化
            operations.watch((K) key);

            ValueOperations<String, String> op1 = (ValueOperations<String, String>) operations.opsForValue();
            String val = op1.get(key);
            int num = Integer.parseInt(value);
            if(val != null && Integer.parseInt(val) >= num) {
                try {
                    // 开启事务
                    operations.multi();

                    // 事务中的命令
                    op1.increment(key, -num);

                    // 执行事务
                    exec = operations.exec();
                } catch (NumberFormatException e) {
                    // 放弃事务
                    operations.discard();
                    e.printStackTrace();
                }
            } else {
                // 取消监控
                operations.unwatch();
                System.out.println("余额不足...");
            }
            return exec;
        }
    });
    System.out.println(exec);
}

（2）使用RedisCallback实现：

public void runTransaction(final String key, final String value) {
    List<Object> exec = redisTemplate.execute(new RedisCallback<List<Object>>() {
        @Override
        public List<Object> doInRedis(RedisConnection connection) throws DataAccessException {
            List<Object> exec = null;
            // 监控键对应值的变化
            connection.watch(key.getBytes(StandardCharsets.UTF_8));

            byte[] val = connection.get(key.getBytes(StandardCharsets.UTF_8));
            int num = Integer.parseInt(value);
            if(val != null && Integer.parseInt(new String(val)) >= num) {
                try {
                    // 开启事务
                    connection.multi();

                    // 事务中的命令
                    connection.incrBy(key.getBytes(StandardCharsets.UTF_8), -num);

                    // 执行事务
                    exec = connection.exec();
                } catch (NumberFormatException e) {
                    // 放弃事务
                    connection.discard();
                    e.printStackTrace();
                }
            } else {
                // 取消监控
                connection.unwatch();
                System.out.println("余额不足...");
            }
            return exec;
        }
    });
    System.out.println(exec);
}

（3）使用@Transactional注解实现：

@Transactional
public void runTransaction(final String key, final String value) {
    // 监控键对应值的变化
    redisTemplate.watch(key);
    String val = redisTemplate.opsForValue().get(key);
    int num = Integer.parseInt(value);
    if(val != null && Integer.parseInt(val) >= num) {
        // 开启事务支持
        // 开启这个值后，所有的命令都会在exec执行完才返回结果，所以需要返回值的命令要在这个方法前执行
        redisTemplate.setEnableTransactionSupport(true);
        try {
            // 开启事务
            redisTemplate.multi();

            // 事务中的命令
            redisTemplate.opsForValue().increment(key, -num);

            // 执行事务
            List<Object> exec = redisTemplate.exec();
            System.out.println(exec);
        } catch (Exception e) {
            // 放弃事务
            redisTemplate.discard();
            e.printStackTrace();
        } finally {
            // 关闭事务支持
            redisTemplate.setEnableTransactionSupport(false);
        }
    } else {
        // 取消监控
        redisTemplate.unwatch();
        System.out.println("余额不足...");
    }
}

事务只能保证每一条命令的原子性，并不能保证事务内所有命令的原子性，上面的示例代码已经验证了这个结论，其实redis中已经提供了一些多值指令，如：mset、mget、hmset、hmget。但是这些只能是一种数据类型的多键值对操作，这些命令是原子操作。
上面这种扣费逻辑，除了使用redis的事务支持，还可以使用lua脚本实现，lua脚本在服务端执行与事务中的命令类似，是不可分割的整体，下面演示lua脚本内容，可以实现上面一样的处理结果：
lua脚本如下：

local b = redis.call('get', KEYS[1]);
if tonumber(b) >= tonumber(ARGV[1]) then
  local rs = redis.call('incrby', KEYS[1], 0 - tonumber(ARGV[1]));
  return rs;
else 
  return nil;
end;

测试过程：

127.0.0.1:6379> set user:balance:1 100
OK
127.0.0.1:6379> get user:balance:1
"100"
127.0.0.1:6379> eval "local b = redis.call('get', KEYS[1]); if tonumber(b) >= tonumber(ARGV[1]) then local rs = redis.call('incrby', KEYS[1], 0 - tonumber(ARGV[1])); return rs; else return nil; end;" 1 user:balance:1 100
(integer) 0
127.0.0.1:6379> get user:balance:1
"0"
127.0.0.1:6379> set user:balance:1 100
OK
127.0.0.1:6379> incrby user:balance:1 -3
(integer) 97
127.0.0.1:6379> eval "local b = redis.call('get', KEYS[1]); if tonumber(b) >= tonumber(ARGV[1]) then local rs = redis.call('incrby', KEYS[1], 0 - tonumber(ARGV[1])); return rs; else return nil; end;" 1 user:balance:1 100
(nil)
127.0.0.1:6379> get user:balance:1
"97"
127.0.0.1:6379>

第一次执行余额正常够扣场景，第二次设置余额不足，会发现扣减逻辑并没有执行。
以上内容就是redis中事务的全部内容，要记住几点：
（1）redis中的事务跟我们平时用的数据库中的事务有一些差异的，它能保证多条命令执行时中间不会插入其他的命令，但并不会保证所有命令都执行成功，单条redis命令能保证原子性，但事务中的多条命令并不是原子性。
（2）redis中事务分两步完成：第一步将所有命令添加到命令队列中，这一步并不会执行命令；第二步执行队列中的命令。如果第一步中的命令有错误，第二步并不会执行；如果第二步已经开始执行了，那么部分失败的命令并不会影响其他正确命令的结果，这样就会导致一部分命令成功而另外一部分命令失败的场景。
（3）事务中不宜执行过多的命令或非常耗时的命令，因为redis底层执行命令是单线程，如果单个事务中执行过多的命令会导致其他客户端的请求被阻塞。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1298197.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

Eclipse 4.30 正式发布 来看看有哪些值得期待的新特性

Eclipse 4.30 正式发布 来看看有哪些值得期待的新特性

Eclipse 4.30 已正式发布&#xff0c;主要特性如下&#xff1a; 1、支持新的 Java 语言特性&#xff1a;包括 JEP 440: Record Patterns 和 JEP 441: Pattern Matching for Switch 2、针对 Java 编辑器的快速修复功能&#xff1a;包括添加默认 case、移除默认 case 和插入 br…
阅读更多...
VGG模型

VGG模型

概念&#xff1a; CNN感受野 在卷积神经网络中&#xff0c;决定某一层输出结果中的一个元素所对应的输入层的区域大小&#xff0c;被称作感受野&#xff08;receptive field&#xff09;。通俗的解释是&#xff0c;输出feature map上的一个单元对应输入层上的区域大小。 VGG…
阅读更多...
IntelliJ IDEA创建一个Maven项目

IntelliJ IDEA创建一个Maven项目

在IDEA中创建Maven项目&#xff0c;前提是已经安装配置好Maven环境 。 本文主要使用的是IntelliJ IDEA 2022.2.1 (Community Edition) 1.创建一个新project:File>Project 2.修改Maven配置&#xff1a;File>Settings>搜索maven 创建好的工程如下&#xff1a; src/main…
阅读更多...
[ 蓝桥杯Web真题 ]-组课神器

[ 蓝桥杯Web真题 ]-组课神器

目录 介绍 准备 目标 规定 思路 参考解法 介绍 在很多教育网站的平台上&#xff0c;课程的章节目录会使用树型组件呈现&#xff0c;为了方便调整菜单&#xff0c;前端工程师会为其赋予拖拽功能。本题需要在已提供的基础项目中&#xff0c;完成可拖拽树型组件的功能。 准…
阅读更多...
【数据结构】——排序篇（上）

【数据结构】——排序篇（上）

前言&#xff1a;前面我们已经学过了许许多多的排序方法&#xff0c;如冒泡排序&#xff0c;选择排序&#xff0c;堆排序等等&#xff0c;那么我们就来将排序的方法总结一下。 我们的排序方法包括以下几种&#xff0c;而快速排序和归并排序我们后面进行详细的讲解。 直接插入…
阅读更多...
【SpringBoot】解析Springboot事件机制，事件发布和监听

【SpringBoot】解析Springboot事件机制，事件发布和监听

解析Springboot事件机制&#xff0c;事件发布和监听 一、Spring的事件是什么二、使用步骤2.1 依赖处理2.2 定义事件实体类2.3 定义事件监听类2.4 事件发布 三、异步调用3.1 启用异步调用3.2 监听器方法上添加 Async 注解 一、Spring的事件是什么 Spring的事件监听&#xff08;…
阅读更多...
Android 从assets读取文件装载成Bitmap，Kotlin

Android 从assets读取文件装载成Bitmap，Kotlin

Android 从assets读取文件装载成Bitmap&#xff0c;Kotlin /*** fileName assets里面图片文件名*/fun readBitmapFromAssets(ctx: Context, fileName: String): Bitmap? {val assetManager: AssetManager ctx.assetsvar bitmap: Bitmap? nulltry {val inputStream assetMa…
阅读更多...
自行编写一个简单的shell！

自行编写一个简单的shell！

本文旨在编写一个简单的shell外壳程序&#xff01;功能类似于shell的一些基本操作&#xff01;虽然不能全部实现shell的一些功能&#xff01;但是通过此文章&#xff0c;自己写一个简单的shell程序也是不成问题&#xff01;并且通过此文章&#xff0c;可以让读者对linux中一些环…
阅读更多...
实现一个简单的外卖系统

实现一个简单的外卖系统

在这个技术飞速发展的时代&#xff0c;外卖系统已经成为人们生活中的一部分。通过一些简单的技术代码&#xff0c;我们可以搭建一个基本的外卖系统&#xff0c;让用户方便地选择、下单和支付。本文将使用Python和Flask框架为基础&#xff0c;演示一个简单的外卖系统的实现。 …
阅读更多...
基于ssm海鲜自助餐厅系统论文

基于ssm海鲜自助餐厅系统论文

摘 要 网络技术和计算机技术发展至今&#xff0c;已经拥有了深厚的理论基础&#xff0c;并在现实中进行了充分运用&#xff0c;尤其是基于计算机运行的软件更是受到各界的关注。加上现在人们已经步入信息时代&#xff0c;所以对于信息的宣传和管理就很关键。因此海鲜餐厅信息的…
阅读更多...
C/C++之输入输出

C/C++之输入输出

文章目录 一.C语言的输入输出1.printfi. 输出整数ii. 浮点数iii.字符 & 字符串 2.scanfi.整数ii.浮点数iii. 字符 & 字符串 3.特殊用法i. * 的应用ii. %n 的应用iii. %[] 的应用 二.C中的输入输出1.couti. 缓冲区&#xff08;buffer&#xff09;ii. cout之格式化输出 2…
阅读更多...
鸿蒙开发组件之Text

鸿蒙开发组件之Text

一、文本组件Text加载主要有两种方式&#xff1a; 1、直接写的文本 Text(你好&#xff0c;世界) 2、从本地资源读取的文本 Text($r(app.string.xxxx)) 二、文本国际化 其中&#xff0c;文本设置可以支持国际化。可以通过对本地文本读取支持国际化。在需要设置国际化的文本…
阅读更多...
在AWS Lambda上部署EC2编译的FFmpeg工具——自定义层的方案

在AWS Lambda上部署EC2编译的FFmpeg工具——自定义层的方案

大纲 1 确定Lambda运行时环境1.1 Lambda系统、镜像、内核版本1.2 运行时1.2.1 Python1.2.2 Java 2 环境准备2.1 创建EC2实例 3 编译FFmpeg3.1 连接EC2 4 编译5 上传S3存储桶5.1 创建S3桶5.2 创建IAM策略5.3 创建IAM角色5.4 EC2关联角色5.5 修改桶策略5.6 打包并上传 6 创建Lamb…
阅读更多...
【vue3】尚硅谷vue3学习笔记

【vue3】尚硅谷vue3学习笔记

Vue3快速上手 1.Vue3简介 2020年9月18日&#xff0c;Vue.js发布3.0版本&#xff0c;代号&#xff1a;One Piece&#xff08;海贼王&#xff09;耗时2年多、2600次提交、30个RFC、600次PR、99位贡献者github上的tags地址&#xff1a;https://github.com/vuejs/vue-next/release…
阅读更多...
记录 | ubuntu监控cpu频率、温度等

记录 | ubuntu监控cpu频率、温度等

ubuntu监控cpu频率、温度等 采用 i7z 进行监控&#xff0c;先安装&#xff1a; sudo apt install i7z -ysudo i7z
阅读更多...
vue3 自己写一个月的日历

vue3 自己写一个月的日历

效果图 代码 <template><div class"monthPage"><div class"calendar" v-loading"loading"><!-- 星期 --><div class"weekBox"><div v-for"(item, index) in dayArr" :key"index&q…
阅读更多...
5G+AI开花结果，助力智慧安检落地

5G+AI开花结果，助力智慧安检落地

“请带包的乘客过机安检&#xff01;”&#xff0c;深圳地铁、腾讯共同打造的5GAI智慧安检辅助系统亮相福田枢纽站&#xff0c;进一步解放了人力&#xff0c;提高安检效率&#xff0c;为交通安全保驾护航&#xff0c;让智慧出行成为现实。 传统的安检设备均为人工肉眼辨识&…
阅读更多...
【Vue+Python】—— 基于Vue与Python的图书管理系统

【Vue+Python】—— 基于Vue与Python的图书管理系统

文章目录 &#x1f356; 前言&#x1f3b6;一、项目描述✨二、项目展示&#x1f3c6;三、撒花 &#x1f356; 前言 【VuePython】—— 基于Vue与Python的图书管理系统 &#x1f3b6;一、项目描述 描述&#xff1a; 本项目为《基于Vue与Python的图书管理系统》&#xff0c;项目…
阅读更多...
Java第21章网络通信

Java第21章网络通信

网络程序设计基础 网络程序设计编写的是与其他计算机进行通信的程序。Java 已经将网络程序所需要的元素封 装成不同的类&#xff0c;用户只要创建这些类的对象&#xff0c;使用相应的方法&#xff0c;即使不具备有关的网络支持&#xff0c;也可 以编写出高质量的网络…
阅读更多...
手把手带你创建HAL版本MDK工程模板

手把手带你创建HAL版本MDK工程模板

手把手带你创建HAL版本MDK工程模板 如何快速开发 STM32 项目&#xff1f;我们总不能每次开发一个项目就搭建一次工程&#xff0c;这样效率太低了。 通常我们会使用一个模板工程&#xff0c;需要开发新项目的时候拿出来添加一些对应的模块及业务代码&#xff0c;一个项目就开发…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023