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语句，提高性能。
Hibernet课堂学习笔记(精髓)
Hibernet:把一个对象转化为一条记录或者把一条记录转化为一个对象。
1读取并且解析配置文件2.获得sessionfactery3获取session。
属性名和字段名一致时候：//1.获取配置文件Configuration cft=new Configuration().configure();//2.获取sessionfactorySessionFactory sf=cft.buildSessionFactory();//3.获取session//Session session=sf.openSession();Session session=sf.getCurrentSession();Session session2=sf.getCurrentSession();在配置openSession()的时候需要在最后手动关闭session.close();当使用getCurrentSession()的时候不需要手动关闭session,他会自动关闭在Hibernate.cfg.xml中配置current_session_context选项中选择thread。
如下图：Format_sql-true,show_sql-true的作用是可以显示出hibernate操作的底层源代码实例：package com.bchy.s33;import org.hibernate.Session;import org.hibernate.SessionFactory;import org.hibernate.Transaction;import org.hibernate.cfg.Configuration;import com.bchy.geimei.entity.Login;public class Getsession {public static void main(String[] args) {//1.获取配置文件Configuration cft=new Configuration().configure();//2.获取sessionfactorySessionFactory sf=cft.buildSessionFactory();//3.获取session/*Session session=sf.openSession();Session session2=sf.openSession();*/Session session=sf.getCurrentSession();Session session2=sf.getCurrentSession();if(session==session2){System.out.println("ok!!!");}//4.开启一个事物Transaction tx=session.beginTransaction();//5.操作数据库Login l=new Login();l.setLogin_id(81);/* l.setLogin_name("张三");l.setPassword("123");*/System.out.println("。
马士兵hibernate学习笔记(文字整理版)
马士兵hibernate学习笔记(文字整理版)课程容 (5)1 HelloWorld (5)2 Hibernate原理模拟 - 什么是O/R Mapping以及为什么要有O/R Mapping (5)3 常见的0/R框架(了解) (5)4 hibernate基础配置（重点） (5)5 ID生成策略（重点 AUTO) (5)6 Hibernate核心开发接口介绍（重点） (5)7 对象的三种状态（了解） (5)8 关系映射（重点） (5)9 Hibernate査询（HQL) (5)10 在Struts基础上继续完善BBS200 (5)11 性能优化（重点） (5)12 补充话题 (5)风格 (5)1 先脉络，后细节 (5)2 先操作，后原理 (5)3 重Annotation,轻xml配置文件 (5)资源 (5)1 . (5)2 hibernate zh_CN文档 (5)3 hibernate annotation references (5)环境准备 (5)1 下载hibernate-distribution-3.3.2.GA-dist (5)2 下载hibernate-annotations-3[1].4.0.GA (5)3 注意阅读hibernate compatibility matrix(hibernate download) (5)4 下载slf4jl.5.8 (6)Hibernate HelloWorld (6)1 建立新java 项目,名为hibernate_0100_HelloWorld (6)2 学习建User-library-hibernate,并加入相应的jar包 (6)3 引入mysql的JDBC驱动包 (6)4 在mysql中建立对应的数据库以及表 (6)5 建立hibernate 配置文件hibernate.cfg.xml (6)6 建立Student 类 (6)7 建立Student 映射文件 Student.hbm.xml (6)8 将映射文件加入到hibernate.cfg.xml中 (6)9 写测试类Main,在Main中对Student对象进行直接的存储测试 (6)10 FAQ： (6)11 Note: (6)12 建立能力 (7)建立 Annotation 版本的 HelloWorld (7)1 创建teacher 表，create table teacher (id int primary key, name varhcar(20), title varchar(lO)); (7)2 创建Teacher 类 (7)3 在hibernate lib 中加入annotation的jar包 (7)4 参考Annotaion文档建立对应的注解 (7)5 在hibernate.cfg.xml中建立映射<mapping class:.../〉 . (7)6 参考文裆进行测试（注意文裆中缺少configure()的小bug) (7)7 FAQ: 不给提示 (7)What is and Why 0/R Mapping (7)1 JDBC操作数据库很繁琐 (7)2 Sql语句编写并不是面向对象的 (7)3 可以在对象和关系表之间建立关联来简化编程 (7)4 0/R Mapping 简化编程 (7)5 0/R Mapping跨越数据库平台 (7)6 Hibernate_0200_OR_Mapping_Simulation (7)0/R Mapping Frameworks (7)1 hibernate (7)2 toplink (8)3 jdo (8)4 JPA (8)Hibernate基础配置 (8)1 对应项目：Hibernate_0300_BasicConfiguration (8)2 介绍MSQL的图形化客户端 (8)3 hibernate.cfg.xml: hbni2ddl.auto (8)4 搭建日志环境并配置显示DDL语句 (8)5 搭建jUnit环境 (8)6 hibernate.cfg.xml：show_sql (8)7 hibernate.cfg.xml：format_sql (8)8 表名和类名不同,对表名进行配置 (8)9 字段名和属性相同 (8)10 字段名和属性名不同 (8)11 不需要psersistence的字段(不用列) (8)12 映射日期与时间类型，指定时间精度 (8)13 映射枚举类型( 比较少用) (9)14 字段映射的位置（field或者get方法） (9)15 Lob (9)16 课外：CLOBBLOB类型的数据存取 (9)17 课外：Hibernate自定义数据类型 (9)18 hibernate 类型 (9)ID生成策略 (9)1 对应项目：hibernate_0400_ID (9)2 注意： (9)3 xml生成id (9)4 注解方式：GeneratedValue (9)5 FAQ; (10)6 联合主键 (10)核心幵发接口介绍 (12)1 hibernate_0500_CoreAPI (12)2 Hibernate API文档需要单独下载 (12)3 Configuration (12)4 SessoinFactor (12)5 Session (12)6 SchemaExport (自动建表) (13)7 Query 接口 (13)8 Note： (13)三种对象状态 (14)1 上一个 project (14)2 三种状态的区分关键在于 (14)3 三种状态： (14)4 对这三种状态需要关注的问题是在该状态下如果进行数据库的操作会发生什么结果，比如改变属性的 (14)关系映射(重要) (15)对象之间的关系 (15)1 这里的关系映射指的是对象之间的关系，并不是指数据库的关系，本章解决的问题是当对象之间处于 (15)2 简化问题： (15)3 —对一 (15)4 —对多 (15)5 组件映射 (15)一对一关联 (16)1 一对一单向外键关联 (16)2 一对一双向外键关联 (16)3 一对一单向主键关联（不重要） (17)4 一对一双向主键关联（不重要） (17)5 联合主键 (17)组件映射 (17)1 项目：hibernate_1100_component (17)2 对象关系：一个对象是另外一个对象的一部分 (17)3 数据库表：一表 (17)4 annotation: Embeddable Embbeded (17)5 xml: 使用<component,例如: (18)多对一与一对多 (18)1 多对一单向关联 (18)2 一对多单向关联 (19)3 一对多（多对一）双向关联 (19)多对多 (20)1 单向关联： (20)2 双向关联： (21)关联关系中的CRUD_Cascade_Fetch (21)1 hibernate_1700_one2many_many2one_bi_crud (21)2 设定cascade以设定在持久化时对于关联对象的操作（CUD，R归Fetch管） (21)3 cascade仅仅是帮我们省了编程的麻烦而已，不要把它的作用看的太大 (21)4 铁律：双向关系在程序中要设定双向关联 (22)5 铁律：双向mappedBy (22)6 fetch (22)7 Update时ManyToOne()中的cascade参数关系 (22)8 Delete时ManyToOne()中的cascade关系 (22)9 O/RMapping 编程模型 (23)10 要想删除或者更新先做load,除了精确知道ID之外 (23)11 如果想消除关联关系，先设定关系为null.再删除对应记录，如果不删记录，该记录变成垃圾数据 (23)12 练习：多对多的CRUD (23)关系映射总结 (24)1 什么样的关系，设计什么样的表，进行什么样的映射 (24)2 CRUD,按照自然的理解即可（动手测试） (24)集合映射（不太重要） (24)1 项目名称：hibernate_1800_Collections_Mapping (24)2 Set (24)3 List (与Set差不多多个OrderBy) (24)4 Map (24)继承映射（不太重要） (24)1 三种方式 (24)作业: (24)1 学生课程、分数的设计(重要) (24)2 设计： (25)3 树状结构的设计（至关重要） (25)Hibernate 查询(Query Language) (26)HQL vs EJBQL (26)1 NativeSQL >HQL.> EJBQL(JPQL 1.0) > QBC(Query By Criteria) > QBE(Query By Example)" 262 总结：QL应该和导航关系结合，共同为査询提供服务。
Hibernate 学习笔记 知识总结
HibernateNote一、hibernate与db中数据类型对照（xml方式）1.与ORACLE常用数据类型对照背景为灰色的表示常用，熟记。
2.与MySql数据类型对照背景为灰色的表示常用，熟记。
2.1 hibernate mysql基本类型映射2.2 Java 时间和日期类型的Hibernate 映射二、Hibernate关系配置1.annotation基本类型配置配置、Jar 包等：a) hibernate annotaion jarb) ejb3 persistence jarc) hibernate common-annotations.jarFAQ: @不给提示，配置eclipse属性信息content assist-activation--加上@通过@Basic 可以声明属性的存取策略：@Basic(fetch=FetchType.EAGER) 即时获取（默认的存取策略）@Basic(fetch=ZY) 延迟获取通过@Temporal 定义映射到数据库的时间精度：@Temporal(TemporalType=DATE) 日期@Temporal(TemporalType=TIME) 时间@Temporal(TemporalType=TIMESTAMP) 两者兼具2.annotation列属性映射使用@Column 映射到列@Column(name="columnName"; // 可选，列名（默认是属性名）boolean unique() default false; // 可选，是否在该列上设置唯一约束（默认false）boolean nullable() default true; // 可选，是否可以为空boolean insertable() default true; // 可选，该列是否作为生成insert语句中的一列boolean updatable() default true; // 可选，该列是否作为生成update语句中的一列String columnDefinition() default ""; // 可选，为这个特定列覆盖SQL DDL 片段（可能导致无法在不同数据库间移植）String table() default ""; // 可选，定义对应的表，默认为主表int length() default 255; // 可选，列长度int precision() default 0; // 可选，列十进制精度（decimal precision）int scale() default 0; // 可选，列十进制数范围（decimal scale）public class Person {@Column(name = "PERSONNAME", unique = true, nullable = false, updatable = true)private String name;@Column(name = "PHOTO", columnDefinition = "BLOB NOT NULL", secondaryTable="PER_PHOTO")private byte[] picture;}3.联合主键：必须实现po层Serializable接口<class name="Student" table="t_student"><composite-id name="studentId" class="StudentId"><key-property name="firstName" length="20"></key-property><key-property name="lastName" length="20"></key-property></composite-id><property name="pwd" length="20"></property>4.组合关系<class name="User" table="t_user" ><id name="id"><generator class="native"></generator></id><property name="name"></property><property name="phone" column="dianhua" length="30"></property><component name="address" class="Address" ><property name="city"></property><property name="street"></property><property name="zipcode"></property></component></class>5.一对多，多对一5.1 xml格式的：一方：<class name="Department" table="t_dept"><id name="id" ><generator class="native"></generator></id><property name="dname" length="20"></property><set name="employees" ><key><column name="department_id"></column></key><one-to-many class="Employee"/></set></class>多方：<class name="Employee" table="t_emp"><id name="id"><generator class="native"></generator></id><property name="ename"></property><many-to-one name="department" class="Department" column="department_id"></many-to-one>5.2 annotation方式的：多方：@Id@GeneratedValue(strategy=GenerationType.AUTO)private Integer id;private String mname;@ManyToOneprivate Student student;一方：@Id@GeneratedValue(strategy=GenerationType.AUTO)private Integer id;private String sname;private String pwd;@OneToMany(mappedBy="student")private Set<Money> moneys;6.一对一外键关联6.1 xml格式的：<class name="Address" table="t_address" ><id name="id"><generator class="native"></generator></id><property name="aname" length="20"></property><one-to-one name="company" class="Company" property-ref="address"></one-to-one> </class><class name="Company" table="t_com" >外键生成<id name="id"><generator class="native"></generator></id><property name="cname" length="20"></property><many-to-one name="address" class="Address" cascade="save-update"><column name="address_id" unique="true"></column></many-to-one></class>6.2 annotation格式的：@Id@GeneratedValue(strategy=GenerationType.AUTO)private Integer id;private String cname;@OneToOne(cascade=CascadeType.ALL)@JoinColumn(name="student_id",unique=true)private Student student;@Id@GeneratedValue(strategy=GenerationType.AUTO)private Integer id;private String sname;@OneToOne(mappedBy="student")private Course course;6.3 一对一主键关联annotation格式的：@Id@GeneratedValue(strategy=GenerationType.AUTO)private Integer id;private String cname;private Integer age;private String des;@OneToOne(cascade=CascadeType.ALL)@PrimaryKeyJoinColumnprivate Student student;@Id@GenericGenerator(name="cc",strategy="foreign",parameters={@Parameter(name="property",value="cour se")})@GeneratedValue(generator="cc")private Integer id;private String sname;private Integer age;private String des;@OneToOne(mappedBy="student",cascade=CascadeType.ALL)private Course course;7.多对多7.1 xml格式的：xml格式的：<class name="Course" table="t_course"><id name="id" ><generator class="native"></generator></id><property name="cname" length="20"></property><set name="students" table="student_course"><key><column name="course_id"></column></key><many-to-many class="Student" column="student_id"></many-to-many></set></class><class name="Student" table="t_student"><id name="id" ><generator class="native"></generator></id><property name="sname" length="20"></property><set name="courses" table="student_course"><key><column name="student_id"></column></key><many-to-many class="Course" column="course_id"></many-to-many></set></class>7.2 annotation格式的：@Id@GeneratedValue(strategy=GenerationType.AUTO)private Integer id;private String mname;@ManyToMany(mappedBy="moneys")private Set<Student> students;@Id@GeneratedValue(strategy=GenerationType.AUTO)private Integer id;private String sname;private String pwd;@ManyToManyprivate Set<Course> moneys;8.其他8.1不需要psersistence的字段a) Annotation：@Transientb) xml不写8.2映射日期与时间类型，指定时间精度a) Annotation：@Temporal(参数) 参数有3种只显示时间,只显示日期,时间日期都显示//@Temporal(TemporalType.DATE) 只显示日期//@Temporal(TemporalType.TIME) 只显示时间//@Temporal(TemporalType.TIMESTAMP) 显示日期与时间b) xml:指定type<class name="Teacher" table="Teacher" ><id name="id" column="id"></id>property name="name" type="time" /></class>三、hibernate序列Sequence<id name="id" ><generator class="native"></generator></id>其他常用的序列生成方式1.<generator class="sequence"/>这是一个非常简单的接口；某些应用程序可以选择提供他们自己特定的实现。
Hibernate学习笔记
2、数据库设计：同上
3、annatation:@OneToMany 默认情况下当多对多处理、会创建一个临时表
4、解决方法： @OneToMany
@JoinColumn(name="groupID")
5、XML：<set name="setname">
public Set<Student> getStudent(){
return student;
}
<key-property name="id"></key-property>
<key-property name="name"></key-property>
</composite-id>
<property name="age"></property>
-------------6----------------
一对一：oneToOne
@JoinColumn(name="wifeID") 使用外键列进行实体的关联.
Annatation配置一对一的双向外键关联:
@OneToOne(mappedBy = "wifeID")
示例：在wife类中的getHusband()方法上注解
只要有双向关联mappedBy必设置 定义一边即可
分布式事务：同时对两个数据库进行操作、但此操作又属于同一事务.需要web服务器支持（Tomcat不能实现）
------对象的三种状态--------
Hibernate基础学习记录文本
一、第一个应用实例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学习笔记
第一次课：持久化：就是把瞬时状态的数据转变为持久化状态的数据，这一个过程就是持久化。
（java中内存分为：栈（变量，方法，形参都是在栈上），堆（new出来的对象在堆上））1）瞬时状态：刚new出来，在内存中存在的对象就是瞬时状态的。
如果程序结束，对象就会被回收。
2）持久化状态：在磁盘或者是数据库中存在的数据就是持久状态。
Hibernate是什么？1）是一个优秀的持久化框架，对jdbc进行进一步的封装。
（hibernate，ibatis ）。
2）是一个ORM (Object relation mapping ).Mysql,oracle,access 是关系型数据库=hibernate操作的是对象。
使用hibernate的步骤：1）新建项目2）引入jar包（hibernate最少依赖8个jar包）3）新建 hibernate配置文件（hibernate.cfg.xml） ,放在src根目录下面。
用于数据库的配置信息。
<hibernate-configuration><!-- 配置连接信息 --><session-factory><!-- 数据库的驱动类 --><property name="connection.driver_class">com.mysql.jdbc.Driver</property><!-- 配置数据库的用户名 --><property name="ername">root</property><!-- 配置密码 --><property name="connection.password">abc</property><!-- 配置数据库的url --><property name="connection.url">jdbc:mysql:///fwcz</property><!-- 配置数据库方言 --><property name="dialect">org.hibernate.dialect.MySQLDialect</property><!-- 自动建表第一次使用的时候，设置create,表建成之后，设置为update --><property name="hbm2ddl.auto">create</property></session-factory></hibernate-configuration>4)写bean/vo类，并且编写映射文件。
Hibernate学习笔记
Hibernate的名字的意义
将JDBC冷冻起来，hibernate的本身的意思是“冬眠”，意思就是让开发者对于JDBC的使用“冻结”起来，其实就是一个封装的概念，Hibernate其实就是对JDBC操作的一个封装
我们把Hibernate叫做一个持久层框架，就是因为hibernate专注于数据库的持久化实现
类和属性的名称不能随意修改，包括大小写，必须严格对应
关于表名和字段名不区分大小写
关于映射后的查询语句
在SQL语句中，你查询可以这样：
select ename,job,sal from emp
select * from emp
这里的*可以代表所有字段
注意，在hibernate中：
OR如何来映射？
1.必须借助于DB Driver连接描述，实际上一个hiberante工具
选择Database explorer，切换到DB Browser视图,新建一个DB Driver，名称可以任意起
2.使用Hibernate映射工具，开始R----O的转换
转换的时候你可以根据自己的需要来选择产生的类
3.Hibernate的连接工厂类HibernateSessionFactory，这个类中默认包含了如何连接数据库并获取数据库连接的代码，以及如何关闭数据库的代码
下一步，如何来操作数据库，比如查询
且慢，hiberante是基于ORM的实现
也就是，hiberante将数据库的表映射成了java类，所以你要对数据库的表来操作，需要先进行类的转换
//关闭数据库连接
HibernateSessionFactory.closeSession();
}
Hibernate_学习笔记
Hibernate -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笔记
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学习笔记1.MyEclipse的使用2.@ 符号不给提示a)可以使用快捷键alt + / 来进行提示b)进行选项设置window-->proferences--> 搜content assist java中的c)@提示preference—> java→ editor→content assistd)3.整行的复制、移动a)复制整行：按ctrl+alt+↑(↓) 来复制当前焦点所在的行b)移动整行：按alt+↑(↓) 来移动当前焦点所在的行4.2. hibernate 调试1.调试bug：表名不能和mappedBy=“”的名相同2.如果使用SchemaExport（cfg）它和SessionFactory 使用的Configuration一定不要是同一个否则会出现Duplicate collection role mapping 的错误3.4.3.hibernate 经验1.先建表a)在公司中一般先建表b)但是在建表的过程中不一定能和实体类中的对应关系对应上，所以可以通过实体类生成表，来看一下表应给怎么建，然后再去调整表，调整完表后，就可以调整实体类，并构建实体类c)现在是做实验一般会让他自动生成，因为实验式不需要对表调优2.4. PowerDisigner的使用1.连接数据库a)一般powerDisigner连接数据库使用odbc，但在Powerdisigner中没有MySQL的odbc数据源b)解决方法：使用jdbc进行连接i.菜单的Database-->configure connections-->connection profiles 设置ii.截图（视频35 （27.56秒视频截图））(设置截图)c)设置完成后测试有可能出现错误d)解决方法: 把mysql的jar 导入到系统的classpath下2.方向工程a)方向工程(reverse Engineer Database)b)作用: 可以把数据库中的表的关系反向再现c)其他的设置问题可以看视频35 （30分钟视频）3.课程内容1.HelloWorda)Xml的配置b)Annotation 的配置2.Hibernate原理模拟- - 什么是O/R Mapping 以及为什么要有O/R Mapping3.常见的O/R 框架（了解）4.Hibernate 基础配置（重点）5.Hibernate核心接口介绍（重点）6.对象的三种状态（了解）7.ID生成策略（重点掌握auto）8.关系映射（重点）9.Hibernate查询（HQL）10.在Struts基础上继续完善BBS200911.性能优化（重点）12.补充话题风格1.先脉络，后细节2.先操作，后原理3.重annotation，轻xml配置a)JPAb)Hibernate-extension环境配置导入hibernate-distribution下的hibernate3.jar导入hibernate-distribution\jpa\hibernate-jpa-2.0-api-1.0.0.Final.jar导入hibernate-distribution\required下的所有jar配置slf4j的日志环境导入slf4j\slf4j-nop-1.6.1.jar配置log4j的日志环境导入apache-log4j-1.2.16\log4j-1.2.16.jar并且要导入slf4j\slf4j-log4j12-1.6.1-sources.jar配置JUnit导入junit4.9b2\junit-4.9b2.jar注意版本的兼容性annotation entitymanager课程内容列表4. Hibernate 基础配置1. 对应项目：hibernate_0300_BasicConfiguration2. Mysql的图形化客户端3.Hibernate.cfg.xml : hbm2ddl.autoa)先建表，然后再创建对象优点：建表以后需要对表进行优化，如果是先建对象就没法对表进行优化啦4.搭建日志环境并配置显示ddl语句a)可以使用好几种日志架构如：slf4j log4j apache-commons-loggingb)使用slf4j 导入slf4j-api-1.6.1.jar 并导入slf4j-nop-1.6.1.jarc)使用log4j导入slf4j-api-1.6.1.ja 、log4j-1.2.16.jar、slf4j-log4j12-1.6.1.jar5.搭建JUnit环境a)注意JUnit的bugb)只需要导入JUnit下的一个jar包junit-4.9b2.jar6.Hibernate.cfg.xml :show_sql7. Hibernate.cfg.xml :format_sql8.表明和类名不同，对表名进行配置a)Annotation：@tableb)Xml table 属性9. 字段名和属性相同a）默认为@basicb）Xml中不用写column10.字段名和属性名不同a）annotation：@columnb）Xml 用column属性11.不需要persistence 的字段a）annotation：@transientb）Xml不写12.映射日期与时间类型，指定时间精度a）annotation：@temporalb）Xml 中使用type= date、time 等13.映射枚举类型a)Annotation：@Enumeratedb)Xml 麻烦14.字段映射的位置（field或者get方法）a)Best practice 保持field和get set方法的一致15.@Lob16.课外：CLOB、BLOB数据类型的存储17.课外：hibernate 自定义数据类型18.Hibernate类型5. ID 生成策略1.对应项目：hibernate_0400_ID2.注意：a)我们观察hibernate生成表的结构并不是为了将来就用它生成，（可能还有自己的扩展，如index 等），而是为了明白我们建立什么样的表和实体类映射3.Xml 生成Ida)Generatorb)常用四个：native identity sequence uuid4.@GeneratedValudea)自定义IDb)AUTOi.默认对mysql 使用auto_incrementii.对oracle 使用hibernate_sequence（名称固定）c) IDENTITYd）SEQUENCEi. @SequenceGeneratore) TABLEi. @TableGenerator5.FAQa)用junit测试时HibernateSessionFactory初始化异常不提示. 疑似一个bugb)用main来测试6.联合主键a)Xml：composite-idi.为什么要重写equals() 和hashCode() 方法，对象使用equals （）方法进行比较来区分两个pk 不同同于数据库中的联合主键两个联合起来是不同的可以用equals（）的返回值来模拟ii.为什么要实现serializable 接口因为当转存到虚拟内存中的时候需要序列化对象。
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笔记一、为什么要学习Hibernate替代JDBC，提高效率。
解决对象和关系的映射问题。
Hibernate的优点：1、开源和免费，可以在需要的时候研究源代码，改写源代码，进行功能的定制。
2、轻量级封装，避免引入过多复杂的问题，调试容易，也减轻程序员的负担。
3、具有可扩展性，API开放，当本身功能不够用的时候，可以自己遍码进行扩展。
4、开发者活跃，产品有稳定的发展保障。
二、对象持久化1、为什么要对象持久化使信息能够在程序中断甚至断电的情况下长期存在，并能够通过适当的方式重新还原为信息等同、结构相似的对象。
2、什么是对象持久化所谓对象持久化，就是将封装在对象中的信息保存在硬盘、磁带等这类物理媒介上。
对象序列化就是一种对象持久化技术，但它是基于文件系统的。
三、持久化对象的状态四、持久化对象的生命周期程序代码 Customer 对象的生命周期 Customer 对象的状态session.beginTransaction();User user1 = new User(1,”Tom”);开始生命周期 临时状态 session.save(user1);处于生命周期中 转化成持续化状态 Long id = user1.getid();User user2 = (User)session.get(User.class,id);session.getTransaction().commit();处于生命周期中 转化成持续化状态 session.close();处于生命周期中 转化成游离状态 System.out.println(user2.getName());处于生命周期中 转化成游离状态 User2 = null;结束生命周期 结束生命周期五、 Hibernate 中常用的接口1、Configuration 接口 {org.hibernate.cfg.Configuration}实例化Configuration 对象，并且从hibernate.cfg.xml 文件中读取信息 Configuration conf=new Configuration.configure();2、SessionFactory 接口：{org.hibernate.SessionFactory}这是一个设计模式，用户从SessionFactory中获取Session对象的实例。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
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)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的字段(不用列) (9)12 映射日期与时间类型，指定时间精度 (9)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 (10)5 FAQ; (11)6 联合主键 (11)核心幵发接口介绍 (12)1 hibernate_0500_CoreAPI (12)2 Hibernate API文档需要单独下载 (12)3 Configuration (12)4 SessoinFactor (12)5 Session (13)6 SchemaExport (自动建表) (14)7 Query 接口 (14)8 Note： (14)三种对象状态 (15)1 上一个 project (15)2 三种状态的区分关键在于 (15)3 三种状态： (15)4 对这三种状态需要关注的问题是在该状态下如果进行数据库的操作会发生什么结果，比如改变属性的 (15)关系映射(重要) (16)对象之间的关系 (18)1 这里的关系映射指的是对象之间的关系，并不是指数据库的关系，本章解决的问题是当对象之间处于 (18)2 简化问题： (18)3 —对一 (18)4 —对多 (18)5 组件映射 (18)1 一对一单向外键关联 (19)2 一对一双向外键关联 (19)3 一对一单向主键关联（不重要） (20)4 一对一双向主键关联（不重要） (20)5 联合主键 (20)组件映射 (20)1 项目：hibernate_1100_component (20)2 对象关系：一个对象是另外一个对象的一部分 (20)3 数据库表：一张表 (20)4 annotation: @ Embeddable @Embbeded (20)5 xml: 使用<component,例如: (21)多对一与一对多 (21)1 多对一单向关联 (21)2 一对多单向关联 (22)3 一对多（多对一）双向关联 (22)多对多 (23)1 单向关联： (23)2 双向关联： (24)关联关系中的CRUD_Cascade_Fetch (24)1 hibernate_1700_one2many_many2one_bi_crud (24)2 设定cascade以设定在持久化时对于关联对象的操作（CUD，R归Fetch管） (24)3 cascade仅仅是帮我们省了编程的麻烦而已，不要把它的作用看的太大 (24)4 铁律：双向关系在程序中要设定双向关联 (25)5 铁律：双向mappedBy (25)6 fetch (25)7 Update时@ManyToOne()中的cascade参数关系 (25)8 Delete时@ManyToOne()中的cascade关系 (25)9 O/RMapping 编程模型 (26)10 要想删除或者更新先做load,除了精确知道ID之外 (26)11 如果想消除关联关系，先设定关系为null.再删除对应记录，如果不删记录，该记录变成垃圾数据 (26)12 练习：多对多的CRUD (26)关系映射总结 (27)1 什么样的关系，设计什么样的表，进行什么样的映射 (27)2 CRUD,按照自然的理解即可（动手测试） (27)集合映射（不太重要） (27)1 项目名称：hibernate_1800_Collections_Mapping (27)2 Set (27)3 List (与Set差不多多个@OrderBy) (27)4 Map (27)继承映射（不太重要） (27)1 三种方式 (27)作业: (27)1 学生课程、分数的设计(重要) (27)2 设计： (28)3 树状结构的设计（至关重要） (28)Hibernate 查询(Query Language) (29)HQL vs EJBQL (29)1 NativeSQL >HQL.> EJBQL(JPQL 1.0) > QBC(Query By Criteria) > QBE(Query By Example)" 292 总结：QL应该和导航关系结合，共同为査询提供服务。
(29)性能优化 (29)1 注意session.clear()的运用，尤其在不断分页循环的时候 (29)2 1+N问题 (典型的面试题) (详见hibernate_2800_Hibernate_1+N项目) (29)3 list和iterate不同之处（//主要为了面试详见hibernate_2900_Hibernate_list_iterate） (29)4 一级缓存和二级缓存和査询缓存（面试题）(详见hibernate_3000_Hibernate_3KindsOf_Cache)295 事务并发处理(面试的意义更大) (30)课程内容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 版本的 HelloWorldannotation就是注解的意思，很多配置的信息不用写配置文件里，直接以编码的方式写在代码里1创建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-jpa-2.0-api-1.0.0.Final.jare)注意文裆中没有提到hibernate-common-annotations.jar 文件4参考Annotaion文档建立对应的注解5在hibernate.cfg.xml中建立映射<mapping class:.../〉6参考文裆进行测试（注意文裆中缺少configure()的小bug)7FAQ: @不给提示a)配置eclipse属性信息content assist-activation--加上@b)@Entity 实体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。