Hibernate笔记

最新推荐文章于 2024-06-04 09:07:32 发布

Linland

最新推荐文章于 2024-06-04 09:07:32 发布

阅读量762

点赞数

分类专栏： java 文章标签： hibernate class table generator pig 数据库

本文链接：https://blog.csdn.net/Linland/article/details/5455910

版权

java 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

hibernate多对一关联映射
关联映射的本质：将关联关系映射到数据库，关联关系在对象模型域中体现为一个或多个引用

<many-to-one>标签会在“多”的一端添加一个外键，指向“一”的一端，这个外键是由<many-to-one>
中的column的属性定义的，如果忽略这个属性，默认创建的外键与实体类的属性名相同

<many-to-one>定义示例：
* <many-to-one name="group" column="groupid"/>

理解cascade
* 是对象之间的连锁操作（只对增删改起作用）
hibernate一对一主键关联映射（单项关联）
hibernate一对一主键关联映射（单项关联）Person--->IdCard

主键关联映射：让两个对象的id保持相同，这样可以避免多余的字段被创建

<one-to-one>标签指示hibernate如何加载其引用对象，缺省情况下根据主键加载其引用对象

<id name="id">
<generator class="foreign">

<param name="property">idCard</param>
</generator>
</id>
<property name="name"/>

<one-to-one name="idCard" constrained="true"/>
hibernate一对一主键关联映射（双项关联）
hibernate一对一主键关联映射（双项关联）Person<--->IdCard

需要在idCard加入<one-to-one>标签，指示hibernate如何加载person，默认情况下根据主键加载

<one-to-one name="person"></one-to-one>
hibernate一对一唯一外键关联映射（单项关联）
hibernate一对一唯一外键关联映射（单项关联）Person--->IdCard

一对一唯一外键关联实际上是多对一关联映射的特例

可以采用<many-to-one>标签，指定“多”的一端unique=“true”，即限制了“多”一端的多重性为“一”
这样就构成了一对一唯一外键关联映射
hibernate一对一唯一外键关联映射（双向关联）
hibernate一对一唯一外键关联映射（双向关联）Person<--->IdCard

一对一唯一外键双向关联映射，需要在另一端(IdCard)，添加<one-to-one>标签，指示hibernate如何
加载其引用对象，默认情况下根据主键加载person，因为外键关联映射中，两个实体的关系是由person的
外键IdCard维护的，所以不能指定person的主键来加载person，而是根据person的外键idCard来加载person
对象，如：
<one-to-one name="person" property-ref="idCard"></one-to-one>

hibernate一对多关联映射（单向关联）
hibernate一对多关联映射（单向关联）Classes--->Student

这种关联映射的原理采用的是多对一关联映射的原理

多对一关联映射，是在“多”的一端添加一个外键指向“一”的一端，它维护的关系多到一的关系
一对多关联应是，是在“多”的一端添加一个外键指向“一”的一端，它维护的关系一到多的关系

也就是说，一对多和多对一关联映射的策略是一致的，只是站的角度不同

缺点：
* 更新student表中的classesid字段时，会发出多余的update语句，来维护classes到student之间的关系
* 如果将t_student中的classesid设置为非空，则不能成功保存

<set name="students" order-by="id">

<key column="classesid"></key>
<one-to-many class="com.bjsxt.hibernate.Student"/>
</set>
hibernate一对多关联映射（双向关联）
hibernate一对多关联映射（双向关联）Classes<--->Student

一对多双向关联映射的方法：
* 在“一”一端的集合中使用<key>标签，在对方表中加入一个外键指向“一”一端
* 在“多"的一端采用<many-to-one>

注意：<key>标签指定的外键字段必须和<many-to-one>指定的外键字段一致，否则引起字段错误
<many-to-one name="classes" column="classesid" cascade="all"></many-to-one>

如果在“一”一端维护一对多关联关系，hibernate会发出多余的update语句，所以我们一般在多的一端来维护关联关系。

