AI 助理
备案控制台
开发者社区 数据库 文章 正文

Hibernate（4）——主键生成策略、CRUD 基础API区别的总结 和 注解的使用

2016-05-19 2274
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
本文涉及的产品
云数据库 RDS SQL Server，基础系列 2核4GB
推荐场景：
SQL Server性能诊断案例分析
RDS SQL Server Serverless，2-4RCU 50GB 3个月
推荐场景：
云数据库 RDS MySQL，集群系列 2核4GB
推荐场景：
搭建个人博客
简介：

俗话说，自己写的代码，6个月后也是别人的代码……复习！复习！复习！涉及的知识点总结如下：

  • hibernate的主键生成策略
  • UUID
  • 配置的补充：hbm2ddl.auto属性用法
  • 注解还是配置文件
  • hibernate注解的基本用法
  • 使用Session API CRUD操作对象，以及对象状态的转换
  • hibernate缓存的概念
  • get()/load()的区别到底是什么，源码分析
  • 代理模式实现的懒加载
  • saveOrUpdate()/merge()的区别 

　　

　　Assigned(常用，一般情况使用很方便)：

　　由程序生成主键值，并且在save()之前指定，否则会抛出异常。

　　特点：主键的生成值完全由用户决定，与底层数据库无关。用户需要维护主键值，在调用session.save()之前要指定主键值。唯一的例外：int auto_increment类型主键除外，在程序中不用指定主键值，直接看代码：

sid是主键，且是int类型，设置为自动增长。

复制代码 
/**
 * StudentDao
 *
 * @author Wang Yishuai.
 * @date 2016/3/11 0011.
 * @Copyright(c) 2016 Wang Yishuai,USTC,SSE.
 */
public class StudentDao {
    private static final Logger LOG = LoggerFactory.getLogger(StudentDao.class);

    private Session session;

    @Before
    public void init() {
        Configuration configuration = new Configuration().configure();
        SessionFactory sessionFactory = configuration.buildSessionFactory();
        this.session = sessionFactory.getCurrentSession();
    }

    @After
    public void clear() {

    }

    @Test
    public void save() {
        Transaction transaction = session.beginTransaction();

        Student student = new Student();

        try {
            //student.setSname("dashuai");
            student.setSname("dadadad");
            session.save(student);
            transaction.commit();
        } catch (Exception e) {
            LOG.error("save error", e);
            transaction.rollback();
        }
    }
}
复制代码

配置文件设置：

复制代码 
<hibernate-mapping>
    <!-- class 里面的属性必须和对应的类名，表名保持一致，实现映射-->
    <class name="zhujian.vo.Student" table="students">
        <!-- id代表数据库表的主键， name="userId"，对应数据库表里的字段column="userId"-->
        <id name="sid" column="sid" type="string">
            <generator class="assigned"/>
        </id>
        <!-- 数据库里其他普通字段和实体属性的映射，属性的类型需要小写-->
        <property name="sname" column="sname" type="string"/>
    </class>
</hibernate-mapping>
复制代码

先后保存两个学生对象，没有错误，如下：

即使我设置了主键生成策略为assigned，因为学生表的sid是自动增长且为int类型，所以程序中不用人工指定sid值，这是一个例外情况。其他情况如果设置主键为asigned策略，必须手动设主键值，否则会出问题。

　　把sid的自动增长设置取消，再运行之前的代码，会发生问题：如果不设置sid（主键）值，则无法成功插入数据，且会生成主键为0的数据记录（if之前没有），本地测试没有报错，但是无法成功插入。

　　把主键改为String（varchar）类型（对象映射文件和实体类也需要修改），再运行之前的代码，同样只能插入sid为0的记录（if之前没有），其他的无法继续插入。若改为手动设置主键值，则恢复正常。

 

　　Increment（MySQL不适用，集群不适用，多进程不适用，与底层数据库有关）

　　Increment方式对主键值采取自动增长的方式生成新的主键值，但要求底层数据库支持Sequence序列。如Oracle，DB2等。需要在映射文件xxx.hbm.xml中加入Increment标志符的设置。

　　特点：由Hibernate本身维护，适用于所有的数据库，不适合多进程并发更新数据库，适合单一进程访问数据库。不能用于群集环境。

　　比如现在有4个数据库的集群，共享一张学生表，我从中查找某个编号（主键）为1000的学生，如果使用的hibernate的主键生成策略为increment，则无法保证编号1000的学生在集群里是唯一的。

　　 Identity (常用，与底层数据库有关，oracle无法使用)

　　Identity根据底层数据库支持自动增长，无需手动设置主键，但不同的数据库用不同的主键增长方式，移植性不好。

　　特点：与底层数据库有关，适用于MySQL、DB2、MS SQL Server，采用数据库生成的主键，用于为long、short、int类型生成唯一标识。使用SQL Server 和 MySQL 的自增字段，这个方法不能放到 Oracle 中，Oracle 不支持自增字段，要设定sequence（MySQL 和 SQL Server 中很常用），Identity无需Hibernate和用户的干涉，使用较为方便，但不便于在不同的数据库之间移植程序。

 

　　Sequence (常用)

　　Sequence需要底层数据库支持Sequence方式，例如Oracle数据库等。

　　特点：需要底层数据库的支持序列，支持序列的数据库有DB2、PostgreSql、Qracle、SAPDb等在不同数据库之间移植程序，特别从支持序列的数据库移植到不支持序列的数据库需要修改配置文件。比如：Oracle：create sequence seq_name increment by 1 start with 1; 需要主键值时可以调用seq_name.nextval或者seq_name.curval得到，数据库会帮助我们维护这个sequence序列，保证每次取到的值唯一，如：insert into tbl_name(id, name) values(seq_name.nextval, ‘Jimliu’);

