Hibernate总结整理及原理分析

最新推荐文章于 2021-04-26 15:34:51 发布

SumStyle

最新推荐文章于 2021-04-26 15:34:51 发布

阅读量399

点赞数

CC 4.0 BY-SA版权

分类专栏： SSH框架应用文章标签： hibernate 框架

本文链接：https://blog.youkuaiyun.com/SumStyle/article/details/61619647

SSH框架应用专栏收录该内容

1 篇文章

订阅专栏

本文深入介绍了Hibernate框架的基础知识，包括其对JDBC的封装、核心接口的功能与使用、配置文件详解、对象关系映射机制等内容，帮助读者快速掌握Hibernate的核心概念。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

Hibernate框架的整理总结

一、原生JDBC的使用方式

1.注册数据库驱动：

Class.forName("com.mysql.jdbc.Driver");

2.连接数据库

Connection conn = DriverManager.getConnection("jdbc:mysql:///day08_jdbc","root", "abc");

3.通过连接获得可执行的sql语句的statement对象

Statement stmt =conn.createStatement（);

4.执行sql语句

stmt.execute(sql)；

二、hibernate框架

hibernate概述：

1.持久层关系型数据库对象关系映射框架（ORM），对jdbc的封装。

2.中心思想是通过操作对象的方式来对数据库进行操作，使操作更加简单，便捷。

3.一级缓存的优点，使开发者只需要注意hibernate的状态，不需要管具体的sql执行

三、Hibernate的应用

1.导入必备的jar包

数据库驱动 mysql-connector-java.jar

依赖Log4j,slf4,Junit

2.创建pojo

3.创建pojo的映射文件xml（pojoname.cfg.xml），使对象中字段与数据库表中字段的对应

注意：主键ID的映射需要使用标签<id><genratorclass=native><id/>

来确定主键生成策略

4.在classpath目录下创建hibernate的主配置文件，配置了hibernate的运行参数

Hibernate.cfg.xml

<?xml version="1.0"encoding="UTF-8"?>

<!DOCTYPEhibernate-configuration PUBLIC

"-//Hibernate/Hibernate ConfigurationDTD 3.0//EN"

"http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">

<hibernate-configuration>

<session-factory>

com.mysql.jdbc.Driver

</property>

jdbc:mysql://localhost:3306/hibernate_test

</property>

org.hibernate.dialect.MySQLDialect

</property>

<!-- 自动生成DDL

根据映射产生表结构的类型:

create-drop:没有表结构创建，下次启动时删除重新创建。适合学习阶段

create：只做创建

update：探测表结构够的变化，对于数据库没有的，进行更新操作。适合学习阶段

validate：对比与数据库的结构

none:什么都不会做

数据库必须自己手动创建，hibernate不会创建 -->

</session-factory>

</hibernate-configuration>

Hibernate执行过程：

1. 创建出pojo，与pojo对应的配置文件，hibernate的主配置文件

2. 通过Configuration类中的configure()方法。加载主配置文件

默认位置是classpath目录下

3. 通过Configuration对象，创建sessionFactory，通过sessionFactory获得session

4. 使用session提供的数据库操作方法对数据库进行操作（更改pojo对象的状态）

5. 使用session中的beginTransction()方法开启事务

6. 通过Transction对象提交事务

7. 关闭资源

pojo映射配置文件，多对一，一对多映射配置

一对多映射：set集合为set标签 List集合为bag标签

Pojo类pojoA：private Set<pojoB>bList;

PojoA的映射文件：

<one-to-manyclass=”pojoB的类名”/>

</set>

多对一映射：pojoA ：private PojoB pojoB;

<many-to-onename=”pojoA对应的字段名”class=“pojoB类名”colum=”pojoA对应的表中字段”/>

尽量让hibernate来管理生成主键OID，因为hibernate通过OID来对对象进行唯一标示，从而借助快照机制来对数据库中表数据进行更新操作

四、hibernate的一级缓存、快照机制

1.内存中的一块为hibernate开辟的区域，是一块map集合结构的空间

以对象的OID进行唯一性鉴别