关于inverse属性：
inverse主要用在一对多和多对多双向关联上，inverse可以被是知道集合标签<set>上，默认inverse为false，
所以我们可以从“一”一端和“多”一端维护关联关系，如果设置成inverse为true，则我们只能从多一端来维护关联关系。

注意：inverse属性，只影响数据的存储，也就是持久化

inverse和cascade
* inverse是关联关系的控制方向
* cascade是指操作上的连锁反映
hibernate多对多关联映射（单项关联）
hibernate多对多关联映射（单项关联）user--->role

映射规则：
<set name="roles" table="t_user_role">
<key column="userid"></key>
<many-to-many class="com.bjsxt.hibernate.Role" column="roleid"/>
</set>
hibernate多对多关联映射（双项关联）
hibernate多对多关联映射（双项关联）user<--->role

映射规则：

Java代码

<set name="users" table="t_user_role" order-by="userid">
<key column="roleid"/>
<many-to-many class="com.bjsxt.hibernate.User" column="userid"></many-to-many>
</set>

<set name="users" table="t_user_role" order-by="userid"> 
<key column="roleid"/> 
<many-to-many class="com.bjsxt.hibernate.User" column="userid"></many-to-many> 
</set>

* table属性值必须和单向关联中的table属性值一致
* <key>标签中的column属性值必须和单向关联中的<many-to-many>中的column属性值一致
* <many-to-many>标签中的column必须和单向关联中的<key>标签中的column属性值一致
基本映射说明
基本映射

类-->数据库表

普通属性-->表字段

通过<class>映射到数据库表，通过<property>将普通属性映射到表字段。
所谓普通属性不包扩，自定义类，集合，数组

实体类主要设计原则：
* 实现一个默认的（即无参数的）构造方法（constructor）
* 提供一个标识属性（identifier property）(可选)
* 使用非final的类（可选）
* 为持久化字段声明访问器（accessors）(可选)

注意：类的名称和属性的名称如果和sql中的关键子重复，必须用table或column重新命名

id的映射：
了解uuid、native和assigned

注意：类的名称和类中属性的名称，如果和sql中的关键字重复，必须用table或column属性重命名
hibernate的session.flush
测试session.flush

1、session在什么情况下清理缓存：
* 默认情况下，当应用程序提交事务，如：Transaction.commit;
* 当我们显示调用flush的时候
* 在执行某些查询的时候，如：iterate

2、session.flush()主要完成两件事情：
* 清理缓存
* 执行sql

3、flush执行的顺序：hibernate按照save,update,delete顺序提交相关操作
Hibernate的一个配置参数hibernate.hbm2ddl.auto
关键字: hibernate hbm2ddl.auto
Java代码
1. <properties>
2.            <property name="hibernate.show_sql" value="true" />
3.            <property name="hibernate.hbm2ddl.auto" value="create" />
4. </properties>

看到了吗？
hibernate.hbm2ddl.auto value=“create”
看一下hibernate的官方解释：
hibernate.hbm2ddl.auto Automatically validate or export schema DDL to the database when the SessionFactory is created. With create-drop, the database schema will be dropped when the SessionFactory is closed explicitly. eg. validate | update | create | create-drop
有意思吧~！
竟然可以自动创建|更新|验证数据库表结构。
呵呵不过如果不是此方面的需求建议set value="none".
下面是这几个属性的解释：
validate               加载hibernate时，验证创建数据库表结构
create                  每次加载hibernate，重新创建数据库表结构，这就是导致数据库表数据丢失的原因。
create-drop         加载hibernate时创建，退出是删除表结构
update                加载hibernate自动更新数据库结构

1.请慎重使用此参数，没必要就不要随便用。如果要用尽量使用update
2.如果发现数据库表丢失，请检查hibernate.hbm2ddl.auto的配置

hibernate lazy策略可以使用在：
* <class>标签上，可以取值：true/false
* <property>标签上，可以取值：true/false需要类增强工具
* <set><list>标签上，可以取值：true/false/extra
* <one-to-one><many-to-one>单端关联上，可以取值：false/proxy/noproxy

lazy概念：只有真正使用该对象时，才会创建，对于hibernate而言，正真使用的时候才会发出sql

