分布式ID选型对比（3）

已于 2024-03-16 08:22:50 修改
阅读量1k 收藏 26
点赞数 20
分类专栏： 框架部分 Java 文章标签： 分布式 分布式ID
于 2024-03-02 14:46:35 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_35255384/article/details/136415622
版权

redis自增

一, 引入依赖:

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
    <version>2.6.5</version>
</dependency>

二, 配置信息:

spring:
  redis:
    # 地址
    host: localhost
    # 端口号
    port: 6379
    # 密码
    password:
    # 超时时间，单位毫秒
    timeout: 3000
    # 数据库编号
    database: 0

JedisConfig:

package org.com.spi.config;

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;

@Configuration
public class JedisConfig {
    @Bean
    public RedisTemplate<String, String> redisTemplate(RedisConnectionFactory factory) {
        StringRedisTemplate template = new StringRedisTemplate(factory);
        //定义key序列化方式
        //RedisSerializer<String> redisSerializer = new StringRedisSerializer();//Long类型会出现异常信息;需要我们上面的自定义key生成策略，一般没必要
        //定义value的序列化方式
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
        ObjectMapper om = new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(om);

        // template.setKeySerializer(redisSerializer);
        template.setValueSerializer(jackson2JsonRedisSerializer);
        template.setHashValueSerializer(jackson2JsonRedisSerializer);
        template.afterPropertiesSet();
        return template;
    }
}

三, redis配置类RedisUtils:

package org.com.spi.utils;

import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;

import javax.annotation.Resource;

@Component
public class RedisUtils {
    @Resource
    private RedisTemplate<String, Object> redisTemplate; //这里使用的是redisTemplate

    /**
     * redis 自增
     * @param key 键
    //     * @param by 要增加几(大于0)
     * @return
     */
    public long incr(String key, long delta){
        if(delta<0){
            throw new RuntimeException("递增因子必须大于0");
        }
        return redisTemplate.opsForValue().increment(key, delta);
    }
}

4, 编写接口controller:

@Autowired
RedisUtils redisUtils;
/**
 * 根据数据库ID自增生成主键
 * 缺点在于数据库不能集群，只能单机搞，不适合ID作为业务传递的场景
 */
@PostMapping("/redisInc")
public Long redisInc(){
    return redisUtils.incr("generate2",1);
}

特点: redis自增仅适合单业务场景,对于多模块、复杂业务场景不太适用;另外,redis的两种持久化机制都有一定的弊端: RDB方式-宕机存在丢失的风险, AOF方式-宕机能恢复数据,但数据恢复时间较长,在并发量大的时候可能导致ID重复的情况.

------------------------------------------------------------------------------------------------

雪花算法

主要类: IdWorker

package org.com.spi.config;

import org.springframework.stereotype.Component;

import java.lang.management.ManagementFactory;
import java.net.InetAddress;
import java.net.NetworkInterface;
import java.net.UnknownHostException;

@Component
public class IdWorker {
    //起始时间戳( 2020-12-26 00:00:00 )
    private static final long START_STAMP = 1608912000000L;

    //序列号占用位数
    private static final long SEQUENCE_BIT = 12;

    //机器标识占用位数
    private static final long MACHINE_BIT = 5;

    //数据中心占用位数
    private static final long DATACENTER_BIT = 5;

    //序列号最大值
    private static final long MAX_SEQUENCE = -1L ^ (-1L << 12); // 4095

    /**
     * 偏移量
     **/
    private static final long MACHINE_LEFT = SEQUENCE_BIT;

    private static final long DATACENTER_LEFT = SEQUENCE_BIT + MACHINE_BIT;

    private static final long TIMESTAMP_LEFT = DATACENTER_LEFT + DATACENTER_BIT;

    private static long dataCenterId; //0,  数据中心(0-31)
    private static long machineId; //0,  机器标识(0-31)

    private static long sequence; //序列号  range(0 ~ 4095)
    private static long lastStamp; //上一次时间戳

