Hibernate--day01

作者: 键盘瞎 | 来源:发表于2017-02-10 16:25 被阅读246次

非本人总结的笔记，抄点笔记复习复习。感谢传智博客及黑马程序猿

记笔记啊记笔记

Hibernate的简介

什么是Hibernate

Hibernate：冬眠。对类进行实例化操作，这里类指的是之前说的javabean，javabean正确的叫法：实体类 entity
Hibernate是轻量级JavaEE应用的持久层解决方案，是一个关系数据库****ORM****框架
Hibernate具体实现的操作：
Hibernate的是开源轻量级的框架，对jdbc的代码进行封装，程序员不需要写底层的sql语句的代码，就可以实现对数据库的操作。实现对数据库的crud操作。

Javaee中有三层结构
Web层：struts2
Service层：spring
持久化层（dao层）：hibernate框架

Hibernate是使用在持久化层的框架

Jdbc底层代码的步骤：
1 加载驱动
2 创建连接
3 对sql语句进行预编译操作
4 设置参数，执行sql语句
5 释放资源

什么是ORM

ORM: object relational mapping , 对象关系映射
ORM 就是通过将Java对象映射到数据库表，通过操作Java对象，就可以完成对数据表的操作
做操作时候，有实体类，有数据库表，
在hibernate中，让实体类和数据库进行映射对应的关系（配置文件配置），
操作实体类就相当于操作数据库表中的数据

画图分析过程

流行数据库框架

JPA Java Persistence API.JPA通过JDK 5.0注解或XML描述对象－关系表的映射关系（只有接口规范）

Hibernate 最流行ORM框架，通过对象-关系映射配置，可以完全脱离底层SQL

MyBatis 本是apache的一个开源项目 iBatis，支持普通 SQL查询，存储过程和高级映射的优秀持久层框架

Apache DBUtils 、Spring JDBCTemplate

Hibernate的优点

Hibernate对JDBC访问数据库的代码做了封装，大大简化了数据访问层繁琐的重复性代码
Hibernate是一个基于jdbc的主流持久化框架，是一个优秀的orm实现，它很大程度的简化了dao层编码工作
Hibernate使用java的反射机制，而不是字节码增强程序类实现透明性
Hibernate的性能非常好，因为它是一个轻量级框架。映射的灵活性很出色。它支持很多关系型数据库，从一对一到多对多的各种复杂关系

Hibernate的版本

Struts2 版本 2.3.15
Hibernate 版本 3.6.10
Hibernate 3.x 4.x 5.x

1、下载hibernate3.x的开发包 (3.6.10)
http://sourceforge.net/projects/hibernate/files/hibernate3/

Hibernate开发包

2.jar包作用

Hibernate的jar包作用

Hibernate的入门案例

Hibernate的开发环境搭建

第一步：导入hibernate的核心的jar包

1、导入hibernate的核心的jar包

Hibernate核心jar包

2、导入lib里面的required里面的所有的jar包

required的jar包

jar包

3、导入lib里面jpa中所有的jar包

jpa的jar包

4、hibernate需要日志的输出

hibernate本身不支持日志输出，导入第三方支持日志输出的jar包（两个）

日志输出jar包

日志输出

5、导入数据库驱动的jar包

加上数据库驱动jar包一共有 11个

jar包

第二步：创建实体类 user类

package cn.itcast.entity;

import java.util.Date;

/**
 * 实体类
 */
public class User {

    private Integer id;
    private String username;
    private Date birthday;
    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    public String getUsername() {
        return username;
    }
    public void setUsername(String username) {
        this.username = username;
    }
    public Date getBirthday() {
        return birthday;
    }
    public void setBirthday(Date birthday) {
        this.birthday = birthday;
    }   
}

第三步：创建Hibernate的核心配置文件

1、Hibernate的核心配置文件

名称必须是 hibernate.cfg.xml，位置放到 src下面

hibernate.cfg.xml配置文件位置

2、在核心配置文件中引入dtd约束

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-configuration PUBLIC
    "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
    "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">

3、配置的相关信息

（1）配置数据库的相关内容

（2）配置hibernate的相关内容