hibernate支持lazy策略只有在session打开状态下有效

<class>标签上的lazy特性只对普通属性起作用hibernate lazy策略可以使用在：
* <class>标签上，可以取值：true/false
* <property>标签上，可以取值：true/false需要类增强工具
* <set><list>标签上，可以取值：true/false/extra
* <one-to-one><many-to-one>单端关联上，可以取值：false/proxy/noproxy

lazy概念：只有真正使用该对象时，才会创建，对于hibernate而言，正真使用的时候才会发出sql

hibernate支持lazy策略只有在session打开状态下有效

<class>标签上的lazy特性只对普通属性起作用
重要的概念：
1、lazy的概念，指在需要的时候才发出sql
2、lazy策略只是在session打开期间才是有效的

注意：
Hibernate类级别的lazy加载策略：可以控制什么时候加载这些普通对象属性

测试单元的使用：
请先运行初时化程序InitData,在执行每个单元测试

Hibernate集合属性的懒加载策略：

在集合属性上，可以配置懒加载策略，取值为：true/false/extra

true:默认取值，它的意思是只有在调用这个集合获取里面的元素对象时，才发出查询语句，加载其
     集合元素的数据
false:取消懒加载特性，即在加载对象的同时，就发出第二条查询语句加载其关联集合的数据
extra:一种比较聪明的懒加载策略，即调用集合的size/contains等方法的时候，hibernate并不会去加载整个集合的数据，而是发出一条聪明的SQL语句，以便获得需要的值，只有在真正需要用到这些集合元素对象数据的时候，才去发出查询语句加载所有对象的数据

Hibernate单端关联懒加载策略：即在<one-to-one>/<many-to-one>标签上可以配置
懒加载策略。

可以取值为：false/proxy/no-proxy
false:取消懒加载策略，即在加载对象的同时，发出查询语句，加载其关联对象
proxy:这是hibernate对单端关联的默认懒加载策略，即只有在调用到其关联对象的方法的时候
      才真正发出查询语句查询其对象数据，其关联对象是代理类
no-proxy:这种懒加载特性需要对类进行增强，使用no-proxy，其关联对象不是代理类

注意：在class标签上配置的lazy属性不会影响到关联对象!!!

hibernate的lazy策略forClass
lazy策略可以用在：
* <class>标签上，可以取值：true/false
* <property>标签上，可以取值：true/false,这个特性需要类增强工具
* <set><list>等集合上，可以取值:true/false/extra
* <one-to-one>和<many-to-many>（单端关联）等标签上，可以取值：false/proxy/noproxy

概念：
1、lazy是只有需要的时候才发出sql语句
2、hibernate支持lazy策略，只有session打开状态下才有效

hibernate类级别的lazy测试，可以控制什么时候加载这些普通属性
把class的lazy设置成false时，再load类时会把普通属性都查出来，但是集合不查
class标签上的lazy不会影响到集合上的lazy特性
class标签上的lazy特性只对普通属性起作用

使用：
1、运行initData
2、运行测试用例
hibernate在集合上的lazy策略
hibernate在集合上的lazy策略，可以取值true/false/extra
测试集合lazy:
get集合时不会发sql,迭代会发sql
查个数的时候会把整个集合查出来，这样的话对效率有影响
lazy在集合上用extra在获取size的时候会发出count语句，这样对效率有提升

使用：
1、运行InitData
2、运行测试用例
hibernate在单端关联上的lazy策略
hibernate在单端关联上的lazy策略,<one-to-one>和<many-to-one>，可以取值：false/proxy/noproxy
在单端关联上lazy默认，和集合一样，在get时返回代理不发查询语句，在使用时发出sql
在单端关联上lazy=false,在访问普通属性时发出两条sql,查询属性以及对应的关联对象
将class标签上lazy设置成false,其它默认：
不会影响单端关联，也不会影响集合

使用：
1、运行InitData
2、运行测试用例

Hibernate中的继承映射
Hibernate的继承映射包含了三种不同的策略：
1. 每棵继承树映射成一张表
2. 每个子类映射成一张表；
3. 每个具体类映射成一张表（有限制）。
每棵继承树映射成一张表

