Hibernate学习笔记
Hibernate笔记完整版
day1一. hibernate数据持久化组件对象持久化(Object Persistence):把数据保存在永久存储介质中（数据库）1.为什么要持久化:a.内存是暂时存储设备,断电后数据易丢失b.网络传输无法传输内存中的对象，需要将对象外化c.内存中数据查询,组织不方便d.内存只能存储少量数据2.怎样持久化a.对象序列化 --> 二进制流合并存储,粒度大,无规律不支持检索只适合少数个别对象的序列化b.用JDBC/EJB/ORM 将数据存入数据库用JDBC:(Java DB Connection)优点:底层开发,控制力强(细); 效率最高; 标准的(SQL)JDBC,有可移植性缺点:过于复杂; 代码量大; 可维护性差(代码重用性低);用EJB:(Entity Java Bean)优点:直接自动生成JDBC代码; 持久对象(PO)的状态由服务器管理; 声明式的事务缺点:功能不全(特殊的组件,不能做继承关系); EJB容器是侵入性容器,失去OO的优点; 调试更复杂用ORM:（object relation mapping）对象关系映射优点:自动生成JDBC(代码量下降); 使用(plain oldest java object---pojo),非侵入型; 提供状态管理; 难度下降,不需要容器缺点:由于开源, 文档少; bug多; 技术支持差结论: 用java开发-->必须将数据持久化-->用数据库持久化-->须用ORM-->需要用Hibernate二. Hibernate1.POJO类plain oldest java object,就是标准的Java Bean。
2.HibernateHibernate -->一个可以自动的根据xml完成对象关系映射，并持久化到数据库的开源组件。
其底层也是由JDBC实现的。
hibernate是通过xml文件的配置，对数据库的底层的方言，以及数据库连接所需的信息，以及连接数据库的驱动。
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课堂笔记
Hibernate部分学习笔记讲师:梁建全liangjq@目录Hibernate部分学习笔记 (1)Day01 (5)一、Hibernate基本概念 (5)1、Hibernate是什么，有什么作用和好处 (5)2、Hibernate实现原理 (5)3、Hibernate框架主要结构 (5)二、Hibernate基本应用 (6)1、Hibernate使用步骤 (6)三、映射类型 (9)1、Hibernate映射类型主要有以下几种： (9)四、主键生成 (10)Day02 (11)一、Hibernate框架的基本特性 (11)1、Hibernate一级缓存 (11)A.一级缓存的特点 (11)B.一级缓存的好处 (11)C.使用建议 (11)2、Hibernate对象持久性 (13)3、Hibernate延迟加载 (14)A.针对于以下方法，Hibernate默认使用延迟加载机制： (14)B.Session的get和load方法区别： (14)C.延迟实现原理 (15)D.Hibernate框架如何动态生成一个代理类 (15)E.使用建议 (15)二、Hibernate综合练习 (15)前期案例：任务列表示例重构（采用Struts2+Hibernate） (15)A.Hibernate前期准备 (15)B.为了更好使用一级缓存，采用ThreadLocal封装Session (16)C.采用Hibernate重构ProjectDAO (17)D.为了支持延迟加载API，采用拦截器实现OpenSessionInView模式 (18)Day03 (20)一、什么是关联映射，有什么好处 (20)二、一对多关联映射 (20)示例：d_order和d_item存在一对多的业务关系 (20)一对多关系映射的实现步骤： (20)三、多对一关联映射 (21)多对一关系映射实现步骤： (21)四、关联操作 (22)1、关联查询 (22)2、利用lazy属性控制延迟加载 (22)3、级联操作（采用关系级联方式进行添加、删除、更新操作） (22)A.在关联属性映射部分添加cascade属性，可以指定以下属性 (22)B.Inverse属性的作用 (22)C.级联添加 (23)D.级联删除 (23)Day04 (24)一、如何使用Myeclipse生成映射文件和实体类? (24)1、如何根据DB生成实体类和映射文件 (24)A.利用Myeclipse追加Hibernate框架步骤: (24)B.利用Myeclipse根据表生成实体类和映射文件 (26)二、多对多关系映射 (29)三、继承关系映射 (30)1、继承关系映射（1） (30)A.首先将Book继承自Product类 (30)B.修改Book.hbm.xml描述信息 (30)2、继承关系映射(2)---理解 (31)Day05 (33)一、其他映射 (33)1、List集合映射 (33)2、formula子查询映射 (33)3、Component组件映射 (34)4、联合主键映射 (35)案例：采用联合主键映射+组件映射对t_person表进行操作。
马士兵hibernate学习笔记(文字整理版)
马士兵hibernate学习笔记(文字整理版)课程容 (5)1 HelloWorld (5)2 Hibernate原理模拟 - 什么是O/R Mapping以及为什么要有O/R Mapping (5)3 常见的0/R框架(了解) (5)4 hibernate基础配置（重点） (5)5 ID生成策略（重点 AUTO) (5)6 Hibernate核心开发接口介绍（重点） (5)7 对象的三种状态（了解） (5)8 关系映射（重点） (5)9 Hibernate査询（HQL) (5)10 在Struts基础上继续完善BBS200 (5)11 性能优化（重点） (5)12 补充话题 (5)风格 (5)1 先脉络，后细节 (5)2 先操作，后原理 (5)3 重Annotation,轻xml配置文件 (5)资源 (5)1 . (5)2 hibernate zh_CN文档 (5)3 hibernate annotation references (5)环境准备 (5)1 下载hibernate-distribution-3.3.2.GA-dist (5)2 下载hibernate-annotations-3[1].4.0.GA (5)3 注意阅读hibernate compatibility matrix(hibernate download) (5)4 下载slf4jl.5.8 (6)Hibernate HelloWorld (6)1 建立新java 项目,名为hibernate_0100_HelloWorld (6)2 学习建User-library-hibernate,并加入相应的jar包 (6)3 引入mysql的JDBC驱动包 (6)4 在mysql中建立对应的数据库以及表 (6)5 建立hibernate 配置文件hibernate.cfg.xml (6)6 建立Student 类 (6)7 建立Student 映射文件 Student.hbm.xml (6)8 将映射文件加入到hibernate.cfg.xml中 (6)9 写测试类Main,在Main中对Student对象进行直接的存储测试 (6)10 FAQ： (6)11 Note: (6)12 建立能力 (7)建立 Annotation 版本的 HelloWorld (7)1 创建teacher 表，create table teacher (id int primary key, name varhcar(20), title varchar(lO)); (7)2 创建Teacher 类 (7)3 在hibernate lib 中加入annotation的jar包 (7)4 参考Annotaion文档建立对应的注解 (7)5 在hibernate.cfg.xml中建立映射<mapping class:.../〉 . (7)6 参考文裆进行测试（注意文裆中缺少configure()的小bug) (7)7 FAQ: 不给提示 (7)What is and Why 0/R Mapping (7)1 JDBC操作数据库很繁琐 (7)2 Sql语句编写并不是面向对象的 (7)3 可以在对象和关系表之间建立关联来简化编程 (7)4 0/R Mapping 简化编程 (7)5 0/R Mapping跨越数据库平台 (7)6 Hibernate_0200_OR_Mapping_Simulation (7)0/R Mapping Frameworks (7)1 hibernate (7)2 toplink (8)3 jdo (8)4 JPA (8)Hibernate基础配置 (8)1 对应项目：Hibernate_0300_BasicConfiguration (8)2 介绍MSQL的图形化客户端 (8)3 hibernate.cfg.xml: hbni2ddl.auto (8)4 搭建日志环境并配置显示DDL语句 (8)5 搭建jUnit环境 (8)6 hibernate.cfg.xml：show_sql (8)7 hibernate.cfg.xml：format_sql (8)8 表名和类名不同,对表名进行配置 (8)9 字段名和属性相同 (8)10 字段名和属性名不同 (8)11 不需要psersistence的字段(不用列) (8)12 映射日期与时间类型，指定时间精度 (8)13 映射枚举类型( 比较少用) (9)14 字段映射的位置（field或者get方法） (9)15 Lob (9)16 课外：CLOBBLOB类型的数据存取 (9)17 课外：Hibernate自定义数据类型 (9)18 hibernate 类型 (9)ID生成策略 (9)1 对应项目：hibernate_0400_ID (9)2 注意： (9)3 xml生成id (9)4 注解方式：GeneratedValue (9)5 FAQ; (10)6 联合主键 (10)核心幵发接口介绍 (12)1 hibernate_0500_CoreAPI (12)2 Hibernate API文档需要单独下载 (12)3 Configuration (12)4 SessoinFactor (12)5 Session (12)6 SchemaExport (自动建表) (13)7 Query 接口 (13)8 Note： (13)三种对象状态 (14)1 上一个 project (14)2 三种状态的区分关键在于 (14)3 三种状态： (14)4 对这三种状态需要关注的问题是在该状态下如果进行数据库的操作会发生什么结果，比如改变属性的 (14)关系映射(重要) (15)对象之间的关系 (15)1 这里的关系映射指的是对象之间的关系，并不是指数据库的关系，本章解决的问题是当对象之间处于 (15)2 简化问题： (15)3 —对一 (15)4 —对多 (15)5 组件映射 (15)一对一关联 (16)1 一对一单向外键关联 (16)2 一对一双向外键关联 (16)3 一对一单向主键关联（不重要） (17)4 一对一双向主键关联（不重要） (17)5 联合主键 (17)组件映射 (17)1 项目：hibernate_1100_component (17)2 对象关系：一个对象是另外一个对象的一部分 (17)3 数据库表：一表 (17)4 annotation: Embeddable Embbeded (17)5 xml: 使用<component,例如: (18)多对一与一对多 (18)1 多对一单向关联 (18)2 一对多单向关联 (19)3 一对多（多对一）双向关联 (19)多对多 (20)1 单向关联： (20)2 双向关联： (21)关联关系中的CRUD_Cascade_Fetch (21)1 hibernate_1700_one2many_many2one_bi_crud (21)2 设定cascade以设定在持久化时对于关联对象的操作（CUD，R归Fetch管） (21)3 cascade仅仅是帮我们省了编程的麻烦而已，不要把它的作用看的太大 (21)4 铁律：双向关系在程序中要设定双向关联 (22)5 铁律：双向mappedBy (22)6 fetch (22)7 Update时ManyToOne()中的cascade参数关系 (22)8 Delete时ManyToOne()中的cascade关系 (22)9 O/RMapping 编程模型 (23)10 要想删除或者更新先做load,除了精确知道ID之外 (23)11 如果想消除关联关系，先设定关系为null.再删除对应记录，如果不删记录，该记录变成垃圾数据 (23)12 练习：多对多的CRUD (23)关系映射总结 (24)1 什么样的关系，设计什么样的表，进行什么样的映射 (24)2 CRUD,按照自然的理解即可（动手测试） (24)集合映射（不太重要） (24)1 项目名称：hibernate_1800_Collections_Mapping (24)2 Set (24)3 List (与Set差不多多个OrderBy) (24)4 Map (24)继承映射（不太重要） (24)1 三种方式 (24)作业: (24)1 学生课程、分数的设计(重要) (24)2 设计： (25)3 树状结构的设计（至关重要） (25)Hibernate 查询(Query Language) (26)HQL vs EJBQL (26)1 NativeSQL >HQL.> EJBQL(JPQL 1.0) > QBC(Query By Criteria) > QBE(Query By Example)" 262 总结：QL应该和导航关系结合，共同为査询提供服务。
hibernate(持久化)学习笔记
hibernate(持久化)学习笔记一、什么是hibernatehibernate是数据访问层(dao层)的框架，对jdbc的封装，针对数据访问层提出面向对象方式，它允许访问对象，间接的操作数据库，自动生成Sql语句，简化dao层的代码，提高开发效率二、hibernate优缺点优点：1、使用jsbc遇到问题--代码中SQL语句--SQL语句中大量的?,需要手动赋值--查询结果手动赋值给model类--SQL语句有特殊关键字或函数，数据库与数据库不能通用2、使用hibernate会解决以上问题--操作对象自动生成SQL语句--自动赋值--查询结果自动赋值给model类--hibernate使用的是hql,根据方言的配置,生成不同数据库的SQL语句,hibernate可以跨数据库平台缺点：1、SQL语句自动生成，人工无法控制，使得SQL语句指行效率慢2、执行效率慢三、什么是ORM*****ORM全称：Object Relation Mapping对象关系映射是一种开发模式，编程思想是为了解决面向对象语言与面向关系型数据库不匹配现象，通过一个配置文件进行关联映射，类表对象记录属性字段优点：使得数据访问层完全面向对象，不用考虑关系型数据库，只要会操作对象就行，使得编程更简单ORM框架：hibernate、mybati、sping jdbc四、搭建hibernate框架1、导包，在hibernate-release-4.3.11.Final包下，\lib\required目录下所有jar包2、引用hibernate主配置文件（hibernate.cfg.xml)到项目classPath路径3、编写一个model类对应数据库的表，配置xxx.hbm.xml映射文件，一个类对应一个映射文件，把表名与类名绑定，把字段名与属性名绑定4、编写hibernate API测试环境五、hibernate工作原理*****1、Configuretion读取并解析配置文件(主配置文件，映射文件)2、使用Configuration对象创建SessionFactory(一个数据库对应一个SessionFactory)3、使用SessionFactory对象打开session(session是数据库会话，一个session代表一次数据库操作)4、使用session对象创建事务(Transaction事务)5、持久化操作(增、删、改、查、(查询不需要事务）)6、关闭session7、当前应用程序关闭，关闭SessionFactory注：SessionFactory是重量级对象，创建很费时，占用时间大，只会创建一次，关闭一次六、hibernate核心组件*****1、hibernate.cfg.xml是hibernate主配置文件，用来配置数据库信息与hibernate框架相关参数2、xxx.hbm.xml是hibernate映射文件，类与表之间的映射文件，类对应表，属性对应字段3、实体类使用类封装数据库的表，一个类对应一个表，一个属性对应一个字段，一定要实现Serializable接口4、hibernate的API用于读取并解析配置文件，然后根据映射关系生成SQL语句，间接操作数据库七、hibernate查询方式1、主键查询session.get()2、hql查询crateQuery(hql)3、SQL查询SQLQuery(sql)4、QBC查询Criteria(object.class)效率：主键查询>SQL查询>hql查询>QBC查询hql=sql+面向对象补记：session方法：save()添加update()修改saveOrUpdate()添加或修改（若果主键有值，则是修改，若果主键无值，则是添加）get()根据id查询createQuery()查询所有delete()删除分页查询：createQuery("from Person").setFirstResult(startIndex)//起始位置.setMaxResults(pageSize)//总共查询多少条.list();uniqueResult()数据库中根据你的查询条件只会返回唯一结果八、hibernate核心开发API(接口)1、Configuration：是一个类，读取并解析配置文件(注配置文件与映射配置文件)2、SessionFactory：是一个接口，与数据库连接，一个数据库对应一个SessionFactory3、Session：是一个接口，代表数据会话，做增删改查操作4、Transition：是一个接口，做数据库事务5、Query：是一个接口，用于数据库查询，包含：hql、SQL6、Criteria：是一个接口，用于数据库查询、QBC查询九、hibernate映射类型hibernate映射文件(xxx.hbm.xml)中，java中数据类型与数据库数据类型相互转换，通过type属性进行指定，类型如下：1、整数型java数据类型hibernate数据类型byte byteshort shortint integerlong long2、浮点型java数据类型hibernate数据类型float floatdouble double3、字符串java数据类型hibernate数据类型ng.String String4、时间java数据类型hibernate数据类型java.util.Date datejava.sql.Date datejava.sql.Time datejava.sql.Timestamp timestamp十、beginTransition()与getTransition()区别*****beginTransition()方法：在session的上下文内容中始终创建一个新的事务getTransition()方法:在session的上下文内容中获取一个事务，如果session中从来没有beginTransition()过, getTransition() 是无法获取返回null;十一、查询方法延迟加载1、什么是方法的延迟加载*****hibernate中存在一些查询方法,在执行查询时并没有马上发送SQL语句去数据库查询，而是返回一个空值对象(空值对象不是null),而是新new出来的对象,除主键外其他属性值都是空的,当程序真正用到此对象时，才会发送SQL语句去数据库中查询,把结果赋值给此对象,这种查询称为方法的延迟加载注：程序使用到此对象的属性时，就是真正用到了此对象2、为什么要延迟加载a、在延迟的这段时间内，并没有访问数据库，可以节约内存空间，减少数据库的访问，提高使用率b、可以防止代码泄露，没有真正使用到对象是不会发送SQL语句的，可以节约内存，减少数据库的访问，提高会用率3、如何使用延迟加载的方法a、hibernate中一些方法自带延迟加载功能，只要使用这些方法，，就可以使用延迟加载b、哪些方法具有延迟加载：延迟加载立即加载session.load()session.get()query.iterate()query.list()4、get()与load()区别*****get()：立即加载，立即发送SQL语句查询，如果查询不到结果返回nullload():延迟加载，不会发送SQL语句查询，返回一个空值对象，真正使用到此对象时，才会发送SQL语句查询，如果查询不到结果会抛出org.hibernate.ObjectNotFoundException异常十二、一级缓存*****1、什么是一级缓存SessionFactory创建session时，会给每个session另外分配一片内存空间，这片内存空间称为一级缓存，用于缓存session操作过的对象，一级缓存是由session 管理并使用，所以也称session管理2、一级缓存的生命周期*****一级缓存的生命周期与session是一致的，SessionFactory对象.openSession(),session被创建一件缓存被分配, session.close()关闭时，一级缓存被回收3、一级缓存的作用作用：一级缓存用于缓存对象数据，相同的数据对象不用每次发送SQL语句去数据库查询，提高查询效率步骤：session查询优先于一级缓存，首先会去一级缓存中查询，如果一级缓存中没有，才会发送SQL语句去数据库查询,查询结果会在一级缓存中存一份，如果再次查询，直接从一级缓存中获取，不会发送SQL语句4、如何使用一级缓存a、一级缓存默认启动，自动使用，session创建时，一级缓存存在，session.close()关闭时，一级缓存消失b、特点(规则)*****i、一级缓存，session与session之间不能共享ii、session查询一组数据时，会将一组数据拆成每个对象存储在一级缓存中，一级缓存存储的是单个对象iii、session操作过的对象，一级缓存中一定会存在不受事务影响，事务的提交或回滚不会清除一级缓存，除非是session被清除或关闭iv、当session.delete(object)时，会在一级缓存中标记此对象为null，再次查询不会发送SQL语句，返回一个null值，当事务提交，以一级缓存为主，发送delete语句到数据库删除，并且会吧此对象在一级缓存中删除，再次查询一级缓存中没有，会发生SQL语句进行查询c、管理一级缓存*****一级缓存是session使用的，由session管理sessio.close()一级缓存回收sessio.clear()清空一级缓存sessio.evict(Object)清除一级缓存某个对象sessio.flush()刷新一级缓存，手动同步一级缓存与数据库，如果一级缓存与数据库不一致,以一级缓存为主,发送SQL语句修改数据库十三、对象的持久性*****1什么是对象持久性session操作对象时，不同的阶段变化，把操作对象看做三个状态：瞬时态、持久态、游离(托管)态2、三个状态的特点(规则)a、瞬时态(transient)--对象被刚刚new出来，称为瞬时态--一级缓存中没有，数据库没有b、持久态(persistent)--被session操作过，一级缓存中有，数据库有，称为持久态--save()、update()、saveOrUpdate()、get()、load()、hql、SQL、QBC方式操作过的对象都是持久态c、游离(托管)态（detached）--一级缓存中没有，数据库有--通过close()、clear()、evict(object)、操作过的对象称为游离(托管)态十四、关系映射*****1、什么是关系映射如果两张表之间有关系，hibernate允许把这种关系提取出来，并且映射到配置文件中，在对一张表进行操作时，hibernate通过映射关系，间接操作另一张表，这两张表的关系配置就是关系映射2、关系映射的类型*****多对一一对多一对一*****多对多注：能用单项映射，绝对不要用双向映射十五、多对一(重点)与一对多1、什么是多对一或一对多两个表之间的关系是多对一或一对多，会在多的那段增加一个外键字段，指向一的那段主键，两个类之间的关系是多对一或一对多，会在多的那段增加一个类属性，指向一那端的类2、案例学生与班级的案例，多个学生属于一个班级，一个班级有多个学生十六、关联操作*****1、关联查询(查)a、延迟加载对于关联属性，hibernate默认采取了延迟加载，查询一端时不会关联查询另一端lazy="proxy"默认方式，多对一标签，一对一标签，采用懒加载lazy="false"立即加载，关联的表都会查询一遍lazy="true"默认方式，一对多标签，多对多标签，采用懒加载b、连接查询fetch="select"默认方式，使用多条SQL语句完成查询，支持懒加载fetch="join"使用一条SQL语句完成查询，懒加载会失效c、使用join的hql查询String hql="from Student t left join fetch t.classes where t.id=:id";//左外连接String hql="from Student t join fetch t.classes where t.id=:id";//内连接注：只支持这两种2、级联(关联)操作(增删改)a、什么是级联操作在对一张表进行增删改时关联的另一张表也做增删改操作b、如何设置级联操作在映射文件中，关联映射配置中使用cascade属性做级联操作，取值如下：none缺省，不支持级联操作all增删改都支持级联操作save-update增、改支持级联操作delete删除支持级联操作注：建议不用级联操作，使用手动代码操作十七、一对一(了解)1、什么是一对一主键一对一：保证两个表的主键一一对应外键一对一：在任意一端增加一个外键，执行另一端的主键，外键保证唯一性2、案例学生与档案一对一，在学生表中增加一个外键，指向档案表的主键，外键保证唯一性注：<many-to-one/>标签写在哪个类上，哪个类对应的表就会增加一个外键字段十八、多对多(重点)1、什么是多对多如果两张表的关系是多对多关系，那么必然产生一张中间表，中间表只有两个字段，分别是两张表的主键字段，这两个主键字段组成复合主键2、案例多个学生有多个老师教十九、二级缓存1、什么是二级缓存二级缓存是SessionFactory级别的缓存，在同一个SessionFactory对象下，查询相同的数据对象，只会发送一条SQL语句，也称为SessionFactory缓存2、如何使用二级缓存二级缓存不是默认开启的，需要配置环境，步骤如下：a、增加jar包ehcache-core-2.4.3.jarhibernate-ehcache-4.3.11.Final.jarslf4j-api-1.6.1.jarb、在hibernate.cfg.xml配置文件中开启二级缓存，并且配置驱动类，配置如下：<!--开启二级缓存--><property name="e_second_level_cache">true</property><!--配置二级缓存的驱动--><propertyname="hibernate.cache.region.factory_class">org.hibernate.cache.ehcache.EhCacheRegionFactory</property>c、把二级缓存文件放入项目中，ehcache.xmld、在xxx.hbm.xml文件中配置哪些对象需要放入二级缓存，配置如下：<!--声明把该对象放入到二级缓存中--><cache usage="read-only"/>3、一级缓存与二级缓存的区别一级缓存是session级别的缓存，session与session之间不能共享，默认自动开启二级缓存是SessionFactory级别的的缓存，session与session之间能共享，二级缓存需手动开启。
hibernate4学习笔记
hibernate4学习笔记Hibernate4学习笔记本⼈全部以⾃学为主，在⽹上收集各种学习资料，总结归纳学习经验，现将学习路径给予⼤家分享。
此次学习的hibernate的版本是：hibernate-release-4.2.4.Final（截⽌2015年7⽉31⽇最新版），JAVA的版本是：java8.0，使⽤的开发⼯具是：Eclipse Mars Release (4.5.0)。
第⼀天：Hibernate4基础知识和HelloWorld简单编程Hibernate是⼀种半成品ORM框架，对数据库持久化操作，程序员对数据库的操作转换成对对象的操作。
ORM 采⽤元数据来描述对象-关系映射细节, 元数据通常采⽤XML 格式, 并且存放在专门的对象-关系映射⽂件中。
HelloWorld简单编程1、准备Hibernate环境（1）导⼊Hibernate的Jar包，如下：（2）导⼊Mysql驱动包，我⽤的数据库是：Mysql 5.0，数据库驱动包如下：以上所有Jar加完毕之后，需要加⼊到Eclipse⾃⾝系统⾥⾯，具体如下：以上操作完毕之后，Hibernate的环境就算搭建完毕，下⾯就可以进⼀步操作。
2、配置hibernate.cfg.xml⽂件，主要是对数据库的连接，具体如下："-//Hibernate/Hibernate Configuration DTD 3.0//EN""/doc/63fa364d5022aaea998f0fde.html /hibernate-configuration-3.0.dtd ">rootmysqlname="connection.driver_class">com.mysql.jdbc.Driver jdbc:mysql:///Test(或者：jdbc:mysql://localhost:3306/Test)name="dialect">org.hibernate.dialect.MySQLInnoDBDialecttruetrueupdate3、编写⼀个实例类News.java，具体代码如下：package com.hibernate.helloworld;import java.sql.Date;public class News {private Integer id;private String title;private Date date;public Integer getId() {return id;}public void setId(Integer id) {this.id = id;}public String getTitle() {return title;}public void setTitle(String title) {this.title = title;}public String getAuthor() {return author;}public void setAuthor(String author) {this.author = author;}public Date getDate() {return date;}public void setDate(Date date) {this.date = date;}public News(String title, String author, Date date) { super();this.title = title;this.author = author;this.date = date;}public News(){}@Overridereturn"News [id="+ id+ ", title="+ title+ ", author="+ author + ", date=" + date + "]";}}4、创建News.hbm.xml配置映射⽂件，具体代码如下："/doc/63fa364d5022aaea998f0fde.html /hibernate-mapping-3.0.dtd">5、将映射⽂件News.hbm.xml指定到hibernate.cfg.xml配置⽂件⾥⾯，即在hibernate.cfg.xml⽂件⾥加⼊⼀⾏映射代码，具体如下：6、创建hibernate API操作测试类（Juit测试），验证hibernate的优势效果，具体代码如下：package com.hibernate.helloworld;import java.sql.Date;import org.hibernate.Session;import org.hibernate.SessionFactory;import org.hibernate.Transaction;import org.hibernate.cfg.Configuration;import org.hibernate.service.ServiceRegistry;import org.hibernate.service.ServiceRegistryBuilder;import org.junit.Test;public class HibernateTest {@Testpublic void test() {//1. 创建⼀个 SessionFactory 对象SessionFactory sessionFactory=null;//1). 创建 Configuration 对象: 对应 hibernate 的基本配置信息和对象关系映射信息Configuration configuration=new Configuration().configure();//4.0 之前这样创建//sessionFactory=configuration.buildSessionFactory();//2). 4.0以后创建⼀个 ServiceRegistry 对象: hibernate 4.x 新添加的对象//hibernate 的任何配置和服务都需要在该对象中注册后才能有效.ServiceRegistry serviceRegistry=newServiceRegistryBuilder().applySettings(configuration.getProperties() ).buildServiceRegistry();sessionFactory=configuration.buildSessionFactory(serviceRegistry) ;//2. 创建⼀个 Session 对象Session session=sessionFactory.openSession();//3. 开启事务Transaction transaction=session.beginTransaction();//4. 执⾏保存操作News news = new News("Java12345", "ATGUIGU", new Date(new java.util.Date().getTime()));session.save(news);//5. 提交事务/doc/63fa364d5022aaea998f0fde.html mit();//6. 关闭 Sessionsession.close();//7. 关闭 SessionFactory 对象sessionFactory.close();}}7、测试结果如下：（1）数据库⾥⾯的结果如下：（2）Eclipse下的语句⽣成如下：以上就是简单Hibernate的测试，总结：1、不需要在数据库⾥⾯创建任何数据，由hibernate ⾃动⽣成；2、代码简单易理解，不复杂，测试数据只需要先创建以下⼏个步骤：SessionFactory-→Session-→Transaction-→session操作数据库-→提交-→关闭；3、不需要写SQL 语句，从头到尾没有写⼀条SQL语句，反⽽Hibernate帮我们⽣成SQL语句。
Hibernate 学习笔记 知识总结
HibernateNote一、hibernate与db中数据类型对照（xml方式）1.与ORACLE常用数据类型对照背景为灰色的表示常用，熟记。
2.与MySql数据类型对照背景为灰色的表示常用，熟记。
2.1 hibernate mysql基本类型映射2.2 Java 时间和日期类型的Hibernate 映射二、Hibernate关系配置1.annotation基本类型配置配置、Jar 包等：a) hibernate annotaion jarb) ejb3 persistence jarc) hibernate common-annotations.jarFAQ: @不给提示，配置eclipse属性信息content assist-activation--加上@通过@Basic 可以声明属性的存取策略：@Basic(fetch=FetchType.EAGER) 即时获取（默认的存取策略）@Basic(fetch=ZY) 延迟获取通过@Temporal 定义映射到数据库的时间精度：@Temporal(TemporalType=DATE) 日期@Temporal(TemporalType=TIME) 时间@Temporal(TemporalType=TIMESTAMP) 两者兼具2.annotation列属性映射使用@Column 映射到列@Column(name="columnName"; // 可选，列名（默认是属性名）boolean unique() default false; // 可选，是否在该列上设置唯一约束（默认false）boolean nullable() default true; // 可选，是否可以为空boolean insertable() default true; // 可选，该列是否作为生成insert语句中的一列boolean updatable() default true; // 可选，该列是否作为生成update语句中的一列String columnDefinition() default ""; // 可选，为这个特定列覆盖SQL DDL 片段（可能导致无法在不同数据库间移植）String table() default ""; // 可选，定义对应的表，默认为主表int length() default 255; // 可选，列长度int precision() default 0; // 可选，列十进制精度（decimal precision）int scale() default 0; // 可选，列十进制数范围（decimal scale）public class Person {@Column(name = "PERSONNAME", unique = true, nullable = false, updatable = true)private String name;@Column(name = "PHOTO", columnDefinition = "BLOB NOT NULL", secondaryTable="PER_PHOTO")private byte[] picture;}3.联合主键：必须实现po层Serializable接口<class name="Student" table="t_student"><composite-id name="studentId" class="StudentId"><key-property name="firstName" length="20"></key-property><key-property name="lastName" length="20"></key-property></composite-id><property name="pwd" length="20"></property>4.组合关系<class name="User" table="t_user" ><id name="id"><generator class="native"></generator></id><property name="name"></property><property name="phone" column="dianhua" length="30"></property><component name="address" class="Address" ><property name="city"></property><property name="street"></property><property name="zipcode"></property></component></class>5.一对多，多对一5.1 xml格式的：一方：<class name="Department" table="t_dept"><id name="id" ><generator class="native"></generator></id><property name="dname" length="20"></property><set name="employees" ><key><column name="department_id"></column></key><one-to-many class="Employee"/></set></class>多方：<class name="Employee" table="t_emp"><id name="id"><generator class="native"></generator></id><property name="ename"></property><many-to-one name="department" class="Department" column="department_id"></many-to-one>5.2 annotation方式的：多方：@Id@GeneratedValue(strategy=GenerationType.AUTO)private Integer id;private String mname;@ManyToOneprivate Student student;一方：@Id@GeneratedValue(strategy=GenerationType.AUTO)private Integer id;private String sname;private String pwd;@OneToMany(mappedBy="student")private Set<Money> moneys;6.一对一外键关联6.1 xml格式的：<class name="Address" table="t_address" ><id name="id"><generator class="native"></generator></id><property name="aname" length="20"></property><one-to-one name="company" class="Company" property-ref="address"></one-to-one> </class><class name="Company" table="t_com" >外键生成<id name="id"><generator class="native"></generator></id><property name="cname" length="20"></property><many-to-one name="address" class="Address" cascade="save-update"><column name="address_id" unique="true"></column></many-to-one></class>6.2 annotation格式的：@Id@GeneratedValue(strategy=GenerationType.AUTO)private Integer id;private String cname;@OneToOne(cascade=CascadeType.ALL)@JoinColumn(name="student_id",unique=true)private Student student;@Id@GeneratedValue(strategy=GenerationType.AUTO)private Integer id;private String sname;@OneToOne(mappedBy="student")private Course course;6.3 一对一主键关联annotation格式的：@Id@GeneratedValue(strategy=GenerationType.AUTO)private Integer id;private String cname;private Integer age;private String des;@OneToOne(cascade=CascadeType.ALL)@PrimaryKeyJoinColumnprivate Student student;@Id@GenericGenerator(name="cc",strategy="foreign",parameters={@Parameter(name="property",value="cour se")})@GeneratedValue(generator="cc")private Integer id;private String sname;private Integer age;private String des;@OneToOne(mappedBy="student",cascade=CascadeType.ALL)private Course course;7.多对多7.1 xml格式的：xml格式的：<class name="Course" table="t_course"><id name="id" ><generator class="native"></generator></id><property name="cname" length="20"></property><set name="students" table="student_course"><key><column name="course_id"></column></key><many-to-many class="Student" column="student_id"></many-to-many></set></class><class name="Student" table="t_student"><id name="id" ><generator class="native"></generator></id><property name="sname" length="20"></property><set name="courses" table="student_course"><key><column name="student_id"></column></key><many-to-many class="Course" column="course_id"></many-to-many></set></class>7.2 annotation格式的：@Id@GeneratedValue(strategy=GenerationType.AUTO)private Integer id;private String mname;@ManyToMany(mappedBy="moneys")private Set<Student> students;@Id@GeneratedValue(strategy=GenerationType.AUTO)private Integer id;private String sname;private String pwd;@ManyToManyprivate Set<Course> moneys;8.其他8.1不需要psersistence的字段a) Annotation：@Transientb) xml不写8.2映射日期与时间类型，指定时间精度a) Annotation：@Temporal(参数) 参数有3种只显示时间,只显示日期,时间日期都显示//@Temporal(TemporalType.DATE) 只显示日期//@Temporal(TemporalType.TIME) 只显示时间//@Temporal(TemporalType.TIMESTAMP) 显示日期与时间b) xml:指定type<class name="Teacher" table="Teacher" ><id name="id" column="id"></id>property name="name" type="time" /></class>三、hibernate序列Sequence<id name="id" ><generator class="native"></generator></id>其他常用的序列生成方式1.<generator class="sequence"/>这是一个非常简单的接口；某些应用程序可以选择提供他们自己特定的实现。
Hibernate学习笔记
Hibermate（7月6号）1.query 与 hbpString sql=”form User(对象) as user where =?”;Query query =session.createQuery(hql);Query.setString(0,name);OrString sql=”form User(对象) as user where =:name”;Query query =session.createQuery(hql);Query.setString(“name”,name);//2.可以用分页时设置Query.setFirstResult(200); //设置查询的开始Query.setMaxResult(10); //设置最大的查询结果Query｜｜preparedstatment相似之处3.条件查询Criteria c =session.createCriteria(User.class); //Criteria是一个容器c.add(Restrictions.eq(“name”,name));c.add(Restrictions.it(“birthday”,new Date()));c.setFristResult(0);c.setMaxResult(10);4.Hibernate一个简单的实例Hinernate.cfg.xml配置文件的几个参数：Connection.driver_class,connection.url,ername,connection.password, Dialect（语言/org.hibernate.dialect.MySQLDialect）, hbm2ddl.auto(自动建表)。
hibernate.cfg.xml<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE hibernate-configuration PUBLIC"-//Hibernate/Hibernate Configuration DTD 3.0//EN""/hibernate-configuration-3.0.dtd"><hibernate-configuration><session-factory><!-- 各属性的配置--><!—为true表示将Hibernate发送给数据库的sql显示出来 --><property name="show_sql">true</property><!-- SQL方言，这边设定的是MySQL --><property name="dialect">net.sf.hibernate.dialect.MySQLDialect</property><!-- 一次读的数据库记录数 --><property name="jdbc.fetch_size">50</property><!-- 设定对数据库进行批量删除 --><property name="jdbc.batch_size">30</property><!—下面为JNDI的配置 --><!-- 数据源的名称 --><property name="connection.datasource">java:comp/env/jdbc/datasourcename</property> <!-- Hibernate的连接加载类 --><propertyname="connection.provider_class">net.sf.hibernate.connection.DatasourceConnectionPr ovider</property><property name="dialect">net.sf.hibernate.dialect.SQLServerDialect</property><!—映射文件 --><mapping resource="com/amigo/pojo/User.hbm.xml"/><mapping resource="com/amigo/pojo/Org.hbm.xml"/></session-factory></hibernate-configuration>2007-12-29 9:29:20 | 编辑hibernate.cfg.xml配置总结Hibernate的描述文件可以是一个properties属性文件，也可以是一个xml文件。
Hibernate学习笔记
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目录下。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
目录一．概述 (1)二．Hibernate的开发步骤 (2)三、Hibernate的几个重要接口和类 (2)四、对象状态管理 (3)五、映射篇 (5)概述： (5)1、单一pojo的映射 (5)A.写pojo和对应的映射文件： (5)B. 写配置文件和测试文件 (6)补充1. 一级缓存的管理： (6)补充2. ID的生成方式 (7)2、pojo对象之间的映射 (8)2.1基数关系映射--1:1 (8)2.2基数关系映射--1:m/m:1 (11)2.3基数关系映射--m:n (16)2.4 组件关系的映射 (17)2.5 继承关系的映射 (19)2.5 值类型集合映射 (21)补充： (24)六、HQL (26)七、并发控制 (28)1. 乐观锁 (28)A. 使用<version>元素： (28)B.使用<timestamp>元素 (28)2. 悲观锁 (29)一．概述Hibernate 是一种（ORM：object relation mapping）对象关系映射工具，是对JDBC 的封装，主要负责 java 对象的持久化，它是可以自动的根据xml 完成对象关系映射，并持久化到数据库的开源框架。
问题1：为什么持久化:a. 内存是非持久的,如掉电数据消失b. 改变数据的存储结构,以便于大规模的检索(内存中的对象的存储是:以对象为节点,用引用串起来的网状结构,它不便于检索)c. 对数据的海量存储(数据仓库)问题2：如何将对象间的关系变为表之间的关系内存对象之间关系：关联关系、继承等DB中表之间关系：主外键关系因此对象之间的关系mapping到表之间关系，是将关联关系或继承关系变为主外键关系二．Hibernate的开发步骤1. 配置环境变量：导入hibernate的jar包、数据库的驱动包2. 写po：注意：oid、空的和有参但不含oid的构造方法、所有属性需有set/get方法3. 写每个po对应的映射文件注意映射关系：类－－表、id属性－－字段、属性－－字段、各种po之间的映射关系4. 写hibernate.cfg.xml<?xml version='1.0' encoding='UTF-8'?><!DOCTYPE hibernate-configuration PUBLIC"-//Hibernate/Hibernate Configuration DTD 3.0//EN""/hibernate-configuration-3.0.dtd"> <hibernate-configuration><session-factory><property name="hbm2ddl.auto">none</property><property name="dialect"> org.hibernate.dialect.MySQLDialect </property><property name="connection.url"> jdbc:mysql://127.0.0.1:3306/test </property><property name="ername">root</property><property name="connection.password">admin</property><property name="connection.driver_class"> com.mysql.jdbc.Driver</property><property name="myeclipse.connection.profile">mysql</property><property name="show_sql">true</property><property name="format_sql">true</property><mapping resource="entity/pk/Account.hbm.xml" /><mapping resource="entity/pk/User.hbm.xml" /></session-factory></hibernate-configuration>5. 写测试代码三、Hibernate的几个重要接口和类1. org.hibernate.cfg.ConfigurationConfiguration接口负责配置并启动Hibernate，创建SessionFactory对象。
在Hibernate的启动的过程中，Configuration类的实例首先定位映射文档位置、读取配置，然后创建SessionFactory对象。
.hibernate.SessionFactorySessionFactory 接口负责创建Session对象。
这里用到了工厂模式。
需要注意的是SessionFactory并不是轻量级的，因为一般情况下，一个项目通常只需要一个SessionFactory就够，当需要操作多个数据库时，可以为每个数据库指定一个SessionFactory。
3. org.hibernate.SessionSession 接口负责执行被持久化对象的CRUD操作(CRUD的任务是完成与数据库的交流，包含了很多常见的SQL语句。
)。
但需要注意的是Session对象是非线程安全的。
同时，Hibernate的session不同于JSP应用中的HttpSession。
这里当使用session这个术语时，其实指的是Hibernate中的session，而以后会将HttpSesion对象称为用户session。
4. Transaction Transaction该接口负责事务相关的操作。
它是可选的，开发人员也可以设计编写自己的底层事务处理代码。
5. Query和Criteria接口:Query和Criteria接口负责执行各种数据库查询。
它可以使用HQL语言或SQL语句两种表达方式。
四、对象状态管理Hibernate 中PO 对象的状态：（对象的状态是）暂态（Transient）：po 对象，在DB 中无记录，和Session 无关，和Hibernate Session 没发生过关系。
持久态（Persistent ）：po 对象，在DB 中有记录，和Session 有关，由 session 自动同步，和Hibernate Session正在发生关系。
游离态（Detached ）：po 对象，在DB 中有记录，和Session 无关，曾经Hibernate Session 发生过关系，用于分布式对象的状态是指属性值的变化。
解析：持久态的自动同步：Session session = HibernateSessionFactory.getSession();session.beginTransaction();Object obj = session.createQuery("from Account a wherea.actno='actno-001'").uniqueResult();Account account = (Account)obj;System.out.println("原来的钱："+account.getBalance());account.withdraw(100);Object obj2 = session.createQuery("from Account a wherea.actno='actno-001'").uniqueResult();Account account2 = (Account)obj2;System.out.println("现在的钱："+account2.getBalance());session.getTransaction().commit();在进行account.withdraw(100)后不需要进行session.update(account)方法的调用，当事物提交时内存中对象状态会同缓存中副本进行对比，不一样则内存中对象实现自动修改，此时数据库与内存实现自动同步。
游离态的手工同步：当account.withdraw(100)之前进行session.evict(account)操作，则将游离态的对象中的balance值减去100，此时若要将修改的值同步到数据库里面去需要手工进行session.update(account)的调用，即：session.evict(account);account.withdraw(100);session.update(account);注意：1. 通过oid返回User类对应的对象的两种方式：User user = (User)load(User.class,new Long(pid)); (找不到对象抛出异常)User user = get(User.class,new Long(pid)); (找不到对象不抛出异常，返回空) 两个方法的原理：Load会去缓存中找（不是去DB）找到：返回对象找不到：返回代理对象Object(proxy)，且将该代理对象放到缓存里。
Proxy到DB中查找产生sql：找到：ok找不到：抛出异常延迟加载原因：使用代理对象进行延迟加载，在缓存中查找该对象，如果不使用该对象且该对象在缓存中没找到则产生代理对象，给予一个假象；如果使用则让代理对象通知db通过sql语句返回需要的对象，数据库中找到则ok，找不到抛异常。
因此load的加载时延迟加载。
get会去缓存中找：找到：返回对象找不到：直接去db中找DB中找到：返回该对象DB中没找到：返回空因此get的原理是立即加载。
注意：在不确定的情况下用get，确定的情况下用load，否则用load会给以假象造成不必要的负担（比如请客吃饭，用load得知一假象要请客，做晚饭了，结果是周日来，白做了）。