　　配置：

<id name="id" column="id" type="long">
<generator class="sequence">
<param name="sequence">seq_name</param>
</generator>
</id>

　　

　　Native(常用，推荐使用，移植性好，也适合多数据库)

　　Native主键生成方式会根据不同的底层数据库自动选择Identity、Sequence、Hilo主键生成方式。

　　特点：根据不同的底层数据库采用不同的主键生成方式。由于Hibernate会根据底层数据库采用不同的映射方式，因此便于程序移植，项目中如果用到多个数据库时，可以使用这种方式。

　　配置：

  View Code

　　

　　UUID（常用在网络环境，但是耗费存储空间）

　　UUID使用128位UUID算法生成主键，能够保证网络环境下的主键唯一性，也就能够保证在不同数据库及不同服务器下主键的唯一性。

　　特点;能够保证数据库中的主键唯一性，生成的主键占用比较多的存贮空间。 

　　配置：

<id name="id" column="id">
<generator class="uuid.hex" /></id>

 

　　Hilo（不常用）

　　使用高低位算法生成主键，高低位算法使用一个高位值和一个低位值，然后把算法得到的两个值拼接起来作为数据库中的唯一主键。Hilo方式需要额外的数据库表和字段提供高位值来源。默认请况下使用的表是hibernate_unique_key，默认字段叫作next_hi。next_hi必须有一条记录否则会出现错误。

　　特点：和底层数据库无关，但是需要额外的数据库表的支持，能保证同一个数据库中主键的唯一性，但不能保证多个数据库之间主键的唯一性。Hilo主键生成方式由Hibernate 维护，所以Hilo方式与底层数据库无关，但不应该手动修改hilo算法使用的表的值，否则会引起主键重复的异常。 

 

　　配置的补充：hbm2ddl.auto属性用法

　　在项目的配置文件里设置：<property name="hbm2ddl.auto">update</property>，属性含义的解释：

  • create：表示启动的时候先drop数据库，再create。
  • create-drop: 也表示创建，只不过再系统关闭前执行一下drop。
  • update: 这个操作启动的时候会去检查schema是否一致，如果不一致会做scheme更新。
  • validate: 启动时验证现有schema与你配置的hibernate是否一致，如果不一致就抛出异常，并不做更新。

 

　 在Hibernate是用映射文件好还是用注解的方式好？

　　两种方式本质上没区别。使用元数据可以在写实体的同时配好映射，而 XML 则需要来回切换配置和实体，不太方便。从维护上来说，注解更好。因为代码和“配置”在一起，不容易漏掉信息。从这一点上来说，注解必须是第一选择。但是也有人说到这样一个问题，如果使用注解，有很大可能会违反开闭原则，使用配置文件则不会。闲言少叙，看代码：

复制代码 
<?xml version='1.0' encoding='UTF-8'?>
<!DOCTYPE hibernate-configuration PUBLIC
          "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
          "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
    <session-factory name="MySQL">
        <property name="connection.driver_class">com.mysql.jdbc.Driver</property>
        <property name="connection.url">jdbc:mysql://localhost:3306/bbs</property>
        <property name="connection.username">root</property>
        <property name="connection.password">123</property>
        <property name="dialect">org.hibernate.dialect.MySQL5Dialect</property>
        <property name="show_sql">true</property>
        <property name="format_sql">true</property>
        <property name="hbm2ddl.auto">update</property>
        <property name="current_session_context_class">thread</property>

        <mapping class="net.nw.vo.Students"/>
    </session-factory>
</hibernate-configuration>
复制代码

写好配置文件，代码如下：

复制代码 
package net.nw.vo;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;

//学生实体类
@Entity
public class Students {
    private int sid;

    private String sname;
    
    @Id
    @GeneratedValue(strategy=GenerationType.AUTO)
    public int getSid() {
        return sid;
    }

    public void setSid(int sid) {
        this.sid = sid;
    }

    public String getSname() {
        return sname;
    }

    public void setSname(String sname) {
        this.sname = sname;
    }
}
复制代码

测试：

复制代码 
import net.nw.vo.Students;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.AnnotationConfiguration;


public class HibernateTest {

    public static void main(String[] args) {
        AnnotationConfiguration annotationConfiguration = new AnnotationConfiguration().configure();
        SessionFactory sessionFactory = annotationConfiguration.buildSessionFactory();
        Session session = sessionFactory.getCurrentSession();
        Transaction transaction = session.beginTransaction();

        try {
            Students s = new Students();
            //s.setSid(1);
            s.setSname("xxxx");
            session.save(s);
            transaction.commit();
        } catch (Exception ex) {
            transaction.rollback();
            ex.printStackTrace();
        }
    }
}
复制代码

执行成功！本地测试成功插入xxxxx（接之前的bbs数据库表students）：

　　小结：

  • 使用AnnotationConfiguration创建config对象代替之前的Configuration方式（hibernate3的方式）。
  • hibernate4中新增了ServiceRegistry接口。4.0以后改为使用ServiceRegistry 注册：
