随着互联网飞速发展，尤其像微博，移动支付行业，用户数据成几何倍数增长，传统的单库已无法满足业务的增长速度，于是就有了分库分表，对业务表进行垂直切分和水平切分，将数据存放在多个数据库中，这每个数据库中存放的业务数据就会相应减少，利于应用访问数据库速度。


       在享受分库分表带来查询速度提升便利的同时，这种切分方案也带来一些问题，例如数据路由，唯一序号等，今天主要说一下唯一序号解决方案

       第一种解决方案：使用UUID随机数，这种方案优点是使用简单，缺点是产生的随机数是128位，并且没有业务规则，不连续，占用数据库空间多，在业务数据量大时，会有性能下降

       第二种解决方案：使用Twitter的雪花算法（snowflake)，此算法产生序号效率极高，每秒能产生26W个ID，但是也存在缺点，非常依赖NTP服务，如果NTP失效，服务器的时间滞后，则此雪花算法就会等待服务器时间追上，才会生成新的ID

       今天就说一下新的解决方案，其架构图如下所示

            



        此方案的好处是，在同城双机房的情况下，可以部署2台mysql数据库，做双主半同步，这样可以保证数据的一致性，如果2台mysql服务器都运行正常，则同机房的应用则访问同机房的mysql数据库，可以事先定制好规则，机房A的应用访问机房A的mysql数据库表seq_a，并只获取奇数的序号，机房B的应用访问机房B的mysql数据库表seq_b，并只获取偶数的序号，2个机房业务均衡，基本无序号空洞产生。

        如果机房A的mysql数据库宕机，则分布式ID生成应用会自动切换数据源，去访问机房B的mysql数据库，并正常读写seq_a表，并只获取奇数的序号，以此来实现架构的高可用。

                                        下面是我的公众号二维码，欢迎添加

                                

自增序号、唯一ID、唯一编码生成器
1、序号发生器生成唯一编码
import com.github.pagehelper.util.StringUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Component;
import java.util.List;

@Component
public class SeqGeneratorUtil {
    @Autowired
    private StringRedisTemplate redisTemplate;
    /**
     * 自增序列号
     * prefix 前缀
     * numLength 要生成多少位的数字
     */
    public String SeqGenerator(String prefix, int numLength) {
        String upperCode = "";
        Long size = redisTemplate.opsForList().size(prefix);//查找以prefix作为key值的数据长度
        if (size > 0) {//有数据
            List leve = redisTemplate.opsForList().range(prefix, 0, -1);//获取该key下面的所有值 （-1所有值；1下一个值）
             upperCode = Collections.max(leve).toString();//返回最大值
        }
        String returnCode = "";
        int Suffix;//后缀数字
        if (!StringUtil.isEmpty(upperCode)) {//有数据
            String sequence = upperCode.substring(prefix.length());//截取前缀开始的后面数字
            Suffix = Integer.parseInt(sequence);
            Suffix++;//最后的序号加一
        } else {//没有数据
            Suffix = 1;
        }
        returnCode = prefix + String.format("%0" + numLength + "d", Suffix);//后缀不够numLength长，前面补充0
        redisTemplate.opsForList().rightPush(prefix, returnCode);//存入Redis
        return returnCode;
    }
}


2、利用redis的incr生成唯一编码

存储过程，用于生成唯一ID,并且在 并发情况下，保证了 ID序号的唯一性。
可以应用在，数据库系统中，作全局唯一序号的获取。
 
以下代码用于 SQL Server 2000 
CREATE PROCEDURE  GetNewID   AS
DECLARE
   @ID int;
  BEGIN TRANSACTION
  　　　　INSERT INTO SysNewID (TmpInt) Values(1);
  　　　　SET @ID = IDENT_CURRENT('SysNewID')
  COMMIT TRANSACTION
  return @ID
GO
/* 相关函数说明，来自 sql server 2000 帮助文件
语法
IDENT_CURRENT('table_name')
参数
table_name
是将要返回其标识值的表的名称。table_name 的数据类型为 varchar，没有默认值。
 
IDENT_CURRENT 返回为任何会话和任何作用域中的特定表最后生成的标识值。
@@IDENTITY 返回为当前会话的所有作用域中的任何表最后生成的标识值。
SCOPE_IDENTITY 返回为当前会话和当前作用域中的任何表最后生成的标识值。
*/
 
//辅助生成ID的数据表
CREATE TABLE [dbo].[SysNewID] (
 [ID] [int] IDENTITY (1, 1) NOT NULL , //自动加一的字段.
 [Tmpint] [int] NULL 
) ON [PRIMARY]
 
/* 查询分析器中的测试代码 */
declare @ID int
exec  @ID =  GetNewID
print @ID
 

想要为类的每一个对象生成一个唯一的序号，且这序号为类的数据成员。

1.使用默认的构造函数，不能使用拷贝初始化，否则序号（mysn会被拷贝）会相同



#include <iostream>

class numbered {
public:
    numbered()
    {
        static int unique = 10;//设计一个静态的数据成员
        mysn = unique++;
    }
    int mysn;
};

void f(numbered s)
{
    std::cout << s.mysn << std::endl;
}

int main()
{
    numbered a, b , c;//只能默认初始化，不能拷贝初始化，像b=a.c=b;这种结果都为10
    f(a);
    f(b);
    f(c);
}
// output
// 10
// 11
// 12

2.使用拷贝构造函数

#include <iostream>
class numbered {
public:
    numbered()
    {
    static int unique = 10;
        mysn = unique++;
    }
    numbered(const numbered& n) { mysn = n.mysn + 1; }
    int mysn;
};
void f(const numbered& s)//
{
    std::cout << s.mysn << std::endl;
}

int main()
{
    numbered a, b = a, c = b,d;
    f(a);
    f(b);//接着a的序号
    f(c);//接着b的序号
    f(d);//接着a的序号
}

// output
// 10
// 11
// 12
// 11

综上所述，暂时先使用同一种初始化方式。