Hibernate基础知识

最新推荐文章于 2020-08-07 10:51:34 发布
最新推荐文章于 2020-08-07 10:51:34 发布
阅读量771 收藏 2
点赞数
文章标签： hibernate generator session class table 数据库
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/s_ongfei/article/details/3207176
版权

一．Hibernate中Session的缓存

要使得一个pojo对象一直处在生命周期中，就必须保证至少有一个变量引用它，或将它放在一个java 的集合中，即集合中存放的就是这个对象的引用。Session接口中的实现类就是一系列的java集合，这就构成了Session的缓存，所以Session可以保存pojo对象。

Session缓存的作用：

1．减少访问数据库的频率

2．保证缓存中的对象与数据库中的相关纪录保持同步。Session并不会立即执行相关的SQL语句，它能够把几条相关的SQL语句合并为一条SQL语句，以便减少访问数据库的次数。

Session清理缓存的时机：

默然情况下，当显示调用了Session的flush()方法的时候；当调用Transaction的commit()方法的时候会先清理缓存，然后再向数据库提交事务；当调用查询方法的时候，如果缓存中没有要查找的对象，会清理缓存，然后去数据库中查找，保证查找的对象是和数据库同步的对象。

可以通过Session的setFlushMode设置清理模式，FlushMode.AUTO; FlushMode.ALWAYS; FlushMode.COMMIT; FlushMode.MANUAL;


二．Hibernate中pojo的三种状态以及转换关系：

临时状态(transient)：刚刚new出来的，还没有被持久化，不处在Session的缓冲区中。（临时对象）

持久化状态(persistent)：已经被持久化,加入到Session的缓存中,正在被Session所管理。（持久化对象)

游离状态(detached)：已经被持久化，但不处于Session的缓存中。（游离对象)



load()方法：返回的是一个pojo类的子类对象（代理对象），该子类是由cglib.jar产生的。load()会使用延迟加载。（延迟加载：只有真正用到类的属性的时候才去数据库中去加载对象。）所以load()方法不会返回一个null，要真正得到一个对象应该调用get()方法。


get()方法：不会产生动态的子类，他会先在缓存里面找该对象，如果没有则马上到数据库中找，然后返回一个pojo对象，如果没有找到就返回null，所以get()没有延迟加载。


save()方法：用来持久化一个临时对象。

//新增

Person person = new Person();

person.setName("new person");

person.setAge(20);

session.save(person);

hibernate将执行insert语句


update()方法：使一个游离对象加入Session缓存中，使它转变为一个持久化对象。当清理缓存的时候执行一条update语句。

//修改

Person person = (Person)session.load(Person.class,2);

person.setName("new test");

hibernate将先装载Person然后执行update语句,如果再次运行则不会再执行update语句


Person person = (Person)session.load(Person.class,2);

person.setName("new test1");

person.setName("new test2");

person.setName("new test1");

只会执行一次update语句

当执行session.flush()的时候执行更新语句，如果不显示执行flush语句，在执行commit的时候会调用session.flush()方法更新语句才能真正被执行。

当开始一个新的session后

Person person = new Person();

session.save(person);这个时候session会先把该person对象存入数据库(执行insert语句)并将会管理这个Person对象。如果一个对象曾经被一个session管理过，但是该session已经被关闭，重新开一个session管理该对象时要更新该对象就要执行session.update()方法.

session = sessionFactory.openSession();

person.setName("ttt");

session.update(person);


saveOrUpdate()方法：如果传入对象是一个临时对象就调用save()方法；如果传入对象是一个游离对象就调用update()方法；如果传入对象是一个持久化对象，就直接返回。该方法是通过判断id来决定是save还是用update。


session.contains(person);用于判断session中是否有一个Person对象.

session = sessionFactory.openSession();

person.setName("ttt");

session.saveOrUpdate(person);


delete()方法：从数据库中删除与pojo对象对应的纪录。如果要删除的是一个持久化对象，Session就将执行一条delete语句；如果传入的是一个游离对象，则先使游离对象被Session关联，使它变成一个持久化对象，然后将执行一条delete语句。注意：只有在清理缓存或调用Session的close方法的时候，delete语句才能真正被执行。