每棵继承树映射成一张表
t_animal
id name Sex weight height type
1 猪猪 True 100 P
2 鸟鸟 False 50 B

Java代码

Animal.java
public class Animal {
private int id;
private String name;
private boolean sex;
getter and setter; }
Pig.java
public class Pig extends Animal {
private int weight;
getter and setter;
}

Animal.java
public class Animal {
	
private int id;
	
private String name;
	
private boolean sex;
	
getter and setter; }
Pig.java
	public class Pig extends Animal {
	
	private int weight;

	getter and setter;
}

Java代码

Bird.java
public class Bird extends Animal {
private int height;
getter and setter;
}

Bird.java
public class Bird extends Animal {

	private int height;

	getter and setter;
	
}

Java代码

Extend.hbm.xml
<hibernate-mapping package="com.bjsxt.hibernate">
<class name="Animal" table="t_animal" lazy="false">
<id name="id">
<generator class="native"/>
</id>
<discriminator column="type" type="string"/>
<property name="name"/>
<property name="sex"/>
<subclass name="Pig" discriminator-value="P">
<property name="weight"/>
</subclass>
<subclass name="Bird" discriminator-value="B">
<property name="height"/>
</subclass>
</class>
</hibernate-mapping>

Extend.hbm.xml
<hibernate-mapping package="com.bjsxt.hibernate">
	<class name="Animal" table="t_animal" lazy="false">
		<id name="id">
			<generator class="native"/>
		</id>
		<discriminator column="type" type="string"/>
		<property name="name"/>
		<property name="sex"/>
		<subclass name="Pig" discriminator-value="P">
			<property name="weight"/>
		</subclass>
		<subclass name="Bird" discriminator-value="B">
			<property name="height"/>
		</subclass>
	</class>
</hibernate-mapping>

每个子类一个表；(效率不高。实体类跟上面的一样)

Java代码

<hibernate-mapping package="com.bjsxt.hibernate">
<class name="Animal" table="t_animal">
<id name="id">
<generator class="native"/>
</id>
<property name="name"/>
<property name="sex"/>
<joined-subclass name="Pig" table="t_pig">
<key column="pid"/>
<property name="weight"/>
</joined-subclass>
<joined-subclass name="Bird" table="t_bird">
<key column="bid"/>
<property name="height"/>
</joined-subclass>
</class>
</hibernate-mapping>

<hibernate-mapping package="com.bjsxt.hibernate">
	<class name="Animal" table="t_animal">
		<id name="id">
			<generator class="native"/>
		</id>
		<property name="name"/>
		<property name="sex"/>
		<joined-subclass name="Pig" table="t_pig">
			<key column="pid"/>
			<property name="weight"/>
		</joined-subclass>
		<joined-subclass name="Bird" table="t_bird">
			<key column="bid"/>
			<property name="height"/>
		</joined-subclass>
	</class>
</hibernate-mapping>

每个具体类映射成一张表（有限制）

每个具体类映射成一张表（主表可以不生成在class中设置 abstract = “ true”）
t_pig
id Name sex weight
1 猪猪 true 100
t_bird
id Name sex height
2 鸟鸟 false 50

session{
map{
key=Animal+id
}
}
(实体类跟上面的一样) 主键不能用自增，主键手动设置

Java代码

Extends.hbm.xml
<hibernate-mapping package="com.bjsxt.hibernate">
<class name="Animal" abstract="true">
<id name="id">
<generator class="assigned"/>
</id>
<property name="name"/>
<property name="sex"/>
<union-subclass name="Pig" table="t_pig">
<property name="weight"/>
</union-subclass>
<union-subclass name="Bird" table="t_bird">
<property name="height"/>
</union-subclass>
</class>
</hibernate-mapping>

Extends.hbm.xml
<hibernate-mapping package="com.bjsxt.hibernate">
	<class name="Animal" abstract="true">
		<id name="id">
			<generator class="assigned"/>
		</id>
		<property name="name"/>
		<property name="sex"/>
		<union-subclass name="Pig" table="t_pig">
			<property name="weight"/>
		</union-subclass>
		<union-subclass name="Bird" table="t_bird">
			<property name="height"/>
		</union-subclass>
	</class>
