<!--插入记录-->
<insert id="insertBlog" parameterType="blog">
    insert into blog values(#{id},#{title},#{author},#{createTtime},#{views});
</insert>

   -  测试 
```java
package com.iflytek.Dao;
import com.iflytek.pojo.Blog;
import com.iflytek.utils.IDutils;
import com.iflytek.utils.MybatisUtils_9;
import org.apache.ibatis.session.SqlSession;
import org.junit.Test;
import java.util.Date;

import java.util.HashMap;
import java.util.List;
@SuppressWarnings(“all”)
public class BlogMapperTest {

  //1.获取连接对象
  SqlSession sqlSession = MybatisUtils_9.getsqlSession();
  //2.获取mapper声明
  BlogMapper mapper = sqlSession.getMapper(BlogMapper.class);
  //添加记录
  @Test
  public void getBlogTest(){
      //创建执行对象
      Blog blog = new Blog();
      //添加记录
      blog.setId(IDutils.getId());
      blog.setTitle("Mybatis");
      blog.setAuthor("狂神说");
      blog.setCreateTtime(new Date());
      blog.setViews(9999);
      mapper.insertBlog(blog);
      blog.setId(IDutils.getId());
      blog.setTitle("Java");
      mapper.insertBlog(blog);
      blog.setId(IDutils.getId());
      blog.setTitle("Spring");
      mapper.insertBlog(blog);
      blog.setId(IDutils.getId());
      blog.setTitle("微服务");
      mapper.insertBlog(blog);
      sqlSession.commit();
      sqlSession.close();
  }

}

• 在没有学习MyBatis-Plus之前，动态SQL是后台与数据库交互最简单的实现方式，没有之一。

1、动态SQL-IF

动态IF查询只要用于，多条件查询时灵活切换条件

• 实体类接口

  //2.if条件查询之博客查询
   List<Blog> queryBlogIF(Map map);

• SQL语句(该方法也称为sql引用)

  <!--if条件查询-->
   <select id="queryBlogIF" parameterType="map" resultType="blog">
       select * from blog
       <!--where自动匹配条查询条件是否满足-->
       <where>
           <include refid="if-title-author"/>
       </where>
   </select>
   <!--sql片段插入公共部分，where语法不能使用,实现代码多次复用，提高程序效率-->
   <sql id="if-title-author">
       <if test="title !=null">
           title =#{title}
       </if>
       <if test="author !=null">
           and author =#{author}
       </if>
   </sql>

• 测试

  //实现动态if条件查询一
   @Test
   public void quaryBlogTest(){
               //1.获取连接对象
               SqlSession sqlSession = MybatisUtils_9.getsqlSession();
               //2.获取mapper声明
           BlogMapper mapper = sqlSession.getMapper(BlogMapper.class);
       //实现动态查询语句的关键
       HashMap map = new HashMap();
       //实现动态SQL
       map.put("title","微服务");
       map.put("author","狂神说");
       List<Blog> blogs = mapper.queryBlogIF(map);
       for (Blog blog : blogs) {
           System.out.println(blog);
       }
       //提交事务
       sqlSession.commit();
       //释放资源
       sqlSession.close();
   }

• SQL语句动态拼接，查询什么字段，自动拼接什么字段

2、动态SQL-常用语句

• 实体类接口

  //2.if条件查询之博客查询
   List<Blog> queryBlogIF(Map map);

• SQL语句（Mapper.xml）

  <!--choose条件查询-->
   <select id="queryBlogChoose" parameterType="map" resultType="blog">
       select *from blog
           <where>
               <!--choose只要满足所有条件中的靠前的一个就停止查询-->
               <choose>
                   <!--满足条件查询一下内容-->
                   <when test="title !=null">
                       title=#{title}
                   </when>
                   <when test="author !=null">
                       and author=#{author}
                   </when>
                   <!--不满足条件查询下面内容-->
                   <otherwise>
                       and views = #{views}
                   </otherwise>
               </choose>
           </where>
   </select>

• 测试

  //实现动态choose条件查询一
   @Test
   public void quaryBlogTest_2() {
       //1.获取连接对象
           SqlSession sqlSession = MybatisUtils_9.getsqlSession();
              //2.获取mapper声明
           BlogMapper mapper = sqlSession.getMapper(BlogMapper.class);
       //实现动态查询语句的关键
       HashMap map = new HashMap();
      // map.put("views",9999);
       map.put("title","Java");
       List<Blog> blogs = mapper.queryBlogChoose(map);
       for (Blog blog : blogs) {
           System.out.println(blog);
       }
       //提交事务
       sqlSession.commit();
       //释放资源
       sqlSession.close();
   }

• SQL拼接在多条件查询下只识别第一个条件，不论顺序先后

3、动态SQL-Foreach

• 实体类接口

  //查询前三条记录
   List<Blog> queryBlogForeach(Map map);

• SQL语句（Mapper.xml）

  <select id="queryBlogForeach" parameterType="map" resultType="blog">
   select * from mybatis.blog
   <where>
       <foreach collection="ids" item="id" open="and (" close=")" separator="or">
           id = #{id}
       </foreach>
   </where>
  </select>

• 测试

  //实现动态foreach查询
   @Test
   public void queryBlogForeach(){
       //实现动态查询语句的关键
       HashMap map = new HashMap();
       //执行动态SQL
       ArrayList<Integer> ids = new ArrayList<Integer>();
       ids.add(1);
       ids.add(2);
       ids.add(3);
       map.put("ids",ids);
       List<Blog> blogs = mapper.queryBlogForeach(map);
       for (Blog blog : blogs) {
           System.out.println(blog);
       }
       //提交事务
       sqlSession.commit();
       //释放资源
       sqlSession.close();
   }

2.5、MyBatis缓存原理

何为缓存？

• 什么是缓存 [ Cache ]？
  • 存在内存中的临时数据。
  • 将用户经常查询的数据放在缓存（内存）中，用户去查询数据就不用从磁盘上(关系型数据库数据文件)查询，从缓存中查询，从而提高查询效率，解决了高并发系统的性能问题。
• 为什么使用缓存？
  • 减少和数据库的交互次数，减少系统开销，提高系统效率。
• 什么样的数据能使用缓存？
  • 经常查询并且不经常改变的数据。
  • 缓存读数据，不缓存写数据。

缓存的多样性

Mamecache

• 一中分布式的高速缓存系统
  • 以更小的资源支持更大负载网站的运行，以小博大
  • 尽量减少用户等待时间，节省系统资源开销，节省带宽使用
  • Memcache内存缓存技术、静态化技术、mysql优化
• Mamecache与Redis的区别与联系
  • redis:支持比较多的数据类型(String、list、set、sortset/hash)，redis支持集合计算的(set类型支持)，每个key最大数据存储量为1G，redis是新兴的内存缓存技术，对各方面支持不完善，支持持久化操作。
  • memcache：老牌的内存缓存技术，对相关领域支持比较丰富，window和linux都可以使用，各种框架(tp、yii等等)都支持使用，session的信息可以非常方便的保存到该memcache中，每个key保存的数据量最大为1M，支持的数据类型比较单一，就是String类型，不支持持久化。

EhCache

• 一个纯Java的进程内缓存框架，具有快速、精干等特点，是Hibernate中默认CacheProvider
  • 一种广泛使用的开源Java分布式缓存
  • 主要面向通用缓存,Java EE和轻量级容器
  • 它具有内存和磁盘存储，缓存加载器,缓存扩展,缓存异常处理程序,一个gzip缓存servlet过滤器,支持REST和SOAP api等特点
  • 快速、简单、支持多种缓存策略
  • 缓存数据有两级：内存和磁盘，因此无需担心容量问题
  • 缓存数据会在虚拟机重启的过程中写入磁盘
  • 可以通过RMI、可插入API等方式进行分布式缓存
  • 具有缓存和缓存管理器的侦听接口
  • 支持多缓存管理器实例，以及一个实例的多个缓存区域
  • 提供Hibernate的缓存实现
• EhCahcee与Redis的区别与联系
  • Redis是通过socket访问到缓存服务，效率比Ehcache低，比数据库要快很多，处理集群和分布式缓存方便，有成熟的方案。
    • 如果是单个应用或者对缓存访问要求很高的应用，用ehcache。如果是大型系统，存在缓存共享、分布式部署、缓存内容很大的，建议用redis。
  • EhCache直接在jvm虚拟机中缓存，速度快，效率高；但是缓存共享麻烦，集群分布式应用不方便。
    • ehcache也有缓存共享方案，不过是通过RMI或者Jgroup多播方式进行广播缓存通知更新，缓存共享复杂，维护不方便；简单的共享可以，但是涉及到缓存恢复，大数据缓存，则不合适。

Redis

• 一个优秀的用于缓存的NoSQL

MyBatis缓存

• MyBatis包含一个非常强大的查询缓存特性，它可以非常方便地定制和配置缓存，缓存可以极大的提升查询效率。
• MyBatis系统中默认定义了两级缓存：一级缓存和二级缓存
• • 默认情况下，只有一级缓存开启。（SqlSession级别的缓存，也称为本地缓存）
  • 二级缓存需要手动开启和配置，他是基于namespace级别的缓存。
  • 为了提高扩展性，MyBatis定义了缓存接口Cache。我们可以通过实现Cache接口来自定义二级缓存
• 
  

1、一级缓存

• 一级缓存也叫本地缓存：
  • 与数据库同一次会话期间查询到的数据会放在本地缓存中。
  • 以后如果需要获取相同的数据，直接从缓存中拿，没必须再去查询数据库。
  • sqlSession开启就缓存到本地了
  • 一级缓存容易失效
    • 查询不同的数据就会更新缓存，导致失效
    • 执行增删改查时会改变原来的数据，也会导致缓存失效
    • 查询不同的Mapper.xml
    • 手动清理缓存导致失效
  • 查询内容 ```xml <?xml version=”1.0” encoding=”UTF-8” ?> <!DOCTYPE mapper PUBLIC “-//mybatis.org//DTD Mapper 3.0//EN” “http://mybatis.org/dtd/mybatis-3-mapper.dtd">

select * from user id=#{id}

   -  测试 
```java
package com.iflytek.Dao;
import com.iflytek.pojo.User;
import com.iflytek.utils.MybatisUtils_10;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.session.SqlSession;
import org.junit.Test;
//二级缓存测试多查询事务回滚
public class UserMapperTest {
    //1.获取连接对象
    SqlSession sqlSession = MybatisUtils_10.getsqlSession();
    //2.获取getMapper连接声明
    UserMapper mapper=  sqlSession.getMapper(UserMapper.class);
    @Test
    public void queryUserById_Test(){
        User user = mapper.queryUserById(1);
        System.out.println(user);
        //增删改查都会刷新一级缓存机制
        System.out.println("-------------------------------------");
        sqlSession.close();
        User user2 = mapper.queryUserById(1);
        System.out.println(user2);
        System.out.println(user == user2);
        //增删改查都会刷新一级缓存机制
        sqlSession.close();
    }
}

• 缓存效果
  
• 执行查询时，缓存已经生成

• 缓存失效

  • 执行CRUD即可导致一级缓存失效 ```xml

  update user set name =#{name},pwd=#{pwd},gender=#{gender},height=#{height} where id=#{id}; java package com.iflytek.Dao;

import com.iflytek.pojo.User; import com.iflytek.utils.MybatisUtils_10; import org.apache.ibatis.annotations.Mapper; import org.apache.ibatis.session.SqlSession; import org.junit.Test;

//二级缓存测试多查询事务回滚 public class UserMapperTest { //1.获取连接对象 SqlSession sqlSession = MybatisUtils_10.getsqlSession();

//2.获取getMapper连接声明
UserMapper mapper=  sqlSession.getMapper(UserMapper.class);
@Test
public void queryUserById_Test(){
    User user = mapper.queryUserById(1);
    System.out.println(user);
    //增删改查都会刷新一级缓存机制
    mapper.updateUser(new User(2,"三岁","111111","男",180));
    System.out.println("-------------------------------------");
    sqlSession.close();
    User user2 = mapper.queryUserById(1);
    System.out.println(user2);
    System.out.println(user == user2);
    //增删改查都会刷新一级缓存机制
    sqlSession.close();
}

}

   -  缓存失效<br />![](https://gitee.com/hg14150/blogiamges/raw/master/img/image-20210415195623543.png#crop=0&crop=0&crop=1&crop=1&id=tvQuR&originHeight=572&originWidth=956&originalType=binary&ratio=1&rotation=0&showTitle=false&status=done&style=none&title=) 
   -  插入语句插队，导致缓存失效，产生第二次查询，缓存记录清空，所以记录为false 
<a name="088daa62"></a>
#### 2、二级缓存
-  二级缓存也叫全局缓存，一级缓存作用域太低了，所以诞生了二级缓存 
-  基于namespace级别的缓存，一个名称空间，对应一个二级缓存； 
-  工作机制 
-  
   -  一个会话查询一条数据，这个数据就会被放在当前会话的一级缓存中； 
   -  如果当前会话关闭了，这个会话对应的一级缓存就没了；但是我们想要的是，会话关闭了，一级缓存中的数据被保存到二级缓存中； 
   -  新的会话查询信息，就可以从二级缓存中获取内容； 
   -  不同的mapper查出的数据会放在自己对应的缓存（map）中； 
-  使用步骤 
   -  开启全局缓存（mybatis-config.xml） 
```xml
<setting name="cacheEnabled" value="true"/>

• 自定义二级缓存设置

  <cache 
       eviction="FIFO"    #创建高级缓存机制，first in first out 先进先出原则
       flushInterval="60000"   #设置刷新时间
       size="512"    #设置最大存储对象
       readOnly="true" #开启返回只读权限
  />

• 测试 ```java package com.iflytek.Dao;

import com.iflytek.pojo.User; import com.iflytek.utils.MybatisUtils_10; import org.apache.ibatis.annotations.Mapper; import org.apache.ibatis.session.SqlSession; import org.junit.Test;

//二级缓存测试多查询事务回滚 public class UserMapperTest { //1.获取连接对象 SqlSession sqlSession = MybatisUtils_10.getsqlSession(); SqlSession sqlSession2 = MybatisUtils_10.getsqlSession();

//2.获取getMapper连接声明
UserMapper mapper=  sqlSession.getMapper(UserMapper.class);
UserMapper mapper2=  sqlSession2.getMapper(UserMapper.class);
@Test
public void queryUserById_Test(){
    User user = mapper.queryUserById(1);
    System.out.println(user);
    //增删改查都会刷新一级缓存机制

// mapper.updateUser(new User(2,”小王”,”111111”,”男”,167)); System.out.println(“——————————————————-“); sqlSession.close();

    User user2 = mapper2.queryUserById(1);
    System.out.println(user2);
    System.out.println(user == user2);
    //增删改查都会刷新一级缓存机制
    sqlSession2.close();
}

}

   -  缓存效果<br />![](https://gitee.com/hg14150/blogiamges/raw/master/img/image-20210415204236842.png#crop=0&crop=0&crop=1&crop=1&id=oVRbb&originHeight=494&originWidth=884&originalType=binary&ratio=1&rotation=0&showTitle=false&status=done&style=none&title=) 
   -  两次查询只有一次记录，证明二级缓存已经生效 
-  总结 
   - 只要开启了二级缓存，我们在同一个Mapper中的查询，可以在二级缓存中拿到数据
   - 查出的数据都会被默认先放在一级缓存中
   - 只有会话提交或者关闭以后，一级缓存中的数据才会转到二级缓存中
<a name="fd1d32b4"></a>
## 三、MyBatis-Plus
<a name="c19cae35"></a>
### 3.1、快速入门MyBats-Plus
- [MyBatis-Plus (opens new window)](https://github.com/baomidou/mybatis-plus)（简称 MP），在 MyBatis 的基础上只做增强不做改变，为简化开发、提高效率而生。
- 基友搭配，效率翻倍。
> 特性
- **无侵入**：只做增强不做改变，引入它不会对现有工程产生影响，如丝般顺滑
- **损耗小**：启动即会自动注入基本 CURD，性能基本无损耗，直接面向对象操作
- **强大的 CRUD 操作**：内置通用 Mapper、通用 Service，仅仅通过少量配置即可实现单表大部分 CRUD 操作，更有强大的条件构造器，满足各类使用需求
- **支持 Lambda 形式调用**：通过 Lambda 表达式，方便的编写各类查询条件，无需再担心字段写错
- **支持主键自动生成**：支持多达 4 种主键策略（内含分布式唯一 ID 生成器 - Sequence），可自由配置，完美解决主键问题
- **支持 ActiveRecord 模式**：支持 ActiveRecord 形式调用，实体类只需继承 Model 类即可进行强大的 CRUD 操作
- **支持自定义全局通用操作**：支持全局通用方法注入（ Write once, use anywhere ）
- **内置代码生成器**：采用代码或者 Maven 插件可快速生成 Mapper 、 Model 、 Service 、 Controller 层代码，支持模板引擎，更有超多自定义配置等您来使用
- **内置分页插件**：基于 MyBatis 物理分页，开发者无需关心具体操作，配置好插件之后，写分页等同于普通 List 查询
- **分页插件支持多种数据库**：支持 MySQL、MariaDB、Oracle、DB2、H2、HSQL、SQLite、Postgre、SQLServer 等多种数据库
- **内置性能分析插件**：可输出 Sql 语句以及其执行时间，建议开发测试时启用该功能，能快速揪出慢查询
- **内置全局拦截插件**：提供全表 delete 、 update 操作智能分析阻断，也可自定义拦截规则，预防误操作
> 框架结构
![](https://gitee.com/hg14150/blogiamges/raw/master/img/image-20210415212019187.png#crop=0&crop=0&crop=1&crop=1&id=SVlp0&originHeight=614&originWidth=1062&originalType=binary&ratio=1&rotation=0&showTitle=false&status=done&style=none&title=)
<a name="c37031af"></a>
#### 3.1.1、快速搭建环境
<a name="d3277b01"></a>
###### 1、初始化Spring-Boot工程 [Spring Initializer (opens new window)](https://start.spring.io/)
<a name="bc6c489e"></a>
###### 2、导入依赖
```xml
 <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <!-- https://mvnrepository.com/artifact/mysql/mysql-connector-java -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.47</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.projectlombok/lombok -->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.12</version>
            <scope>provided</scope>
        </dependency>
        <!--mybaits-plus-->
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.0.5</version>
        </dependency>
        <dependency>
            <groupId>javax.xml.bind</groupId>
            <artifactId>jaxb-api</artifactId>
            <version>2.3.0</version>
        </dependency>
        <dependency>
            <groupId>com.sun.xml.bind</groupId>
            <artifactId>jaxb-impl</artifactId>
            <version>2.3.0</version>
        </dependency>
        <dependency>
            <groupId>com.sun.xml.bind</groupId>
            <artifactId>jaxb-core</artifactId>
            <version>2.3.0</version>
        </dependency>
        <dependency>
            <groupId>javax.activation</groupId>
            <artifactId>activation</artifactId>
            <version>1.1.1</version>
        </dependency>

3、连接配置

#数据库连接配置
spring.datasource.driver-class-name=com.mysql.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/school?useUnicode=true&characterEncoding=UTF-8&useSSL=false
spring.datasource.username=root
spring.datasource.password=123456
#日志配置,默认日志支持
mybatis-plus.configuration.log-impl=org.apache.ibatis.logging.stdout.StdOutImpl

4、使用

• 在配置完实体类接口后要在主方法上添加扫描包,@MapperScan("com.iflytek.mapper") ```java package com.iflytek;

import org.mybatis.spring.annotation.MapperScan; import org.springframework.boot.SpringApplication; import org.springframework.boot.autoconfigure.SpringBootApplication;

@MapperScan(“com.iflytek.mapper”) @SpringBootApplication public class MybatisPlus1Application { public static void main(String[] args) { SpringApplication.run(MybatisPlus1Application.class, args); } }

-  `BaseMapper<User>`的使用 
   -  在xxxMapper.java接口中继承 **BaseMapper**父类，可以省略所以简单SQL的CRUD语句，范型是SQL操作需要使用的查询范型，增加后SQL操作中将不需要再手动添加 
```java
public interface UserMapper extends BaseMapper<Person> {
    void selectList();
}

• 测试 ```java package com.iflytek;

import com.iflytek.mapper.UserMapper; import com.iflytek.pojo.Person; import org.apache.catalina.User; import org.junit.jupiter.api.Test; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.boot.test.context.SpringBootTest;

import java.util.List;

@SpringBootTest class MybatisPlus1ApplicationTests {

@Autowired
private UserMapper userMapper;
@Test
void contextLoads() {
    List<Person> personList = userMapper.selectList(null);
    personList.forEach(System.out::println);
}

}

   -  结果<br />![](https://gitee.com/hg14150/blogiamges/raw/master/img/image-20210416193459291.png#crop=0&crop=0&crop=1&crop=1&id=XQfiN&originHeight=587&originWidth=1416&originalType=binary&ratio=1&rotation=0&showTitle=false&status=done&style=none&title=) 
<a name="7121e0e2"></a>
### 3.2、CRUD高阶处理
> 实体类接口继承了**BaseMapper**父类，简单SQL语句可省不写
<a name="77933ad0"></a>
#### 3.2.1、CURUD简单操作
-  **Insert插入** 
   -  测试 
```java
 //测试数据插入
    @Test
    public void InsertTest(){
        Person person = new Person();
        person.setName("二哈");
        person.setAge(18);
        person.setEmail("123456@qq.com");
        int insert = userMapper.insert(person);
        System.out.println(insert);
        System.out.println(person);
    }

• 结果
  
  • Update更新
• 测试

  //测试数据更新
  @Test
  public void UpdataTest(){
    Person person = new Person();
    person.setId(6L);
    person.setName("小黄");
    person.setAge(18);
    person.setEmail("11445522@qq.com");
    int update = userMapper.updateById(person);
    System.out.println(update);
    System.out.println(person);
  }

• 结果
  
  • Delete删除
• 测试

  //测试数据删除
  @Test
  public void DeleteTest(){
    Person person = new Person();
    person.setId(5L);
    int delete = userMapper.deleteById(person);
    System.out.println(delete);
    System.out.println(person);
  }

• 结果
  
  • Select查询
• 测试1，测试多个id的数据

  //多数据查询
  @Test
  public void SelectByIdTest(){
    List<Person> personList = userMapper.selectBatchIds(Arrays.asList(1, 2, 3));
    System.out.println(personList);
  }

• 结果1
  

• 测试2，条件查询，使用万能的Map更加方便

  //条件查询
  @Test
  public void SelectByOther(){
    HashMap<Object, Object> map = new HashMap<>();
    //定义SQL
    map.put("name","李四");
   List<Person> persons= userMapper.selectByMap(map);
    System.out.println(persons);
  }

• 结果2
  

3.2.2、雪花算法及主键策略

3.2.2.1、雪花算法

• snowflake是Twitter开源的分布式ID生成算法，结果是一个long型的ID。其核心思想是：使用41bit作为毫秒数，10bit作为机器的ID（5个bit是数据中心，5个bit的机器ID），12bit作为毫秒内的流水号（意味着每个节点在每毫秒可以产生 4096 个 ID），最后还有一个符号位，永远是0。
• 最常见的方式。利用数据库，全数据库唯一。
  • 优点：
    1）简单，代码方便，性能可以接受。
    2）数字ID天然排序，对分页或者需要排序的结果很有帮助。
  • 缺点：
    1）不同数据库语法和实现不同，数据库迁移的时候或多数据库版本支持的时候需要处理。
    2）在单个数据库或读写分离或一主多从的情况下，只有一个主库可以生成，有单点故障的风险。
    3）在性能达不到要求的情况下，比较难于扩展。
    4）如果遇见多个系统需要合并或者涉及到数据迁移会相当痛苦。
    5）分表分库的时候会有麻烦。
• 在id自动填充的阵营里，还有UUID,Redis，zookeeper等都能达到唯一标准的效果

• 雪花算法的实现

  public class IdWorker{
   //下面两个每个5位，加起来就是10位的工作机器id
   private long workerId;    //工作id
   private long datacenterId;   //数据id
   //12位的序列号
   private long sequence;
   public IdWorker(long workerId, long datacenterId, long sequence){
       // sanity check for workerId
       if (workerId > maxWorkerId || workerId < 0) {
           throw new IllegalArgumentException(String.format("worker Id can't be greater than %d or less than 0",maxWorkerId));
       }
       if (datacenterId > maxDatacenterId || datacenterId < 0) {
           throw new IllegalArgumentException(String.format("datacenter Id can't be greater than %d or less than 0",maxDatacenterId));
       }
       System.out.printf("worker starting. timestamp left shift %d, datacenter id bits %d, worker id bits %d, sequence bits %d, workerid %d",
               timestampLeftShift, datacenterIdBits, workerIdBits, sequenceBits, workerId);
       this.workerId = workerId;
       this.datacenterId = datacenterId;
       this.sequence = sequence;
   }
   //初始时间戳
   private long twepoch = 1288834974657L;
   //长度为5位
   private long workerIdBits = 5L;
   private long datacenterIdBits = 5L;
   //最大值
   private long maxWorkerId = -1L ^ (-1L << workerIdBits);
   private long maxDatacenterId = -1L ^ (-1L << datacenterIdBits);
   //序列号id长度
   private long sequenceBits = 12L;
   //序列号最大值
   private long sequenceMask = -1L ^ (-1L << sequenceBits);
   //工作id需要左移的位数，12位
   private long workerIdShift = sequenceBits;
  //数据id需要左移位数 12+5=17位
   private long datacenterIdShift = sequenceBits + workerIdBits;
   //时间戳需要左移位数 12+5+5=22位
   private long timestampLeftShift = sequenceBits + workerIdBits + datacenterIdBits;
   //上次时间戳，初始值为负数
   private long lastTimestamp = -1L;
   public long getWorkerId(){
       return workerId;
   }
   public long getDatacenterId(){
       return datacenterId;
   }
   public long getTimestamp(){
       return System.currentTimeMillis();
   }
    //下一个ID生成算法
   public synchronized long nextId() {
       long timestamp = timeGen();
       //获取当前时间戳如果小于上次时间戳，则表示时间戳获取出现异常
       if (timestamp < lastTimestamp) {
           System.err.printf("clock is moving backwards.  Rejecting requests until %d.", lastTimestamp);
           throw new RuntimeException(String.format("Clock moved backwards.  Refusing to generate id for %d milliseconds",
                   lastTimestamp - timestamp));
       }
       //获取当前时间戳如果等于上次时间戳（同一毫秒内），则在序列号加一；否则序列号赋值为0，从0开始。
       if (lastTimestamp == timestamp) {
           sequence = (sequence + 1) & sequenceMask;
           if (sequence == 0) {
               timestamp = tilNextMillis(lastTimestamp);
           }
       } else {
           sequence = 0;
       }
       //将上次时间戳值刷新
       lastTimestamp = timestamp;
       /**
         * 返回结果：
         * (timestamp - twepoch) << timestampLeftShift) 表示将时间戳减去初始时间戳，再左移相应位数
         * (datacenterId << datacenterIdShift) 表示将数据id左移相应位数
         * (workerId << workerIdShift) 表示将工作id左移相应位数
         * | 是按位或运算符，例如：x | y，只有当x，y都为0的时候结果才为0，其它情况结果都为1。
         * 因为个部分只有相应位上的值有意义，其它位上都是0，所以将各部分的值进行 | 运算就能得到最终拼接好的id
       */
       return ((timestamp - twepoch) << timestampLeftShift) |
               (datacenterId << datacenterIdShift) |
               (workerId << workerIdShift) |
               sequence;
   }
   //获取时间戳，并与上次时间戳比较
   private long tilNextMillis(long lastTimestamp) {
       long timestamp = timeGen();
       while (timestamp <= lastTimestamp) {
           timestamp = timeGen();
       }
       return timestamp;
   }
   //获取系统时间戳
   private long timeGen(){
       return System.currentTimeMillis();
   }
   //---------------测试---------------
   public static void main(String[] args) {
       IdWorker worker = new IdWorker(1,1,1);
       for (int i = 0; i < 30; i++) {
           System.out.println(worker.nextId());
       }
   }
  }