<hibernate-configuration>
<session-factory>
    <!-- 配置数据库的相关信息 -->
    <property name="hibernate.connection.driver_class">
        com.mysql.jdbc.Driver
    </property>
    <property name="hibernate.connection.url">
        jdbc:mysql:///hibernate_day01
    </property>
    <property name="hibernate.connection.username">root</property>
    <property name="hibernate.connection.password">root</property>
    <!-- 配置数据库的方言 
        比如在mysql里面有关键字  limit ，只能使用在mysql里面
        让hibernate识别到不同数据库自己特有的语句
    -->
    <property name="hibernate.dialect">
        org.hibernate.dialect.MySQLDialect
    </property>

    <!-- 配置hibernate的相关信息 -->
    <!-- 是否显示底层的sql语句 -->
    <property name="hibernate.show_sql">true</property>
    <!-- 是否格式化sql语句 -->
    <property name="hibernate.format_sql">true</property>
    <!-- hibernate会帮自己创建数据库表，默认不会创建，需要配置 
        值 update： 如果数据库里面不存在表，创建；如果已经存在，更新
    -->
    <property name="hibernate.hbm2ddl.auto">update</property>
    
    <!-- 配置事务自动提交 -->
    <!-- <property name="hibernate.connection.autocommit">true</property> -->
    
    <!-- 引入映射配置文件 -->
    <mapping resource="cn/itcast/entity/User.hbm.xml" />
</session-factory>
</hibernate-configuration>

第四步：配置实体类和数据表映射关系

1、创建映射配置文件，文件格式xml

但是这个文件映射配置文件名称和位置没有要求，一般建议：命名(实体类.hbm.xml) 位置：放到实体类所在的包里面

映射文件位置

2、映入dtd约束

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC 
    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
    "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">

3、配置实体类和表映射关系

<hibernate-mapping>
    <!-- 配置实体类名称和表名称对应 
        name：实体类全路径
        table：表名称
    -->
    <class name="cn.itcast.entity.User" table="USER">
        <!-- 
            在hibernate中要求每个表有一个唯一标识 
         -->
         <id name="id" column="ID">
            <generator class="identity"></generator>
         </id>
         <!-- 配置其他的属性和其他字段映射 
            name: 实体类属性名称
            column: 表里面字段名称
            
            细节问题： 
             1 propery里面有 type属性，指定字段类型，但是可以省略
             2 column属性，实体类属性名称和字段名称一样，column可以省略
         -->
         <property name="username" column="USERNAME"></property>
         <property name="birthday" column="BIRTHDAY"></property>
    </class>    
</hibernate-mapping>

第五步：在Hibernate的核心配置文件中映入映射文件

因为hibernate只会加载核心配置文件，其他文件不会加载

如果没有在核心文件中引入映射文件，出现错误

可以在myeclipse 直接把映射文件拖到核心配置文件里就可以了

异常

<!--
    引入映射配置文件 -->
      <mapping resource="cn/itcast/entity/User.hbm.xml"
/>

实现添加操作

使用hibernate代码实现crud操作，步骤是固定
第一步加载核心配置文件
第二步创建sessionFactory
第三步使用sessionFactory创建session
第四步开启事务
第五步写具体逻辑（crud）
第六步提交事务
第七步关闭资源

  package cn.itcast.hibernate.test;
  import java.util.Date;
  import java.util.List;
  import org.hibernate.Query;
  import org.hibernate.Session;
  import org.hibernate.SessionFactory;
  import org.hibernate.Transaction;
  import org.hibernate.cfg.Configuration;
  import org.junit.Test;

  import cn.itcast.entity.User;
  import cn.itcast.utils.HibernateUtils;

  /**

 实现hibernate的crud的操作
   */
  public class TestDemo1 {

      //实现添加操作
      @Test
      public void add() {
          //加载核心配置文件
          Configuration cfg = new Configuration();
          cfg.configure();
          //创建sessionFactory
          SessionFactory sessionFactory = cfg.buildSessionFactory();
          //打开session
          Session session = sessionFactory.openSession();
          //开启事务
          Transaction tx = session.beginTransaction();
          //写添加逻辑
          //项数据库设置值
          User user = new User();
          user.setUsername("lucy");
          user.setBirthday(new Date());
          //调用session里面的方法 save方法,保存的意思
          session.save(user);
          //提交事务
          tx.commit();
          //关闭连接
          session.close();
          sessionFactory.close();
      }
  }

