Java相关课程系列笔记之十四Hibernate学习笔记(建议用WPS打开)

合集下载

Hibernate学笔记

Hibernate学习笔记Hibernate是一个开放源代码的对象关系映射框架，它对JDBC进行了非常轻量级的对象封装，它将POJO与数据库表建立映射关系，是一个全自动的orm框架，hibernate可以自动生成SQL语句，自动执行，使得Java程序员可以随心所欲的使用对象编程思维来操纵数据库。

Hibernate可以应用在任何使用JDBC的场合，既可以在Java的客户端程序使用，也可以在Servlet/JSP的Web应用中使用，最具革命意义的是，Hibernate可以在应用EJB的J2EE架构中取代CMP，完成数据持久化的重任。

支持各种主流数据库。

核心APIHibernate的API一共有6个，分别为:Session、SessionFactory、Transaction、Query、Criteria和Configuration。

通过这些接口，可以对持久化对象进行存取、事务控制。

SessionSession接口负责执行被持久化对象的CRUD操作(CRUD的任务是完成与数据库的交流，包含了很多常见的SQL语句)。

但需要注意的是Session对象是非线程安全的。

同时，Hibernate的session不同于JSP应用中的HttpSession。

这里当使用session这个术语时，其实指的是Hibernate中的session，而以后会将HttpSession对象称为用户session。

SessionFactorySessionFactory接口负责初始化Hibernate。

它充当数据存储源的代理，并负责创建Session对象。

这里用到了工厂模式。

需要注意的是SessionFactory并不是轻量级的，因为一般情况下，一个项目通常只需要一个SessionFactory就够，当需要操作多个数据库时，可以为每个数据库指定一个SessionFactory。

TransactionTransaction 接口是一个可选的API，可以选择不使用这个接口，取而代之的是Hibernate 的设计者自己写的底层事务处理代码。

Hibernate学习笔记

