Hibernate文档笔记共分为三个部分.(中)
强人Hibernate文档笔记(上中下)
强人Hibernate文档笔记（上）Hibernate文档笔记共分为三个部分，此处是第一部分，讲述了对象定义、实例状态、JMX 集成和JCA 支持四个部分的内容。
一、对象定义.hibernate.SessionFactory对于单个数据库，被编译的映射，是一个线程安全的缓冲区。
是一个Session和ConnectionProvider客户端的工厂。
拥有可选的对过程级和集群级重复利用的数据的缓存（二级缓存）。
.hibernate.Session单线程、短生命周期的在应用程序和持久化存储系统之间的一个会话对象。
封装了一个JDBC连接。
是一个事务的工厂。
拥有强制的对持久化对象的缓存（一级缓存），当通过标识浏览对象之间关系和查找对象时使用。
3.Persistent objects and collections包含执久化状态和业务功能的短生命周期的、单线程对象。
可以是POJOs，通常是和Session（严格说，是单个Session）相关联的对象。
Session一关闭，他们将和Session 分离，可以自由的使用在应用层的任何地方。
（也就是说，作为传输对象使用（Transfer Object）。
）4.Transient and detached objects and collections不和当前Session关联的持久化类的实例。
他们可以被应用程序在不持久化时实例化，也可以被关闭的Session实例化。
.hibernate.Transaction （可选）应用程序用来指定一个原子操作的单线程、短生命周期的对象。
低层JDBC、JTA、CORBA 事务的抽象程序。
在相似的情况下，一个Session可以同时横跨多个事务。
事务划分，既可以使用低层的APIs，也可以使用Transaction。
.hibernate.connection.ConnectionProvider （可选）JDBC连接或JDBC连接池的工厂。
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="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常用知识点总结
一．Hibernate的流程1．开发数据库，建立数据库表2．通过DB Browser配置数据库连接3．添加Hibernate的支持（1）添加hibernate需要的jar包到WEB-INF/lib下（2）添加hibernate.cfg.xml配置文件（3）添加了HibernateSessionFactory.java类（session工厂类，用来产生session）4．映射表（1）添加PO持久化类如：er.java（2）添加了持久化类和关系表对应配置文件如：User.hbm.xml（映射了类和表、属性和列之间对应，主键生成方式）5．编写业务接口及实现类6．编写测试类进行测试二．Hibernate的基本配置1．hibernate.cfg.xml<hibernate-configuration><session-factory><!-- 显示操作时底层执行SQL --><property name="show_sql">true</property><!-- SQL方言，这里设定的是MySQL --><propertyname="dialect">org.hibernate.dialect.MySQLDialect</property><!-- JDBC驱动--><propertyname="connection.driver_class">com.mysql.jdbc.Driver</property><!-- JDBC URL --><propertyname="connection.url">jdbc:mysql://localhost:3306/hibernateTest</property><!-- 数据库用户名--><property name="ername">root</property><!-- 数据库密码--><property name="connection.password">root</property><!-- 对象、数据库表映射文件--><mapping resource="com/ascent/hib/po/User.hbm.xml"/></session-factory></hibernate-configuration>2．hibernate.properties3．*.hbm.xml<hibernate-mapping><class name="er" table="user" ><id name="id" type="integer"><column name="id" /><generator class="increment" /></id><property name="name" type="string"><column name="name" length="15" not-null="true" /></property><property name="pwd" type="string"><column name="password" length="15" not-null="true" /></property></class></hibernate-mapping>映射文件中主要包括三部份：类名与表名的映射、id属性与主鍵的映射、类属性和表列的映射。
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笔记
HibernateClass name=”student ”是类名，当数据库中的表名和类名相同时，就不需要设置column=”student ”.Id name=”id ”,id 为主键类中的属性，当表中的字段和属性名相同时，也可以不写column=”id ”, <property name=”name ”>是在设置其他属性。
划线部分是配置文件在哪里找。
按照如下方法写，可以不用写对应的hbm.xml文件。
在test里面会有所变动。
有了hbm文件或者annotation后，通过上面划线语句可以自动创建与文件相关的表。
对类进行junit测试（上面俩个图）如果在配置文件中或者类中不小心写错了，应该报个异常的，但是在运行时却没有，这是个bug，需要上面两种解决方法，这样就能检测到异常。
Formatsql和showsql的区别，前者会把SQL语句不打印在一行上，是分层的，更加清楚。
当表名和类名不一致时，需要改动，如下有两种方式。
用annotation非常方便，只要定义了@id其他属性不用再@，默认会配置，而hbm.xml文件中需要全部写出来。
当字段名和属性名不一致时，有如下2种方法。
注意，在annotation中，都要写在get方法上。
当有的属性不希望持久化，不需要在数据库中出现，就用下面的@语句。
当新增加属性date时，默认类型是日期加具体的时间。
如果想只有日期，可以用@temporal 来指定，如下图所示，temporaltype.date前面是有属性名叫value的，但是在annotation里面属性名是value的可以省略。
在XML配置文件中用type来指定。
映射枚举类型时，第一种string会输出职称的名字也就是ABC，第二种ordinal会输出职称对应下标值。
@id可以定义在field上面，但是这样就破坏了java的封装性，很少用，多数都用定义在get 方法上的。
Id生成策略Uuid返回的是字符串格式。
hibernate总结
Hibernate读书笔记-----Hibernate知识总结2012-07-16 11:24:31 我来说两句收藏我要投稿利用一个星期（实际上是两个星期的上午）的时间终于是结束了Hibernate，本来在四月份就可以结束的，但是由于为期一个月的实习，加上各种考试、三个课程设计，hibernate 的学习一直都是断断续续的，等到暑假有时间了，也差不多都忘记了，于是只有从头开始了。
下面是我就这个星期所学的知识的一个简要的总结。
一、Hibernate开发流程Hibernate是一个面向java环境的对象/关系数据库映射工具，用来把对象模型表示的对象映射到基于SQL的关系模型数据结构中去。
主要是完成面向对象的编程语言到关系型数据库的映射Hibernate的开发流程一般有如下几个步骤：1、编写domain对象：持久化类。
2、加入hibernate.jar和其依赖的包。
3、编写XX.hbm.xml映射文件。
4、编写hibernate.cfg.xml配置文件。
必须要提供以下几个参数：connection.driver_class、connection.url、ername、connection.password、dialect、hbm2ddl.auto。
5、编写HibernateUtil工具类、主要用于完成hibernate的初始化过程和提供一个获得session的方法（可选）。
6、编写实现类。
二、Hibernate的体系结构Hibernate有如下三种体系结构：非常简要的Hibernate体系结构的概要图：从这个图可以看出，Hibernate使用数据库和配置信息来为应用程序提供持久化服务（以及持久的对象）。
轻型”的体系结构方案，它要求应用程序提供自己的JDBC 连接并管理自己的事务全面解决”的体系结构方案，将应用层从底层的JDBC/JTA API中抽象出来，而让Hibernate来处理这些细节。
三、Hibernate的持久化类Hibernate采用完全面向对象的方式来操作数据库，通过Hibernate的支持，我们只需要管理对象的状态，无须关心底层数据库系统的细节。
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><!-- 配置数据库的url --><property name="connection.url">jdbc:mysql:///fwcz</property><!-- 配置数据库方言 --><property name="dialect">org.hibernate.dialect.MySQLDialect</property><!-- 自动建表第一次使用的时候，设置create,表建成之后，设置为update --><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笔记截图版手打出来的有颜色部分的文字是我学习的时候自己添加的笔记说明(红色的除外)刨除去颜色部分就是和马士兵老师的原版文档一模一样了希望能给好学的朋友一点帮助目录课程内容 (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 http://www. (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 双向关联： (20)关联关系中的CRUD_Cascade_Fetch (21)1 hibernate_1700_one2many_many2one_bi_crud (21)2 设定cascade以设定在持久化时对于关联对象的操作（CUD，R归Fetch管） (21)3 cascade仅仅是帮我们省了编程的麻烦而已，不要把它的作用看的太大 (21)4 铁律：双向关系在程序中要设定双向关联 (21)5 铁律：双向mappedBy (21)6 fetch (21)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 设计： (24)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学习笔记
19.flush():强制缓存与数据库同步
20.merge:合并 inverse:反转(true) cascade:级联(all)
21.关系映射:
2)不存在对应记录时表现不一样,get会返回null,load会抛出异常
16.merge:合并
17.update的用法:
1)用来更新detached对象,更新完状态转为persistent
2)更新transient对象会报错,除非自己设定id
3)persistent状态的对象只要设定不同字段就会发生更新(不用调update ()方法)
hibernate学习笔记
1.persist-->持久
PO-->Persistent Object:持久化对象
2.dialect:方言
3.factory:工厂
4.annotation:注释
5.assist-->辅助，帮助
Content assist--myeclipse不给提示
vii)一对多双向:两个PO都加对方对象引用
22.cascade:all/persist(存储)/remove(删除) 级联操作
写在保存的一方,例如要保存A的同时，把B也存进去，则在A的PO类 里加上@ManyToOne(cascade={CascadeType.ALL})，即在getB的属 性上加cascade
6.schema-->模式
7.@Transient--->短暂的，瞬变的,透明的
@Basic--->默认加上去的
Hibernate学习笔记
Hibernate为什么使用O/R映射？JDBC操作数据库很繁琐SQL语句编写并不是面向对象的可以在对象和关系表之间建立关联来简化编程O/R Mapping简化编程O/R Mapping跨越数据库平台持久化类：1、无参构造方法2、getter/setter方法3、惟一标识符（外加的中性的）映射文件：1、一个映射文件描述一个持久类2、映射文件的名字应该与其所描述的持久类的名字保持一致3、映射文件应与其所描述的持久类放在同一个包路径下映射原则(对单一实体来说)：1、类对应表2、属性对应字段3、对象对应记录映射文件的基本结构：<?xml version="1.0"?><!DOCTYPE hibernate-mapping PUBLIC"-//Hibernate/Hibernate Mapping DTD 3.0//EN""/hibernate-mapping-3.0.dtd"><hibernate-mapping package="org.hibernate.tutorial.domain"> <class name="" table=""><id name="" column=""><generator class="" /></id><property name="" column=""></property></class></hibernate-mapping>org.hibernate.SessionFactory:1、1个够用2、是线程安全3、是重量级的对象，开销比较大使用原则：一个应用程序只用一个org.hibernate.Session:1、轻量级对象2、线程不安全使用原则：一个线程一个Session;一个Session一个事务。
Hibernate小结
第一章：Hibernate基础知识1.Hibernate定义：Hibernate是一个优秀的java持久化层解决方案,是当今主统的对象——关系映射（ORM）工具.2.持久化定义;将数据在瞬时状态和持久状态之间进行转化的一种机制3.ORM：三个对应关系，两个文件（配置文件，映射文件）对应关系：1，类和表2，属性和列3，对象和数据库中的数据配置文件放在src根目录下；配置文件的名字永远是hibernate.cfg.xml;配置文件包含三大块内容：1，JDBC的配置信息2，hibernate本身的配置信息（方言，show_sql）3，映射文件的配置信息4.准备hibernate（三步）1），引入jar包2），配置文件3），创建实体类和实体映射文件（entity,dao）Entity:需要进行序列化并手动添加一个无参的构造方法Dao:七个步骤（1）读取并解析配置文件（2）读取并解析映射信息，创建SessionFactory（3）打开Session（4）开始一个事务（5）数据库操作（6）提交事务（回滚事务）（7）关闭Session5.实体对象的三种状态1）瞬时状态：刚用new语句创建还没有被持久化，且不处于Session的缓存中2）持久状态：已经被持久化，且加入到Session的缓存中3）游离状态：已经被持久化，但不再处于Session的缓存中注：Session不绑定线程时，session 开始缓存打开session 关闭缓存关闭第二章：关联映射实体之间的关系有关联关系：通过一个对象持有另一个对象的事例泛化关系：通过对象之间的继承方法来实现1.many-to-one类与类之间的多对一的单向关联关系和关系数据库中的外键参照关系最匹配，是最常见的单向关联关系多的一方持有一的一方，由多的一端进行数据维护2.One-to-many由一的一端加载多的一端，一的一端持有多的一端的集合，关系由一的一端进行维护，（在开发过程中一般不建议从一的一端进行数据维护）3.双向One-to-many4.Cascade与inverseCascade 级联：当对一个表进行操作时也会对与该表有相关关系的表进行相应的操作Cascade 属性：1）All：对所有操作进行级联操作2）Save-update：执行保存和更新操作时进行级联操作3）Delete：执行删除操作时进行级联操作4）None ：对所有操作都不执行级联操作Inverse 控制反转：当inverse=true时放弃控制权，由另一方负责维护关联关系在One-to-many关联中将one的一方inverse设置为true有助于性能的改善5.Many-to-many在实体表之外再设置一个关系表，关系表中只有外键，分别对应实体表中的主键，关系表没有实体类。
Hibernate学习笔记4---Transient、Persistent、Detached三个状态
Transient、Persistent、Detached是Hibernate三个核心的状态：---------------------------------------------------------------------------Transient状态最大的特征是：* 在数据库中没有与之匹配的数据* 没有纳入session的管理Persistent状态最大的特征是：* 在数据库中有与之匹配的数据* 纳入了session的管理* 在清理缓存(脏数据检查)的时候，会和数据库同步Detached状态最大的特征是：* 在数据库中有与之匹配的数据* 没有纳入session的管理---------------------------------------------------------------------------如下面的两个图（中英文对照）以下是一段用于说明这三个状态的代码：package com.ahuzl.hibernate;import java.util.Date;import org.hibernate.Session;import org.hibernate.Transaction;import junit.framework.TestCase;public class SessionTest extends TestCase {public void testSession(){Session session = null;Transaction tx = null;User user = null;try {session = HibernateUtils.getSession();tx = session.beginTransaction();//Transient状态，临时状态，一经save就会转变到Persistent状态user = new User();user.setName("中田");user.setPassword("nakada");user.setCreateTime(new Date());user.setExpireTime(new Date());//Persistent状态，持久化状态(数据库中有相同的值与之对应)，当属性发生改变时，hibernate会自动与数据库同步，不需要updatesession.save(user);user.setName("幸島");mit();}catch (Exception e){e.printStackTrace();tx.rollback();}finally {HibernateUtils.closeSession(session);}//Detached状态，游离状态，session关闭之后，便由persistent状态变为Detached状态try{session = HibernateUtils.getSession();session.beginTransaction();user.setName("幸島");//在Detached状态下，更新对象的属性，需要update才能反映到数据库session.update(user);session.getTransaction().commit();}catch(Exception e){e.printStackTrace();session.getTransaction().rollback(); }finally{HibernateUtils.closeSession(session);}}}。
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。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
Hibernate文档笔记共分为三个部分，此处是第二部分，讲述了Contextual Sessions、Configuration、获取SessionFactory和JDBC Connections（Session是对JDBC连接的封装）。
五、Contextual Sessions许多应用程序需要一种和上下文有关联Hibernate session，这样的session是指贯穿于给定环境的上下文中都有效的session。
无论如何，贯穿于应用程序应用上下文由什么组成的清晰度不同，不同的上下文针对当前的概念有不同的范围。
使用Hibernate 3.0以前版本的应用程序，趋于使用自已实现的基于ThreadLocal来维护前后关系的session、诸如HibernateUtil的帮助类；或使用基于代理或拦截机制的第三方的框架（Spring或Pico）。
从Hibernate 3.0.1，Hibernate加入了SessionFactory.getCurrentSession()方法。
最初，假定使用JTA事务定义了当前session的scope和context。
Hibernate团队维护时，给定了成熟的卓越的JTA TransactionManager的实现方式，多数（但不是所有）应用程序应该使JTA transaction management，不论它是否发布到一个JEE容器中。
基于这一点，基于用JTA来维护上下文关系中的session应该是必须的。
无论如何，在Hibernate 3.1，SessionFactory.getCurrentSession()之后的处理，是可以被插拔的，也就是说可以session的范围和上下文。
新扩展接口（org.hibernate.context.CurrentSessionContext）和新的配置参数（hibernate.current_session_context_class）被加入，允许插拔，也就是说可以定义session的范围和上下文。
细节可以查看org.hibernate.context.CurrentSessionContext的文档。
它定义了一个currentSession()方法，负责跟踪与当前上下文相关联的session。
Hibernate提供了这个接口的三种实现方式。
.hibernate.context.JTASessionContext当前session，通过JTA事务跟踪和标识生命周期。
这里的处理过程在处理方法上和老JTA是相似的。
.hibernate.context.ThreadLocalSessionContext当前session，通过当前执行的线程来跟踪。
.hibernate.context.ManagedSessionContext当前session，通过当前执行的线程来跟踪。
你是负责绑定和解除当前session到执行线程通过使用这个类的静态方法。
该类不会open、flush、close session。
前两个实现类，提供了“一个session对应一个数据库事务”的编程模式，也就是众所周知的“session-per-request”模式。
Hibernate session的开始和结束，是以数据库中事务的执行时间为依据的。
如果你使用编程方式划分事务，用简单的JSE需不是JTA，你应该考虑使用Hibernate事务APIs来隐藏低层的事务代码。
如果你使用的是JTA，使用JTA的接口来划分事务。
如果你在一个支持CMT（Container Management Transaction）的容器运行程序，事务是通过声明定义，在你程序中不需要任何的代码来划分事务。
Hibernate.current_session_context_class参数应该指定，一个org.hibernate.context.CurrentSessionContext的实现类。
如果配置参数没有被设置，而是配置了一个org.hibernate.transaction.TransactionManagerLookup被设置，Hibernate将使用org.hibernate.context.JTASessionContext，这里要考虑向后兼容。
典型的情况下，这个参数是使用的类的名字。
对于Hibernate提供的三个实现类，有对应的三个简短名，“jta”、“thread”、“managed”。
六、Configuration1.编程配置一个org.hibernate.cfg.Configuration的实例表示一个应用程序的所有Java类型到数据库类型的映射。
org.hibernate.cfg.Configuration是用来建造一个org.hibernate.SessionFactory。
被编译的映射是来自所有的XML映射文件。
片断1.1Configuration cfg =new Configuration().addResource(“test.hbm.xml”);片断2.2Configuration cfg =new Configuration().addClass(com.test.class);片断3.3Configuration cfg =new Configuration().setProperty(“hibernate.dialect”, “org.hibernate.dialect.DB2Dialect”);Configuration可以接收的选项：（1）传递一个java.util.Properties到Configuration.setProperties()。
（2）放一个hibernate.properties文件到类路径的根目录。
（3）设置系统properties，通过java –Dproperty=value。
（4）包含标签指定值在hibernate.cfg.xml文件。
org.hibernate.cfg.Configuration对象是有意作为一个开始时间生成的对象的，一旦SessionFactory被创建，他将被抛弃掉。
七、获取SessionFactory当org.hibernate.cfg.Configuration解析完所有的映射文件后，应用程序应该获取一个org.hibernate.Session实例的工厂。
这个工厂是被应用程序的所有线程共享的。
4SessionFactory sessionFactory = cfg.buildSessionFactory();Hibernate允许应用程序实例多个SessionFactory。
对于使用多个数据库的应用程序是非常有用的。
八、JDBC Connections（Session是对JDBC连接的封装）通常，你应该使用org.hibernate.SessionFactory来创建或共享JDBC。
如果这采用这种方法，是非常简单的。
5Session session = sessionFactory.openSession();当你的操作需要访问数据库时，一个JDBC连接就会从连接池中被获取。
对于这个工作，我们应该给Hibernate提供一些JDBC连接属性。
所有的Hibernate 属性名和语义学都被定义在org.hibernate.cfg.Environment。
我们现在描述对于JDBC连接配置的一些更重要的设置。
1.如果你设置以下属性，Hibernate将获取或共享连接使用java.sql.DriverManager：6hibernate.connection.driver_class78hibernate.connection.url9ername1112hibernate.connection.password1314hibernate.connection.pool_sizeHibernate自己拥有的连接池算法是没有发展的。
他是为了你的初始接触使用的，而不是为了你的产品使用的，甚至性能测试时使用。
为了更好的性能和稳定性考虑，你应该使用第三方的连接池产品。
只需要替换hibernate.connection.pool_size属性的设置用相应连接池的设置。
这将关闭Hibernate内部的连接池。
例如，可以使用C3P0。
C3P0是一个开源的JDBC连接池，被放置在Hibernate发布文件的lib目录下，随Hibernate一块发行。
如果你设置hibernate.c3p0.*属性，Hibernate将会使用org.hibernate.connection.C3P0ConnectionProvider为共享连接。
如果你想使用proxool作为连接池，你可以通过查阅hibernat.properties或Hibernate站点获取需要设置的属性名设置。
C3P0配置举例，属性文件片断：15hibernate.connection.driver_class=1617hibernate.connection.url=18ername=2021hibernate.connection.password=2223hibernate.c3p0.min_size=2425hibernate.c3p0.max_size=2627hibernate.c3p0.timeout=2829hibernate.c3p0.max_statements=3031hibernate.dialect=2.对于在应用服务器内运行的程序，多数情况你应该配置Hibernate通过JNDI找到服务器的javax.sql.DataSource来获取连接。
你需要设置以下属性。
32hibernate.connection.datasource3334hibernate.jndi.url (可选)3536hibernate.jndi.class (可选)37ername (可选)3940hibernate.connection.password (可选)你可以通过实现org.hibernate.connection.ConnectionProvider来定义自己的获得连接的策略。
通过hibernate.connection.provider_class配置使用自己的定义起作用。