Hibernate学习笔记
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笔记完整版
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应该和导航关系结合,共同为査询提供服务。
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语句。
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文件,主要是对数据库的连接,具体如下:<?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="ername">root</property><property name="connection.password">mysql</property><propertyname="connection.driver_class">com.mysql.jdbc.Driver</property> <property name="connection.url">jdbc:mysql:///Test(或者:jdbc:mysql://localhost:3306/Test)</property><!-- 配置 hibernate 的基本信息 --><!-- hibernate 所使用的数据库方言 --><propertyname="dialect">org.hibernate.dialect.MySQLInnoDBDialect</property> <!-- 执行操作时是否在控制台打印 SQL --><property name="show_sql">true</property><!-- 是否对 SQL 进行格式化 --><property name="format_sql">true</property><!-- 指定自动生成数据表的策略 --><property name="hbm2ddl.auto">update</property></session-factory></hibernate-configuration>3、编写一个实例类News.java,具体代码如下:package com.hibernate.helloworld;import java.sql.Date;public class News {private Integer id;private String title;private String author;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(){}@Overridepublic String toString() {return"News [id="+ id+ ", title="+ title+ ", author="+ author + ", date=" + date + "]";}}4、创建News.hbm.xml配置映射文件,具体代码如下:<?xml version="1.0"?><!DOCTYPE hibernate-mapping PUBLIC"-//Hibernate/Hibernate Mapping DTD 3.0//EN""/hibernate-mapping-3.0.dtd"><!-- Generated 2015-7-31 17:08:25 by Hibernate Tools 3.4.0.CR1 --><hibernate-mapping><class name="com.hibernate.helloworld.News"table="NEWS"> <id name="id"type="ng.Integer"><column name="ID"/><!-- 指定主键的生成方式,系统默认的是:assigned, 改成native: 使用数据库本地方式 --><generator class="native" /></id><property name="title"type="ng.String"><column name="TITLE"/></property><property name="author"type="ng.String"><column name="AUTHOR"/></property><property name="date"type="java.sql.Date"><column name="DATE"/></property></class></hibernate-mapping>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. 提交事务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学习笔记
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项目1、新建java项目2、创建User Library用户自定义库,加入如下jar* HIBERNATE_HOME/hibernate3.jar* HIBERNATE_HOME/lib/*.jar* MySql jdbc驱动3、创建hibernate配置文件hibernate.cfg.xml,为了便于调试最好加入log4j.propertise配置文件4、定义实体类5、定义User类的映射文件User.hbm.xml6、将User.hbml.xml文件加入到hibernate.cfg.xml文件中<mapping resource=”com/hpjianhua/hibernate/User”/>7、编写hbm2ddl工具类,将实体类生成数据库表其中的ExportDB.java是常用类了,写一次就够了.session.◊SessionFactory◊8、开发客户端:掌握:Configuration为了方便跟踪sql执行,在hibernate.cfg.xml文件中加入<property name="hibernate.show_sql">true</property>第二个Hibernate_session项目:测试实体对象的生命周期junit简介:* 编写测试类xxxTest,需要继承TestCase* 编写单元测试方法,测试方法必须以test开头,测试方法不能含有参数和返回值,如:public void testHello1() {}* 最好单元测试的代码单独建立一个目录了解Hibernate中CRUD操作了解get和load的区别?* get不支持lazy,load支持lazy* 采用get加载数据,如果没有匹配的数据,返回null,而load则抛出异常transient状态的特征?* 在数据库中没有与之匹配的数据* 没有纳入session的管理persistent状态的特征?* persistent状态的对象在数据库中有与之匹配的数据* 纳入了session的管理* 在清理缓存(脏数据检查)的时候,会和数据库同步detached状态的特征?* 在数据库中有与之匹配的数据* 没有纳入session的管理第三个Hibernate_basemapping项目:hibernate基本映射实体类---表实体类中的普通属性---表字段采用<class>标签映射成数据库表,通过<property>标签将普通属性映射成表字段所谓普通属性指不包括自定义类、集合和数组等注意:如果实体类和实体类中的属性和sql中的关键字重复,必须采用table或column重新命名实体类的设计原则:* 实现一个默认的(即无参数的)构造方法(constructor)* 提供一个标识属性(identifier property)(可选)* 使用非final的类(可选)* 为持久化字段声明访问器(accessors)主键生成策略:uuid、native和assigned第四个多对一关系项目:hibernate多对一关联映射关联映射的本质:* 将关联关系映射到数据库,所谓的关联关系是对象模型在内存中的一个或多个引用<many-to-one>会在多的一端加入一个外键,指向一的一端,这个外键是由<many-to-one> 中的column属性定义的,如果忽略了这个属性那么默认的外键与实体的属性一致<many-to-one>标签的定义示例:λ <many-to-one name="group" column="groupid"/>λ <!-采用cascade属性是解决TransientObjectException异常的一种手段-- >λ <many-to-one name="group" column="groupid" cascade=”all”/>理解级联的含义?是对象的连锁操作λ第五个一对一关系项目:hibernate一对一主键关联映射(单向关联Person---->IdCard)一对一主键关联映射:让两个实体对象的id保持相同,这样可以避免多余的字段被创建具体映射:<id name="id"><!—主键生成策略person的主键来源idCard,也就是共享idCard的主键--><generator class="foreign"><!—param 中的name是固定的”property”属性--><param name="property">idCard</param></generator></id><property name="name"/><!-- one-to-one标签的含义,指示hibernate怎么加载它的关联对象,默认根据主键加载,constrained="true",表明当前主键上存在一个约束,person的主键作为外键参照了idCard --><one-to-one name="idCard" constrained="true"/>第六个一对一主键双向映射项目:hibernate一对一主键关联映射(双向关联Person<---->IdCard)需要在idcard映射文件中加入<one-to-one>标签指向person,指示hibernate如何加载person 默认根据主键加载第七个一对一唯一外键关联项目:hibernate一对一唯一外键关联映射(单向关联Person---->IdCard)一对唯一外键关联映射是多对一关联映射的特例可以采用<many-to-one>标签,指定多的一端的unique=true,这样就限制了多的一端的多重性为一通过这种手段映射一对一唯一外键关联第八个一对一唯一外键关联项目:hibernate一对一唯一外键关联映射(双向关联Person<---->IdCard)一对一唯一外键关联双向,需要在另一端(idcard),添加<one-to-one>标签,指示hibernate 如何加载其关联对象,默认根据主键加载person,外键关联映射中,因为两个实体采用的是person 的外键维护的关系,所以不能指定主键加载person,而要根据person的外键加载,所以采用如下映射方式:<one-to-one name="person" property-ref="idCard"/>第九个Session_flush项目:session flush测试:session flush方法主要做了两件事:* 清理缓存* 执行sqlsession在什么情况下执行flush* 默认在事务提交时* 显示的调用flush* 在执行查询前,如:iteratehibernate按照save(insert),update、delete顺序提交相关操作一个完整的Test测试类用Junit工具:实例.第十个一对多单向项目:hihernate一对多关联映射(单向Classes----->Student)一对多关联映射利用了多对一关联映射原理多对一关联映射:在多的一端加入一个外键指向一的一端,它维护的关系是多指向一一对多关联映射:在多的一端加入一个外键指向一的一端,它维护的关系是一指向多也就是说一对多和多对一的映射策略是一样的,只是站的角度不同在一一端维护关系的缺点:* 如果将t_student表里的classesid字段设置为非空,则无法保存* 因为不是在student这一端维护关系,所以student不知道是哪个班的,所以需要发出多余的update语句来更新关系第十一个一对多双向项目:hihernate一对多关联映射(双向Classes<----->Student)一对多双向关联映射:* 在一一端的集合上使用<key>,在对方表中加入一个外键指向一一端* 在多一端采用<many-to-one>注意:<key>标签指定的外键字段必须和<many-to-one>指定的外键字段一致,否则引用字段的错误如果在”一“一端维护一对多关联关系,hibernate会发出多余的udpate语句,所以我们一般在多的一端来维护关联关系关于inverse属性:inverse主要用在一对多和多对多双向关联上,inverse可以被设置到集合标签<set>上,默认inverse为false,所以我们可以从”一“一端和”多“一端维护关联关系,如果设置成inverse为true,则我们只能从多一端来维护关联关系注意:inverse属性,只影响数据的存储,也就是持久化inverse和cascade* inverse是关联关系的控制方向* cascade操作上的连锁反应第十二个多对多单向映射项目:hibernate多对多关联映射(单向User---->Role)具体映射方式:<set name="roles" table="t_user_role"><key column="userid"/><many-to-many class="com.bjsxt.hibernate.Role" column="roleid"/></set>第十三个多对多映射项目:hibernate多对多关联映射(双向User<---->Role)映射方法:<set name="roles" table="t_user_role"><key column="userid"/><many-to-many class="com.bjsxt.hibernate.Role" column="roleid"/></set>table属性值必须和单向关联中的table属性值一致<key>中column属性值要与单向关联中的<many-to-many>标签中的column属性值一致在<many-to-many>中的column属性值要与单向关联中<key>标签的column属性值一致第十四个Lazy策略项目:hibernate lazy策略可以使用在:* <class>标签上,可以取值:true/false* <property>标签上,可以取值:true/false需要类增强工具* <set><list>标签上,可以取值:true/false/extra* <one-to-one><many-to-one>单端关联上,可以取值:false/proxy/noproxylazy概念:只有真正使用该对象时,才会创建,对于hibernate而言,正真使用的时候才会发出sqlhibernate支持lazy策略只有在session打开状态下有效<class>标签上的lazy特性只对普通属性起作用hibernate在集合上的lazy策略,可以取值:true/false/extra<class>标签上的lazy不会影响到集合上的lazy特性hibernate在单端关联上的lazy策略,可以取值:false/proxy/noproxy<class>标签上的lazy不会影响到单端关联上的lazy特性第十七个项目: 每棵继承树映射成一张表1、理解如何映射因为类继承树肯定是对应多个类,要把多个类的信息存放在一张表中,必须有某种机制来区分哪些记录是属于哪个类的。
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学习笔记
Hibernate 学习笔记2010年7月9日星期五1目录1.学习纲要2.学习目的3.达标标准4.名词解释5.学习时间:两天又3小时(16~19pm)2具体内容2.1学习纲要2.1.1什么是hibernate?它是连接JAVA应用程序和关系数据库的中间件它对JDBC API进行了封装,负责JAVA对象的持久化在分层的软件架构中它位于持久化层,封装了所有数据访问细节,使业务逻辑层可以专注于实现业务逻辑。
它是一种ORM映射工具,能够建立面向对象的域模型和关系数据模型之间的映射2.1.2HIBERNATE原理依赖的技术有:JAVA反射机制(在org.hibernate.property中得到较多应用,通过INVORK()方法调用POJO对象的setter,getter方法设置和获取属性的值)i.Class类ii.getMethods方法得到Method类iii.Method类iv.invoke方法用来调用被反射类的方法CGLIB(用于对持久化类进行延迟加载时生成代理类)i.以asm项目为基础,对asm的功能进行封装和扩展,实现并扩展了JAVA的反射功能,可以在运行时状态下实现JAVA接口,扩展JAVA类ii.Asm项目是一个简洁的字节码工具,能够在运行的状态下动态的修改编译完成的JAVA类JAVASSIST(同CGLIB,是另一套解决方案,可以通过修改org.hibernate.cfg.Environment.java原码进行设置)i.是一个执行字节码操作的强有力的驱动代码库。
它允许开发者在代码被JAVA虚拟机载入之前定义一个新类或者修改类的的原代码。
XML技术(DOM4J)i.用来解析XML配置文件Antlr(another tool for language recognition)i.它是一个开源的工具,利用后缀为“.g”的文件来定义语法规则ii.Hibernate提供的语法规则有iii.Hql.giv.Hql-sql.gv.Sql-gen.gvi.Hibernate通过调用这些生成的解析类完成把HQL语句转为SQL语句的工作2.1.3HIBERNATE方法的内部实现略2.1.4Hibernate能做什么?2.1.5hibernate应用在哪些方面2.1.6Hibernate关联关系1.一对多关联<many-to-one name=”customer”column=”CUSTOMER_ID”class=”mypack.Customer”lazy=”false” not-null=”true”/>此种情况下不会加载关联的临时对象。
Hibernate_学习笔记
Hibernate -annotation 学习笔记---wjt276[2010-01-18完]目录第1课课程内容 (6)第2课 Hibernate UML图 (6)第3课风格 (7)第4课资源 (7)第5课环境准备 (7)第6课第一个示例Hibernate HelloWorld (7)第7课建立Annotation版本的HellWorld (9)第8课什么是O/R Mapping (11)一、定义: (11)二、Hibernate的创始人: (12)三、Hibernate做什么: (12)四、Hibernate存在的原因: (12)五、Hibernate的优缺点: (13)六、Hibernate使用范围: (13)第9课 Hibernate的重点学习:Hibernate的对象关系映射 (13)一、对象---关系映射模式 (13)二、常用的O/R映射框架: (13)第10课模拟Hibernate原理(OR模拟) (13)一、项目名称 (14)二、原代码 (14)第11课 Hibernate基础配置 (15)一、提纲 (15)二、介绍MYSQL的图形化客户端 (16)三、Hibernate.cfg.xml:hbm2ddl.auto (16)四、搭建日志环境并配置显示DDL语句 (16)五、搭建Junit环境 (17)六、ehibernate.cfg.xml : show_sql (17)七、hibernate.cfg.xml :format_sql (17)八、表名和类名不同,对表名进行配置 (18)九、字段名和属性相同 (18)十、字段名和属性名不同 (18)十一、不需要(持久化)psersistence的字段 (19)十二、映射日期与时间类型,指定时间精度 (19)十三、映射枚举类型 (19)第12课使用hibernate工具类将对象模型生成关系模型 (20)第13课 ID主键生成策略 (20)一、Xml方式 (20)<generator>元素(主键生成策略) (21)二、annotateon方式 (22)1、AUTO默认 (22)2、IDENTITY (23)3、SEQUENCE (23)4、为Oracle指定定义的Sequence (23)5、TABLE - 使用表保存id值 (24)三、联合主键 (25)1、xml方式 (25)2、annotation方式 (28)第14课 Hibernate核心开发接口(重点) (30)一、Configuration(AnnotationConfiguration) (30)二、SessionFactory (30)三、Session (31)1、管理一个数据库的任务单元 (31)2、save(); (31)3、delete() (31)4、load() (31)5、Get() (32)6、load()与get()区别 (33)7、update() (33)8、saveOrUpdate() (34)9、clear() (34)10、flush() (34)11、evict() (35)第15课持久化对象的三种状态 (36)一、瞬时对象(Transient Object): (36)二、持久化对象(Persistent Object): (36)三、离线对象(Detached Object): (36)四、三种状态的区分: (37)五、总结: (37)第16课关系映射(重点) (37)一、一对一关联映射 (37)(一) 唯一外键关联-单向(unilateralism) (38)(二) 唯一外键关联-双向 (41)(三) 主键关联-单向(不重要) (43)(四) 主键关联-双向(不重要) (45)(五) 联合主键关联(Annotation方式) (46)二、component(组件)关联映射 (47)(一) Component关联映射: (47)(二) User实体类: (47)(三) Contact值对象: (48)(四) xml--User映射文件(组件映射): (48)(五) annotateon注解 (48)(六) 导出数据库输出SQL语句: (49)(七) 数据表结构: (49)(八) 组件映射数据保存: (49)三、多对一–单向 (50)(一) 对象模型图: (50)(二) 关系模型: (50)(三) 关联映射的本质: (50)(四) 实体类 (50)(五) xml方式:映射文件: (51)(六) annotation (52)(七) 多对一存储(先存储group(对象持久化状态后,再保存user)): (52)(八) 重要属性-cascade(级联): (53)(九) 多对一加载数据 (53)四、一对多 - 单向 (54)(一) 对象模型: (54)(二) 关系模型: (54)(三) 多对一、一对多的区别: (54)(四) 实体类 (54)(五) xml方式:映射 (55)(六) annotateon注解 (55)(七) 导出至数据库(hbm ddl)生成的SQL语句: (56)(八) 一对多单向存储实例: (56)(九) 生成的SQL语句: (56)(十) 一对多,在一的一端维护关系的缺点: (56)(十一) 一对多单向数据加载: (56)(十二) 加载生成SQL语句: (57)五、一对多 - 双向 (57)(一) xml方式:映射 (57)(二) annotateon方式注解 (58)(三) 数据保存: (58)(四) 关于inverse属性: (59)(五) Inverse和cascade区别: (59)(六) 一对多双向关联映射总结: (59)六、多对多 - 单向 (59)(一) 实例场景: (59)(二) 对象模型: (59)(三) 关系模型: (59)(四) 实体类 (60)(五) xml方式:映射 (60)(六) annotation注解方式 (61)(七) 生成SQL语句 (61)(八) 数据库表及结构: (61)(九) 多对多关联映射单向数据存储: (62)(十) 多对多关联映射单向数据加载: (63)七、多对多 - 双向 (64)(一) xml方式:映射 (64)(二) annotation注解方式 (64)八、关联关系中的CRUD_Cascade_Fetch (66)九、集合映射 (68)十、继承关联映射 (68)(一) 继承关联映射的分类: (68)(二) 对象模型: (69)(三) 单表继承SINGLE_TABLE: (69)(四) 具体表继承JOINED: (75)(五) 类表继承TABLE_PER_CLASS (76)(六) 三种继承关联映射的区别: (79)第17课 hibernate树形结构(重点) (80)一、节点实体类: (80)二、xml方式:映射文件: (80)三、annotation注解 (81)四、测试代码: (81)五、相应的类代码: (81)第18课作业-学生、课程、分数的映射关系 (84)一、设计 (84)二、代码: (84)三、注意 (85)第19课 Hibernate查询(Query Language) (85)一、Hibernate可以使用的查询语言 (85)二、实例一 (85)三、实体一测试代码: (87)四、实例二 (91)五、实例二测试代码 (92)第20课 Query by Criteria(QBC) (94)一、实体代码: (95)二、Restrictions用法 (95)三、工具类Order提供设置排序方式 (96)四、工具类Projections提供对查询结果进行统计与分组操作 (97)五、QBC分页查询 (97)六、QBC复合查询 (97)七、QBC离线查询 (98)第21课 Query By Example(QBE) (98)一、实例代码 (98)第22课 Query.list与query.iterate(不太重要) (98)一、query.iterate查询数据 (98)二、query.list()和query.iterate()的区别 (99)三、两次query.list() (100)第23课性能优化策略 (100)第24课 hibernate缓存 (100)一、Session级缓存(一级缓存) (100)二、二级缓存 (101)1、二级缓存的配置和使用: (101)2、二级缓存的开启: (102)3、指定二级缓存产品提供商: (102)4、使用二级缓存 (102)5、应用范围 (105)6、二级缓存的管理: (105)7、二级缓存的交互 (106)8、总结 (107)三、查询缓存 (108)四、缓存算法 (109)第25课事务并发处理 (109)一、数据库的隔离级别:并发性作用。
尚学堂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
一、什么是Hibernate?Hibernate是一个轻量级的ORMapping框架ORMapping原理(Object Relational Mapping)ORMapping基本对应规则:1:类跟表相对应2:类的属性跟表的字段相对应3:类的实例与表中具体的一条记录相对应4:一个类可以对应多个表,一个表也可以对应对个类5:DB中的表可以没有主键,但是Object中必须设置主键字段6:DB中表与表之间的关系(如:外键)映射成为Object之间的关系7:Object中属性的个数和名称可以和表中定义的字段个数和名称不一样ORMapping的基本实现方式:使用JDBC,用SQL来操作数据库,只是看动态生成还是人工写代码来实现。
大家想想,我们实现过ORMapping吗?二、Hibernate能干什么:Hibernate主要用来实现Java对象和表之间的映射,除此之外还提供还提供数据查询和获取数据的方法,可以大幅度减少开发时人工使用SQL和JDBC处理数据的时间。
Hibernate的目标是对于开发者通常的数据持久化相关的编程任务,解放其中的95%。
对于以数据为中心的程序来说,它们往往只在数据库中使用存储过程来实现商业逻辑,Hibernate 可能不是最好的解决方案;对于那些在基于Java的中间层应用中,它们实现面向对象的业务模型和商业逻辑的应用,Hibernate是最有用的。
Hibernate可以帮助你消除或者包装那些针对特定厂商的SQL代码,并且帮你把结果集从表格式的表示形式转换到一系列的对象去。
一个非常简要的Hibernate体系结构的高层概要图Hibernate运行时体系结构“最小”的体系结构方案,要求应用程序提供自己的JDBC 连接并管理自己的事务。
这种方案使用了Hibernate API 的最小子集.“全面解决”的体系结构方案,将应用层从底层的JDBC/JTA API中抽象出来,而让Hibernate 来处理这些细节。
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运行环境看的。
Hibernate课堂笔记
Hibernate课堂笔记一、H ibernate环境搭建1)Hibernate3最后一个版本Hibernate3.6.10的环境搭建1、导入项目所需要的包hibernate3.jar,lib/required下的所有包和lib/jpa下的包2、编写配置文件和映射文件参考documentation\manual\zh-CN\html_single1.1.4. Hibernate 配置1.1.3. 映射文件3、创建SessionFactory和Sessionpublic class HibernateUtil {private static SessionFactory sessionFactory = null;static{sessionFactory = new Configuration().configure().buildSessionFactory();}public Session getSession(){return sessionFactory.openSession();}}2)截至目前为止,Hibernate4最新版本Hibernate4.3.8的环境搭建1、导入项目所需要的包lib/required下的所有包2、编写配置文件和映射文件参考documentation\manual\en-US\html_single1.1.4. Hibernate configuration1.1.3. The mapping file3、创建SessionFactory和Sessionpublic class HibernateUtil {private static SessionFactory sessionFactory = null;static{Configuration cfg = new Configuration().configure();ServiceRegistry sr = new StandardServiceRegistryBuilder().applySettings(cfg.getProperties()).build();sessionFactory = cfg.buildSessionFactory(serviceRegistry);}public Session getSession(){return sessionFactory.openSession();}}二、H ibernate对象三种状态Hibernate中的对象有三种状态:瞬时状态(Transient),持久状态(Persistent),脱管状态(Detached)1.瞬时状态(Transient)由new 命令开辟内存空间的Java 对象,也就是平时所熟悉的普通Java 对象。
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一个事务。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
1、session = HibernateSessionFactory.getSession();// 开启连接Transaction tx = session.beginTransaction(); // 开启事务Student stu = (Student) session.get(Student.class, id);session.delete(stu);mit();2、session.save(stu);3、Query q = session.createQuery("from Student");list = q.list();4、session.update(stu);5、url:jdbc:mysql://localhost:3306/HibernateProject01Driver:com.mysql.jdbc.Driver6、在src源码包中新建log4j.propertieslog4j.rootLogger=info,CONSOLElog4j.appender.CONSOLE=org.apache.log4j.ConsoleAppenderlog4j.appender.CONSOLE.Target=System.outyout=org.apache.log4j.PatternLayoutyout.ConversionPattern= %4p[%t](%F:%L) -%m%n7、<set name="students" inverse="true" outer-join="false" lazy="false"><key column="team_id" /><one-to-many class="com.qrsx.hibernate.model.Student" /></set>8、session = HibernateUtil.currentSession(); // 开启连接session.setFlushMode(FlushMode.AUTO);tx = session.beginTransaction(); // 开启事务stu = (Student) session.get(Student.class, "ff80808105416d");mit();9、one-to-one和many-to-one中,lazy只可以为false,或不填写当不填写的时候,采用相应的类里的设置Set标签是可以的10、outer-join="true"预先抓取,sql文中是利用连接来实现常常与hibernate.cfg.xml中的<property name="max_fetch_depth">1</property>一起使用11、批量立即加载<set name="students" inverse="true"batch-size="2"outer-join="false" lazy="false"><key column="team_id" /><one-to-many class="com.qrsx.hibernate.model.Student" /> </set>在实现上,采用where s.team_id in (?, ?)的形式12、stu = (Student)session.get(Student.class,"ff80808105416d30001"); stu.setCardId("456"); // 对脱管对象进行更改session.update(stu);13、在使用update()方法进行脱管对象关联时,不管这个脱管对象在离开Session 之后有没有更改过,在清理缓存时Hibernate总是发送一条update语句,以确保脱管对象和数据库记录的数据一致如果希望只有脱管对象改变了,Hibernate才生成update语句,可以把映射文件中<class>标签的select-before-update设为true,这样在执行这一个类的update 语句之前,Hibernate都会发送一条select语句取得数据库中的值,和当前对象的值进行对比,如果值相同则不必发送update语句,只有不相同才发送update语句。
<class name="com.qrsx.hibernate.model.Student"table="student" lazy="false"select-before-update="true">如:session = HibernateSessionFactory.getSession();Transaction tx = session.beginTransaction(); // 开启事务Student stu1 = (Student)session.get(Student.class, "8ae18ba42");mit();session.close();session = HibernateSessionFactory.getSession();tx = session.beginTransaction(); // 开启事务session.update(stu1);mit();如果不加select-before-update标签,则输出一条select语句一条update语句否则,将输出两条select语句。
14、session = HibernateUtil.currentSession(); //开启连接tx = session.beginTransaction(); //开启事务Connection conn=session.connection();PreparedStatement stmt=conn.prepareStatement("update student s set s.cardId=concat(s.cardid,'beijing') ");t1=System.nanoTime();stmt.executeUpdate();t2 = System.nanoTime();mit();15、Query q = session.createQuery("delete from Student");q.executeUpdate();session.delete(stu);16、Query query = session.createQuery("update Student s set s.cardId = 'beijing'");query.executeUpdate();17、session = HibernateSessionFactory.getSession();Transaction tx = session.beginTransaction(); // 开启事务Student stu1 = (Student)session.get(Student.class,"8ae18ba424817afc0124817b00e50001");mit();HibernateSessionFactory.closeSession();System.out.println(stu1.getName());能够正常输出,但是使用load时,会抛出异常。
18、session = HibernateUtil.currentSession(); // 开启连接tx = session.beginTransaction(); // 开启事务Query query = session.createQuery("from Student s where s.age>? and like ?");query.setInteger(0, 20); // 设置age>中的?为整型25query.setString(1, "%王%");// 设置" like ?"中的?为字符串"%王%" 19、Query query = session.createQuery("from Student s where s.age>:minAge and like :likeName");query.setInteger("minAge", 20); // 设置age>中的?为整型25query.setString("likeName", "%王%");// 设置" like ?"中的?为字符串"%王%"20、Team team = (Team)session.get(Team.class, "ff80808105416d3b0105");Query query = session.createQuery("from Student s wheres.team=:team");//query.setEntity(0, team); //使用索引传递也可以query.setEntity("team", team);21、stu = new Student();stu.setAge(20);Query query = session.createQuery("from Student s where s.age>:age");//query.setParameter(0, team); //使用索引传递也可以query.setProperties(stu);22、命名查询(namedQuery)修改Student.hbm.xml,添加:<query name="queryStudent_byAgeAdnName"><![CDATA[from Student s where s.age>:minAge and like :likeName]]></query>Query query = session.getNamedQuery("queryStudent_byAgeAdnName"); uery.setInteger("minAge", 25); //设置“:”号后的minAge变量值query.setString("likeName", "%clus%");//设置“:”号后的likeName变量值List list=query.list();23、list用法:List list=query.list();(1)stu=(Student) list.get(i);(2)Object[] ob =(Object[]) list.get(i);System.out.println(ob[0]);System.out.println(ob[1]);24、当确信使用HQL语句查询返回的集合中只有一个对象时,就可以使用uniqueResult()方法。