复制代码 
Configuration cfg = new Configuration().configure(); 
ServiceRegistry serviceRegistry = new ServiceRegistryBuilder().applySettings(cfg.getProperties()).buildServiceRegistry(); 
SessionFactory factory = cfg.buildSessionFactory(serviceRegistry); 
Session s = factory.openSession();
复制代码
  • @Entity——必选的注解，在class类体上面，注解将一个类声明为一个实体bean。属性 name 可选，对应数据库中的一个表。若表名与实体类名相同，则可以省略。

  • @Table(name="",catalog="",schema="") ——该注解可选，通常和@Entity 配合使用，只能标注在实体的 class 定义处，表示实体对应的数据库表的信息。属性：

    • name - 可选，表示表的名称，默认地，表名和实体名称一致，只有在不一致的情况下才需要指定表名

    • catalog - 可选，表示Catalog名称，默认为 Catalog("").

    • schema - 可选 , 表示 Schema 名称 , 默认为Schema("").

  • @Id——必选，一般加在getter方法上面， 定义了映射到数据库表的主键的属性，一个实体只能有一个属性被映射为主键，置于get方法前。
  • @GeneratedValue(strategy=GenerationType,generator="") ——可选，用于定义主键生成策略。属性：
    • Strategy - 表示主键生成策略，取值有：
      • GenerationType.AUTO - 根据底层数据库自动选择（默认），若数据库支持自动增长类型，则为自动增长。

      • GenerationType.INDENTITY - 根据数据库的Identity字段生成，支持DB2、MySQL、MS、SQL Server、SyBase与HyperanoicSQL数据库的Identity类型主键。

      • GenerationType.SEQUENCE - 使用Sequence来决定主键的取值，适合Oracle、DB2等 ，支持Sequence的数据库，一般结合@SequenceGenerator使用。(Oracle没有自动增长类型，只能用Sequence)

      • GenerationType.TABLE - 使用指定表来决定主键取值，结合@TableGenerator使用。如：

        @Id

@TableGenerator(name="tab_cat_gen",allocationSize=1)

@GeneratedValue(Strategy=GenerationType.Table)

    • Generator - 表示主键生成器的名称，这个属性通常和ORM框架相关 , 例如：Hibernate 可以指定 uuid 等主键生成方式

  • @Version——可以在实体bean中使用@Version注解,通过这种方式可添加对乐观锁定的支持。

  • @Basic ——用于声明属性的存取策略：

    • @Basic(fetch=FetchType.EAGER)   即时获取（默认的存取策略）

    • @Basic(fetch=FetchType.LAZY)    延迟获取

  • @Temporal ——用于定义映射到数据库的时间精度：@Temporal(TemporalType=TIME) 时间、@Temporal(TemporalType=DATE) 日期、@Temporal(TemporalType=TIMESTAMP) 两者兼具

 

　　注解太多了，以后一一说明。

  • 使用注解，在Hibernate.cfg.xml中同样也需要注册实体类。当然配置文件不用配，只是还是需要引入实体类的关系，<mapping class="net.nw.vo.Students"/>，配置文件方式的resource=改为了class=。

 

　　使用session api实现crud

　　结合之前的总结，看看crud时对象状态的转换关系。直接看代码：

  • create，session.save(obj);，注意这里面的玄机：
    • 如果当前对象是持久态，则执行save方法，会自动触发Update语句的执行，而不是insert语句。
    • 如果当前对象为瞬时态，则执行save方法，会立刻执行insert语句，使得对象从瞬时态转换为持久态。
复制代码 
    @Test
    public void save() {
        Transaction transaction = session.beginTransaction();
        Student student = new Student();

        try {
            student.setSname("xiaoli");
            // 之前的student是瞬时态的
            session.save(student);
            // 之后变为持久态
            transaction.commit();
        } catch (Exception e) {
            LOG.error("save error", e);
            transaction.rollback();
        }
    }
复制代码

debug一下，验证之前的理论：在sava处断点，step over之后，立即控制台打印了insert into students（sname） values（？）。后台数据库也插入了xiaoli。

　　下面看如果当前对象是持久态的情况：

复制代码 
    @Test
    public void save() {
        Transaction transaction = session.beginTransaction();
//        Student student = new Student();

        try {
//            student.setSname("xiaoli");

            // 从数据库读取xiaoli，该对象是持久态的
            Student student = (Student) session.get(Student.class, 7);
            // 重新赋值，再保存
            student.setSname("小李");
            session.save(student);
            transaction.commit();
        } catch (Exception e) {
            LOG.error("save error", e);
            transaction.rollback();
        }
    }
复制代码

还是在save处debug，发现首先发送SQL语句：

复制代码 
    select
        student0_.sid as sid2_0_,
        student0_.sname as sname2_0_ 
    from
        students student0_ 
    where
        student0_.sid=?
复制代码

执行save之后，发送的SQL是：

复制代码 
    update
        students 
    set
        sname=? 
    where
        sid=?
复制代码

道理很明显，如果还是插入语句，则会插入新的记录，显然不对了。

  • retrive，hibernate基本的查询api是get和load（只根据主键查询，不能根据其它字段查询，如果想根据非主键查询，可以使用HQL），之前也看了get的用法了，使用get查询对象，执行之后，对象变为持久态的，立刻发送SQL语句select……而且也可以直接填写实体类名，get查找返回的是真正的实体对象，如果找不到则返回null，代码如下：
Student student = (Student) session.get("zhujian.vo.Student", 1);
            LOG.info("sid = {}, sname = {}", student.getSid(), student.getSname());

debug一下：

执行48句之后：

再看load方法，参数写法和get一样的，但是load是一种懒加载的方式，只有使用的时候才生成sql语句：

复制代码 
    @Test
    public void retrive() {
        Transaction transaction = session.beginTransaction();

        try {
            Student student = (Student) session.load(Student.class, 2);
            student.setSname("小李");
            session.save(student);
            transaction.commit();
        } catch (Exception e) {
            LOG.error("save error", e);
            transaction.rollback();
        }
    }