Hibernate的配置文件详解（hibernate.cfg.xml）

1、hibernate中加载核心配置文件

要求

位置：放到src下
名称：必须是hibernate.cfg.xml

配置三部分

配置数据库信息（必须的）
配置hibernate的相关信息（不是必须的）
配置引入的映射文件（如果有映射文件必须配置）

2、映射配置文件

位置和名称没有固定要求

映射配置文件

核心API使用

Configuration类（管理Hibernate的配置信息）

Configuration 类负责管理 Hibernate 的配置信息。包括如下内容：

加载hibernate.properties 和 hibernate.cfg.xml

持久化类与数据表的映射关系（*.hbm.xml文件）

创建Configuration 的两种方式

属性文件（hibernate.properties）:

Configuration cfg = new Configuration(); //手动加载hbm

Xml文件（hibernate.cfg.xml）

Configuration cfg = newConfiguration().configure();

在核心配置文件中引入映射配置文件
之前做法：

语句

还有另外方式加载映射配置文件（了解）

加载配置文件

SessionFactory接口（获取Session对象）

Configuration对象根据当前的配置信息生成SessionFactory对象

SessionFactory对象中保存了当前数据库配置信息和所有映射关系以及预定义的SQL语句

SessionFactory对象是线程安全的

SessionFactory还负责维护Hibernate的二级缓存

Configuration configuration = new Configuration().configure();

创建sessionFactory

SessionFactory sessionFactory = configuration.buildSessionFactory();

可以通过SessionFactory对象获得Session对象

Session session = sessionFactory.openSession();

构造SessionFactory 很消耗资源，一般情况下一个应用只初始化一个

☆抽取HibernateUtils 用来提供Session对象

创建HibernateUtils

package cn.itcast.utils;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;

/**
 * 创建sessionFactory对象
 */
public class HibernateUtils {
    
    static Configuration cfg = null;
    static SessionFactory sessionFactory  = null;
    //静态代码块
    static {
        cfg = new Configuration();
        cfg.configure();
        //创建sessionFactory
        sessionFactory  = cfg.buildSessionFactory();
    }

    //提供得到Session的方法
    public static Session getSession() {
        Session session = sessionFactory.openSession();
        return session;
    }
}

使用工具类得到session对象

package cn.itcast.hibernate.test;

import java.util.Date;
import java.util.List;

import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
import org.junit.Test;

import cn.itcast.entity.User;
import cn.itcast.utils.HibernateUtils;

/**
 * 实现hibernate的crud的操作
 */
public class TestDemo1 {

    //实现添加操作
    @Test
    public void addTestSession() {
        //根据工具类得到session对象
        Session session = HibernateUtils.getSession();
        //开启事务
        Transaction tx = session.beginTransaction();
        //写添加逻辑
        User user = new User();
        user.setUsername("jacktom");
        user.setBirthday(new Date());
        //调用session里面的方法 save方法
        session.save(user);
    
        //提交事务
        tx.commit();
        //关闭连接
        session.close();
        //sessionFactory不需要关闭了
//      sessionFactory.close();
    }
}

Session接口（CRUD操作）

调用Session里面的方法，实现crud操作

Session是单线程对象，只能有一个操作时候，不能同时多个操作使用，不要把Session变量定义成成员变量，每次使用都创建新对象，相当于JDBC的Connection

Session是应用程序与数据库之间交互操作的一个单线程对象，是 Hibernate 运作的中心；Session是线程不安全的

所有持久化对象必须在session 的管理下才可以进行持久化操作

Session 对象有一个一级缓存，显式执行 flush 之前，所有的持久化操作的数据都缓存在 session 对象处

持久化类与 Session 关联起来后就具有了持久化的能力

常用方法

