Hibernate--day01

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


记笔记啊记笔记

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的优点

  1. Hibernate对JDBC访问数据库的代码做了封装，大大简化了数据访问层繁琐的重复性代码
  2. Hibernate是一个基于jdbc的主流持久化框架，是一个优秀的orm实现，它很大程度的简化了dao层编码工作
  3. Hibernate使用java的反射机制，而不是字节码增强程序类实现透明性
  4. 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中加载核心配置文件

要求

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

配置三部分

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

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标识符生成器
最后编辑于 ：
©著作权归作者所有,转载或内容合作请联系作者
  • 人面猴
    序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
    沈念sama阅读 194,390评论 5赞 459
  • 死咒
    序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
    沈念sama阅读 81,821评论 2赞 371
  • 救了他两次的神仙让他今天三更去死
    文/潘晓璐 我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
    开封第一讲书人阅读 141,632评论 0赞 319
  • 道士缉凶录：失踪的卖姜人
    文/不坏的土叔 我叫张陵，是天一观的道长。 经常有香客问我，道长，这世上最难降的妖魔是什么？ 我笑而不...
    开封第一讲书人阅读 52,170评论 1赞 263
  • 港岛之恋（遗憾婚礼）
    正文 为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
    茶点故事阅读 61,033评论 4赞 355
  • 恶毒庶女顶嫁案：这布局不是一般人想出来的
    文/花漫 我一把揭开白布。 她就那样静静地躺着，像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上，一...
    开封第一讲书人阅读 46,098评论 1赞 272
  • 城市分裂传说
    那天，我揣着相机与录音，去河边找鬼。 笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。 我是一名探鬼主播，决...
    沈念sama阅读 36,511评论 3赞 381
  • 双鸳鸯连环套：你想象不到人心有多黑
    文/苍兰香墨 我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
    开封第一讲书人阅读 35,204评论 0赞 253
  • 万荣杀人案实录
    序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
    沈念sama阅读 39,479评论 1赞 290
  • 护林员之死
    正文 独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 34,572评论 2赞 309
  • 白月光启示录
    正文 我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 36,341评论 1赞 326
  • 活死人
    序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
    沈念sama阅读 32,213评论 3赞 312
  • 日本核电站爆炸内幕
    正文 年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
    茶点故事阅读 37,576评论 3赞 298
  • 男人毒药：我在死后第九天来索命
    文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 28,893评论 0赞 17
  • 一桩弑父案，背后竟有这般阴谋
    文/苍兰香墨 我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 30,171评论 1赞 250
  • 情欲美人皮
    我被黑心中介骗来泰国打工， 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。 一个月前我还...
    沈念sama阅读 41,486评论 2赞 341
  • 代替公主和亲
    正文 我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
    茶点故事阅读 40,676评论 2赞 335

推荐阅读更多精彩内容

  • Hibernate随笔
    Hibernate: 一个持久化框架 一个ORM框架 加载：根据特定的OID,把一个对象从数据库加载到内存中OID...
    JHMichael阅读 1,948评论 0赞 27
  • Struts、Spring、Hibernate、Mybatis框技术 面试题
    （一）Struts、Spring、Hibernate、Mybatis框技术 1.Struts2.0有几种标签库 【...
    独云阅读 3,208评论 0赞 62
  • Java初级面试题
    1. Java基础部分 基础部分的顺序：基本语法，类相关的语法，内部类的语法，继承相关的语法，异常的语法，线程的语...
    子非鱼_t_阅读 31,497评论 18赞 399
  • Hibernate 入门
    本文包括： 1、CRM 项目的整体介绍 2、Hibernate 框架概述 3、Hibernate 快速入门 4、H...
    廖少少阅读 3,461评论 9赞 66
  • 这样改变自己
    改一个毛病， 定一个目标， 做一番尝试， 累一会自己， 笑一下曾经。 这样改变自己， 你离梦想还远， 请再接再厉……
    小剧在成长阅读 161评论 0赞 4