复制代码

load方法查询的对象是代理对象，且执行此方法时不会立即发出查询语句。因为使用load加载对象去查询某一条数据的时候并不会直接将这条数据以指定对象的形式来返回，而是在真正需要使用该对象里面的一些属性的时候才会去查找对象。他的好处就是可以减少程序本身因为与数据库频繁的交互造成的处理速度缓慢的问题。

　　而hibernate的load方法延迟加载实现原理是使用代理（代理设计模式在hibernate的的应用），Hibernate的懒加载，是通过在内存中对类、集合等的增强（即在内存中扩展类的特性[继承]）来实现的，这些类通常称为代理类。比如我们通过session.load(class, id)操作，加载一个对象的时候，hibernate返回的实际上是实体类的代理类实例。如图：

执行65句之后：

　　但如通过session.get操作，则返回实际的对象实例（不是代理类实例），对上例而言，get操作返回实体类的实例。采用load()方法加载数据，如果数据库中没有相应的记录，则会抛出异常：org.hibernate.ObjectNotFoundException: No row with the given identifier exists：……所以如果我知道该id在数据库中一定有对应记录存在，那么我就可以使用load方法来实现延迟加载。

　　

　　session缓存（hibernate一级缓存）概念

　　在继续探讨这个问题之前，必须先提前总结下缓存的一些东西。

　　Hibernate缓存包括两大类：Hibernate一级缓存和Hibernate二级缓存。

　　一级缓存就是Session级别的缓存，一个Session做了一个查询操作，它会把这个操作的结果放在一级缓存中，如果短时间内这个session（一定要同一个session）又做了同一个操作，那么hibernate直接从一级缓存中拿，而不会再去连数据库取数据。它是属于事务范围的缓存，Session对象的生命周期通常对应一个数据库事务或者一个应用事务，一级缓存中，持久化类的每个实例都具有唯一的OID。这一级别的缓存由hibernate管理，无需主动干预即可工作。

　　二级缓存就是 SessionFactory 级别的缓存，查询的时候会把查询结果缓存到二级缓存中，如果同一个sessionFactory创建的某个session执行了相同的操作，hibernate就会从二级缓存中拿结果，而不会再去连接数据库，因为SessionFactory对象的生命周期和应用程序的整个过程对应，因此Hibernate二级缓存是进程范围或者集群范围的缓存，有可能出现并发问题，因此需要采用适当的并发访问策略，该策略为被缓存的数据提供了事务隔离级别，需要人工配置和更改，可以动态加载，卸载（二级缓存是一个可配置的插件，默认下SessionFactory不会启用这个插件。）。而一级缓存不可以卸载。

　　当Hibernate根据ID访问数据对象的时候，首先从Session一级缓存中查，查不到，如果配置了二级缓存，那么从二级缓存中查，如果都查不到，再查询数据库，把结果按照ID放入到缓存删除、更新、增加数据的时候，同时更新缓存。

复制代码 
            Student student = (Student) session.get(Student.class, 6);
            LOG.info("student sid = {}, student sname = {}", student.getSid(), student.getSname());

            Student student1 = (Student) session.get(Student.class, 6);
            LOG.info("student1 sid = {}, student1 sname = {}", student1.getSid(), student1.getSname());
复制代码

debug查看效果：执行完第一个get语句，立即发送了SQL语句，执行第二个一样的get语句时，我发现并没打印SQL语句，而是直接打印了log，只能说明，它第二次一样的对象查询是在缓存中查找到的。

　　网上有人说get不从缓存中查找，这是不对的，还有人说get不会去二级缓存中查找，其实也不对。或者严格的说必须指定哪个版本的hibernate再来讨论这个问题，下面还会分析源码来再次佐证（hibernate 3）。

 

　　再看load的方式：

复制代码 
            Student student = (Student) session.load(Student.class, 6);
            LOG.info("sid = {}, sname = {}", student.getSid(), student.getSname());

            Student student1 = (Student) session.load(Student.class, 6);
            LOG.info("student1 sid = {}, student1 sname = {}", student.getSid(), student.getSname());
复制代码

也是第二次查找同一个对象的时候，没有再生成SQL语句，直接打印的两个log，只能说明它是在缓存中查询了。load方法也是走缓存的。那么具体怎么走，下面看源码级别的分析。

 

　　load和get的源码分析：

　　先看get和load的api源码，位于SessionImpl类，它是Session接口的一个实现类：

上面是load方法的，下面是get方法：

两种方式类似，那么继续看重载的load和get方法源码：

复制代码 
public Object get(String entityName, Serializable id) throws HibernateException {
        LoadEvent event = new LoadEvent(id, entityName, false, this);
        boolean success = false;

        Object var5;
        try {
            this.fireLoad(event, LoadEventListener.GET);
            success = true;
            var5 = event.getResult();
        } finally {
            this.afterOperation(success);
        }

        return var5;
    }


    public Object load(String entityName, Serializable id) throws HibernateException {
        LoadEvent event = new LoadEvent(id, entityName, false, this);
        boolean success = false;

        Object var5;
        try {
            this.fireLoad(event, LoadEventListener.LOAD);
            if(event.getResult() == null) {
                this.getFactory().getEntityNotFoundDelegate().handleEntityNotFound(entityName, id);
            }

            success = true;
            var5 = event.getResult();
        } finally {
            this.afterOperation(success);
        }

        return var5;
    }
复制代码