方法	作用
save()/persist() 、update() 、saveOrUpdate()	增加和修改对象
delete()	删除对象
get()/load()	根据主键查询
createQuery()、createSQLQuery()	数据库操作对象
createCriteria	条件查询

Transaction接口(事务)

代表数据库操作的事务对象

Transactiontransaction = session.beginTransaction();

提供事务管理的方法

commit():提交相关联的session实例

rollback():撤销事务操作

wasCommitted():检查事务是否提交

回顾：
什么是事务

两个操作：提交和回滚

事务特性：原子性、一致性、隔离性、持久性

不考虑隔离性产生问题：脏读、不可重复读、虚读

在jdbc中，使用jdbc代码实现添加操作，默认事务自动提交

在hibernate中，事务默认不是自动提交的，需要手动配置，手动代码提交

如果没有开启事务，那么每个Session的操作，都相当于一个独立的事务

让hibernate事务提交有两种：
第一种：通过配置方式设置hibernate是自动提交

自动提交

产生问题：第一个save方法添加数据，但是添加之后出现异常，第二个添加不能完成

示例

第二种：手动代码方式控制事务

  package cn.itcast.hibernate.test;

  import java.util.Date;
  import java.util.List;

  import org.hibernate.Query;
  import org.hibernate.Session;
  import org.hibernate.SessionFactory;
  import org.hibernate.Transaction;
  import org.hibernate.cfg.Configuration;
  import org.junit.Test;

  import cn.itcast.entity.User;
  import cn.itcast.utils.HibernateUtils;

  /**
   *实现hibernate的crud的操作
   *
   */
  public class TestDemo1 {

      //事务操作
      @Test
      public void testTx() {

          //根据工具类得到session对象

          Session session = null;
          //开启事务
          Transaction tx = null;
          try {

              session = HibernateUtils.getSession();
              tx = session.beginTransaction();

              //实现两次添加操作
              //写添加逻辑

              User user = new User();
              user.setUsername("jacktom");
              user.setBirthday(new Date());

              //调用session里面的方法 save方法
              session.save(user);
      
              //发生异常
              int a = 1/0;
            
              User user1 = new User();
              user1.setUsername("lilei");
              user1.setBirthday(new Date());

              //调用session里面的方法 save方法
              session.save(user1);

              //提交
              tx.commit();
          }catch(Exceptione) {
              e.printStackTrace();
              //回滚
              tx.rollback();
          }finally {
              //关闭session
              session.close();
          }
      }
  }

Query接口(HQL语句查询操作)

Query代表面向对象的一个Hibernate查询操作

session.createQuery 接受一个HQL语句

HQL是Hibernate Query Language缩写，语法很像SQL语法，但是完全面向对象的

使用Query对象步骤

    获得Hibernate Session对象

    编写HQL语句

调用session.createQuery 创建查询对象

如果HQL语句包含参数，则调用Query的setXXX设置参数

调用Query对象的list() 或uniqueResult() 方法执行查询

Query还包含两个方法用于控制返回结果

setFirstResult(intfirstResult) 设置返回结果从第几条开始

setMaxResults(intmaxResults) 设置本次返回结果记录条数

实现查询的操作

Query query = session.createQuery(“hql语句”)

query.list(); 返回集合

package cn.itcast.hibernate.test;


import java.util.Date;
import java.util.List;

import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
import org.junit.Test;

import cn.itcast.entity.User;
import cn.itcast.utils.HibernateUtils;

/**
 * 实现hibernate的crud的操作
 */
public class TestDemo1 {
    
    //query使用
    @Test
    public void testQuery() {
        Session session = null;
        Transaction tx = null;
        try {
            session = HibernateUtils.getSession();
            tx = session.beginTransaction();
            //查询表中所有的记录
            //hql语句   User是实体类的名称
            Query query = session.createQuery("from User");
            List<User> list = query.list();
            for (User user : list) {
                System.out.println(user);
            }
            
            tx.commit();
        }catch(Exception e) {
            tx.rollback();
        }finally {
            session.close();
        }       
    }
}

Hibernate实现crud操作（重点）

功能具体介绍

（1）添加操作save

调用Session里的save（实体类对象），不需要设置对象的id值