    private final String POD_IP = getPodIp();
    private final int lastThreeCount=3;
    private final int lastOneCount=1;

    public IdWorker(){
//        this.dataCenterId = getDatacenterId(MAX_DATA_CENTER_NUM);
//        this.machineId = getMaxWorkerId(dataCenterId, MAX_MACHINE_NUM);
        this.dataCenterId = getLastCount(lastOneCount);
        this.machineId = getLastCount(lastThreeCount);
    }

    /**
     * <p>
     * 数据标识id部分
     * </p>
     */
    public static long getDatacenterId(long maxDatacenterId) {
        long id = 0L;
        try {
            InetAddress ip = InetAddress.getLocalHost();
            NetworkInterface network = NetworkInterface.getByInetAddress(ip);
            if (network == null) {
                id = 1L;
            } else {
                byte[] mac = network.getHardwareAddress();
                id = ((0x000000FF & (long) mac[mac.length - 1])
                        | (0x0000FF00 & (((long) mac[mac.length - 2]) << 8))) >> 6;
                id = id % (maxDatacenterId + 1);
            }
        } catch (Exception e) {
            System.out.println(" getDatacenterId: " + e.getMessage());
        }
        return id;
    }

    /**
     * <p>
     * 获取 maxWorkerId
     * </p>
     */
    public static long getMaxWorkerId(long datacenterId, long maxWorkerId) {
        StringBuffer mpid = new StringBuffer();
        mpid.append(datacenterId);
        String name = ManagementFactory.getRuntimeMXBean().getName();
        if (!name.isEmpty()) {
            /*
             * GET jvmPid
             */
            mpid.append(name.split("@")[0]);
        }
        /*
         * MAC + PID 的 hashcode 获取16个低位
         */
        return (mpid.toString().hashCode() & 0xffff) % (maxWorkerId + 1);
    }

    /**
     * 产生下一个ID
     */
    public static synchronized long nextId() {
        long currentStamp = System.currentTimeMillis();
        if (currentStamp < lastStamp) {
            throw new IllegalArgumentException("时间被回退，不能继续产生id");
        }
        if (currentStamp == lastStamp) {
            //相同毫秒内，序列号自增
            sequence = (sequence + 1) & MAX_SEQUENCE;
            if (sequence == 0L) {
                //序列号已经到最大值
                System.out.println("序列号已经到达最大值");
                //使用下一个时间戳
                currentStamp = getNextStamp();
            }
        } else {
            //不同毫秒，序列号重置
            sequence = 0L;
        }
        lastStamp = currentStamp;//当前时间戳存档，用于判断下次产生id时间戳是否相同
        return (currentStamp - START_STAMP) << TIMESTAMP_LEFT
                | dataCenterId << DATACENTER_LEFT
                | machineId << MACHINE_LEFT
                | sequence;
    }

    public static long getNextStamp() {
        long newStamp = getCurrentStamp();
        while (newStamp <= lastStamp) {
            newStamp = getCurrentStamp();
        }
        return newStamp;
    }
    /**
     * 获取当前时间戳
     *
     * @return
     */
    public static long getCurrentStamp() {
        return System.currentTimeMillis();
    }

    private long getNextMill() {
        long mill = getNewStamp();
        while (mill <= lastStamp) {
            mill = getNewStamp();
        }
        return mill;
    }

    public String getPodIp(){
        try {
            InetAddress localHost = InetAddress.getLocalHost();
            return localHost.getHostAddress().replaceAll("\\.", "");
        } catch (UnknownHostException e) {
            e.printStackTrace();
        }
        return "0";
    }

    /**
     * 截取ip数
     * @param lastCount
     * @return
     */
    public Long getLastCount(int lastCount){
        return Long.valueOf(POD_IP.substring(POD_IP.length() - lastCount));
    }

    private long getNewStamp() {
        return System.currentTimeMillis();
    }