关键区别是this.fireLoad(event, LoadEventListener.LOAD);和this.fireLoad(event, LoadEventListener.GET);这两句代码，官方文档说，使用fireLoad方法把加载事件event和事件加载的监听器（一个接口）的方式组合，也就是这两个方法触发事件的方式不一样。下面先看看这两个代表不同触发方式的常量：

复制代码 
    LoadEventListener.LoadType GET = (new LoadEventListener.LoadType("GET")).setAllowNulls(true).setAllowProxyCreation(false).setCheckDeleted(true).setNakedEntityReturned(false);
    LoadEventListener.LoadType LOAD = (new LoadEventListener.LoadType("LOAD")).setAllowNulls(false).setAllowProxyCreation(true).setCheckDeleted(true).setNakedEntityReturned(false);
复制代码

区别就是：在allowNulls上get允许空，也就是get找不到就返回null，而load不允许空，所以抛出异常！而在allowProxyCreation上get不允许代理创建，而load允许代理的创建，记住这点。继续看fireload方法源码：

复制代码 
    private void fireLoad(LoadEvent event, LoadType loadType) {
        this.errorIfClosed();
        this.checkTransactionSynchStatus();
        LoadEventListener[] loadEventListener = this.listeners.getLoadEventListeners();

        for(int i = 0; i < loadEventListener.length; ++i) {
            loadEventListener[i].onLoad(event, loadType);
        }

    }
复制代码

使用的内部的LoadEventListener[] loadEventListener数组去调用loadEventListener[i].onLoad(event, loadType);方法，加载方式和事件作为参数传入，下面看onload方法：

复制代码 
    public void onLoad(LoadEvent event, LoadType loadType) throws HibernateException {
        EventSource source = event.getSession();
        EntityPersister persister;
        if(event.getInstanceToLoad() != null) {
            persister = source.getEntityPersister((String)null, event.getInstanceToLoad());
            event.setEntityClassName(event.getInstanceToLoad().getClass().getName());
        } else {
            persister = source.getFactory().getEntityPersister(event.getEntityClassName());
        }

        if(persister == null) {
            throw new HibernateException("Unable to locate persister: " + event.getEntityClassName());
        } else {
            if(!persister.getIdentifierType().isComponentType() || EntityMode.DOM4J != event.getSession().getEntityMode()) {
                Class keyToLoad = persister.getIdentifierType().getReturnedClass();
                if(keyToLoad != null && !keyToLoad.isInstance(event.getEntityId())) {
                    throw new TypeMismatchException("Provided id of the wrong type for class " + persister.getEntityName() + ". Expected: " + keyToLoad + ", got " + event.getEntityId().getClass());
                }
            }

            EntityKey keyToLoad1 = new EntityKey(event.getEntityId(), persister, source.getEntityMode());

            try {
                if(loadType.isNakedEntityReturned()) {
                    event.setResult(this.load(event, persister, keyToLoad1, loadType));
                } else if(event.getLockMode() == LockMode.NONE) {
                    event.setResult(this.proxyOrLoad(event, persister, keyToLoad1, loadType));
                } else {
                    event.setResult(this.lockAndLoad(event, persister, keyToLoad1, loadType, source));
                }

            } catch (HibernateException var7) {
                log.info("Error performing load command", var7);
                throw var7;
            }
        }
    }
复制代码

找到关键的代码，因为我的测试例子里，两个方法都没有调用带 lockMode 的 api，它们默认 null，执行这一句：

get和load查询方法都走该句，那么继续看proxyOrLoad方法：

复制代码 
    protected Object proxyOrLoad(LoadEvent event, EntityPersister persister, EntityKey keyToLoad, LoadType options) {
        if(log.isTraceEnabled()) {
            log.trace("loading entity: " + MessageHelper.infoString(persister, event.getEntityId(), event.getSession().getFactory()));
        }

        if(!persister.hasProxy()) {
            return this.load(event, persister, keyToLoad, options);
        } else {
            PersistenceContext persistenceContext = event.getSession().getPersistenceContext();
            Object proxy = persistenceContext.getProxy(keyToLoad);
            return proxy != null?this.returnNarrowedProxy(event, persister, keyToLoad, options, persistenceContext, proxy):(options.isAllowProxyCreation()?this.createProxyIfNecessary(event, persister, keyToLoad, options, persistenceContext):this.load(event, persister, keyToLoad, options));
        }
    }
复制代码

关键语句 if(!persister.hasProxy())，大概机制就是当该方式没有发现代理存在，也就是get的加载方式，就return this.load(event, persister, keyToLoad, options) 方法的值，那么看load方法的源码：

复制代码 
    protected Object load(LoadEvent event, EntityPersister persister, EntityKey keyToLoad, LoadType options) {
        if(event.getInstanceToLoad() != null) {
            if(event.getSession().getPersistenceContext().getEntry(event.getInstanceToLoad()) != null) {
                throw new PersistentObjectException("attempted to load into an instance that was already associated with the session: " + MessageHelper.infoString(persister, event.getEntityId(), event.getSession().getFactory()));
            }

            persister.setIdentifier(event.getInstanceToLoad(), event.getEntityId(), event.getSession().getEntityMode());
        }

        Object entity = this.doLoad(event, persister, keyToLoad, options);
        boolean isOptionalInstance = event.getInstanceToLoad() != null;
        if((!options.isAllowNulls() || isOptionalInstance) && entity == null) {
            event.getSession().getFactory().getEntityNotFoundDelegate().handleEntityNotFound(event.getEntityClassName(), event.getEntityId());
        }

        if(isOptionalInstance && entity != event.getInstanceToLoad()) {
            throw new NonUniqueObjectException(event.getEntityId(), event.getEntityClassName());
        } else {
            return entity;
        }
    }