主讲：刘涛(Robin)第一天：第一章Hibernate入门1、持久化：狭义：将数据持久地保存(将处于临时状态的数据持久的保存到文件或数据库中)；广义：对数据进行CRUD操作；employee(idnameagedeptidaddressid)2、ORM：将内存中的对象映射到关系型数据库中；面向对象的java 关系型数据库-----------------------------------类表属性字段(列)关系表OID PK注意：派生属性不需要映射派生属性，即可以由其他属性计算出来的属性3、公用持久化模板的要求：1）提供API供客户使用，执行CRUD操作；2）提供一种语言访问数据库（面向对象的）；如HQL：Hibernate Query Language 3）允许客户制定表和类之间的映射关系，一般写在xml中；4）提供一些优化机制，来提高性能，如：缓存、延迟加载等；4、什么是Hibernate?1）中间件，介于应用程序和数据库之间的软件；2）持久化工具，封装了和数据库访问的细节，可以让程序开发人员更加关注于业务逻辑的处理；3）ORM工具，将面向对象的java同关系型数据库进行映射，可以实现内存中的数据和数据库中数据的双向同步更新；5、Hibernate涉及的文件：1）pojo：封装数据；2）配置文件：hibernate.properties 或hibernate.cfg.xml，用来配置和数据库连接相关的信息；3）映射文件：xx.hbm.xml(hbm：hibernate mapping)，用来映射表和类之间的对应关系；4）hibernate API：1.核心接口：CRUD操作，事务处理等；2.回调接口：当特定时间触发时，回调客户端程序；3.类型：hibernate有自己定义的类型；4.可扩展接口：可以以hibernate为基础进行扩展；6、核心接口：1）org.hibernate.cfg.Configuration：1.对hibernate进行配置，根启动hibernate;2.创建SessionFactory;2）org.hibernate.SessionFactory: 1.重量级的(非常的占用资源)，不要频繁的创建，删除，一般一个数据库对应一个SessionFactory；2.线程安全的；3.缓存sql语句；如：student(idnameage)缓存的四条sql语句：select id,name,age from student where id=?delete from student where id=? update student set name=?,age=? where id=?insert into student values(?,?,?)4.维护着hibernate的二级缓存（可选的）；5.创建Session；3）org.hibernate.Session:1.轻量级的，可以频繁的创建和删除，一般一个事务中的操作对应一个Session;2.线程不安全的(多线程访问需要进行线程控制)；3.维护着hibernate的一级缓存（必用的）；4.可以执行CRUD操作；session.save(...);session.delete(...);session.update(...);session.get(...);session.load(...);4）org.hibernate.Transaction：hibernate中的事务控制，包括：jdbc 事务、JTA事务、CORBA事务；5）org.hibernate.Query：通过HQL执行查询操作； ---> "Hibernate Query Language" session.createQuery(String queryString)sql：select id,name,age from studenthql：from Student6）org.hibernate.Criteria：擅长于做动态查询7、Hibernate编程步骤：1）创建pojo类；2）创建配置文件（包含数据库连接的相关信息，以及连接的映射文件）；3）创建映射文件；4）调用hibernate的API；1.创建Configuration;2.创建SessionFactory;3.创建Session;4.启动事务，session.beginTransaction();5.执行CRUD操作；6.提交或回滚事务；mit()，transaction.rollback()create table xuxiang_student(id number(7) primary key,name varchar2(25),age number,gendar varchar2(10),address varchar2(50));添加Hibernate驱动：项目名--->右键--->Properties--->Java Build Path--->Libraries--->Add Library...--->MyEclipselibraries--->Hibernate 3.0 Core Librariessrc--com.briup.first--StudentTestDTD，XML，Schema第二章对象/关系映射基础1、映射文件：xx.hbm.xml在同一个映射文件中，可以映射多个pojo类，但建议只映射一个；2、常用标签介绍：1）<class>：用来映射表2）<id>：用来映射主键3）name：类中set/get方法后的名字4）column：表中的列名5）type： hibernate数据类型6）<generator>：用来制定主键的生成方式1. increment：由hibernate按照自增长方式产生唯一主键，注意在多线程访问时不要使用；对应的java类：org.hibernate.id.IncrementGenera tor2. identity：由支持identity的数据库产生主键；--org.hibernate.id.IdentityGener atorid number primary key identity 3. sequence：由数据库sequence来产生唯一主键；--org.hibernate.id.SequenceGener atorcreate sequence xuxiang_sequence start with 100;4. hilo：由数据库按高低值算法产生唯一主键（主键高值存在于表中）；--org.hibernate.id.TableHiLoGene rator算法：id=hi*(max_lo+1)+lo如下，则有：id=100*(100+1)+0=10100 create table xuxiang_hi(nextval number);insert into xuxiang_hivalues(100);commit;5. seqhilo：由数据库按高低值算法产生唯一主键（主键高值存在于sequence中）；--org.hibernate.id.SequenceHiLoG enerator6. assign：手动指定主键值；7）<property>：用来映射普通的列；8）<discriminator>：识别器，整个类层次映射成一张表时使用；9）<one-to-one>：用来映射一对一关系；10）<many-to-one>：用来映射多对一关系；11）<many-to-many>：用来映射多对多关系；12）<composite-id>：用来映射联合主键；positecreate table xuxiang_student2(id1 number,id2 number, name varchar2(25),age number,primary key(id1,id2));13）<component>：用来映射组合关系；ponent--User,Addresscreate table xuxiang_user(id number primary key,name varchar2(25),age number,city varchar2(20),street varchar2(50));14）<subclass>：用来映射子类；15）<formula>：计算表达式，映射派生属性时经常使用；User--Date bornDate3、作业：建一个表product，对其进行CRUD操作，要求主键由sequence生成，映射派生属性totalPrice;create table xuxiang_product(id number primary key,name varchar2(25),price number,count number);第二天：4、Hibernate中的类型：1）值类型：没有映射文件，不能直接映射到数据库中；基本数据类型，对象类型(如Address) 2）实体类型：有映射文件，可以直接映射到数据库中；第三章关联关系映射1、一对一映射：1）唯一外键关联；表上：table user table addressid<PK> idname city... ...addressid<FK>类上：class User class Addressid idname city... ...Address address User user对应的映射文件：User.hbm.xml<many-to-one name="address" class="Address"column="addressid"unique="true" />注意：由于<one-to-one>已被主键关联占用，为了与其区别，故引入了<many-to-one>!Address.hbm.xml<one-to-one name="user"class="User" />com.briup.third.one2one.fk create table xuxiang_address( id number primary key,city varchar2(20),street varchar2(50));create table xuxiang_user(id number primary key,name varchar2(25),age number,addressid number references xuxiang_address(id));2）主键关联；表上：table user table addressid<PK> id<PK,FK>name city... ...类上：class User class Addressid idname city ... ...Address address User user映射文件：User.hbm.xml<one-to-one name="address"class="Address" />Address.hbm.xml<one-to-one name="user"class="User" /><generator class="foreign"><paramname="property">user</param></generator>com.briup.third.one2one.pk create table xuxiang_user2(id number primary key,name varchar2(25),age number);create table xuxiang_address2( id number referencesxuxiang_user2(id),city varchar2(20),street varchar2(50),primary key(id));2、一对多映射：1）单向：只能在类上体现，表上是不能体现的，故单向和双向的表是完全相同的；表上：table user table addressid<PK> idname city... ...addressid<FK>类上：class User class Addressid idname city... ...Address address映射文件：User.hbm.xml<many-to-one name="address" class="Address"column="addressid" notnull=" true"/>Address.hbm.xml不需要作任何配置；com.briup.third.many2one.unidire ctcreate table xuxiang_address3( id number primary key,city varchar2(20),street varchar2(50));create table xuxiang_user3(id number primary key,name varchar2(25),age number,addressid number references xuxiang_address3(id));2）双向：表上：table user table addressid<PK> idname city... ...addressid<FK>类上：class User class Addressid idname city... ...Address address List users映射文件：User.hbm.xml<many-to-one name="address" class="Address"/>Address.hbm.xml<set name="users"><key column="addressid"/><one-to-many class="User"/></set>注意：cascade：设置级联sava-update：级联保存、更新delete：级联删除none：不级联，默认值all：级联保存、更新、删除inverse：在映射一对多关系时，一般将该属性设置为true，表示表间的关联关系由一方设置，减少update语句，提高性能。