//删除

Person person = (Person)session.load(Person.class,2);

session.delete(person);

hibernate将先装载Person然后执行delete语句


三．主键生成方式

sequence：在Oracle,DB2,PostgreSQL, SAP DB, McKoi中使用序列（sequence)。返回的标识符是long, short或者 int类型的。

执行sql语句：create sequence my_key;

<id name="id">

<generator class="sequence">

<param name="sequence">my_key</param>

</generator>

</id>


increment：用于为long, short或者int类型生成 唯一标识。只有在没有其他进程往同一张表中插入数据时才能使用。 在集群下不要使用。

<id name="id">

<generator class="increment"></generator>

</id>


identity：由底层数据库来负责生成标示符，它要求底层数据库把主键定义为自动增长字段类型。如：在mysql中应把主键定义为：auto_increment类型；在SQL Server中应把主键定义为identity类型。

<id name="id">

<generator class=" identity "/>

</id>


native：根据底层数据库的能力选择identity, sequence 或者hilo中的一个。适合跨数据库平台开发。

<id name="id">

<generator class=" native "/>

</id>


Hilo：使用一个高/低位算法高效的生成long, short 或者 int类型的标识符。给定一个表和字段（默认分别是 hibernate_unique_key 和next_hi）作为高位值的来源。 高/低位算法生成的标识符只在一个特定的数据库中是唯一的。

执行sql语句：

create table hi_value (

next_value number(6,0)

);

insert into hi_value values(0);


<id name="id">

<generator class=" hilo ">

<param name="table">hi_value</param>

<param name="column">next_value</param>

<param name="max_lo">100</param>

</generator>

</id>


uuid：用一个128-bit的UUID算法生成字符串类型的标识符， 这在一个网络中是唯一的（使用了IP地址）。UUID被编码为一个32位16进制数字的字符串。


package net.xiaopi.pojo;


import java.io.Serializable;


public class UUIDObject implements Serializable {


private static final long serialVersionUID = -7800543060715584111L;


private String id;


public String getId() {

return id;

}


public void setId (String id) {

this.id = id;

}

}


执行sql语句：

create table hi_UUIDObject (

id char(32) primary key

);


<class name="UUIDObject">

<id name="id">

<generator class="uuid"></generator>

</id>

</class>


l 跨平台

l UUID

l Hilo

l 依赖数据库

l Squence

l Identity

l Native

l 其他方式

l Assigned，increment

l foreign


四．关联关系映射

1．单向many-to-one关联 

<class name="Person">
  
  
 <id name="id" column="personId">
  
  
 <generator class="native"/>
  
  
 </id>
  
  
 <many-to-one name="address" 
  
  
column="addressId"
  
  
 not-null="true"/>
  
  
</class>
  
  
 
 
  
  
 
 
<class name="Address">
  
  
 <id name="id" column="addressId">
  
  
 <generator class="native"/>
  
  
 </id>
  
  
</class>
  
  
 
 
  
  
 
 
Sql语句：
  
  
 create table Person ( personId bigint not null primary key, addressId bigint not null )
  
  
 create table Address ( addressId bigint not null primary key )
  
  
 
  
  
 2．双向many-to-one/one-to-many关联
  
  
 <class name="Person">
  
  
 <id name="id" column="personId">
  
  
 <generator class="native"/>
  
  
 </id>
  
  
 <many-to-one name="address" 
  
  
column="addressId"
  
  
 not-null="true"/>
  
  
</class>
  
  
 
 
  
  
 
 
<class name="Address">
  
  
 <id name="id" column="addressId">
  
  
 <generator class="native"/>
  
  
 </id>
  
  
 <set name="people" inverse="true">
  
  
 <key column="addressId"/>
  
  
 <one-to-many class="Person"/>
  
  
 </set>
  
  