复制代码

关键一句：Object entity = this.doLoad(event, persister, keyToLoad, options);，到这里就一目了然了：

复制代码 
 1 protected Object doLoad(LoadEvent event, EntityPersister persister, EntityKey keyToLoad, LoadType options) {
 2         if(log.isTraceEnabled()) {
 3             log.trace("attempting to resolve: " + MessageHelper.infoString(persister, event.getEntityId(), event.getSession().getFactory()));
 4         }
 5 
 6         Object entity = this.loadFromSessionCache(event, keyToLoad, options);// 先从session缓存（一级缓存）中加载对象
 7 
 8         if(entity == REMOVED_ENTITY_MARKER) {
 9             log.debug("load request found matching entity in context, but it is scheduled for removal; returning null");
10             return null;
11         } else if(entity == INCONSISTENT_RTN_CLASS_MARKER) {
12             log.debug("load request found matching entity in context, but the matched entity was of an inconsistent return type; returning null");
13             return null;
14         } else if(entity != null) {// 在一级缓存里查找到对象就返回该对象
15             if(log.isTraceEnabled()) {
16                 log.trace("resolved object in session cache: " + MessageHelper.infoString(persister, event.getEntityId(), event.getSession().getFactory()));
17             }
18 
19             return entity;
20         } else { // 一级缓存找不到，get方法去二级缓存找
21             entity = this.loadFromSecondLevelCache(event, persister, options);
22             if(entity != null) {// 如果存在且找到就返回该对象
23                 if(log.isTraceEnabled()) {
24                     log.trace("resolved object in second-level cache: " + MessageHelper.infoString(persister, event.getEntityId(), event.getSession().getFactory()));
25                 }
26 
27                 return entity;
28             } else { // 最后缓存找不到，才去数据库查询
29                 if(log.isTraceEnabled()) {
30                     log.trace("object not resolved in any cache: " + MessageHelper.infoString(persister, event.getEntityId(), event.getSession().getFactory()));
31                 }
32 
33                 return this.loadFromDatasource(event, persister, keyToLoad, options);
34             }
35         }
36     }
复制代码

　　显然，get的查询方式，首先查询session缓存，也就是一级缓存，没有就去查询二级缓存，如果没有二级缓存或者没找到，最后才去查数据库。

　　下面看看load方法，其实大同小异，和get的源码差不多，只不过走了其他一些分支，还是看方法proxyOrLoad里，如果找到了代理（也就是使用的load查找方式），进入如下分支：

复制代码 
PersistenceContext persistenceContext = event.getSession().getPersistenceContext();// load方式先从事件的上下文环境中查找（一级缓存session）
// 返回的对象赋值给proxy，名字都那么明显了，代理对象
Object proxy = persistenceContext.getProxy(keyToLoad);
// 如果是空的，就创建代理对象，不是空的，先判断是否允许创建代理（还记得之前的LOAD和GET常量么，就在这里起作用），load肯定允许，那么开始创建代理
return proxy != null?this.returnNarrowedProxy(event, persister, keyToLoad, options, persistenceContext, proxy):(options.isAllowProxyCreation()?this.createProxyIfNecessary(event, persister, keyToLoad, options, persistenceContext):this.load(event, persister, keyToLoad, options));
复制代码

　　到这里肯定明确一点：load查找方式首先会去缓存里查找，那么load的代理对象在获取对象属性时究竟如何加载数据？

　　如果缓存中找不到对象，则进入该方法：

复制代码 
// 该内部的私有方法中第一个log就说了：实体代理类先从session中查找
private Object returnNarrowedProxy(LoadEvent event, EntityPersister persister, EntityKey keyToLoad, LoadType options, PersistenceContext persistenceContext, Object proxy) {
        log.trace("entity proxy found in session cache");
        // 执行的是懒加载
        LazyInitializer li = ((HibernateProxy)proxy).getHibernateLazyInitializer();
        if(li.isUnwrap()) {// 没有解包，就直接返回该代理对象
            return li.getImplementation();
        } else {
            Object impl = null;
            // load查找允许创建代理，那么这个if肯定不进入执行
            if(!options.isAllowProxyCreation()) {
                impl = this.load(event, persister, keyToLoad, options);
                // 没有找到就返回异常信息
                if(impl == null) {
                    event.getSession().getFactory().getEntityNotFoundDelegate().handleEntityNotFound(persister.getEntityName(), keyToLoad.getIdentifier());
                }
            }
   
            // 重写使用代理包装一下再返回
            return persistenceContext.narrowProxy(proxy, persister, keyToLoad, impl);
        }
    }
复制代码

也就是说，此时的load方式直接返回相应的对象，不会发送SQL语句查询数据库，也不管给定的id是否在数据库中存在数据对象。也就是此时此刻load不会直接访问数据库，只是简单地返回一个由底层封装的一个代理对象，永远不为null，null会抛出异常。当然了，当然了最后load也会查数据，只不过是在实际使用数据时才去查询二级缓存，二级缓存找不到，最后去数据库查找，否则抛出异常。

　　以上源码，来自hibernate 3。如果其他版本情况大同小异，大不了变化了就分析源码，看官方文档……再也不随便相信网上的一些不负责任转载的文章了。

 