hibernate学习笔记

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

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

</generator>
<generator class="sequence">
<param name="sequence">jdbc_car_seq</param>
</generator>
</id>
<property name="xxx" column="xxx" type="xxx">
....
<property name="connection.isolation">2</property>

<property name="transaction.factory_class">
org.hibernate.transaction.JDBCTransactionFactory
<generator class="sequence">
<param name="sequence">jdbc_car_pk_seq</param>
"/hibernate-configuration-3.0.dtd">

Hibernate学习笔记

1、类：在一的一方存在多方的集合最匹配的类型Set
2、数据库设计：同上
3、annatation:@OneToMany 默认情况下当多对多处理、会创建一个临时表
4、解决方法： @OneToMany
@JoinColumn(name="groupID")
5、XML：<set name="setname">
public Set<Student> getStudent(){
return student;
}
<key-property name="id"></key-property>
<key-property name="name"></key-property>
</composite-id>
<property name="age"></property>
-------------6----------------
一对一：oneToOne
@JoinColumn(name="wifeID") 使用外键列进行实体的关联.
Annatation配置一对一的双向外键关联:
@OneToOne(mappedBy = "wifeID")
示例：在wife类中的getHusband()方法上注解
只要有双向关联mappedBy必设置定义一边即可
分布式事务：同时对两个数据库进行操作、但此操作又属于同一事务.需要web服务器支持（Tomcat不能实现）
------对象的三种状态--------

Hibernate学习笔记

Hibernate项目的构建与配置1.在项目里倒入Hibernate所必须的Jar包(1)Hibernate框架可以使用在任何的Java项目里，并不一定是Web项目。

只需要在项目里倒入Hibernate所必须要使用的jar包就可以了。

(2)在Hibernate的官网下载hibernate-release-4.2.2.Final.zip解压，要使用Hibernate必须导入的jar包就在目录“hibernate-release-4.2.2.Final\lib\required”下。

倒入此路径下的所有jar包就可以了。

2.配置hibernate.cfg.xml文件(1)配置hibernate.cfg.xml文件可以参考“\project\etc”目录下的hibernate.cfg.xml文件与hibernate.properties文件。

(2)使用Hibernate连接MySQL的hibernate.cfg.xml配置文件如下：<!DOCTYPE hibernate-configuration PUBLIC"-//Hibernate/Hibernate Configuration DTD 3.0//EN""/dtd/hibernate-configuration-3.0.dtd"><hibernate-configuration><session-factory>（设置显示Hibernate产生的SQL语句）<property name="show_sql">true</property>（设置MySQL的SQL语法的方言）<property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>（设置MySQL的驱动程序）<property name="hibernate.connection.driver_class">org.gjt.mm.mysql.Driver</property>（设置MySQL的数据库路径、用户名、密码）<property name="hibernate.connection.url">jdbc:mysql:///java</property><property name="ername">root</property><property name="hibernate.connection.password">lizhiwei</property>（设置当数据库要保存的表不存在时，就新建表）<property name="hibernate.hbm2ddl.auto">update</property>（设置对象与数据库表的关系映射文件）<mapping resource="vo/User.hbm.xml"/></session-factory></hibernate-configuration>(3)此配置文件一般放在项目的src目录下。