User user = new User();
user.setUsername("jackTom");
user.setBirthday(new Date());
session.save(user);//调用Session里的save方法

（2）根据主键查询操作

调用Session里面的get方法

get方法里面有两个参数：

参数	值
参数一	返回实体类的Class
参数二	id值

User user = (User)session.get(User.class, 1);//调用Session里面的get方法

（3）修改操作update

调用session里面的方法update方法
update方法里面传递参数有一个：
修改之后的值，封装到实体类对象，这个对象中必须有id值

做修改操作时候实现的步骤：首先根据id把原始信息查询出来其次，设置要修改的值最后，调用update方法实现

User user = new User();
user.setId(2);
user.setUsername("东方不败");

session.update(user);

img
做修改操作时候实现的步骤：
首先根据id把原始信息查询出来
其次，设置要修改的值
最后，调用update方法实现

//修改：根据id修改
//修改id=1的username，修改为其他值
//根据id查询出来对象
User user = (User)session.get(User.class, 1);
//设置对象中，要修改的值
user.setUsername("大腹便便");
//调用update方法实现
session.update(user);

img

（4）删除操作delete

调用session里面的方法 delete方法

Delete方法中传递一个参数：实体类对象，对象中至少要有一个id值

实现方式有两种
第一种先查询出来对象，再调用delete方法删除

//删除id是4的记录
//查询id是4的记录
User user = (User)session.get(User.class, 4);
//调用delete方法
session.delete(user)

img

第二种创建对象，设置id值，再调用delete方法删除

//删除id是3的记录
//创建对象
User user = new User();
//设置id值
user.setId(3);
//调用delete方法删除
session.delete(user);

（5）查询操作(3种)hql sql qbc

查询表中所有记录

第一种使用hql查询

//创建query对象
Query query = session.createQuery("from User");
//调用query里面list方法返回list集合
List<User> list = query.list();
for(User user : list){
    System.out.println(user);
}

第二种使用本地sql查询（会用）

//创建对象
SQLQuery query = session.createSQLQuery("select * from user");
//调用query里面的方法
//返回list集合，每部分不是对象形式，而是数据形式
List<Object[]> list = query.list();
for(Object[] objects : list) {
    System.out.println(Arrays.toString(objects));
}

crud代码演示:

package cn.itcast.hibernate.test;


import java.util.Arrays;
import java.util.List;

import org.hibernate.Query;
import org.hibernate.SQLQuery;
import org.hibernate.Session;
import org.hibernate.Transaction;
import org.junit.Test;

import cn.itcast.entity.User;
import cn.itcast.utils.HibernateUtils;

/**
 * 实现hibernate的crud的操作
 */
public class TestDemo2 {
    
    //根据主键查询
    @Test
    public void testGet() {
        Session session = null;
        Transaction tx = null;
        try {
            session = HibernateUtils.getSession();
            tx = session.beginTransaction();
            
            //调用session里面get方法
            User user = (User) session.get(User.class, 1);
            
            System.out.println(user);
            
            tx.commit();
        }catch(Exception e) {
            tx.rollback();
        }finally {
            session.close();
        }       
    }   

    //本地sql查询
    @Test
    public void testSQL() {
        Session session = null;
        Transaction tx = null;
        try {
            session = HibernateUtils.getSession();
            tx = session.beginTransaction();
            
            //创建对象
            SQLQuery query = session.createSQLQuery("select * from user");
            //调用query里面的方法
            //返回list里面，每部分不是对象形式，而是数组形式
            List<Object[]> list = query.list();
            for (Object[] objects : list) {
                System.out.println(Arrays.toString(objects));
            }
            
            tx.commit();
        }catch(Exception e) {
            tx.rollback();
        }finally {
            session.close();
        }   
    }
    
    //hql语句查询   Query
    @Test
    public void testHQL() {
        Session session = null;
        Transaction tx = null;
        try {
            session = HibernateUtils.getSession();
            tx = session.beginTransaction();
            
            //创建query对象
            Query query = session.createQuery("from User");
            //调用query里面list方法返回list集合
            List<User> list = query.list();
            for (User user : list) {
                System.out.println(user);
            }
            
            tx.commit();
        }catch(Exception e) {
            tx.rollback();
        }finally {
            session.close();
        }   
    }
    