　　Get()和Load()的区别小结

  1. get()方法默认不支持lazy(延迟加载)功能，而load支持延迟加载get方法，get方法首先查询session缓存，也就是一级缓存，没有找到查二级缓存，如果没二级缓存或者找不到，则查询数据库，而load方法创建时首先查询session缓存，没有就创建代理对象并返回，实际使用数据时才查询二级缓存，没有就查询数据库。
  2. 如果找不到符合条件的记录，get方法返回null，而load方法抛出异常(ObjectNotFoundException)，load拥有不为null。
  3. 使用load方法，一般都假定你要取得对象肯定是存在的，才能使用，否则报错，而get方法则尝试查找，如果不存在，就返回null。
  4. get()和load()只根据主键查询，不能根据其它字段查询，如果想根据非主键查询，可以使用HQL或者原生SQL。
  5. 使用load()时如果在session关闭之后再查询此对象，会报异常：could not initialize proxy - no Session。处理办法：在session关闭之前初始化一下查询出来的对象：Hibernate.initialize(对象);
  6. 虽然好多书中都这么说：“get()永远只返回实体类”，但实际上这是不正确的，get方法如果在session缓存中找到了该id对应的对象，如果刚好该对象前面是被代理过的，如被load方法使用过，或者被其他关联对象延迟加载过，那么返回的还是原先的代理对象，而不是实体类对象，如果该代理对象还没有加载实体数据（就是id以外的其他属性数据），那么它会查询二级缓存或者数据库来加载数据，但是返回的还是代理对象，只不过已经加载了实体数据。
  7. 前面已经从源码角度讲了，get方法首先查询session缓存，没有的话查询二级缓存，最后查询数据库；load方法创建时首先查询session缓存，没有就创建代理，实际使用数据时才查询二级缓存和数据库。

 

这里比较细致了，继续看删除和修改：

  • update，总结两点：
    • 瞬时态不能执行update()。
    • 持久态和游离态可以执行update()。
    • 注意：代理对象在session关闭之后，不能执行update()。

第一个瞬时态对象，也就是数据库没有该对象保存，那么肯定更新不了啦！很好理解。看代码：

复制代码 
        try {
            Student student = new Student();
            // 创建瞬时态对象student
            student.setSid(9);
            student.setSname("隔壁老王");
            // 更新瞬时态对象
            session.update(student);
            transaction.commit();
        } catch (Exception e) {
            LOG.error("save error", e);
            transaction.rollback();
        }
复制代码

报错：org.hibernate.StaleStateException: Batch update returned unexpected row count from update [0]

第二个持久态肯定能执行更新，毋庸置疑，先从数据库中把对象读取，变为持久态，在更新就ok。而游离态是存在于数据库，但是脱离session管理的对象，也是可以更新的。道理都一样。比如：

复制代码 
    @Test
    public void updateObj() {
        Transaction transaction = session.beginTransaction();

        try {
            Student student = (Student) session.get(Student.class, 1);
            transaction.commit(); // 读取一个持久对象，什么都不做，提交事务，session自动关闭（使用的线程封闭的session）
            // 此时student变为游离态
            // 重新开启session和事务
            session = sessionFactory.getCurrentSession();
            Transaction transaction1 = session.beginTransaction();
            session.update(student); // ok
            transaction1.commit();// ok
        } catch (Exception e) {
            LOG.error("save error", e);
            transaction.rollback();
        }
    }
复制代码

发送了SQL：

update
students 
set
sname=? 
where
sid=?

Process finished with exit code 0

  • SaveOrUpdate()：当对象从瞬时态转换为持久态时，如果不确定主键是否冲突，推荐使用SaveOrUpdate()。很简单，顾名思义，设置的主键在数据库存在，自动执行的是更新方法update，如果主键不存在，那么执行的是save方法保存这个对象，把对象从瞬时态变为持久态。站在用户角度，用户事先不知道该主键在数据库存在否，使用这个保险。当然了，主键生成策略不能是native，因为它会自增，根本不会冲突。使用assigned就可以。
  • delete：持久态或者游离态对象都可以执行delete()方法。不过瞬时态对象也可以执行delete()，但Hibernate并不推荐使用delete()删除瞬时状态对象，因为这样做没有任何意义。 
  • merge方法：如果数据库中有该记录，则更新该记录，如果不存在该记录，则进行insert。乍一看很像saveOrUpdate方法，但是有区别，因为执行完merge(obj)后，它返回一个持久化对象的引用，而实参obj本身还是游离的。

　　merge和saveOrUpdate方法区别

　　使用saveOrUpdate，如果数据库中有记录，会无条件执行update，如果数据库中无记录，则执行insert操作。merge方法是把我们提供的对象变为游离状态的对象，只不过merger重新返回一个新的持久化对象的引用。而saveOrUpdate则把我们提供的对象转变为一个持久化对象。

　　也就是说saveOrUpdate后的对象会纳入session的管理，对象的状态会跟数据库同步，再次查询该对象会直接从session缓存中取，merge后的对象不会纳入session的管理，再次查询该对象还是会从数据库中取。

复制代码 
Students s1 = new Students();

s1.setSid(4);// 假设id=4的对象存在数据库

s1.setSname(“masi”);//s1是托管态的

Students s2 =(Students)session.merge(s1);
复制代码

但是merge（s1）之后，返回的s2（引用）这个对象纳入了session管理，和数据库同步，变为持久化态，而s1还是托管态的，没有session管理它。

 

