马士兵hibernate学习笔记(原版)-你信不信,我反正是信了

合集下载

hibernate 学习笔记精要

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

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

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

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

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

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

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应该和导航关系结合，共同为査询提供服务。

马士兵Struts2学习笔记

1noitcAnigoL A COI�者三后 .4 器容于赖依�者三后 .3 )种这用只( COI�者三前 .2 器容于赖依�者三前 .1 :用引的txetnoCtelvreS ,noisseSpttH ,tseuqeRtelvreSpttH 型类实真,noitacilppa,noisses,tseuqer型类paM得取 …点重 ) stnemelEbeWsseccA_0021_2sturtS( 素元面页问访 .21
>tluser/<psj.sseccus_dda_resu/>tluser<
>noitca/<
>egakcap/<
用调态动IMD dohteMnoitcA .5
>a/<psj.xedni>"psj.xedni"=ferh a< >daeh/< … ………
ecroFXevoL yb 71:15:0 6-7-0102 记笔课听 2sturtS_兵士马堂学尚
象对 troppuSnoitcA 行执则,””=ssalc 有没
ecroFXevoL yb 71:15:0 6-7-0102 记笔课听 2sturtS_兵士马堂学尚
> "xedni"=eman noitca<
3
{ )(dda gnirtS cilbup ;resu resU etavirp
noitca应对 >a/<户用加添>"8=ega.resu&a=eman.resu?dda!resu/resu"=ferh a<数参收接ledoM niamoD用使 )tupnImaraPledoMniamoD_0080_2sturtS( 数参收接型模域ledoMniamoD用

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><propertyname="dialect">org.hibernate.dialect.MySQLInnoDBDialect</property> <property name="show_sql">true</property><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"><hibernate-mapping><class name="com.hibernate.helloworld.News"table="NEWS"> <id name="id"type="ng.Integer"><column name="ID"/><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语句。

java-hibernate笔记(讲义)-【尚学堂马士兵老师】

java-hibernate笔记(讲义)-【尚学堂马士兵老师】知识点终结：1 新建项目2 学习建立user-library-hibernate,并加入相应的jar包a项目右键-build path-configure build path-add libraryb选择user-library,在其中新建library,命命为hibernatec 在该library中加入hibernate所需要的jar包hibernate3.3.2/hibernate3.jar/lib/required目录下的所有包6个Sl4j-nop jar3 引入mysql的JDBC驱动包4 在MYSQL中建数据库和相应的表student(id,name,age)5 建立hibernate配置文件hibernate.cfg.xml参考文档中COPY,修改对应的数据库连接,6 建立student类7 建立映射文件Student.hbm.xml 参考相应文档8 将映射文件加到hibernate-cfg.xml中搭建日志环境并配置显示DDL语句slf的实现:slf4j nodep ,log4j ,jdk logging api ,apache common-log.slf4j.nop.jar是slf-api.jar其相应的接口实现把slf的接口对到log4j的实现,在user library中hibernate,把slf的实现slf4j-nop-1.5.8.jar去掉,添加log4j的实现log4j-1.2.15.jar,再添加一个slf-api和log4j转换器slf4j-log4j12-1.5.8.jar.把slf的接口转换成log4j的接口.最后添加一个log4j的配置文件log4j.properties利用HIBERNA TE导出数据库建表//读取配置文件hibernate.cfg.xmlConfiguration cfg=new AnnotationConfiguration().configure();(有注解时使用AnnotationConfiguration),configure()可以手动指定配置文件名称. Configuration cfg=new Configuration(),会默认读取hibernate.properties文件//创建schemaExport对象import org.hibernate.tool.hbm2ddl.SchemaExport;SchemaExport export=new SchemaExport(cfg);//创建数据库表export.create(true, true);对象映射(采用Annotation注解方式)1 建表Create table teacher(id int primary key,name varchar(20),title varchar(20));2 创建teacher类,并进行注解@import javax.persistence.Entity;import javax.persistence.Id;在bean中加注解@ Entity,@Id(加在getId()上面)3 在hibernate中加入annotation相应的jar包hibernate-annotations.jar/lib目录下加入相应的包ejb3-persistence.jar, hibernate-commons-annotations.jar注意:annotation文档中并没有提到hibernate-annotations.jar包4 参考annotation文档建立对应的注解5 在hibernate.cfg.xml中建立映射<mapping class=”com.xx.xx”/>6 示例//AnnotationConfiguration;Configuration cfg=new AnnotationConfiguration();SessionFactory sf=cfg.configure().buildSessionFactory();Session session=sf.openSession();session.beginTransaction();session.save(t);//session.getTransaction().commit();session.close();sf.close();对象映射(采用配置文件方式)1 在相应的类中建立对应的配置文件.例如Student类对应的配置文件Student.hbm.xml<hibernate-mapping package="com.model"><class name="Student" table=" Student" ><id name="id" column="id"></id><property name="name" column="name" /><property name="age" column="age" /></class></hibernate-mapping>2 在hibernate.cfg.xml中添加该映射文件Student.hbm.xml即可<mapping resource="com/model/Student.hbm.xml"/>注意包名的写法3 示例//读取配置文件hibernate.cfg.xmlConfiguration cfg=new Configuration().configure();//创建SessionFactorySessionFactory sf=cfg.configure().buildSessionFactory();//创建sessionSession session=sf.openSession();session.beginTransaction();session.save(s);session.getTransaction().commit();session.close();sf.close();hibernate.cfg.xml配置hibernate.hbm2ddl.auto属性取值: validate | update | create | create-drop在sessionfactory创建时,自动检查数据结构,或者将数据库schema(表)的DDL导出到数据库,使用create-drop时,在显式关闭sessionfactory时,将drop掉数据库schema.validate 加载hibernate时，验证创建数据库表结构create 每次加载hibernate，重新创建数据库表结构create-drop 加载hibernate时创建，退出是删除表结构update 加载hibernate自动更新数据库结构表名和类名不同的情况时,对表名进行配置1 在注解中import javax.persistence.Table;@Table(name=”TableName”)2 在XML文件中<hibernate-mapping package="com.model"><class name="Teacher" table="Teacher" >配置对应的table属性为相应的表名<id name="id" column="id"></id>…</class></hibernate-mapping>字段名和属性名相同,默认为对于annotation,如果什么注解都不写的话,相当于加了注解@Basic实体bean中所有的非static非transient的属性都可以被持久化, 除非你将其注解为@Transient.所有没有定义注解的属性等价于在其上面添加了@Basic注解. 通过@Basic注解可以声明属性的获取策略(fetch strategy)：对于XML文件中不用写column.字段名和属性名不同时Annotation:@column(name=”column_name”)加上相应的getXXX()方法上XML:column属性不需要persistence的字段import javax.persistence.Transient;@ Transient 意思是说这个属性是透明的,不进行持久化,存储的时候不存进去映射日期和时间类型,指定时间精度Annotation:import javax.persistence.Temporal;@Temporal(TemporalType.TIME)XML:指定type<class name="Teacher" table="Teacher" ><id name="id" column="id"></id><property name="name" type="time" />type=time或date</class>枚举类型的转换@Enumerated(EnumType.STRING)字段映射的位置推荐写在gexXXX方法上在程序中通过Hibernate 来保存java.sql.Clob 或者java.sql.Blob 实例时，必须包含两个步骤：1 在一个数据库事务中先保存一个空的Blob 或Clob 实例。

Hibernate学习笔记

Hibernate学习笔记以下文档将说明学习并运行简单的hibernate程序的详细步骤。

注意这只是最简单的程序范例，OR映射都只是最简单的one-to-one.步骤一:下载所需的程序和文件Hibernate3.0.5ant1.6.5mysql4.1jdbc-driverjdk1.5.0Tomcat5.5.8步骤二:部署运行环境1.安装jdk并配置环境变量path,JAVA_HOME,CLASS_PATH2.解压Ant并配置环境变量path,ANT_HOME3.安装mysql并配置环境变量path4.新建工作目录5.在工作目录中新建lib文件夹，将hibernate\lib下的文件拷贝过来hibernate文档中说拷贝以下几个jar包就可以了antlr.jarcglib-full.jarasm.jarasm-attrs.jarscommons-collections.jarcommons-logging.jarehcache.jarhibernate3.jarjta.jardom4j.jarlog4j.jar但为了保险起见，我拷贝了所有的jar包。

然后记得把hibernate3.jar也拷贝到lib下。

接下来就要拷贝jdbc derver了，这里我用的是mysql数据库，应用到的驱动文件是aspectjrt.jaraspectjtools.jaraspectjweaver.jarmysql-connector-java-3.1.8-bin-g.jar步骤三：配置Ant配置文件注:这个文件完全是参考Hibernate文档的范例而来在工作目录里新建build.xml，内容如下＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝<project name="hibernate-tutorial" default="compile"><property name="sourcedir" value="${basedir}/src"/><property name="targetdir" value="${basedir}/bin"/><property name="librarydir" value="${basedir}/lib"/><path id="libraries"><fileset dir="${librarydir}"><include name="*.jar"/></fileset></path><target name="clean"><delete dir="${targetdir}"/><mkdir dir="${targetdir}"/></target><target name="compile" depends="clean, copy-resources"><javac srcdir="${sourcedir}"destdir="${targetdir}"classpathref="libraries"/></target><target name="copy-resources"><copy todir="${targetdir}"><fileset dir="${sourcedir}"><exclude name="**/*.java"/></fileset></copy></target><target name="run" depends="compile"><java fork="true" classname="EventManager" classpathref="libraries"><classpath path="${targetdir}"/><arg value="${action}"/></java></target></project>＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝现在可以写个小程序测试一下ant和配置文件是否工作正常在工作目录新建一个文件夹src（这里也是以后所有程序的存放文件夹）写个HelloWorld程序HelloWorld.java==================================================== public class HelloWorld{public static void main(String args[]){System.out.println("Ant Success!";}}====================================================在控制台下切换到工作目录并运行ant命令，就可以看到程序的运行结果了步骤四：部署程序新建Event.java====================================================== import java.util.Date;public class Event {private Long id;private String title;private Date date;Event() {}public Long getId() {return id;}private void setId(Long id) {this.id = id;}public Date getDate() {return date;}public void setDate(Date date) {this.date = date;}public String getTitle() {return title;}public void setTitle(String title) {this.title = title;}}=====================================================新建EventManager.java===================================================== import org.hibernate.Transaction;import org.hibernate.Session;import java.util.*;import java.util.Date;public class EventManager {public static void main(String[] args) {EventManager mgr = new EventManager();if (args[0].equals("store") {mgr.createAndStoreEvent("My Event", new Date());}else if (args[0].equals("list") {List events = mgr.listEvents();for (int i = 0; i < events.size(); i++) {Event theEvent = (Event) events.get(i);System.out.println("Event: " + theEvent.getTitle() +" Time: " + theEvent.getDate());}}HibernateUtil.sessionFactory.close();}private void createAndStoreEvent(String title, Date theDate) {Session session = HibernateUtil.currentSession();Transaction tx = session.beginTransaction();Event theEvent = new Event();theEvent.setTitle(title);theEvent.setDate(theDate);session.save(theEvent);mit();HibernateUtil.closeSession();}private List listEvents() {Session session = HibernateUtil.currentSession();Transaction tx = session.beginTransaction();List result = session.createQuery("from Event".list();mit();session.close();return result;}}======================================================== =====然后新建Event.hbm.xml======================================================== =====<?xml version="1.0"?><!DOCTYPE hibernate-mapping PUBLIC"-//Hibernate/Hibernate Mapping DTD 3.0//EN""/hibernate-mapping-3.0.dtd"><hibernate-mapping><class name="Event" table="EVENTS"><id name="id" column="EVENT_ID"><generator class="increment"/></id><property name="date" type="timestamp" column="EVENT_DATE"/><property name="title"/></class></hibernate-mapping>======================================================== ======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="connection.driver_class">com.mysql.jdbc.Driver</property> <property name="connection.url">jdbc:mysql://localhost/king</property><property name="ername">root</property><property name="connection.password">root</property><property name="connection.pool_size">1</property><property name="dialect">org.hibernate.dialect.HSQLDialect</property><property name="show_sql">true</property><property name="hbm2ddl.auto">create</property><mapping resource="Event.hbm.xml"/></session-factory></hibernate-configuration>＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝这个文件里有数据库的连接属性和映射文件的设置最后是在数据库里建好需要的表DROP TABLE IF EXISTS `events`;CREATE TABLE `events` (`EVENT_ID` int(11) NOT NULL default '0',`EVENT_DATE` date default NULL,`TITLE` varchar(50) default NULL,PRIMARY KEY (`EVENT_ID`)) ENGINE=InnoDB DEFAULT CHARSET=gbk;另外还有一点就是不要忘记了加上一个log4j配置文件，我当初就是因为没有加这个配置文件，总是报错NullPointerException,查了半天也没有个结果＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝log4j.properties=================================================### direct log messages to stdout ####log4j.appender.stdout=org.apache.log4j.ConsoleAppender#log4j.appender.stdout.Target=System.out#yout=org.apache.log4j.PatternLayout#yout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L- %m%n### direct messages to file hibernate.log ###log4j.appender.file=org.apache.log4j.FileAppenderlog4j.appender.file.File=hibernate.logyout=org.apache.log4j.PatternLayoutyout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L - %m%n ### set log levels - for more verbose logging change 'info' to 'debug' ###log4j.rootLogger=warn, stdout.hibernate=info#.hibernate=debug### log HQL query parser activity#.hibernate.hql.ast.AST=debug### log just the SQL#.hibernate.SQL=debug### log JDBC bind parameters ###.hibernate.type=info#.hibernate.type=debug### log schema export/update ###.hibernate.tool.hbm2ddl=debug### log HQL parse trees#.hibernate.hql=debug### log cache activity ####.hibernate.cache=debug### log transaction activity#.hibernate.transaction=debug### log JDBC resource acquisition#.hibernate.jdbc=debug### enable the following line if you want to track down connection ###### leakages when using DriverManagerConnectionProvider ####.hibernate.connection.DriverManagerConnectionProvider=trace======================================================== =======================在hibernate文档中有一句话是We finally need to configure a logging system - Hibernate uses commons logging and leaves you the choice between Log4j and JDK 1.4 logging. Most developers prefer Log4j: copylog4j.properties from the Hibernate distribution (it's in the etc/ directory) to your src directory, next to hibernate.cfg.xml. Have a look at the example configuration and change the settings if you like to have more verbose output. By default, only Hibernate startup message are shown on stdout.怪我当初没有仔细看这句话，害的今天调试这个错误费了4个小时。

Hibernate入门笔记

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

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

说明，如果使用最新的hibernatehibernate 的基本jar 包（7个）来源：13.2lib\required 下的所有jar 包2. 简述 Hibernate 的作用：ORM ： Object Relational Mapping» 对象关系映射。

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

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

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

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

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

内容如下：packagepublic int getIdO { return id;public void setld(int id) { =id;public String getName() { return name;public void setName(String name) { =name;public Date getDateO { return date;public void setDate (Date date) { =date;4. 编写配置文件：。

它和放在同一个包下。

内容如下：<xml version=""〉<!DOCTYPE hibernate-mapping PUBLIC"-体类定义规则：Domain object （java 对象）必须要有构造方法，同时建议有一个id 属性，为了赖加载, 这个java 类的声明最好不用finalo8•开发流程： private private class User{ int id;String name;private Date date;官方推荐：先Domain object 再mapping,最后是DB 。

马士兵mysql视频的个人笔记

如果你的root现在有密码了，那么修改密码为abc的命令是：mysqladmin -u root -p password youyou 注意，命令回车后会问你旧密码，输入旧密码之后命令完成，密码修改成功。

---------02_mysql_startedcreate database mydata; //创建一个数据库use mydata; //使用当前已经创建的数据库create table dept //创建dept表(deptno int primary key,dname varchar(14),loc varchar(13)--部门位置);create table emp(empno int primary key,ename varchar(10),job varchar(10),mgr int,--所属经理编号hiredate datetime,--入职日期sal double,comm double,--奖金deptno int,foreign key (deptno) references dept(deptno) #外键deptno参考dept表的deptno);?:显示帮助信息\. 执行一个SQL的脚本文件，用一个文件名作为参数例如\. c:\\mysql_script\\mydata.sqlcreate table salgrade #创建薪水等级表salgrade(grade int primary key,losal int,hisal int);insert into dept values(10,'a','a');insert into dept values(20,'b','b');insert into dept values(30,'c','c');insert into dept values(40,'d','d');insert into dept(deptno,dname) values(50,'e');insert into dept values(60,'f','f');---------03_page_seperationshow databases; #查看当前MYSQL环境下有多少个数据库show tables; #查看当前使用中数据库下面有多少张表。

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)一、数据库的隔离级别：并发性作用。

hibernate02笔记

提问：1. Hibernate与ORM 关系2. Hibenate开发步骤、执行流程3. Hibernate 中方言作用4. 映射文件起什么作用？5. 如何进行联合主键映射？<composite-id>执行流程1. 创建Configuration对象2. 加载主配置文件:hibernate.cfg.xml3. 接着，创建SessionFactory对象4. 创建Session5. 开启事务6. –执行操作–7. 提交/关闭目标：1. hibernate对象状态2. hibenate 一级缓存3. 集合映射/多对一/一对多映射1. hibernate对象状态session.save(对象);(一)临时状态1 . 直接new出来的对象2. 不处于session的管理(即没有与任何一个session关联)3. 对象在数据库中没有对应的记录！Employee e = new Employee();e.setId(2); 只要主键在数据库中存在，就说这个对象在数据库中有对应记录！在数据库中叫主键！OID, object identified 对象的唯一标识（对应数据库中的主键）(二)持久化状态1. 处于session的管理范围当执行session的方法如：save/update/saveOrUpdate/get/load对象就会自动转变为持久化状态！2. 在数据库中有对应的记录3. 处于持久化状态的对象，当对对象属性进行更改的时候，提交事务更改会反映到数据库中！(三)游离状态1. 对象不处于session的管理范围；通常指session关闭后对象的状态2. 对象在数据库中有对应的记录2. Session缓存概念:Session缓存，也叫做一级缓存！当执行session的相关方法，如: save()/update()/get()/load()等方法的时候，对象会自动放入一级缓存中。

当Session关闭后，一级缓存内容失效！特点：1）缓存有效范围，只在当前session范围内有效！缓存时间很短、作用范围小！2）一级缓存，可以在短时间内多次操作数据库的时候，才会明显提升效率！一级缓存的结构：Ma<主键，对象>3）在提交事务时候，Hibernate会同步缓存数据到数据库中，会对比缓存数据与数据库数据是否一致，如果不一致，才提交更改到数据库(生成update)!4) hibernate提供的一级缓存有hibernate自身维护，如果想操作一级缓存内容，必须通过hibernate提供的方法；session.flush(); 手动让让一级缓存内容与数据库同步session.evict(emp1); 清空一级缓存中对象: 清除指定的对象session.clear(); 清空一级缓存中对象: 清除所有的对象list()与iterator()查询区别list: (通常使用频率较高)Query接口定义的list查询方法，一次查询所有满足需要的数据！iterator:Query接口定义的iterator查询方法，1. 先查询所有满足条件记录的主键（查询1次）2. 再根据每一个id，进行主键查询，有多少记录，查询多少次（查询n次）3. iterator查询：N + 14. iterator查询，迭代数据的时候，只有用到数据的时候，才会查找数据库(懒加载)区别：1. 查询数据方式不同：查询全部与查询N+12. 一级缓存List查询，查询的结果会放入一级缓存，但不会从一级缓存中获取！Iteraotro查询，会放入一级缓存，同时也会从一级缓存中获取！3. lazy 属性Hibernate为了提升程序运行效率，提供了懒加载！lazy 属性表示懒加载！true 支持懒加载false 关闭懒加载extra (集合属性时候使用)懒加载：用到数据的时候，才向数据库发送查询的sql！(1) 主键查询：get/loadget:及时加载, 只要get就立刻查询数据库如果查询的主键不存在，返回nullLoad:懒加载，只有在用到数据的时候，才向数据库发送sql语句！如果查询的主键不存在，只要使用就报错！(2) 懒加载作用位置类级别，默认支持懒加载，但只有在使用load使用才会应用这个特性！字段级别，普通字段无效，大数据类型会有影响(long/longtext)集合属性，默认支持懒加载(3) 懒加载异常zyInitializationException: could not initialize proxy - no Session解决思路：在关闭后，不能能懒加载数据，那么就要求关闭前把懒加载使用的数据先查询出来！4.集合映射1. 需求：购物填写地址，一个用户，对应多个地址！2. 数据库设计：3. 设计javabean封装数据4. 写映射5. App.java 测试思考：集合映射，如果保存的数据只有一个可以使使用List/Set集合！如果保存的数据有2个，使用Map集合如果保存的数据是2个以上，集合元素类型，能否为对象？5.多对一、一对多映射需求：保存用户信息，用户对应的多个地址！周颖，年龄25, 广州天河，gzth，510000欧阳光，年龄25, 广州天河，gzth，510000用户与地址的关系：一对多【一个用户对应多个地址】地址与用户的关系多对一【多个地址对应一个用户】数据库设计:Javabean封装数据库数据：映射:App:多对一，实现目的：一对多，实现总结：一对多与多对一映射，可以只配置多对一，只能通过的多的一方维护关系!可以只配置一对多，只能通过一的一方维护关系双向配置：一对多与多对一, 可以通过双向维护关系！作业：一对多与多对一练习，需求自拟！-→用户与地址→用户与订单→老师与学员→部门/ 员工。

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在内存地址中存在一个一级缓存，存在在一级缓存中的对象，就说明该对象具有了持久化的能力，如果对象具有持久化能力就能操作数据库。

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

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

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

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

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

马士兵hibernate学习笔记课程内容 (6)1HelloWorld (6)2Hibernate原理模拟 - 什么是O/R Mapping以及为什么要有O/R Mapping (6)3常见的0/R框架(了解) (6)4hibernate基础配置（重点） (6)5ID生成策略（重点 AUTO) (6)6Hibernate核心开发接口介绍（重点） (6)7对象的三种状态（了解） (6)8关系映射（重点） (6)9Hibernate査询（HQL) (6)10在Struts基础上继续完善BBS200 (6)11性能优化（重点） (6)12补充话题 (6)风格 (6)1先脉络，后细节 (6)2先操作，后原理 (6)3重Annotation,轻xml配置文件 (6)资源 (6)1http://www. (6)2hibernate zh_CN文档 (6)3hibernate annotation references (6)环境准备 (6)1下载hibernate-distribution-3.3.2.GA-dist (6)2下载hibernate-annotations-3[1].4.0.GA (6)3注意阅读hibernate compatibility matrix(hibernate 网站download) (6)4下载slf4jl.5.8 (7)Hibernate HelloWorld (7)1建立新java 项目,名为hibernate_0100_HelloWorld (7)2学习建User-library-hibernate,并加入相应的jar包 (7)3引入mysql的JDBC驱动包 (7)4在mysql中建立对应的数据库以及表 (7)5建立hibernate 配置文件hibernate.cfg.xml (7)6建立Student 类 (7)7建立Student 映射文件 Student.hbm.xml (7)8将映射文件加入到hibernate.cfg.xml中 (7)9写测试类Main,在Main中对Student对象进行直接的存储测试 (7)10FAQ： (7)11Note: (7)12建立能力 (8)建立 Annotation 版本的 HelloWorld (8)1创建teacher 表，create table teacher (id int primary key, name varhcar(20), title varchar(lO));. 8 2创建Teacher 类 (8)3在hibernate lib 中加入annotation的jar包 (8)4参考Annotaion文档建立对应的注解 (8)5在hibernate.cfg.xml中建立映射<mapping class:.../〉.. (8)6参考文裆进行测试（注意文裆中缺少configure()的小bug) (8)7FAQ: @不给提示 (8)What is and Why 0/R Mapping (8)1JDBC操作数据库很繁琐 (8)2Sql语句编写并不是面向对象的 (8)3可以在对象和关系表之间建立关联来简化编程 (8)40/R Mapping 简化编程 (8)50/R Mapping跨越数据库平台 (8)6Hibernate_0200_OR_Mapping_Simulation (8)0/R Mapping Frameworks (8)1hibernate (8)2toplink (9)3jdo (9)4JPA (9)Hibernate基础配置 (9)1对应项目：Hibernate_0300_BasicConfiguration (9)2介绍MSQL的图形化客户端 (9)3hibernate.cfg.xml: hbni2ddl.auto (9)4搭建日志环境并配置显示DDL语句 (9)5搭建jUnit环境 (9)6hibernate.cfg.xml：show_sql (9)7hibernate.cfg.xml：format_sql (9)8表名和类名不同,对表名进行配置 (9)9字段名和属性相同 (9)10字段名和属性名不同 (9)11不需要psersistence的字段(不用列) (9)12映射日期与时间类型，指定时间精度 (9)13映射枚举类型( 比较少用) (10)14字段映射的位置（field或者get方法） (10)15@Lob (10)16课外：CLOBBLOB类型的数据存取 (10)17课外：Hibernate自定义数据类型 (10)18hibernate 类型 (10)ID生成策略 (10)1对应项目：hibernate_0400_ID (10)2注意： (10)3xml生成id (10)4注解方式：@GeneratedValue (10)5FAQ; (11)6联合主键 (11)核心幵发接口介绍 (13)1hibernate_0500_CoreAPI (13)2Hibernate API文档需要单独下载 (13)3Configuration (13)4SessoinFactor (13)5Session (13)6SchemaExport (自动建表) (14)7Query 接口 (14)8Note： (14)三种对象状态 (15)1上一个 project (15)2三种状态的区分关键在于 (15)3三种状态： (15)4对这三种状态需要关注的问题是在该状态下如果进行数据库的操作会发生什么结果，比如改变属性的 (15)关系映射(重要) (16)对象之间的关系 (16)1这里的关系映射指的是对象之间的关系，并不是指数据库的关系，本章解决的问题是当对象之间处于 (16)2简化问题： (16)3—对一 (16)4—对多 (16)5组件映射 (16)一对一关联 (17)1一对一单向外键关联 (17)2一对一双向外键关联 (17)3一对一单向主键关联（不重要） (18)4一对一双向主键关联（不重要） (18)5联合主键 (18)组件映射 (18)1项目：hibernate_1100_component (18)2对象关系：一个对象是另外一个对象的一部分 (18)3数据库表：一张表 (18)4annotation: @ Embeddable @Embbeded (18)5xml: 使用<component,例如: (19)多对一与一对多 (19)1多对一单向关联 (19)2一对多单向关联 (20)3一对多（多对一）双向关联 (20)多对多 (21)1单向关联： (21)2双向关联： (22)关联关系中的CRUD_Cascade_Fetch (22)1hibernate_1700_one2many_many2one_bi_crud (22)2设定cascade以设定在持久化时对于关联对象的操作（CUD，R归Fetch管） (22)3cascade仅仅是帮我们省了编程的麻烦而已，不要把它的作用看的太大 (22)4铁律：双向关系在程序中要设定双向关联 (23)5铁律：双向mappedBy (23)6fetch (23)7Update时@ManyToOne()中的cascade参数关系 (23)8Delete时@ManyToOne()中的cascade关系 (23)9O/RMapping 编程模型 (24)10要想删除或者更新先做load,除了精确知道ID之外 (24)11如果想消除关联关系，先设定关系为null.再删除对应记录，如果不删记录，该记录变成垃圾数据 (24)12练习：多对多的CRUD (24)关系映射总结 (25)1什么样的关系，设计什么样的表，进行什么样的映射 (25)2CRUD,按照自然的理解即可（动手测试） (25)集合映射（不太重要） (25)1项目名称：hibernate_1800_Collections_Mapping (25)2Set (25)3List (与Set差不多多个@OrderBy) (25)4Map (25)继承映射（不太重要） (25)1三种方式 (25)作业: (25)1学生课程、分数的设计(重要) (25)2设计： (26)3树状结构的设计（至关重要） (26)Hibernate 查询(Query Language) (27)HQL vs EJBQL (27)1NativeSQL >HQL.> EJBQL(JPQL 1.0) > QBC(Query By Criteria) > QBE(Query By Example)"272总结：QL应该和导航关系结合，共同为査询提供服务。

(27)性能优化 (27)1注意session.clear()的运用，尤其在不断分页循环的时候 (27)21+N问题 (典型的面试题) (详见hibernate_2800_Hibernate_1+N项目) (27)3list和iterate不同之处（//主要为了面试详见hibernate_2900_Hibernate_list_iterate） (27)4一级缓存和二级缓存和査询缓存（面试题）(详见hibernate_3000_Hibernate_3KindsOf_Cache)275事务并发处理(面试的意义更大) (28)课程内容1HelloWorlda)Xmlb)annotation2Hibernate原理模拟 - 什么是O/R Mapping以及为什么要有O/R Mapping 3常见的0/R框架(了解)4hibernate基础配置（重点）5ID生成策略（重点 AUTO)6Hibernate核心开发接口介绍（重点）7对象的三种状态（了解）8关系映射（重点）9Hibernate査询（HQL)10在Struts基础上继续完善BBS20011性能优化（重点）12补充话题风格1先脉络，后细节2先操作，后原理3重Annotation,轻xml配置文件a)JPAb)hibernate – extension资源1http://www. 2hibernate zh_CN文档3hibernate annotation references环境准备1下载hibernate-distribution-3.3.2.GA-dist2下载hibernate-annotations-3[1].4.0.GA3注意阅读hibernate compatibility matrix(hibernate 网站download)4下载slf4jl.5.8Hibernate HelloWorld1建立新java 项目,名为hibernate_0100_HelloWorld2学习建User-library-hibernate,并加入相应的jar包a)项目右键-buildpath-configure build path-add library—b)选择User-library,在其中新建 libraray,命名为 hibernatec)在该library中加入hibernate所需jar包i.hibernate coreii./requirediii.slf-nop jar3引入mysql的JDBC驱动包4在mysql中建立对应的数据库以及表a)create database hibernate；b)use hibernate；c)create table Student (id int primary key, namevarchar(20), age int)；5建立hibernate 配置文件hibernate.cfg.xmla)从参考文档中copyb)修改对应的数据库连接c)注释掉暂时用不上的内容6建立Student 类7建立Student 映射文件 Student.hbm.xmla)参考文档8将映射文件加入到hibernate.cfg.xml中a)参考文档9写测试类Main,在Main中对Student对象进行直接的存储测试a)参考文挡10FAQ：a)要调用 new Configuration().configure().buildSessionFactory(),而不是要省略 configure，否则会出 hibernate dialect must be set 的异常11Note:a)请务必建立自己动手査文挡的能力b)重要的是:i.要建立自己动手查一手文档的信心ii.还有建立自己动手查一手文档的习惯！iii.主动学习，砍弃被动接受灌输的习惯！12建立能力a)错误读完整b)读—昔误的关键行c)排除法d)比较法e)google建立 Annotation 版本的 HelloWorld1创建teacher 表，create table teacher (id int primary key, name varhcar(20), title varchar(lO));2创建Teacher 类3在hibernate lib 中加入annotation的jar包a)hibernate annotaion jarb)ejb3 persistence jarc)hibernate common-annotations.jard)注意文裆中没有提到hibernate-common-annotations.jar 文件4参考Annotaion文档建立对应的注解5在hibernate.cfg.xml中建立映射<mapping class:.../〉6参考文裆进行测试（注意文裆中缺少configure()的小bug)7FAQ: @不给提示a)配置eclipse属性信息content assist-activation--加上@What is and Why 0/R Mapping1JDBC操作数据库很繁琐2Sql语句编写并不是面向对象的3可以在对象和关系表之间建立关联来简化编程40/R Mapping 简化编程50/R Mapping跨越数据库平台6Hibernate_0200_OR_Mapping_Simulation0/R Mapping Frameworks1hibernate2toplink3jdo4JPAa)意愿统一天下Hibernate基础配置1对应项目：Hibernate_0300_BasicConfiguration2介绍MSQL的图形化客户端3hibernate.cfg.xml: hbni2ddl.auto：create、update。