2. 在执行save，get，load,等方法将hibernate对象变成持久态时，会将为对象添加上id主键，并且将数据返回，存储到一级缓存中，并且备份一份数据到快照区中。一级缓存中存储的是对象本身的地址引用，而快照区中保存的是数据的备份。

3.使用场景：

当对该对象进行操作的时候，更改了其中数据，将在进行事务提交（commit）的时候将一级缓存中该对象与快照区中的数据进行对比。如果不相同，则将数据进行提交。重新备份快照区。如果相同则不进行更改。

五、hibernate对象的三种状态（加删除态是四种）

1. 瞬时态（transient）

a) 实体类刚刚被创建，还没有与session产生交互，没有OID字段数据

2. 持久态（persistent）OID已经产生了并且与session正在交互一级缓存中已经有了实体类引用

3. 游离态（detached）存在OID但是Session已经关闭了，不再进行交互了，缓存也已经清除了

4. 删除态（removed）对象进行delete（）即将被删除的状态准确的可以不算上

六、一对多双向关系级联配置

1. Cascade属性：代表设置级联配置

取值：update-save：级联保存更新

delete 代表级联删除

2. inverse属性：代表放弃维护权利，即放弃级联关系

a) inverse取值：false (默认值，不放弃维护权利) true(放弃维护权利)

b) inverse属性在一对多双向关联关系中，设置在多的一方

！！引用大神07年笔记

1. hibernate核心接口

在项目种使用Hibernate框架，非常关键的一点就是要了解Hibernate的核心接口。Hibernate 接口位于业务层和持久化层。

图1 Hibernate核心接口的层次架构关系

　　Hibernate的核心接口一共有5个，分别为:Session、 SessionFactory、Transaction、Query和Configuration。这5个核心接口在任何开发中都会用到。通过这些接口，不仅可以对持久化对象进行存取，还能够进行事务控制。下面对这五的核心接口分别加以介绍。

Session接口:Session接口负责执行被持久化对象的CRUD操作(CRUD的任务是完成与数据库的交流，包含了很多常见的SQL语句。)。但需要注意的是Session对象是非线程安全的。同时，Hibernate的session不同于JSP应用中的HttpSession。这里当使用session这个术语时，其实指的是 Hibernate中的session，而以后会将HttpSesion对象称为用户session。
SessionFactory接口:SessionFactroy接口负责初始化Hibernate。它充当数据存储源的代理，并负责创建 Session对象。这里用到了工厂模式。需要注意的是SessionFactory并不是轻量级的，因为一般情况下，一个项目通常只需要一个 SessionFactory就够，当需要操作多个数据库时，可以为每个数据库指定一个SessionFactory。
Configuration接口:Configuration接口负责配置并启动Hibernate，创建SessionFactory对象。在 Hibernate的启动的过程中，Configuration类的实例首先定位映射文档位置、读取配置，然后创建SessionFactory对象。
Transaction接口:Transaction接口负责事务相关的操作。它是可选的，可发人员也可以设计编写自己的底层事务处理代码。
Query和Criteria接口:Query和Criteria接口负责执行各种数据库查询。它可以使用HQL语言或SQL语句两种表达方式。

/**

简单应用

        SessionFactory sf = newConfiguration().configure().buildSessionFactory();
        Session session = sf.openSession();
        Transaction tx =session.beginTransaction();
        User user = new User();

        user.setUsername("starxing");
       user.setEmail("star_xing@126.com");
        user.setPassword("starixng");
        session.save(user);
        tx.commit();
        session.close();
**/

2. Hibernate 的配置文件应用。

2.1 配置文件中映射元素详解

对象关系的映射是用一个XML文档来说明的。映射文档可以使用工具来生成，如XDoclet，Middlegen和AndroMDA等。下面从一个映射的例子开始讲解映射元素，映射文件的代码如下。

<?xml version="1.0"?>

<!DOCTYPE hibernate-mapping PUBLIC
      "-//Hibernate/Hibernate Mapping DTD3.0//EN"
          "http：//hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">