    public static void main(String[] args) {
//        IdWorker snowFlake = new IdWorker();
//        long start = System.currentTimeMillis();
//        for (int i = 0; i < 10; i++) {
//            System.out.println(snowFlake.nextId());
//            System.out.println("dataId:"+ snowFlake.dataCenterId);
//            System.out.println("workId:"+ snowFlake.machineId);
//        }
//        System.out.println(snowFlake.getLastCount(4));
//        System.out.println(snowFlake.getLastCount(1));
//        System.out.println(System.currentTimeMillis() - start);
        System.out.println(MAX_SEQUENCE);
    }
}

特点: 雪花算法对于NIO多并发环境下如果用它本身的datacenterId和workId的方法可能在多pod环境下出现ID重复的情况,可以自定义根据IP后几位来生成datacenterId和workId的方式.另外,如果出现时钟回拨,也会导致ID重复.

------------------------------------------------------------------------------------

滴滴Tiny

基于号段模式原理实现的与Leaf如出一辙，每个服务获取一个号段（1000,2000]、（2000,3000]、（3000,4000]

24d5f04abb444379a5162902e2b078bf.png

Tinyid提供http和tinyid-client两种方式接入

Http方式接入

（1）导入Tinyid源码：

git clone https://github.com/didi/tinyid.git

（2）创建数据表：

CREATE TABLE `tiny_id_info` (
  `id` bigint(20) unsigned NOT NULL AUTO_INCREMENT COMMENT '自增主键',
  `biz_type` varchar(63) NOT NULL DEFAULT '' COMMENT '业务类型，唯一',
  `begin_id` bigint(20) NOT NULL DEFAULT '0' COMMENT '开始id，仅记录初始值，无其他含义。初始化时begin_id和max_id应相同',
  `max_id` bigint(20) NOT NULL DEFAULT '0' COMMENT '当前最大id',
  `step` int(11) DEFAULT '0' COMMENT '步长',
  `delta` int(11) NOT NULL DEFAULT '1' COMMENT '每次id增量',
  `remainder` int(11) NOT NULL DEFAULT '0' COMMENT '余数',
  `create_time` timestamp NOT NULL DEFAULT '2010-01-01 00:00:00' COMMENT '创建时间',
  `update_time` timestamp NOT NULL DEFAULT '2010-01-01 00:00:00' COMMENT '更新时间',
  `version` bigint(20) NOT NULL DEFAULT '0' COMMENT '版本号',
  PRIMARY KEY (`id`),
  UNIQUE KEY `uniq_biz_type` (`biz_type`)
) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8 COMMENT 'id信息表';