</class>
  
  
 
 
  
  
 
 
Sql语句：
  
  
 create table Person ( personId bigint not null primary key, addressId bigint not null )
  
  
 create table Address ( addressId bigint not null primary key )
  
  
 
 
  
  
 
 
 加载"主"(即有从的主键,如Person为主,Address为从)不会立即加载"从",而是延迟加载
  
  
 建立关联最好建立双向关联.
  
  
 注意建立pojo的时候set属性应该马上new一个集合对象.
  
  
 
 
  
  
 
 
 inverse:是否放弃维护关系.没有放弃维护关系,会执行一条update语句
  
  
比如:address 中的inverse=true;
  
  
cascade=All:看管理的集合对象是否持久化,没有持久化就持久化.
  
  
级联是级联持久化.没有负责维护关系.
  
  
cascade="save-update":级联持久化状态
  
  
 如果"主"被持久化,他所管理的集合里面的"从"也会被持久化.
  
  
cascade="all",对父对象进行save/update/delete操作就会导致子对象也进行save/update/delete操作
   
   
delete-orphan:删除“孤儿”模式，此时不被任何一个父对象引用的子对象会被删除.
   
   
cascade="all-delete-orphan"
  
  
级联(cascade)通常在 <one-to-one>和<one-to-many>关系中比较有用
   
   
 
 
  
  
 
 
3．基于外键关联的单向one-to-many关联。
  
  
<class name="Person">
  
  
 <id name="id" column="personId">
  
  
 <generator class="native"/>
  
  
 </id>
  
  
 <set name="addresses">
  
  
 <key column="personId" 
  
  
not-null="true"/>
  
  
 <one-to-many class="Address"/>
  
  
 </set>
  
  
</class>
  
  
 
 
  
  
 
 
<class name="Address">
  
  
 <id name="id" column="addressId">
  
  
 <generator class="native"/>
  
  
 </id>
  
  
</class>
  
  
 
 
  
  
 
 
 SQL语句：
  
  
create table Person ( personId bigint not null primary key )
  
  
create table Address ( addressId bigint not null primary key, personId bigint not null )
  
  

  
  
 基于外键关联的一对多关联是一种很少见的情况，并不推荐使用，对于这种关联关系最好使用连接表。
  
  
 
 
  
  
 
 
 4．单向many-to-many关联
 
 
 <class name="Person">
  
  
 <id name="id" column="personId">
  
  
 <generator class="native"/>
  
  
 </id>
  
  
 <set name="addresses" table="PersonAddress">
  
  
 <key column="personId"/>
  
  
 <many-to-many column="addressId"
  
  
 class="Address"/>
  
  
 </set>
  
  
</class>
  
  
 
 
  
  
 
 
<class name="Address">
  
  
 <id name="id" column="addressId">
  
  
 <generator class="native"/>
  
  
 </id>
  
  
</class>
  
  
SQL语句：
  
  
create table Person ( personId bigint not null primary key )
  
  
create table PersonAddress ( personId bigint not null, addressId bigint not null, primary key (personId, addressId) )
  
  
create table Address ( addressId bigint not null primary key )
  
  
 
  
  
 5．双向many-to-many关联
  
  
<class name="Person">
  
  
 <id name="id" column="personId">
  
  
 <generator class="native"/>
  
  
 </id>
  
  
 <set name="addresses" table="PersonAddress">
  
  
 <key column="personId"/>
  
  
 <many-to-many column="addressId"
  
  
 class="Address"/>
  
  
 </set>
  
  
</class>
  
  
 
 
  
  
 
 
<class name="Address">
  
  
 <id name="id" column="addressId">
  
  
 <generator class="native"/>
  
  
 </id>
  
  
 <set name="people" inverse="true" table="PersonAddress">
  
  
 <key column="addressId"/>
  
  
 <many-to-many column="personId"
  
  
 class="Person"/>
  
  
 </set>
  
  
</class>
  
  
 
 
  
  
 
 
SQL语句：
  
  
create table Person ( personId bigint not null primary key )
  
  
create table PersonAddress ( personId bigint not null, addressId bigint not null, primary key (personId, addressId) )
  
  
create table Address ( addressId bigint not null primary key )
  
  
 
  
  
 作新增操作时，必须有一方放弃维护关系：inverse="true" ,否则数据库中会多增加一条相同的纪录. cascade="save-update"
  
  
 
 
  
  
 
 
 6．单向one-to-one关联
  
  
 a．基于外键关联的双向一对一关联
  
  
