微服务 分布式ID生成方式雪花算法

微服务 分布式ID生成方式雪花算法

  • 1. 分布式ID概述
    • 1.1 为什么需要分布式全局唯一ID
    • 1.2 ID生成规则要求
    • 1.3 ID号生成系统的可用性要求
  • 2. 分布式ID生成方式
    • 2.1 UUID
    • 2.2 数据库自增主键
    • 2.3 基于Redis生成全局ID策略
    • 2.4 雪花算法
  • 3. 雪花算法详解
    • 3.1 雪花算法概述
    • 3.2 雪花算法结构
    • 3.3 雪花算法使用年限
    • 3.4 雪花算法优缺点
    • 3.5 其他方式
  • 4. 整合springboot
    • 4.1 依赖hutool
    • 4.2 案例验证

1. 分布式ID概述

1.1 为什么需要分布式全局唯一ID

简单概括下就是分布式微服务所带来的的问题,在单体架构环境下UUID或者auto_increment即可满足,保证ID的全局唯一,随着业务的发展,分布式微服务架构,导致UUID或者auto_increment不能保证全局的唯一,这就带来了需要生成全局唯一的分布式ID的需求。

1.2 ID生成规则要求

1.全局唯一,不能出现重复ID,用来标识唯一。
2.趋势递增,Mysql的InnoDB引擎使用的是聚簇索引,由于多数RDBMS使用Btree的数据结构存储索引数据,主键有序可以提高写入性能。
3.单调递增,主键ID单调递增,利于后续排序等功能。
4.信息安全,连续的ID容易暴露交易信息,如果是订单号就可以推出订单量等信息,一些场景下的无规则才能保证信息安全,不容易泄露。
5.含时间戳,时间戳有利于统计,问题定位分析等。

1.3 ID号生成系统的可用性要求

1.高可用
2.高性能
3.高并发

2. 分布式ID生成方式

对于技术选型通常有四种常见的方案,UUID,数据库自增主键,基于Redis生成全局ID策略,雪花算法。

2.1 UUID

优点:性能高,唯一性,没有网络消耗。
缺点:无序,过长。

2.2 数据库自增主键

优点:有序,递增,唯一
缺点:集群分布式下需要设置不同的增长步长。

2.3 基于Redis生成全局ID策略

优点:Redis单线程天生保证原子性,可以使用INCR与INCRBY来实现,适合分布式集群,全局唯一,有序递增。
缺点:要单独维护Redis集群,并保证高可用,维护成本高。与MySQL相同集群分布式下需要设置不同的增长步长同时key要设置有限期。
比如一个集群5台Redis,初始化Redis值分别是1,2,3,4,5,然后步长都是5。

2.4 雪花算法

优点:一套成熟的算法体系,递增,有序,高性能。
缺点:沿用到2039年。

3. 雪花算法详解

3.1 雪花算法概述

snowflake地址:https://github.com/twitter-archive/snowflake

1. Twitter的分布式雪花算法snow flake,经过测试测试能够产生26万个自增有序ID。
2. snow flake能够按照时间有序生成ID。
3. snowflake算法生成ID的结果是一个64bit大小的证书,为一个Long型(转换为字符串后长度最多19位)。
4. 分布式系统内不会产生ID碰撞(由datacenter和workerID作为分区)并且效率高。

3.2 雪花算法结构

在这里插入图片描述

3.3 雪花算法使用年限


/**
 * 2039年来源
 * @author zrj
 * @date 2021/2/15
 * @since V1.0
 **/
public class SnowFlakeTest {

    public static void main(String[] args) {
        System.out.println( "雪花算法时间" );

        System.out.println( "11111111111111111111111111111111111111111".length() );
        long time = 2199023255551L;//2进制的41个1,转换10进制数字

        Date date = new Date();
        date.setTime( time );

        //2039-09-07
        System.out.println( new SimpleDateFormat( "yyyy-MM-dd" ).format( date ) );
    }
}

3.4 雪花算法优缺点

在这里插入图片描述

3.5 其他方式

百度开源分布式唯一id生成器UidGenerator。
Leaf,美团点评分布式id生成系统。

4. 整合springboot

4.1 依赖hutool

官网地址:https://hutool.cn/
hutool是一个很好用的java开源工具包,很干净,没有其他复杂的依赖。

4.2 案例验证

git地址:https://github.com/zrj-coder/snowflakeboot

maven依赖