    //第二种直接删除操作(不建议使用)
    @Test
    public void testDeleteDemo2() {
        Session session = null;
        Transaction tx = null;
        try {
            session = HibernateUtils.getSession();
            tx = session.beginTransaction();
            
            //删除id是3的记录
            //创建对象
            User user = new User();
            //设置id值
            user.setId(2);
            //调用delete方法删除
            session.delete(user);
            
            tx.commit();
        }catch(Exception e) {
            tx.rollback();
        }finally {
            session.close();
        }   
    }
    
    //第一种删除操作(先查询在删除方法)建议使用
    @Test
    public void testDeleteDemo1() {
        Session session = null;
        Transaction tx = null;
        try {
            session = HibernateUtils.getSession();
            tx = session.beginTransaction();
            
            //删除id是4的记录
            //查询id是4的对象
            User user = (User) session.get(User.class, 4);
            //调用delete方法
            session.delete(user);
            
            tx.commit();
        }catch(Exception e) {
            tx.rollback();
        }finally {
            session.close();
        }   
    }
    
    //修改操作(先查询在修改)
    @Test
    public void testUpdateSuccess() {
        Session session = null;
        Transaction tx = null;
        try {
            session = HibernateUtils.getSession();
            tx = session.beginTransaction();
            
            //修改：根据id修改
            // 修改id=1的username，修改为 其他值
            //根据id查询出来对象
            User user = (User) session.get(User.class, 1);
            //设置对象中，要修改成的值
            user.setUsername("大腹便便");
            //调用update方法实现
            session.update(user);
            
            tx.commit();
        }catch(Exception e) {
            tx.rollback();
        }finally {
            session.close();
        }       
    }
    
    //修改操作(直接修改)
    @Test
    public void testUpdate() {
        Session session = null;
        Transaction tx = null;
        try {
            session = HibernateUtils.getSession();
            tx = session.beginTransaction();
            
            //修改：根据id修改
            // 修改id=2的username，修改为 东方不败
            //创建实体类对象
            //操作实现修改，但是问题：
            //调用update方法之后，把表里面所有字段都修改
            //只是设置id和username值，根据id修改username和birthday
            User user = new User();
            user.setId(2);
            user.setUsername("东方不败");
            
            session.update(user);
            
            tx.commit();
        }catch(Exception e) {
            tx.rollback();
        }finally {
            session.close();
        }       
    }
    
}

基本数据类型和包装类使用

回顾：
Java中基本数据类型有8个 byte short int long float double char boolean
对应的包装类：
int---Integer char---Character，其他是首字母大写

在实体类中使用基本数据类型还是使用包装类？
都是使用包装类。

考试成绩。
可以使用类型 int 和包装类 Integer
一般都使用包装类

表示学生得分是 0 分
int score = 0;
Integer score = 0;

表示学生是否参加考试
int score = 0;
Integer score = null;

Hibernate的主键oid

什么是oid

在java中，区分不同的对象，根据对象的地址
在数据库中，区别不同的记录，根据主键id值

现在是实体类和数据库映射关系
在java中没有主键，在数据库里面没有地址

使用hibernate的OID区别不同的对象，如果OID相同的就是一个对象

自然主键和代理主键
自然主键：
Oid和业务相关的属性或者字段
比如人的身份证号码

代理主键：
Oid和业务不相关的属性和字段
比如写id

配置Hibernate的oid

<id name="id" column="ID">
    <generator class="native"></generator>
</id>

使用id标签

有name属性值写实体类属性名称

Column属性值写数据库表字段

在id标签里面使用 generator，配置oid

有class属性值 oid主键的生成策略

Hibernate的oid主键生成策略

Increment和identity

使用increment作为生成策略，生成建表语句中没有AUTO_INCREMENT自动增长

使用identity作为生成策略，生成的语句中有AUTO_INCREMENT自动增长

hibernate的主键生成策略

详解:

increment标识符生成器

identity标识符生成器

sequence标识符生成器

native标识符生成器

uuid32位标识符生成器

assigned标识符生成器