<class name="Person">
  
  
 <id name="id" column="personId">
  
  
 <generator class="native"/>
  
  
 </id>
  
  
 <many-to-one name="address" 
  
  
column="addressId" 
  
  
unique="true"
  
  
 not-null="true"/>
  
  
</class>
  
  
 
 
  
  
 
 
<class name="Address">
  
  
 <id name="id" column="addressId">
  
  
 <generator class="native"/>
  
  
 </id>
  
  
 <one-to-one name="person" 
  
  
property-ref="address"/>
  
  
</class>
  
  
SQL语句：
  
  
create table Person ( personId bigint not null primary key, addressId bigint not null unique )
  
  
create table Address ( addressId bigint not null primary key )
  
  
 外键一对一:
  
  
 主：
  
  
 <one-to-one name="..." property-ref="">
  
  
 
  
  
 从：
  
  
 <many-to-one name="" column="" unique="true" not-null="true"> 
  
  
 加载“主”会立即加载”从“，没有使用延迟加载
  
  
 加载“从”不会立即加载“主”，使用延迟加载
  
  
 加载的时候，总是加载主 
  
  
 
  
  
 可以更新，
  
  
 
  
  
 删除时
  
  
 在“主”写cascade="delete",去将从级联删除，
  
  
 但在实际的工程中，有没有delete 得从业务角度考虑
  
  
 
  
  
 b．基于主键关联的一对一关联，要使用特定的id生成器。
  
  
<class name="Person">
  
  
 <id name="id" column="personId">
  
  
 <generator class="native"/>
  
  
 </id>
  
  
 <one-to-one name="address"/>
  
  
</class>
  
  
 
 
  
  
 
 
<class name="Address">
  
  
 <id name="id" column="personId">
  
  
 <generator class="foreign">
  
  
 <param name="property">person</param>
  
  
 </generator>
  
  
 </id>
  
  
 <one-to-one name="person" 
  
  
constrained="true"/>
  
  
</class>
  
  
SQL语句：
  
  
create table Person ( personId bigint not null primary key )
  
  
create table Address ( personId bigint not null primary key )
  
  
 
  
  
 主键一对一:
  
  
 加载"主"会立即加载"从",没有使用延迟加载.
  
  
 加载"从"不会立即加载"主",使用延迟加载.
  
  
 加载的时候,总是加载主就OK了.
  
  
 
 
  
  
 
 
 增加时,先增加"主"还时先增加"从"都没有关系.
  
  
 如果单增加"从",会自动增加"主".
  
  
 如果单增加"主",不会自动增加"从",除非有cascade="save-update".
  
  
 这样的特性都是因为主键生成方式的原因.
  
  
 
 
  
  
 
 
 <one-to-one>永远不负责维护关系.