</hibernate-mapping>

component映射（只建一张表）

在hibernate中,component是某个实体的逻辑组成部分，它与实体的根本区别是没有oid，
component可以成为是值对象（DDD）

采用component映射的好处：它实现了对象模型的细粒度划分，层次会更分明，复用率会更高

Java代码

Contact.java
public class Contact {
private String email;
private String address;
private String zipCode;
private String contactTel;
getter and setter;
}

Contact.java
public class Contact {
	
	private String email;
	
	private String address;
	
	private String zipCode;
	
	private String contactTel;
getter and setter;

	
}

Java代码

User.java
public class User {
private int id;
private String name;
private Contact contact;
getter and setter;
}

User.java
public class User {
	
	private int id;
	
	private String name;
	
	private Contact contact;
	getter and setter;

}

Java代码

User.hbm.xml
<hibernate-mapping>
<class name="com.bjsxt.hibernate.User" table="t_user">
<id name="id">
<generator class="native"/>
</id>
<property name="name"/>
<component name="contact">
<property name="email"/>
<property name="address"/>
<property name="zipCode"/>
<property name="contactTel"/>
</component>
</class>
</hibernate-mapping>

User.hbm.xml
<hibernate-mapping>
	<class name="com.bjsxt.hibernate.User" table="t_user">
		<id name="id">
			<generator class="native"/>
		</id>
		<property name="name"/>
		<component name="contact">
			<property name="email"/>
			<property name="address"/>
			<property name="zipCode"/>
			<property name="contactTel"/>
		</component>
	</class>
</hibernate-mapping>

复合主键映射（单独建一个实体类，重写hashCode和equals方法，实现序列化接口）
通常将复合主键相关的属性，单独放到一个类中
* 此类必须实现序列化接口
* 覆写hashcode和equals方法

Java代码

<hibernate-mapping>
<class name="com.bjsxt.hibernate.FiscalYearPeriod" table="t_fiscal_year_period">
<composite-id name="fiscalYearPeriodPK">
<key-property name="fiscalYear"/> //第一个主键
<key-property name="fiscalPeriod"/> //第二个主键
</composite-id>
<property name="beginDate"/>
<property name="endDate"/>
<property name="periodSts"/>
</class>
</hibernate-mapping>

<hibernate-mapping>
	<class name="com.bjsxt.hibernate.FiscalYearPeriod" table="t_fiscal_year_period">
		<composite-id name="fiscalYearPeriodPK">
			<key-property name="fiscalYear"/>   //第一个主键
			<key-property name="fiscalPeriod"/>	//第二个主键
		</composite-id>
		<property name="beginDate"/>
		<property name="endDate"/>
		<property name="periodSts"/>
	</class>
</hibernate-mapping>

hibernate-悲观锁与乐观锁
悲观锁

悲观锁的实现，通常依赖于数据库机制，在整个过程中将数据锁定，其它任何用户都不能读取或修改

Java代码

Inventory.java
public class Inventory {
private int itemNo;
private String itemName;
private int quantity;}

Inventory.java
public class Inventory {

	private int itemNo;
	
	private String itemName;
	
	private int quantity;}

Java代码

<PRE class=java name="code">Inventory.hbm..xml
<hibernate-mapping>
<class name="com.bjsxt.hibernate.Inventory" table="t_inventory">
<id name="itemNo">
<generator class="native"/>
</id>
<property name="itemName"/>
<property name="quantity"/>
</class>
</hibernate-mapping></PRE>操作类中实现：
<BR> Inventory inv = (Inventory)session.load(Inventory.class, 1, LockMode.UPGRADE);


   
   
    
    
     
     
      
      Java代码 
      
      
     
     
    
    
    
    Inventory.hbm..xml   
<hibernate-mapping>   
    <class name="com.bjsxt.hibernate.Inventory" table="t_inventory">   
        <id name="itemNo">   
            <generator class="native"/>   
        </id>   
        <property name="itemName"/>   
        <property name="quantity"/>   
    </class>   