<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0modelVersion>
    <parent>
        <groupId>org.springframework.bootgroupId>
        <artifactId>spring-boot-starter-parentartifactId>
        <version>2.4.2version>
        <relativePath/> 
    parent>
    <groupId>com.hello.snowflakegroupId>
    <artifactId>snowflakebootartifactId>
    <version>0.0.1-SNAPSHOTversion>
    <name>snowflakebootname>
    <description>Demo project for Spring Bootdescription>
    <properties>
        <java.version>1.8java.version>
    properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-webartifactId>
        dependency>

        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-devtoolsartifactId>
            <scope>runtimescope>
            <optional>trueoptional>
        dependency>
        <dependency>
            <groupId>org.projectlombokgroupId>
            <artifactId>lombokartifactId>
            <optional>trueoptional>
        dependency>
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-testartifactId>
            <scope>testscope>
        dependency>

        <dependency>
            <groupId>junitgroupId>
            <artifactId>junitartifactId>
            <version>4.13version>
        dependency>
        <dependency>
            <groupId>log4jgroupId>
            <artifactId>log4jartifactId>
            <version>1.2.17version>
        dependency>

        <dependency>
            <groupId>cn.hutoolgroupId>
            <artifactId>hutool-allartifactId>
            <version>5.1.0version>
        dependency>
        <dependency>
            <groupId>com.google.guavagroupId>
            <artifactId>guavaartifactId>
            <version>16.0.1version>
        dependency>

    dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.bootgroupId>
                <artifactId>spring-boot-maven-pluginartifactId>
                <configuration>
                    <excludes>
                        <exclude>
                            <groupId>org.projectlombokgroupId>
                            <artifactId>lombokartifactId>
                        exclude>
                    excludes>
                configuration>
            plugin>
        plugins>
    build>

project>

配置

server:
  port: 8888

controller


/**
 * @author zrj
 * @date 2021/2/15
 * @since V1.0
 **/
@RestController
public class SnowFlakeController {

    @Resource
    private SnowFlakeService snowFlakeService;

    @GetMapping("/snowflakeId")
    public String getSnowflakeId(){
        return snowFlakeService.getIdBySnowFlake();
    }
}

service


/**
 * @author zrj
 * @date 2021/2/15
 * @since V1.0
 **/
public interface SnowFlakeService {
    /**
     * 根据雪花算法获取ID
     *
     * @return
     */
    String getIdBySnowFlake();
}
package com.hello.snowflake.snowflakeboot.service.impl;

import com.google.common.util.concurrent.ThreadFactoryBuilder;
import com.hello.snowflake.snowflakeboot.service.SnowFlakeService;
import com.hello.snowflake.snowflakeboot.util.IdGeneratorSnowflake;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.concurrent.*;

/**
 * 多线程雪花算法获取ID
 * 这里多线程使用的是guava的包
 *
 * @author zrj
 * @date 2021/2/15
 * @since V1.0
 **/
@Service
public class SnowFlakeServiceImpl implements SnowFlakeService {
    /**
     * 参数根据实际需要调整,这里只做测试
     */
    private static ThreadFactory namedThreadFactory = new ThreadFactoryBuilder().setNameFormat( "adsytfs-pool-%d" ).build();
    private static ExecutorService pool = new ThreadPoolExecutor( 200, 300, 60L, TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>( 1 )
            , namedThreadFactory, new ThreadPoolExecutor.AbortPolicy() );

    @Autowired
    private IdGeneratorSnowflake idGeneratorSnowflake;

    /**
     * 根据雪花算法获取ID
     *
     * @return
     */
    @Override
    public String getIdBySnowFlake() {
        for (int i = 0; i < 20; i++) {
            pool.execute( () -> {
                long snowflakeId = idGeneratorSnowflake.snowflakeId();
                System.out.println( "多线程获取snowflakeId:" + snowflakeId );
            } );
        }
        // 关闭线程
        pool.shutdown();

        return "snowflake success";
    }
}

util

package com.hello.snowflake.snowflakeboot.util;

import cn.hutool.core.lang.Snowflake;
import cn.hutool.core.net.NetUtil;
import cn.hutool.core.util.IdUtil;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;

import javax.annotation.PostConstruct;

/**
 * 雪花算法获取分布式ID
 *
 * @author zrj
 * @date 2021/2/15
 * @since V1.0
 **/
@Slf4j
@Component
public class IdGeneratorSnowflake {

    /**
     * 机房ID
     */
    private long workerId = 0;
    /**
     * 机器ID
     */
    private long datacenterId = 1;

    private Snowflake snowflake = IdUtil.createSnowflake( workerId, datacenterId );

    @PostConstruct
    public void init() {
        try {
            workerId = NetUtil.ipv4ToLong( NetUtil.getLocalhostStr() );
            log.info( "当前机器的workerId:{}", workerId );
        } catch (Exception e) {
            log.warn( "当前机器workerId获取失败", e );
            workerId = NetUtil.getLocalhostStr().hashCode();
        }
    }

    /**
     * 无参获取通过默认机房机器号获取id
     *
     * @return
     */
    public synchronized long snowflakeId() {
        return snowflake.nextId();
    }

    /**
     * 有参根据参数获取ID
     *
     * @param workerId     机房ID
     * @param datacenterId 机器ID
     * @return
     */
    public synchronized long snowflakeId(long workerId, long datacenterId) {
        Snowflake snowflake = IdUtil.createSnowflake( workerId, datacenterId );
        return snowflake.nextId();
    }

    public static void main(String[] args) {
        long snowflakeId = new IdGeneratorSnowflake().snowflakeId();
        log.info( "雪花算法ID:{}", snowflakeId );
    }
}

你可能感兴趣的:(服务架构,分布式ID生成方式雪花算法)