牛十二
关注
为什么hibernate正在被人们淘汰?
cxy_xxx的博客
01-16 3657
声明：本文只是本人的一点拙见，不喜勿喷。 欲速则不达，欲达则欲速！ 一、hibernate优势 hibernate让你不用写sql了，这不单可以让你的应用更好移植其它数据库，更主要的是让程序员更专注业务逻辑、数据关系、对象关系等。hibernate对一对多，多对多关系实现是非常好的。很关键一点，它支持lazy，可以让你的数据只在需要的时候被加载，听起来很完美。hibernate还有一个更牛的就是H...
HIbernate基础知识积累
05-25
**Hibernate基础知识积累** Hibernate是一个强大的Java持久化框架，它简化了数据库操作，使得开发者能够更加专注于业务逻辑，而不是底层的数据存取细节。本篇将深入探讨Hibernate的核心概念、配置、对象关系映射...
Hibernate的基础知识
brave_o的博客
05-28 291
ORM框架 Object References Mapping 操作对象即操作表 三层 MVC层/表示层/视图层  业务逻辑层   数据持久层Hibernate DButils MyBatis---------------------------------------------------------------------1.新建Maven的项目pom.xml文件 &lt;dependen...
Hibernate基础知识演示代码
01-25
本示例代码旨在帮助初学者理解和掌握Hibernate的基础知识。 1. **Hibernate概述** Hibernate是Java开发中的一个开源框架，它提供了对象-关系映射（ORM）功能，使得在Java应用中处理数据库变得更为简单。通过...
Hibernate应用基础知识.rar
01-14
【标题】"Hibernate应用基础知识" 是一个针对初学者的教程，旨在介绍Hibernate这一流行Java持久化框架的基础知识。Hibernate是一个对象关系映射（ORM）工具，它允许开发人员使用面向对象的方式来操作数据库，从而...
SSH基础知识之Hibernate
06-03
SSH基础知识之Hibernate,hibernate,spring,struts,ssh
Hibernate（基础知识）
bggl的博客
04-15 333
Hibernate（开放源代码的对象关系映射框架） Hibernate是一个开放源代码的对象关系映射框架，它对JDBC进行了非常轻量级的对象封装，它将POJO与数据库表建立映射关系，是一个全自动的orm框架，hibernate可以自动生成SQL语句，自动执行，使得Java程序员可以随心所欲的使用对象编程思维来操纵数据库。 Hibernate可以应用在任何使用JDBC的场合，既可以在Java的客户...
Hibernate基础知识点
qq_38063979的博客
08-07 174
Hibernate的作用是什么，对比mybatis有什么特点？ Hibernate就是将数据库中的关系型数据映射成Java对象。 相同点 Hibernate与MyBatis都可以是通过SessionFactoryBuider由XML配置文件生成SessionFactory，然后由SessionFactory 生成Session，最后由Session来开启执行事务和SQL语句。 其中SessionFactoryBuider，SessionFactory，Session的生命周期都是差不多的。Hiberna.
Hibernate基础知识整理
惊鸿的技术博客
10-16 377
ORM 对象关系数据库映射，应用程序和数据库的桥梁 特征：完成面向对象的编程语言到数据库的映射 作用：把关系数据库包装成面向对象的模型 采用ORM框架后，应用程序不在直接访问底层数据库，而是以面向对象的方式操作数据库， 而ORM框架则将这些面向对象的操作转换成底层sql操作 ORM基本映射方式： 1.数据表映射类 2.数据表的行映射对象（实例） 3.数据表的列（字段）映射对象属性 常用O...
Hibernate基础知识（8）
lsq_java_4的博客
08-25 373
一、Hibernate对事务的并发处理       事务的四个特性：ACID，原子性、一致性、隔离性、持久性。       1、隔离性引发问题： 脏读、不可重复读、虚读 、丢失更新 （lost update）       * 脏读 ： 一个事务 读取 另一个事务 未提交的数据        * 不可重复读： 一个事务中 连续读取 两次， 第二次读取另一个事务 已经提交 update修改数据
Hibernate的基础知识点介绍
GoldWashing的博客
07-27 619
1.1什么是hibernate Hibernate是一个开放源代码的对象关系映射框架，它对JDBC进行了非常轻量级的对象封装，它将POJO与数据库表建立映射关系，是一个全自动的orm框架，hibernate可以自动生成SQL语句，自动执行，使得Java程序员可以随心所欲的使用对象编程思维来操纵数据库。简单说,hibernate它是一个轻量级的jdbc封装,也就是说,我们可以使用hibernate...
初学Hibernate学习1 基础知识掌握
Mr long的博客
08-01 529
Hibernate 持久化 netbeans 国外开发用的比较多 java名字的来历，咖啡 （爪哇岛 猫屎咖啡） Oracal（橡树） 持久化：就是把数据保存到持久化设备。即永久可以保存的存储设备中（如磁盘） Hibernate是DAO层，和数据库打交道 为什么要持久化? 内存不能持久化 内存容量有限 业务数据共享的需要 数据安全管理的需要 为了使用大规模的检索
Hibernate基础知识详解
Hibernate 相关基础知识点 1. 对象关系映射 (ORM) 在 Hibernate 中，对象关系映射（Object-Relational Mapping，ORM）是将 Java 对象与关系数据库表之间建立映射关系的技术。ORM 的主要目的是将 Java 对象转换为...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值