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

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 );
    }
}