<hibernate-mapping schema="schemaName" default-cascade="none"
    auto-import="true"   package="test">
        
        <class name="People" table="person">
               
               <id name="id">
                       
                       <generatorclass="native"/>
               </id>

               <discriminator column="subclass"type="character"/>
              
              <property name="name" type="string">
                     <column name="name"length="64" not-null="true" />
              </property>
              <property name="sex"
              not-null="true"
              update="false"/>
              
              <many-to-one name="friend"
              column="friend_id"
              update="false"/>
               
               <set name="friends"
                   inverse="true"
                   order-by="id">
                       <keycolumn="friend_id"/>
                       <!—一对多映射-->
                       <one-to-many class="Cat"/>
               </set>
        </class>
</hibernate-mapping>

2.2 组件应用的方法

组件有两种类型，即组件（component）和动态组件（dynamic-component）。在配置文件中，component元素为子对象的元素与父类对应表的字段建立起映射关系。然后组件可以声明它们自己的属性、组件或者集合。component元素的定义如下所示：

在这段代码中，name是指属性名，class是类的名字，insert指的是被映射的字段是否出现在SQL的INSERT语句中，upate指出被映射的字段是否出现在SQL的UPDATE语句中，access指出访问属性的策略。

2.3 Hiebernate的基本配置

Hibernate的数据库连接信息是从配置文件中加载的。Hibernate的配置文件有两种形式：一种是XML格式的文件，一种是properties属性文件。properties形式的配置文件默认文件名是hibernate.properties，一个properties形式的配置文件内容如下所示：

#指定数据库使用的驱动类
hibernate.connection.driver_class = com.mysql.jdbc.Driver r
#指定数据库连接串
hibernate.connection.url = jdbc:mysql://localhost:3306/db
#指定数据库连接的用户名
hibernate.connection.username = user
#指定数据库连接的密码
hibernate.connection.password = password
#指定数据库使用的方言
hibernate.dialect = net.sf.hibernate.dialect.MySQLDialect
#指定是否打印SQL语句
hibernate.show_sql=true

在配置文件中包含了一系列属性的配置，Hibernate将根据这些属性来连接数据库。

在XML格式的配置文件中，除了基本的Hibernate配置信息，还可以指定具体的持久化类的映射文件，这可以避免将持久化类的配置文件硬编码在程序中。XML格式的配置文件的默认文件名为hibernate.cfg.xml，一个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>
                  
                  <propertyname="show_sql">true</property>
                  
                  <propertyname="connection.url">jdbc:mysql://localhost:3306/STU</property>
                  
                  <property name="connection.username">root</property>
                  
                  <property name="connection.password">root</property>

                  
                  <property name="connection.driver_class">com.mysql.jdbc.Driver</property>
                  
                  <propertyname="dialect">org.hibernate.dialect.MySQLDialect</property>
                  
                  <mapping resource="com/stuman/domain/Admin.hbm.xml"/>
                  
                  <mapping resource="com/stuman/domain/Student.hbm.xml" />
         </session-factory>
</hibernate-configuration>

properties形式的配置文件和XML格式的配置文件可以同时使用。当同时使用两种类型的配置文件时，XML配置文件中的设置会覆盖properties配置文件的相同的属性。

2.4 对象标识符号

在关系数据库表中，主键（Primary Key）用来识别记录，并保证每条记录的唯一性。在Java语言中，通过比较两个变量所引用对象的内存地址是否相同，或者比较两个变量引用的对象值是否相同来判断两对象是否相等。Hibernate为了解决两者之间的不同，使用对象标识符（OID）来标识对象的唯一性。OID是关系数据库中主键在Java对象模型中的等价物。在运行时，Hibernate根据OID来维持Java对象和数据库表中记录的对应关系。如下代码所示，三次调用了Session的load()方法，分别加载OID为1或3的User对象。

Transaction tx = session.beginTransaction();
User user1 = (User)session.load(User.class,new Long(1));
User user2 = (User)session.load(User.class,new Long(1));
User user3 = (User)session.load(User.class,new Long(3));
System.out.println( user1 == user2 );
System.out.println( user1 == user3 );

应用程序在执行上述代码时，第一次加载OID为1的User对象，从数据库中查找ID为1的记录，然后创建相应的User实例，并把它保存在Session缓存中，最后将该实例的引用赋值给变量user1。第二次加载OID为1的对象时，直接把Session缓存中OID为1的实例的引用赋值给变量user2。因此，表达式user1==user2的结果为true。