CREATE TABLE `tiny_id_token` (
  `id` int(11) unsigned NOT NULL AUTO_INCREMENT COMMENT '自增id',
  `token` varchar(255) NOT NULL DEFAULT '' COMMENT 'token',
  `biz_type` varchar(63) NOT NULL DEFAULT '' COMMENT '此token可访问的业务类型标识',
  `remark` varchar(255) NOT NULL DEFAULT '' COMMENT '备注',
  `create_time` timestamp NOT NULL DEFAULT '2010-01-01 00:00:00' COMMENT '创建时间',
  `update_time` timestamp NOT NULL DEFAULT '2010-01-01 00:00:00' COMMENT '更新时间',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8 COMMENT 'token信息表';

INSERT INTO `tiny_id_info` (`id`, `biz_type`, `begin_id`, `max_id`, `step`, `delta`, `remainder`, `create_time`, `update_time`, `version`)
VALUES
    (1, 'test', 1, 1, 100000, 1, 0, '2018-07-21 23:52:58', '2018-07-22 23:19:27', 1);

INSERT INTO `tiny_id_info` (`id`, `biz_type`, `begin_id`, `max_id`, `step`, `delta`, `remainder`, `create_time`, `update_time`, `version`)
VALUES
    (2, 'test_odd', 1, 1, 100000, 2, 1, '2018-07-21 23:52:58', '2018-07-23 00:39:24', 3);


INSERT INTO `tiny_id_token` (`id`, `token`, `biz_type`, `remark`, `create_time`, `update_time`)
VALUES
    (1, '0f673adf80504e2eaa552f5d791b644c', 'test', '1', '2017-12-14 16:36:46', '2017-12-14 16:36:48');

INSERT INTO `tiny_id_token` (`id`, `token`, `biz_type`, `remark`, `create_time`, `update_time`)
VALUES
    (2, '0f673adf80504e2eaa552f5d791b644c', 'test_odd', '1', '2017-12-14 16:36:46', '2017-12-14 16:36:48');

（3）配置数据库：

datasource.tinyid.names=primary
datasource.tinyid.primary.driver-class-name=com.mysql.jdbc.Driver
datasource.tinyid.primary.url=jdbc:mysql://ip:port/databaseName?autoReconnect=true&useUnicode=true&characterEncoding=UTF-8
datasource.tinyid.primary.username=root
datasource.tinyid.primary.password=123456

（4）启动tinyid-server后测试

获取分布式自增ID: http://localhost:9999/tinyid/id/nextIdSimple?bizType=test&token=0f673adf80504e2eaa552f5d791b644c'
返回结果: 3

批量获取分布式自增ID:
http://localhost:9999/tinyid/id/nextIdSimple?bizType=test&token=0f673adf80504e2eaa552f5d791b644c&batchSize=10'
返回结果:  4,5,6,7,8,9,10,11,12,13

Java客户端方式接入

重复Http方式的（2）（3）操作

引入依赖

d56d6e43300e4f33ba97260ef08b1bfc.png

配置文件

a93921478d6b436a9b128328e55ef68a.png

test 、tinyid.token是在数据库表中预先插入的数据，test 是具体业务类型，tinyid.token表示可访问的业务类型

744bd2c50d9c45268ce82b8e04e497c6.png

Github地址：https://github.com/didi/tinyid。

特点: 可以独立项目作为ID服务中心,对外提供http接口获取ID,但这种方式会影响性能;如果需要性能最大化,就需要根据源码进行二次开发,在项目中直接拷贝源码进行相应修改.与美团相比,最大特点是 支持多节点部署。

------------------------------------------------------------------------------

美团Leaf

同时支持号段模式和snowflake算法模式，可以切换使用

号段模式

先导入源码 https://github.com/Meituan-Dianping/Leaf ，在建一张表leaf_alloc

DROP TABLE IF EXISTS `leaf_alloc`;

CREATE TABLE `leaf_alloc` (
  `biz_tag` varchar(128)  NOT NULL DEFAULT '' COMMENT '业务key',
  `max_id` bigint(20) NOT NULL DEFAULT '1' COMMENT '当前已经分配了的最大id',
  `step` int(11) NOT NULL COMMENT '初始步长，也是动态调整的最小步长',
  `description` varchar(256)  DEFAULT NULL COMMENT '业务key的描述',
  `update_time` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '数据库维护的更新时间',
  PRIMARY KEY (`biz_tag`)
) ENGINE=InnoDB;

然后在项目中开启号段模式，配置对应的数据库信息，并关闭snowflake模

leaf.name=com.sankuai.leaf.opensource.test
leaf.segment.enable=true
leaf.jdbc.url=jdbc:mysql://localhost:3306/leaf_test?useUnicode=true&characterEncoding=utf8&characterSetResults=utf8
leaf.jdbc.username=root
leaf.jdbc.password=root

leaf.snowflake.enable=false
#leaf.snowflake.zk.address=
#leaf.snowflake.port=

启动leaf-server 模块的 LeafServerApplication项目就跑起来了

号段模式获取分布式自增ID的测试url ：http：//localhost：8080/api/segment/get/leaf-segment-test

监控号段模式：http://localhost:8080/cache

snowflake模式

Leaf的snowflake模式依赖于ZooKeeper，不同于原始snowflake算法也主要是在workId的生成上，Leaf中workId是基于ZooKeeper的顺序Id来生成的，每个应用在使用Leaf-snowflake时，启动时都会都在Zookeeper中生成一个顺序Id，相当于一台机器对应一个顺序节点，也就是一个workId。

b5f53444a57a4c61b87aed6b3e7b5789.png

snowflake模式获取分布式自增ID的测试url：http://localhost:8080/api/snowflake/get/test

github地址：https://github.com/Meituan-Dianping/Leaf

特点: 可以独立项目作为ID服务中心,对外提供http接口获取ID,但这种方式会影响性能;如果需要性能最大化,就需要根据源码进行二次开发,在项目中直接拷贝源码进行相应修改.在百度uid generator基础上优化的,可以独立一个服务来提供访问

 

远方的、远方的、、、
关注
  • 20
    点赞
  • 踩
  • 26
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
分布式ID选型对比（2）
thinkers
03-02 636
三, resources目录下编写自动生成代码配置文件: generatorConfig.xml。4, resources/mybatis目录下建: IdGeneratorMapper.xml。特点: 相较于数据库自增,扩展性更好,但缺点是每次取ID都需要加锁,性能较低.3, controller层: GenerateIdController。2, dao层接口: IdGeneratorMapper。1, 对象 IdGenerator。
分布式事务选型及对比
chuixue24的博客
08-19 1468
分布式事务产生的条件 说到分布式事务，我们先来看看分布式事务的产生条件 这里我们举一个栗子： 当用户进行下单以后，会去调用派单服务进行派单，即向派单服务数据库中插入一条派单业务。 派单成功之后，订单服务在执行后面的业务代码中，报错了 此时订单服务事务回滚，而派单服务的事务已经提交了，导致了数据的不一致。 此时，小伙伴可能有疑问：派单服务报错呢？会不会也产生分布式事务问题？ 实际上如果派单服务报错，会将执行结果返回给订单服务，订单服务执行相应的处理即可，并不会发生分布式事务。 什么是分...
分布式ID选型对比（1）
thinkers
03-02 1230
可以实现自己的ID生成中心,即TynyId-server,由该项目提供获取ID的方法供调用,但该方式比较耗IO,性能会有所下降。可以实现自己的ID生成中心,即leaf-server,由该项目提供获取ID的方法供调用,但该方式比较耗IO,性能会有所下降。特点: 对于高并发的系统,如果做了分库分表就不适合了,且数据库数量达到500万时就容易出现瓶颈,仅适合小数据量的系统.高(本地生成,(无网络开销,需要自己实现)高(本地生成,(无网络开销,需要自己实现)依赖数据库,需要频繁更新数据库maxId。
分布式数据库选型1
08-08
分布式数据库是现代大数据处理的关键组件，它允许在多台服务器之间分布数据，以实现高可用性、可伸缩性和性能优化。本文将深入探讨两个重要的分布式数据库系统：Hypertable和HBase，它们都是受到Google核心技术启发...
分布式数据库选型方案.docx
04-26
分布式数据库选型方案.docx
分布式配置中心选型
02-24
关于分布式配置中心，网上已经有很多开源的解决方案，例如：Apollo（阿波罗）是携程框架部门研发的分布式配置中心，能够集中化管理应用不同环境、不同集群的配置，配置修改后能够实时推送到应用端，并且具备规范的...
常用分布式文件系统选型对比
10-30
介绍HDFS,GlusterFS,Ceph,等常用分布式文件系统的特点性能以及技术选型，
浅谈常用的分布式事务选型
07-24
1、通用分布式事务规范XA 2、JAVA分布式事务规范（JTA） 3、常用的分布式事务框架： 2PC/3PC（强一致性事务） TCC（事务补偿） MQ（消息事务） Seata（柔性事务） Saga
JWT加密解密案例
热门推荐
thinkers
06-19 1万+
------1，创建一个用户对象Userpackage com.xforceplus.hera; public class User { private String userName; private String password; private String tel; public User(String userName,String password,...
微服务日志系统
thinkers
12-06 3807
1.初始ELK ELK是一个技术栈，包括Elasticsearch、Logstash和Kibana,ELK是三种技术首字母的缩写。ELK主要用于日志收集、存储和查询。 1.1 为什么要用ELK ELK主要用于处理日志。作用如下： a) 定位问题：线下也许可以通过debug一行一行来调试，但是线上可能不会给你远程调试的权限；当然，如果代码庞大，调试可...
swagger环境搭建及使用
thinkers
05-23 1675
swagger环境搭建及使用： 1，导入swagger所需要的jar包及插件 pom文件 &lt;!-- 合并swagge文档 --&gt; &lt;plugin&gt; &lt;groupId&gt;org.codehaus.gmaven&lt;/groupId&gt; &lt;artifactId&gt;groovy-maven-plugin&lt;...
Java实战-- 线程池及lambda
thinkers
02-29 1340
Java实战技巧 多线程并发编程 lambda高级用法
POI 实现Excel 导入、导出功能
thinkers
06-04 865
【代码】POI 实现Excel 导入、导出功能。
Spring+Mybatis-plus 实现 Gauss DB数据库代码生成
thinkers
05-13 650
3，在idea 右上角 plugins-> mybatis-generator-> mybatis-generator:generator 双击执行，即可在指定配置中生成代码。使用的gauss db数据库（类似oracle语法），需要根据指定表生成entity、dao等代码。2，在resources目录下 mybatis-plus 的配置文件 mybatis-generator.xml。
日志记录功能
最新发布
thinkers
06-25 642
1，可记录页面操作模块、按钮的日志记录。自定义 controller/service层方法注解。OperationLogMapper 的相关代码这里略。4，需要考虑到扩展性及个性化定制。2，记录详细的指定操作数据日志。3，记录的数据可能需要查询表。实体对象OperationLog。controller层使用案例。Mapper层自定义注解。mapper层切面实现。mapper层使用案例。
SpringBoot Validation自定义注解之校验指定最小整数
thinkers
05-21 632
1，引入核心关键依赖。
异步编程实战之r2dbc
thinkers
03-03 607
五, 编写DataSourceConfig。controller模板。四, 编写入口生成主类。二, 数据库连接配置。
Spring JdbcTemplate实现自定义动态sql拼接功能
thinkers
05-06 506
sql 需要能满足支持动态拼接，包含 查询字段、查询表、关联表、查询条件、关联表的查询条件、排序、分组、去重等。11，核心类之 BasicConditionQueryCriteria（入参）7，核心类之 PredicateCondition。8，核心类之 PropertyCondition。10，核心类之 ExecutionSql。9，核心类之 SqlBuilder。6，核心类之 Condition。2，创建项目并引入 pom依赖。4，核心类之 Column。5，核心类之 Table。
分布式文件系统选型对比
03-19
当选择分布式文件系统时，需要考虑多个因素，包括性能、可靠性、扩展性、一致性和易用性等。以下是几种常见的分布式文件系统及其对比： 1. HDFS（Hadoop Distributed File System）： - 优点：高可靠性、高扩展性、合大数据处理，支持数据冗余和容错。 - 缺点：不适合小文件存储，写入延迟较高。 2. Ceph： - 优点：高可靠性、高扩展性，支持多种存储接口（块、文件和对象存储）。 - 缺点：配置和管理复杂，对网络要求较高。 3. GlusterFS： - 优点：易于部署和管理，支持线性扩展，适合大规模存储。 - 缺点：不适合小文件存储，写入性能较差。 4. Lustre： - 优点：高性能、高可靠性，适合超大规模存储和高性能计算。 - 缺点：配置和管理复杂，对网络要求较高。 5. NFS（Network File System）： - 优点：易于使用和集成，适合小规模存储。 - 缺点：单点故障、性能受限于网络速度。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

远方的、远方的、、、

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

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

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

打赏作者

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

抵扣说明：

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

余额充值