hibernate培训笔记

hibernate培训笔记2006年11月1 7日hibernate简史3标准方面3ORM(object relational mapping) 3成功之道4何为hibernate 4持久层设计5持久层概念5ORM(object relational mapper)对象-关系型数据映射组件5设计模式5资源治理模式5解藕合设计6体系结构6概况6实例状态7O/R映射7basic o/r mapping 7集合类映射8关联关系映射8组件映射8继承映射8核心接口8分类8详解9数据检索12Hibernate Query Language (HQL) 12Criteria queries (QBC) 12Native SQL queries 12开发12差不多配置12高级配置13hibernate最佳实践13参考13hibernate简史hibernate是在JDBC之上提供一层薄薄的封装，在提供完全透亮的持久化机制的同时又提供尽可能多的灵活性。

相比之ibatis则是面向“语句映射”的层面，使用SQL作为查询语言。

标准方面J2EE提供了两个持久化的手段：JDBC，它是J2SE中访咨询关系数据库系统的标准API，然而却以一种错误的编程模型来强制开发者用java代码来处理关系思想；另一个是实体Beans ,它是EJB中专门模型化持久化实体的组件，一是不能处理持久对象间的关系，二是使用了糟糕的查询语言，三是难于测试。

ORM(object relational mapping)由于J2EE持久化标准关于处理对象与关系的尴尬，而且持久化咨询题的解决方案是由关系-对象映射（ORM）来解决的，它能够透亮地持久化一般java对象（POJO）。

因此，ORM框架悠然而生。

1990年，一些商业的ORM工具就显现了，例如TopLink。

但由于其价格昂贵、结构复杂同时与Sun的实体bean标准相左，因此专门少人会用。

2001年末，hibernate第一个正式版本对外公布，赢得了开源社区的一片赞誉。

Hibernate学习笔记

Hibernate 复习笔记一、第一个应用实例1．搭建环境：新建一个名为HibernateDemo的java工程，并导入Hibernate的jar包，特别要注意除了导入lib下的jar包还需导入hibernate3.jar核心jar包。

由于涉及数据库操作，还应导入mysql驱动包。

说明，如果使用最新的hibernate，hibernate开发的基本jar包(7个) 来源：hibernate-distribution-3.3.2.GA.ziphibernate3.jarlib\required下的所有jar包2．简述Hibernate的作用：ORM：Object Relational Mapping，对象关系映射。

将java 程序中的对象自动持久化到关系数据库中。

而Hibernate的作用好比就是在java对象与关系数据库之间的一座桥梁，它主要负责两者之间的映射。

在Hibernate内部封装了JDBC 技术（但只是一个轻量级的封装，因而可以让程序设计人员更方便的以面向对象的思想操纵数据库），并向外提供API接口。

3．建新一个名为User.java的类，即是上面所说的java对象。

我们以后称这种类为实体类（或是持久化类），它的对象为实体对象（或是持久化对象）。

User.java内容如下：package com.asm.hibernate.domain;import java.util.Date;public class User {private int id;private String name;private Date date;public int getId() {return id;}public void setId(int id) {this.id = id;}public String getName() {return name;}public void setName(String name) { = name;}public Date getDate() {return date;}public void setDate(Date date) {this.date = date;}}4．编写配置文件：User.hbm.xml。

hibernate学习笔记

第一次课：持久化：就是把瞬时状态的数据转变为持久化状态的数据，这一个过程就是持久化。

（java中内存分为：栈（变量，方法，形参都是在栈上），堆（new出来的对象在堆上））1）瞬时状态：刚new出来，在内存中存在的对象就是瞬时状态的。

如果程序结束，对象就会被回收。

2）持久化状态：在磁盘或者是数据库中存在的数据就是持久状态。

Hibernate是什么？1）是一个优秀的持久化框架，对jdbc进行进一步的封装。

（hibernate，ibatis ）。

2）是一个ORM (Object relation mapping ).Mysql,oracle,access 是关系型数据库=hibernate操作的是对象。

使用hibernate的步骤：1）新建项目2）引入jar包（hibernate最少依赖8个jar包）3）新建 hibernate配置文件（hibernate.cfg.xml） ,放在src根目录下面。

用于数据库的配置信息。