标识的生成可以使用不同的策略，表4.1为Hibernate内置的标识生成策略。

表 4.1 Hibernate标识生成策略

标识符生成器	描述
increment	适用于代理主键。由Hibernate自动以递增方式生成。
identity	适用于代理主键。由底层数据库生成标识符。
sequence	适用于代理主键。Hibernate根据底层数据库的序列生成标识符，这要求底层数据库支持序列。
hilo	适用于代理主键。Hibernate分局high/low算法生成标识符。
seqhilo	适用于代理主键。使用一个高/低位算法来高效的生成long，short或者int类型的标识符。
native	适用于代理主键。根据底层数据库对自动生成标识符的方式，自动选择identity、sequence或hilo。
uuid.hex	适用于代理主键。Hibernate采用128位的UUID算法生成标识符。
uuid.string	适用于代理主键。UUID被编码成一个16字符长的字符串。
assigned	适用于自然主键。由Java应用程序负责生成标识符。
foreign	适用于代理主键。使用另外一个相关联的对象的标识符。

2.5 Hibernate映射类型

在对象/关系映射文件中，Hibernate采用映射类型作为Java类型和SQL类型的桥梁。Hibernate映射类型分为2种：内置映射类型和自定义映射类型。

1 内置映射类型

Hibernate对所有的Java原生类型、常用的Java类型如String、Date等都定义了内置的映射类型。表4.2列出了Hibernate映射类型、对应的Java类型以及对应的标准SQL类型。

表4.2 Hibernate内置映射类型

Hibernate映射类型	Java类型	标准SQL类型	大小
integer/int	java.lang.Integer/int	INTEGER	4字节
long	java.lang.Long/long	BIGINT	8字节
short	java.lang.Short/short	SMALLINT	2字节
byte	java.lang.Byte/byte	TINYINT	1字节
float	java.lang.Float/float	FLOAT	4字节
double	java.lang.Double/double	DOUBLE	8字节
big_decimal	java.math.BigDecimal	NUMERIC
character	java.lang.Character/java.lang.String/char	CHAR(1)	定长字符
string	java.lang.String	VARCHAR	变长字符
boolean/ yes_no/true_false	java.lang.Boolean/Boolean	BIT	布尔类型
date	java.util.Date/java.sql.Date	DATE	日期
timestamp	java.util.Date/java.util.Timestamp	TIMESTAMP	日期
calendar	java.util.Calendar	TIMESTAMP	日期
calendar_date	java.util.Calendar	DATE	日期
binary	byte[]	BLOB	BLOB
text	java.lang.String	TEXT	CLOB
serializable	实现java.io.Serializablej接口的任意Java类	BLOB	BLOB
clob	java.sql.Clob	CLOB	CLOB
blob	java.sql.Blob	BLOB	BLOB
class	java.lang.Class	VARCHAR	定长字符
locale	java.util.Locale	VARCHAR	定长字符
timezone	java.util.TimeZone	VARCHAR	定长字符
currency	java.util.Currency	VARCHAR	定长字符

2 自定义映射类型

Hibernate提供了自定义映射类型接口，允许用户以编程的方式创建自定义的映射类型。用户自定义的映射类型需要实现net.sf.hibernate.UserType或net.sf.hibernate.CompositeUserType接口。具体的创建自定义映射类型的方法请参考hibernate官方文档或相关资料，这里不再详细介绍。

3.1 一对一映射

Hibernate中，持久化对象间的一对一关联是通过one-to-one元素定义的。其定义方式如下所示。

在这段代码中，name是指属性的名字，class指的是被关联的类的名字。cascade是可选项，表明操作是否从父对象级联到被关联的对象。constrained表明该类对应的表对应的数据库表，和被关联的对象所对应的数据库表之间，通过一个外键引用对主键进行约束。

outer-join也是可选项，它指的是当设置hibernate.use_outer_join的时候，对这个关联允许外连接抓取。property-ref指定关联类的一个属性，这个属性将会和本外键相对应。如果没有指定，会使用对方关联类的主键。access是Hibernate用来访问属性的策略。