辛苦的劳动，转载请注明出处，谢谢……
http://www.cnblogs.com/kubixuesheng/p/5276843.html
文章标签：
云数据库 RDS MySQL 版
云数据库 RDS SQL Server 版
数据库
缓存
Java
数据库连接
关系型数据库
关键词：
API区别
Hibernate策略
Hibernate注解
hibernate API
Hibernate区别
相关实践学习
如何在云端创建MySQL数据库
开始实验后，系统会自动创建一台自建MySQL的 源数据库 ECS 实例和一台 目标数据库 RDS。
全面了解阿里云能为你做什么
阿里云在全球各地部署高效节能的绿色数据中心，利用清洁计算为万物互联的新世界提供源源不断的能源动力，目前开服的区域包括中国（华北、华东、华南、香港）、新加坡、美国（美东、美西）、欧洲、中东、澳大利亚、日本。目前阿里云的产品涵盖弹性计算、数据库、存储与CDN、分析与搜索、云通信、网络、管理与监控、应用服务、互联网中间件、移动服务、视频服务等。通过本课程，来了解阿里云能够为你的业务带来哪些帮助 &nbsp; &nbsp; 相关的阿里云产品：云服务器ECS 云服务器 ECS（Elastic Compute Service）是一种弹性可伸缩的计算服务，助您降低 IT 成本，提升运维效率，使您更专注于核心业务创新。产品详情: https://www.aliyun.com/product/ecs
ghost丶桃子
目录
相关文章
爱专研的技术土狗
|
2月前
|
编译器 API 定位技术
API和SDK的区别
API 和 SDK 的区别在于：API 是一组定义了软件组件之间交互规范的接口，用于实现不同软件组件之间的通信；而 SDK 是一个全面的工具集合，包含 API、编译器、调试器、文档等，用于特定平台的应用程序开发。SDK 范围更广，内容更丰富，更具体和具象化，适合复杂的开发需求；API 则更加抽象，侧重于功能的定义和调用方式。
爱专研的技术土狗
111 2
斯卡喵
|
2月前
|
人工智能 监控 负载均衡
一文详述：AI 网关与 API 网关到底有什么区别？
近年来，AI发展迅猛，大模型成为推动业务创新的关键力量。企业面临如何安全管理和部署AI应用的挑战，需设计既能满足当前需求又可适应未来发展的基础架构。AI网关应运而生，在集成、管理和优化AI应用中扮演重要角色。本文探讨AI网关与API网关的区别，分析AI系统为何需要专门网关，并提供选择合适AI网关的建议。AI网关不仅支持多种模型，还具备高级安全性和性能优化功能，有助于企业在复杂环境中灵活应用AI技术。
斯卡喵
102 1
游客yruxkrkc2uipi
|
2月前
|
编译器 API 定位技术
API和SDK的区别
API（应用程序编程接口）和SDK（软件开发工具包）的主要区别在于范围、内容、抽象程度及使用方式。API定义了软件组件间的交互规则，范围较窄，更抽象；而SDK提供了一整套开发工具，包括API、编译器、调试器等，范围广泛，具体且实用，有助于提高开发效率。
游客yruxkrkc2uipi
226 0
我是快乐的嘟嘟
|
2月前
|
JavaScript 前端开发 安全
Vue3 的组合式 API 与 Vue2 的选项式 API 有何区别？
【10月更文挑战第4天】
我是快乐的嘟嘟
144 0
土木林森
|
3月前
|
缓存 NoSQL Java
揭秘性能提升的超级武器：掌握Hibernate二级缓存策略！
【9月更文挑战第3天】在软件开发中，性能优化至关重要。使用Hibernate进行数据持久化的应用可通过二级缓存提升数据访问速度。一级缓存随Session生命周期变化，而二级缓存是SessionFactory级别的全局缓存，能显著减少数据库访问次数，提高性能。要启用二级缓存，需在映射文件或实体类上添加相应配置。然而，并非所有场景都适合使用二级缓存，需根据业务需求和数据变更频率决定。此外，还可与EhCache、Redis等第三方缓存集成，进一步增强缓存效果。合理运用二级缓存策略，有助于大幅提升应用性能。
土木林森
101 5
Yaiba123
|
4月前
|
XML JSON Java
使用IDEA+Maven搭建整合一个Struts2+Spring4+Hibernate4项目，混合使用传统Xml与@注解，返回JSP视图或JSON数据，快来给你的SSH老项目翻新一下吧
本文介绍了如何使用IntelliJ IDEA和Maven搭建一个整合了Struts2、Spring4、Hibernate4的J2EE项目，并配置了项目目录结构、web.xml、welcome.jsp以及多个JSP页面，用于刷新和学习传统的SSH框架。
Yaiba123
115 0
使用IDEA+Maven搭建整合一个Struts2+Spring4+Hibernate4项目，混合使用传统Xml与@注解，返回JSP视图或JSON数据，快来给你的SSH老项目翻新一下吧
小周sir
|
4月前
|
移动开发 前端开发 API
React路由和HTML5 History API有什么区别
【8月更文挑战第11天】React路由和HTML5 History API有什么区别
小周sir
50 1
土木林森
|
4月前
|
数据库 开发者 Java
Hibernate映射注解的魔力：实体类配置的革命，让你的代码量瞬间蒸发！
【8月更文挑战第31天】Hibernate 是一款出色的对象关系映射框架，简化了 Java 应用与数据库的交互。其映射注解让实体类配置变得直观简洁。本文深入剖析核心概念与使用技巧，通过示例展示如何简化配置。
土木林森
55 0
wljslmz
|
4月前
|
XML 安全 API
REST 和 SOAP API 有什么区别？
【8月更文挑战第31天】
wljslmz
255 0
wljslmz
|
4月前
|
缓存 Java 数据库连接
Hibernate 中的获取策略有哪些？
【8月更文挑战第21天】
wljslmz
24 0