<hibernate-configuration><session-factory><property name="connection.driver_class">com.mysql.jdbc.Driver</property><property name="ername">root</property><property name="connection.password">abc</property><property name="connection.url">jdbc:mysql:///fwcz</property><property name="dialect">org.hibernate.dialect.MySQLDialect</property><property name="hbm2ddl.auto">create</property></session-factory></hibernate-configuration>4)写bean/vo类，并且编写映射文件。

Hibernate学习笔记

Hibernate的名字的意义
将JDBC冷冻起来，hibernate的本身的意思是“冬眠”，意思就是让开发者对于JDBC的使用“冻结”起来，其实就是一个封装的概念，Hibernate其实就是对JDBC操作的一个封装
我们把Hibernate叫做一个持久层框架，就是因为hibernate专注于数据库的持久化实现
类和属性的名称不能随意修改，包括大小写，必须严格对应
关于表名和字段名不区分大小写
关于映射后的查询语句
在SQL语句中，你查询可以这样：
select ename,job,sal from emp
select * from emp
这里的*可以代表所有字段
注意，在hibernate中：
OR如何来映射？
1.必须借助于DB Driver连接描述，实际上一个hiberante工具
选择Database explorer，切换到DB Browser视图,新建一个DB Driver，名称可以任意起
2.使用Hibernate映射工具，开始R----O的转换
转换的时候你可以根据自己的需要来选择产生的类
3.Hibernate的连接工厂类HibernateSessionFactory，这个类中默认包含了如何连接数据库并获取数据库连接的代码，以及如何关闭数据库的代码
下一步，如何来操作数据库，比如查询
且慢，hiberante是基于ORM的实现
也就是，hiberante将数据库的表映射成了java类，所以你要对数据库的表来操作，需要先进行类的转换
//关闭数据库连接
HibernateSessionFactory.closeSession();
}

Hibernate笔记

Hibernate笔记一、为什么要学习Hibernate替代JDBC，提高效率。

解决对象和关系的映射问题。

Hibernate的优点：1、开源和免费，可以在需要的时候研究源代码，改写源代码，进行功能的定制。

2、轻量级封装，避免引入过多复杂的问题，调试容易，也减轻程序员的负担。

3、具有可扩展性，API开放，当本身功能不够用的时候，可以自己遍码进行扩展。

4、开发者活跃，产品有稳定的发展保障。

二、对象持久化1、为什么要对象持久化使信息能够在程序中断甚至断电的情况下长期存在，并能够通过适当的方式重新还原为信息等同、结构相似的对象。

2、什么是对象持久化所谓对象持久化，就是将封装在对象中的信息保存在硬盘、磁带等这类物理媒介上。

对象序列化就是一种对象持久化技术，但它是基于文件系统的。

三、持久化对象的状态四、持久化对象的生命周期程序代码 Customer 对象的生命周期 Customer 对象的状态session.beginTransaction();User user1 = new User(1,”Tom”);开始生命周期临时状态 session.save(user1);处于生命周期中转化成持续化状态 Long id = user1.getid();User user2 = (User)session.get(User.class,id);session.getTransaction().commit();处于生命周期中转化成持续化状态 session.close();处于生命周期中转化成游离状态 System.out.println(user2.getName());处于生命周期中转化成游离状态 User2 = null;结束生命周期结束生命周期五、 Hibernate 中常用的接口1、Configuration 接口 {org.hibernate.cfg.Configuration}实例化Configuration 对象，并且从hibernate.cfg.xml 文件中读取信息 Configuration conf=new Configuration.configure();2、SessionFactory 接口：{org.hibernate.SessionFactory}这是一个设计模式，用户从SessionFactory中获取Session对象的实例。

hibernate笔记