一对一关联有两种不同的形式，即主键关联和唯一外键关联：

1 主键关联

主键关联不需要额外的表字段。如下所示的代码，将Student和Person表的主键进行一对一关联：

<one-to-one name="person"class="Person"/>

<one-to-one name="student" class="Student"constrained="true"/>

Person和Student两个表中相关字段是对等的。在下面的代码中，Person表的主键将采用foreign的方式生成。

<class name="Person" table=" Person ">
    <id name="id" column=" Person_ID">
        <generator class="foreign">
            <paramname="property">employee</param>
        </generator>
    </id>
    ...
    <one-to-one name="Student"
        class="Student"
        constrained="true"/>
</class>

2 惟一外键关联

此种关联方式是指一个外键与一个惟一的关键字相关联，上面的Student和Person的例子，如果使这种关联方式，应该表达成：

<many-to-onename=" Person " class="Person" column=" Person_ID" unique="true"/>

3.2 多对一映射

持久化对象间的多对一关联是通过many-to-one元素定义的。其定义方式如下所示。

在这段代码中，name指类的属性名，column指表的字段名，class是可选项，指关联的类的名字。cascade指明哪些操作会从父对象级联到关联的对象，outer-join指的是当设置hibernate.use_outer_join的时候，对这个关联允许外连接抓取。update用于指定对应的字段是否用于UPDATE，property-ref用于指定关联类的一个属性，这个属性将会和本外键相对应，access为可选项，指访问属性的策略。

4.4 Hibernate的检索方式

Hibernate的检索方式主要有HQL、QBC、QBE检索等几种方式。Hibernate查询语言（Hibernate Query Language，简称HQL）是一种面向对象的查询语言。HQL功能强大且简单易学，它具有以下功能。

在查询语句中设定各种查询条件。
支持投影查询，即仅检索出对象的部分属性。
支持分页查询。
支持连接查询。
支持分组查询，允许使用having和group by关键字。
提供内置聚集函数，如sum()、min()、max()等。
能够调用用户自定义的SQL函数。
支持子查询，即嵌入式查询。
支持动态绑定参数。

Session接口的find()方法及Query接口都支持HQL检索方式。如下代码是一个使用Query接口查询的示例。

//创建一个Query对象
Query query = session.createQuery ( “form User as u where u.name=:userName” + “and u.age=:userAge” ) ;
//动态绑定参数
query.setString( “userName” , “Bush” );
query.setString( “userAge” , “50” );
//执行查询语句，返回查询结果X
List results = query.list();

Query By Criteria（QBC）和Query By Example（QBE）提供了检索对象的其他方式，这些检索方式主要由Criteria接口、Criterion接口、Expression类和Example类组成，支持在运行时动态生成查询语句。

1.1 附录：QBC自定义条件速查表

短语	含义
Restrictions.eq	等于=
Restrictions.allEq	使用Map,使用key/value进行多个等于的判断
Restrictions.gt	大于>
Restrictions.ge	大于等于>=
Restrictions.lt	小于<
Restrictions.le	小于等于<=
Restrictions.between	对应sql的between子句
Restrictions.like	对应sql的like子句
Restrictions.in	对应sql的in子句
Restrictions.and	and 关系
Restrictions.or	or关系
Restrictions.sqlRestriction	Sql限定查询
Restrictions.asc()	根据传入的字段进行升序排序
Restrictions.desc()	根据传入的字段进行降序排序

运算类型	HQL运算符	QBC运算方法
比较运算	=	Restrictions.eq()
	<>	Restrictions.not(Restrictions.eq())
	>=	Restrictions.ge()
	<	Restrictions.lt()
	<=	Restrictions.le()
	is null	Restrictions.isNull()
	is not null	Restrictions.isNotNull()
范围运算符	in	Restrictions.in()
	not in	Restrictions.not(Restrictions.in())
	between	Restrictions.between()
	not between	Restrictions.not(Restrictions.between())

运算类型	HQL运算符	QBC运算方法
字符串模式匹配	like	Restrictions.like()
逻辑	and	Restrictions.and()\| Restrictions.conjunction()
	or	Restrictions.or()\| Restrictions.disjunction()
	not	Restrictions.not()