kettas笔记_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学习笔记

<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课堂笔记

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(持久化)学习笔记一、什么是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学习笔记

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不能实现）
------对象的三种状态--------

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

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

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

类型对应表，属性对应列，关系对应外键，对象对应行HIBERNATE第一天对象持久化对象关系映射(object Relational Mapping 简称：ORMapping)使用在java应用中，自动将对象保存在关系数据库中提供的解决方案：1）CRUT的操作，SQL中的增删改查2）查询对象，作用在类型和属性上3）描述4）实现事物管理优点：1）代码简单，维护性好，调试性好2）性能3）4）Hibernet属于Source Forge(开源的)。

TopLink属于Oracle。

OpenJPA属于Apache 配置开发环境：Property:属性Reference(ref)引用Column：列Constrained:受约束的Generator：生成器Foreign：外国，外键Primary:主要的Orphan：孤儿cascade:应用内存session cache 数据库idTransient 存在不存在不存在不存在Persistent 存在存在存在存在Detached 存在不存在存在存在load():找不到对象时抛出的是异常。

可以返回一个proxy代替对象get()：找不到对象时返回的是null。

直接返回对象ormapping不适合做在线事物的分析，也就是说不可以做大量的插入查询，hibernate-mapping格式：表中的列对应实体类中的成员变量，如果有多个实体类和表对应，则在mapping里面写上多个<class></class>就可以了<hibernate-mapping package="实体类所在的包"><class name="类名" table="表名"><id name="leagueId" unsaved-value="null"><generator class="sequence"><param name="sequence">league_leagueId_seq</param> </generator></id><property name="leagueName"></property><property name="sport"></property></class></hibernate-mapping>hibernate-configuration配置：<hibernate-configuration><session-factory>Oracle驱动<property name="connection.driver_class">oracle.jdbc.driver.OracleDriver</property>地址<property name="connection.url">jdbc:oracle:thin:@10.10.20.20:1521:kettas</property>用户名<property name="ername">cksd0906_1</property>密码<property name="connection.password">cksd0906_1</property>线程<property name="current_session_context_class">thread</property><property name="dialect">org.hibernate.dialect.Oracle9Dialect</property><property name="show_sql">true</property>批处理时用到<property name="jdbc.batch_size">20</property>二级缓存<property name="e_second_level_cache">false</property>资源文件，所配置的xml文件在哪里<mapping resource="net/kettas/entity/day1/Student.hbm.xml"/><mappingresource="net/kettas/entity/association/many2many/day2/Teacher.hbm.xm l"/></session-factory></hibernate-configuration>重讲Hibernate一：CurrentSession和Session区别CurrentSession：1)是绑定在线程中的Session对象，在同一线程中，多次调用getCurrentSession()方法，得到的都是一个Session对象不能多线程。

共享一般都是绑定在线程。

OpenSession：只要调用就会创建对象，每次都创建新的对象2)必须工作在事物环境下，否则会有异常发生如：transaction.begin();Session session = HibernateUtio.getCurrentSession();3)CurrentSession不需要调用session.close();会随着事物的结束（commit/rollback）而自动关闭。

4）在hibernate.cfg.xml中需要作特殊的配置。

Current_session_context_class thread二：映射关系关系，指实体之间的关联关系1）编写实体和关系属性确立对象和对象之间的关系。

2）根据实体建表，要体现出实体和实体之间的关系。

3）在映射文件中对实体和表进行配置，体现实体间的关系4）利用Hibernate对实体进行操作对关系属性的描述：1）描述关系的类别（1：1，1：*，*：1）2）描述关系属性来自哪张表，3）对方表和自己表是如何连接起来的。

4）级联操作1对1如果是1对1，在Hibernate中默认是共享主键的。

共享主键的特征：两个实体之间的关系密切，主对象决定附对象的生命周期Constrained：有外键，删除时先删除外键cascade：级联操作.如果要进行增删改查的操作可以写成allunique="true"：唯一约束，对该列的值是否为唯一的<hibernate-mapping package="实体类的包名"><class name="实体类名" table="该实体类对应的表名"><id name="id"><generator class="increment"/></id><property name="成员变量名" column=”当成员变量名和列名相同时可省略”type="string"/><property name="openDate" column="open_date" type="date"/>//建立映射关系<one-to-one property-ref="company" name="address"cascade="save-update"/></class><class name="Address" table="t_address"><id name="id"><generator class="increment"></generator></id><property name="city" type="string"/><property name="street" type="string"/><property name="postcode" type="string"/><many-to-one unique="true" name="company" column="c_id" cascade="save-update"/></class></hibernate-mapping>1 ：1和* ：1实例：使用唯一外键property-ref="company" 说明不是共享主键<hibernate-mapping package="com.kettas.association.o2o"><class name="Company" table="t_company"><id name="id"><generator class="increment"/></id><property name="name" type="string"/><property name="openDate" column="open_date" type="date"/> <one-to-one property-ref="company" name="address"cascade="save-update"/></class><class name="Address" table="t_address"><id name="id"><generator class="increment"></generator></id><property name="city" type="string"/><property name="street" type="string"/><property name="postcode" type="string"/><many-to-one unique="true" name="company" column="c_id" cascade="save-update"/></class></hibernate-mapping>1 ：1实例：使用共享主键<hibernate-mapping package="com.kettas.association.o2o"><class name="Person" table="t_person"><id name="id" ><generator class="increment"></generator></id><property name="name" type="string"/><property name="email" type="string"/><one-to-one name="passport" class="Passport" cascade="all"/> </class><class name="Passport" table="t_passport"><id name="id"><generator class="foreign"><param name="property">person</param></generator></id><property name="serial" type="string"/><property name="expiry" type="integer"/><one-to-one name="person" constrained="true" cascade="all"/> </class></hibernate-mapping>1 ：*实例inverse=”true”：把填写外键的职责交给对方<hibernate-mapping package="com.kettas.association.o2m"><class name="Department" table ="t_department"><id name="id"><generator class="increment"></generator></id><property name="name" type="string"/><property name="code" type="string"/><set name="employees" inverse="true" cascade="save-update"> <key column="d_id"/><one-to-many class="Employee"/></set></class><class name="Employee" table="t_employee"><id name="id"><generator class="increment"/></id><property name="name" type="string"/><property name="email" type="string"/><property name="birthday" type="date"/><many-to-one name="department" column="d_id"cascade="save-update"/></class></hibernate-mapping>* ：*实例<hibernate-mapping package="com.kettas.association.m2m"><class name="User" table="t_user"><id name="id"><generator class="increment"></generator></id><property name="realName" column="real_name" type="string"/><property name="loginName" column="login_name" type="string"/><property name="password" type="string"/><set name="roles" table="t_role_user" cascade="save-update"> <key column="user_id"/><many-to-many class="Role" column="role_id"></many-to-many> </set></class><class name="Role" table="t_role"><id name="id"><generator class="increment"></generator></id><property name="name" type="string"/><property name="code" type="string"/><set name="users" inverse="true" table="t_role_user"cascade="save-update"><key column="role_id"/><many-to-many class="User" column="user_id"></many-to-many> </set></class></hibernate-mapping>第二天Hibernate高级特性1）SQL延缓写入2）Hibernate的脏数据检查3）Hibernate的二级缓存4）Hibernate的延迟加载5）Hibernate对象状态转化1）SQL延缓写入(增删改)可以充分利用batch提高程序性能。