configuration.addClass(Customer.class);sf = configuration.buildSessionFactory();}（2）新增保存：save方法/**保存*/@Testpublic void save(){Session s = sf.openSession();Transaction tr = s.beginTransaction();Customer c = new Customer();c.setName("洪七公");c.setAge(60);c.setDes("帮助");s.save(c);mit();//实质上执行了2步操作，1：s.flush();//清理缓存，让session缓存中的数据与数据库同步，2：事务提交s.close();//Session的缓存就没有了}（3）更新：update方法/**更新*/@Testpublic void update(){Session s = sf.openSession();Transaction tr = s.beginTransaction();Customer c = new Customer();c.setId(3);c.setName("黄老邪");c.setAge(59);c.setDes("药师");s.update(c);mit();s.close();}（4）删除：delete方法@Testpublic void delete(){Session s = sf.openSession();Transaction tr = s.beginTransaction();Customer c = new Customer();c.setId(3);s.delete(c);mit();s.close();}（5）查询：get和load方法/**使用ID查询信息*/@Testpublic void findCustomerById(){Session s = sf.openSession();Transaction tr = s.beginTransaction();Customer c = (Customer) s.get(Customer.class, 2);System.out.println(c.getId()+" "+c.getName()+""+c.getAge()+" "+c.getDes());mit();s.close();}（6）查询：query查询（支持hql语句，sql语句，qbc语句）/**查询所有信息*/@Testpublic void findAllCustomerList(){Session s = sf.openSession();Transaction tr = s.beginTransaction();/**使用Hql语句：操作持久对象和属性* 复习sql语句：操作数据库表和数据库表的列*/Query query = s.createQuery("from Customer o");List<Customer> list = query.list();if(list!=null && list.size()>0){for(Customer c:list){System.out.println(c.getId()+" "+c.getName()+" "+c.getAge()+" "+c.getDes());}}mit();s.close();}●hibernate在内存地址中存在一个一级缓存，存在在一级缓存中的对象，就说明该对象具有了持久化的能力，如果对象具有持久化能力就能操作数据库。

hibernate 学习笔记精要

使用hibernate编程，继承了面向对象编程的特点，使我们屏蔽了直接的拼sql语句对数据库表进行操作。

JDBC操作数据库很繁琐，sql语句编写并不是面向对象的，可以在对象和关系表间建立关联来简化编程，跨数据库平台，只需改写方言Dialect学习建立user library->hibernate，并加入相应的jar包：可以在项目右键build path->configure build path->add library选择user library，在其中新建library，命名为hibernate，加入所需的包（hibernate core、required、slf4j jar、log4j.jar）配置文件hibernate.cfg.xml一般放在src根目录下面，这样当读取这个配置文件时，就可以直接使用configuration.configure()方法,而不需设置这个配置文件所在路径所有的POJO最好都放到一个package下面，这样与之对应的映射文件*.hbm.xml也都放在了那下面在hibernate3以后开始支持annotation，目标是建立符合JPA标准的annotation，可以下载与hibernate版本对应的annotation包，引入三个jar包：hibernate-commons-annotations.jar，ejb3-persistence.jar，hibernate-annotations.jar。

new Configuration时，要使用AnnocationConfiguration使用注解时，如果想要当自己一键入@就给提示，content-assist的activation中加上@符号就可以了。

目前比较流行的ORM框架有hibernate，toplink，jdo，ibatis(“半自动化”的ORM实现，而非“一站式”)，jpa；jpa(意愿一统天下)slf是一个日志框架，针对不同的实现，我们只需引入相关的jar包，比如slf4j nop,log4j, jdk logging, commons-logging，这种方式很像JPA，JDBC我们可以常常看看project->etc下面的一些文件，主要是些配置文件，我们用的时候可以参考，比如log4j.properties注解有的是写给javac编译器看的，有的是写给java运行环境看的。

Java相关课程系列笔记之十四Hibernate学习笔记-(28076)

Hibernate学习笔记Java相关课程系列笔记之十四笔记内容说明Hibernate（梁建全老师主讲，占笔记内容100%）；目录一、Hibernate的概述 (1)1.1 Hibernate框架的作用 (1)1.2 Hibernate访问数据库的优点 (1)1.3 JDBC访问数据库的缺点 (1)1.4 Hibernate的设计思想 (2)二、Hibernate的基本使用 (3)2.1 Hibernate的主要结构 (3)2.2 Hibernate主要的API (3)2.3 Hibernate使用步骤 (4)2.4 HQL语句（简要介绍） (15)三、数据映射类型 (16)3.1映射类型的作用 (16)3.2 type映射类型的两种写法 (16)四、Hibernate主键生成方式 (18)4.1五种生成方式 (18)五、Hibernate基本特性 (20)5.1对象持久性 (20)5.2处于持久状态的对象具有的特点 (20)5.3三种状态下的对象的转换 (21)5.4批量操作：注意及时清除缓存 (21)5.5案例：三种状态下的对象使用 (21)5.6一级缓存机制（默认开启） (23)5.7一级缓存的好处 (23)5.8管理一级缓存的方法 (24)5.9延迟加载机制 (26)5.10具有延迟加载机制的操作 (26)5.11常犯的错误 (26)5.12延迟加载的原理 (27)5.13 Session的get和load方法的区别 (28)5.14延迟加载的好处 (28)5.15案例：测试延迟加载 (29)5.16案例：重构NetCTOSS资费管理模块 (30)5.17 Java Web程序中如何用延迟加载操作（OpenSessionInView） (35)六、关联映射 (41)6.1一对多关系one-to-many (41)6.2多对一关系many-to-one (43)6.3多对多关联映射many-to-many (45)6.4关联操作（查询join fetch/级联cascade） (49)6.5继承关系映射 (57)七、Hibernate查询方法 (63)7.1 HQL查询 (63)7.2 HQL和SQL的相同点 (63)7.3 HQL和SQL的不同点 (63)7.4 HQL典型案例 (64)7.5 Criteria查询 (71)7.6 Native SQL原生SQL查询 (73)八、Hibernate高级特性 (75)8.1二级缓存 (75)8.2二级缓存开启方法及测试 (75)8.3二级缓存管理方法 (77)8.4二级缓存的使用环境 (78)8.5查询缓存 (78)8.6查询缓存开启方法及测试 (78)8.7查询缓存的使用环境 (79)九、Hibernate锁机制 (80)9.1悲观锁 (80)9.2悲观锁的实现原理 (80)9.3悲观锁使用步骤及测试 (80)9.4乐观锁 (83)9.5乐观锁的实现原理 (83)9.6乐观锁使用步骤及测试 (83)十、其他注意事项 (85)10.1源码服务器管理工具 (85)10.2利用MyEclipse根据数据表自动生成实体类、hbm.xml (85)10.3根据实体类和hbm.xml生成数据表 (88)10.4 Hibernate中分页查询使用join fatch的缺点 (88)10.5 Hibernate的子查询映射 (89)一、Hibernate的概述1.1 Hibernate框架的作用Hibernate框架是一个数据访问框架（也叫持久层框架，可将实体对象变成持久对象，详见第5章）。

Java相关课程系列笔记之十四Hibernate学习笔记

1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。

！Hibernate学习笔记Java相关课程系列笔记之十四笔记内容说明Hibernate（梁建全老师主讲，占笔记内容100%）；目录一、 Hibernate的概述 0Hibernate框架的作用 0Hibernate访问数据库的优点 0JDBC访问数据库的缺点 0Hibernate的设计思想 0二、 Hibernate的基本使用 (1)Hibernate的主要结构 (1)Hibernate主要的API (1)Hibernate使用步骤 (1)HQL语句（简要介绍） (3)三、数据映射类型 (3)映射类型的作用 (3)type映射类型的两种写法 (3)四、 Hibernate主键生成方式 (3)五种生成方式 (3)五、 Hibernate基本特性 (4)对象持久性 (4)处于持久状态的对象具有的特点 (4)三种状态下的对象的转换 (4)批量操作：注意及时清除缓存 (4)案例：三种状态下的对象使用 (4)一级缓存机制（默认开启） (4)一级缓存的好处 (4)管理一级缓存的方法 (4)延迟加载机制 (4)具有延迟加载机制的操作 (4)常犯的错误 (4)延迟加载的原理 (4)Session的get和load方法的区别 (4)延迟加载的好处 (5)案例：测试延迟加载 (5)案例：重构NetCTOSS资费管理模块 (5)Java Web程序中如何用延迟加载操作（OpenSessionInView） (5)六、关联映射 (5)一对多关系one-to-many (5)多对一关系many-to-one (5)多对多关联映射many-to-many (5)关联操作（查询join fetch/级联cascade） (5)继承关系映射 (5)七、 Hibernate查询方法 (6)HQL查询 (6)HQL和SQL的相同点 (6)HQL和SQL的不同点 (6)HQL典型案例 (6)Criteria查询 (6)Native SQL原生SQL查询 (7)八、 Hibernate高级特性 (7)二级缓存 (7)二级缓存开启方法及测试 (7)二级缓存管理方法 (7)二级缓存的使用环境 (7)查询缓存 (7)查询缓存开启方法及测试 (7)查询缓存的使用环境 (7)九、 Hibernate锁机制 (7)悲观锁 (7)悲观锁的实现原理 (7)悲观锁使用步骤及测试 (7)乐观锁 (7)乐观锁的实现原理 (7)乐观锁使用步骤及测试 (7)十、其他注意事项 (7)源码服务器管理工具 (7)利用MyEclipse根据数据表自动生成实体类、 (7)根据实体类和生成数据表 (7)Hibernate中分页查询使用join fatch的缺点 (7)Hibernate的子查询映射 (8)一、Hibernate的概述Hibernate框架的作用Hibernate框架是一个数据访问框架（也叫持久层框架，可将实体对象变成持久对象，详见第5章）。

通过Hibernate框架可以对数据库进行增删改查操作，为业务层构建一个持久层。

可以使用它替代以前的JDBC访问数据。

Hibernate访问数据库的优点1）简单，可以简化数据库操作代码。

2）Hibernate可以自动生成SQL，可以将ResultSet中的记录和实体类自动的映射（转化）。

3）Hibernate不和数据库关联，是一种通用的数据库框架（支持30多种数据库），可以方便数据库移植。

任何数据库都可以执行它的API。

因为Hibernate的API中是不涉及SQL 语句的，它会根据Hibernate的配置文件，自动生成相应数据库的SQL语句。

JDBC访问数据库的缺点1）需要编写大量的复杂的SQL语句、表字段多时SQL也繁琐、设置各个问号值。

2）需要编写实体对象和记录之间的代码，较为繁琐。

3）数据库移植时需要修改大量的SQL语句。

Hibernate的设计思想Hibernate是基于ORM（Object Relation Mapping）思想设计的，称为对象关系映射。

负责Java对象和数据库表数据之间的映射。

Hibernate是一款主流的ORM工具，还有其他很多ORM工具，如：MyBatis（以前叫iBatis）、JPA。

Hibernate功能比MyBatis强大些，属于全自动类型，MyBatis属于半自动。

但全自动会有些不可控因素，因此有些公司会用MyBatis。

ORM工具在完成Java对象和数据库之间的映射后：1）在查询时，直接利用工具取出“对象”（不论是查询一条记录还是多条记录，取出的都是一个个对象，我们不用再去转化实体了）。

2）在增删改操作时，直接利用工具将“对象”更新到数据库表中（我们不用再去把对象转成数据了）。

3）中间的SQL+JDBC细节，都被封装在了工具底层，不需要程序员参与。

注意事项：Java程序想访问数据库，只能通过JDBC的方式，而Hibernate框架也就是基于ORM思想对JDBC的封装。

Hibernate是以“对象”为单位进行数据库的操作。

二、Hibernate的基本使用Hibernate的主要结构1）（仅1个）：Hibernate的主配置文件，主要定义数据连接参数和框架设置参数。

注意事项：就是个xml文件，只是名字比较奇葩！2）Entity实体类（n个，一个表一个）：主要用于封装数据库数据。

3）映射文件（n个）：主要描述实体类和数据表之间的映射信息。

描述表与类，字段与属性的对应关系。

注意事项：是个后缀，如：命名可写。

Hibernate主要的API1）Configuration：用于加载配置信息。

用于创建SessionFactory。

2）SessionFactory：存储了中描述的信息，内置了一些预编译的SQL，可以创建Session 对象。

3）Session：负责对数据表执行增删改查操作。

表示Java程序与数据库的一次连接会话，是对以前的Connection对象的封装。

和JSP中的session不是一回事，就是名字一样而已。

4）Query：负责对数据表执行特殊查询操作。

5）Transaction：负责Hibernate操作的事务管理。

默认情况下Hibernate事务关闭了自动提交功能，需要显式的追加事务管理（如调用Transaction对象中的commit();提交事务）！注意事项：这些API都是在Hibernate包下的，导包别导错！第一次访问数据库比较慢，比较耗资源，因为加载的信息多。

Hibernate使用步骤step1：建立数据库表。

step2：建立Java工程（Web工程也可），引入Hibernate开发包和数据库驱动包。

必须引入的包：、、、、…等step3：添加配置文件，文件内容如下：<xml version='' encoding='UTF-8'><!DOCTYPE hibernate-configuration PUBLIC"-名，指定是哪个类；table：数据库中哪个表；catalog：对Oracle而言为哪个数据库，对MySQl而言为某个用户（MySQl是在用户下建表，Oracle是在库中建表），不写也行（若用工具则会自动生成）。

例如，select * from cost_chang则会在配置文件中定义的库（或用户）下去找表。

若写了则为select * from --><class name="" table="COST_CHANG" catalog="system"><id name="id" type=""><column name="ID" />  <generator class="sequence"><param name="sequence">COST_SEQ_CHANG</param> </generator></id><property name="name" type=""><column name="NAME" /></property><property name="baseDuration" type=""><column name="BASE_DURATION" /></property><property name="baseCost" type=""><column name="BASE_COST" /></property><property name="startTime" type=""><column name="STARTIME" /> </property>…………其他省略…………</class></hibernate-mapping>注意事项：映射文件默认与POJO类放在一起；命名规则为：类名.。