</hibernate-mapping>  
   
   Inventory.hbm..xml
<hibernate-mapping>
	<class name="com.bjsxt.hibernate.Inventory" table="t_inventory">
		<id name="itemNo">
			<generator class="native"/>
		</id>
		<property name="itemName"/>
		<property name="quantity"/>
	</class>
</hibernate-mapping>
操作类中实现：

	Inventory inv = (Inventory)session.load(Inventory.class, 1, LockMode.UPGRADE);

Hibernate的加锁模式有：

LockMode.NONE ：无锁机制。
LockMode.WRITE ：Hibernate在Insert和Update记录的时候会自动获取。
LockMode.READ ： Hibernate在读取记录的时候会自动获取。

以上这三种锁机制一般由Hibernate内部使用，如Hibernate为了保证Update
过程中对象不会被外界修改，会在save方法实现中自动为目标对象加上WRITE锁。

LockMode.UPGRADE ：利用数据库的for update子句加锁。
LockMode. UPGRADE_NOWAIT ：Oracle的特定实现，利用Oracle的for update nowait子句实现加锁。

乐观锁
大多数基于数据版本记录机制（version）实现，一般是在数据库表中加入一个version字段
读取数据时将版本号一同读出，之后更新数据时版本号加一，如果提交数据时版本号小于或等于数据表中
的版本号，则认为数据是过期的，否则给予更新

Java代码

<hibernate-mapping>
<class name="Inventory" table="t_inventory" optimistic-lock="version">
<id name="itemNo">
<generator class="native"/>
</id>
<version name="version"/>
<property name="itemName"/>
<property name="quantity"/>
</class>
</hibernate-mapping>

<hibernate-mapping>
	<class name="Inventory" table="t_inventory" optimistic-lock="version">
		<id name="itemNo">
			<generator class="native"/>
		</id>
		<version name="version"/>
		<property name="itemName"/>
		<property name="quantity"/>
	</class>
</hibernate-mapping>

hibernate查询语言hql

1、简单属性查询【重要】
* 单一属性查询，返回结果集属性列表，元素类型和实体类中相应的属性类型一致
* 多个属性查询,返回的集合元素是对象数组,数组元素的类型和对应的属性在实体类中的类型一致
*在hql中关键字不区分大小写，但是属性和类名区分大小写

数组的长度取决与select中属性的个数
* 如果认为返回数组不够对象化，可以采用hql动态实例化Student对象
参见：SimplePropertyQueryTest.java

2、实体对象查询【重要】
* N + 1问题，在默认情况下，使用query.iterate查询，有可以能出现N+1问题
所谓的N+1是在查询的时候发出了N+1条sql语句
1: 首先发出一条查询对象id列表的sql
N: 根据id列表到缓存中查询，如果缓存中不存在与之匹配的数据，那么会根据id发出相应的sql语句
* list和iterate的区别？
* list每次都会发出sql语句，list会向缓存中放入数据，而不利用缓存中的数据
* iterate：在默认情况下iterate利用缓存数据，但如果缓存中不存在数据有可以能出现N+1问题
参见：SimpleObjectQueryTest1.java/SimpleObjectQueryTest2.java

3、条件查询【重要】
* 可以采用拼字符串的方式传递参数
* 可以采用？来传递参数（索引从0开始）
* 可以采用 :参数名来传递参数
* 如果传递多个参数，可以采用setParamterList方法
* 在hql中可以使用数据库的函数，如：date_format
参见：SimpleConditionQueryTest.java %

Linland

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Hibernate笔记

hibernate多对一关联映射关联映射的本质：将关联关系映射到数据库，关联关系在对象模型域中体现为一个或多个引用标签会在“多”的一端添加一个外键，指向“一”的一端，这个外键是由中的column的属性定义的，如果忽略这个属性，默认创建的外键与实体类的属性名相同定义示例： * 理解cascade * 是对象之间的连锁操作（只对增删改起作用） hibernate一对一主键关联映射（单项关联）
复制链接

扫一扫