Hibernate知识点总结
Hibernate知识点
1 什么是HibernateHibernate是一个开放源代码的对象关系映射框架，它对JDBC进行了非常轻量级的对象封装，使得Java程序员可以随心所欲的使用对象编程思维来操纵数据库。
Hibernate可以应用在任何使用JDBC的场合，既可以在Java的客户端程序使用，也可以在Servlet/JSP的Web应用中使用，最具革命意义的是，Hibernate可以在应用EJB的J2EE架构中取代CMP，完成数据持久化的重任2 Hibernate的核心类和接口：<1>Configuration负责管理Hibernate的配置信息，这些配置信息都是从配置文件hibernate.cfg.xml或者Hibernate.properties读取的，当然也可以自定义文件名称，只要在实例化Configuration的时候指定具体的路径就可以了<2>SessionFactoryConfiguration的实例会根据当前的配置信息，构造SessionFactory实例。
SessionFactory是线程安全的，一般情况下一个应用中一个数据库共享一个SessionFactory实例。
<3>Session一般的持久化方法（CRUD）都是通过Session来调用的，Session是非线程安全的<4>Transaction事务管理<5>Query查询的接口3 Hibernate的原理及步骤1. 读取并解析配置文件//采用默认的hibernate.cfg.xml来启动一个Configuration的实例例：Configuration configuration=new Configuration().configure();//如要修改默认配置文件名当然你可以选择不修改Configuration configuration=new Configuration().configure(new File("src/xxx.xml"));2. 读取并解析映射信息，创建SessionFactory例：SessionFactory sessionFactory =configuration.buildSessionFactory();3. 打开Session实例(它是线程不安全的，是共享同一个session，所以要ThreadLocal模式来控制)例：Session session = sessionFactory.openSession();4. 创建事务Transaction例：Transaction transaction = (Transaction)session.beginTransaction();5. CRUD操作(执行数据操作 CRUD 增删查改)例：增加session.save(pojo对象);增加或者修改session.saveOrOpdate(pojo对象)//当修改时候,id不存在将被抛出异常删除session.delete(pojo对象)//根据主键加载p1=(Person)session.load(pojo类.class, 主键值);6. 提交事务例：mit();7. 关闭Session实例及SessionFactory例： session.close();sessionFactory.close();4.Session的管理Session是Hibernate运作的中心，对象的生命周期、事务的管理、数据库的存取，都与 Session息息相关，就如同在编写JDBC时需关心Connection的管理，以有效的方法创建、利用与回收Connection，以减少资源的消耗，增加系统执行效能一样，有效的Session管理，也是Hibernate应用时需关注的焦点。
韩顺平 hibernate笔记
◆hibernate是什么?1.hibernate 是一个框架(framework)2.hibernate 是一个orm框架[]●orm (object relation mapping) 对象关系映射框架o object -> 业务层(只对对象操作)r relation-> 关系数据库m mapping 对象关系映射文件3.hibernate 处于我们项目的持久层位置(正因为如此，所以有人又把hibernate称为持久层框架)4.hibernate 实际上就是对jdbc进行了轻量级的封装.5.hibernate 的基础还是我们java 反射机制●除了hiberante 这个orm框架，还有一些:apache ojb / toplink / ibatis / ejb cmpApache OJB （）Cayenne （）Jaxor （）Hibernate（）iBatis （）jRelationalFramework （）mirage （）SMYLE （）TopLink （）把对象持久化: 把对象的信息保存到数据库或者是文件.总结: hibernate 是对jdbc进行轻量级封装的orm 框架，充当项目的持久层.◆为什么需要hibernate?◆快如入门案例:hiberante 可以用在j2se 项目，也可以用在j2ee (web项目中)struts是web框架,所以用在web项目我们使用手动配置hibernate方式开发一个hibernate 项目，完成crud操作。
开发流程1.创建一个项目2.画出一个简单项目框架示意图3.引入hibernate 开发包(从网上下载google hibernate ),完后我们4.开发hibernate 有三种方法（开发顺序）我们使用第二种开发项目创建employe 表.create table employee(id number primary key,name varchar2(64) not null,email varchar2(64) not null,hiredate date not null)创建一个序列，将来用于主键的自增长:--创建一个序列create sequence emp_seqstart with 1increment by 1minvalue 1nomaxvaluenocyclenocache5.开发domain对象和对象关系映射文件对象关系映射文件：作用是用于指定domain对象和表的映射关系. ,该文件的取名有规范: domain对象.hbm.xml,一般我们放在和domain对象同一个文件夹下(包下)我们的Employee.hbml.xml配置文件：<!DOCTYPE hibernate-mapping PUBLIC"-//Hibernate/Hibernate Mapping DTD 3.0//EN""/hibernate-mapping-3.0.dtd"><hibernate-mapping package="com.hsp.domain"><class name="Employee" table="employee"><!-- id元素用于指定主键属性--><id name="id" column="id" type="ng.Integer"><!-- 该元素用于指定主键值生成策略hilo native increment sequence uuid --><generator class="sequence"><param name="sequence">emp_seq</param></generator></id><!-- 对其它属性还有配置--><property name="name" type="ng.String"><column name="name" not-null="false" /></property><property name="email" type="ng.String" ><column name="email" not-null="false"/></property><property name="hiredate" type="java.util.Date"><column name="hiredate" not-null="false" /></property></class></hibernate-mapping>6.手动配置我们的hibernate.cfg.xml文件，该文件用于配置连接的数据库的类型，driver, ,用户名，密码,url ....同时管理对象关系映射文件,该文件的名称，我们一般不修改.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><!-- hibernate 设计者，给我们提供了一写常用的配置--><!-- 配置使用的driver --><property name="connection.driver_class">oracle.jdbc.driver.OracleDriver</property> <property name="ername">scott</property><property name="connection.password">tiger</property><property name="connection.url">jdbc:oracle:thin:@127.0.0.1:1521:orclhsp</property> <!-- 配置dialect方言,明确告诉hibernate连接是哪种数据库--><property name="dialect">org.hibernate.dialect.OracleDialect</property><!-- 显示出对于sql --><property name="show_sql">true</property><!-- 指定管理的对象映射文件--><mapping resource="com/hsp/domain/Employee.hbm.xml"/></session-factory></hibernate-configuration>7.测试文件TestMain.javapackage com.hsp.view;import com.hsp.util.*;import java.util.Date;import org.hibernate.Session;import org.hibernate.SessionFactory;import org.hibernate.Transaction;import org.hibernate.cfg.*;import com.hsp.domain.Employee;public class TestMain {/*** @param args*/public static void main(String[] args) {//查询[load]->hql语句(hibernate query language)}public static void delEmp() {//删除//获取一个sessionSession session=MySessionFactory.getSessionFactory().openSession();Transaction ts=session.beginTransaction();//删除1.先获取该雇员，然后删除Employee emp=(Employee) session.load(Employee.class, 3);session.delete(emp);mit();session.close();}public static void updateEmp() {// TODO Auto-generated method stub//修改用户//获取一个会话Session session=MySessionFactory.getSessionFactory().openSession();Transaction ts=session.beginTransaction();//修改用户1. 获取要修改的用户，2.修改//load是通过主键属性，获取该对象实例.<--->表的记录对应Employee emp=(Employee) session.load(Employee.class, 3);emp.setName("韩顺平8");//update...emp.setEmail("abc@");mit();session.close();}public static void addEmployee() {//我们使用hibernate完成crud操作[这里我们只见对象，不见表]//现在我们不是用service ,直接测试.//1。
Hibernate常用知识点总结
一．Hibernate的流程1．开发数据库，建立数据库表2．通过DB Browser配置数据库连接3．添加Hibernate的支持（1）添加hibernate需要的jar包到WEB-INF/lib下（2）添加hibernate.cfg.xml配置文件（3）添加了HibernateSessionFactory.java类（session工厂类，用来产生session）4．映射表（1）添加PO持久化类如：er.java（2）添加了持久化类和关系表对应配置文件如：User.hbm.xml（映射了类和表、属性和列之间对应，主键生成方式）5．编写业务接口及实现类6．编写测试类进行测试二．Hibernate的基本配置1．hibernate.cfg.xml<hibernate-configuration><session-factory><!-- 显示操作时底层执行SQL --><property name="show_sql">true</property><!-- SQL方言，这里设定的是MySQL --><propertyname="dialect">org.hibernate.dialect.MySQLDialect</property><!-- JDBC驱动--><propertyname="connection.driver_class">com.mysql.jdbc.Driver</property><!-- JDBC URL --><propertyname="connection.url">jdbc:mysql://localhost:3306/hibernateTest</property><!-- 数据库用户名--><property name="ername">root</property><!-- 数据库密码--><property name="connection.password">root</property><!-- 对象、数据库表映射文件--><mapping resource="com/ascent/hib/po/User.hbm.xml"/></session-factory></hibernate-configuration>2．hibernate.properties3．*.hbm.xml<hibernate-mapping><class name="er" table="user" ><id name="id" type="integer"><column name="id" /><generator class="increment" /></id><property name="name" type="string"><column name="name" length="15" not-null="true" /></property><property name="pwd" type="string"><column name="password" length="15" not-null="true" /></property></class></hibernate-mapping>映射文件中主要包括三部份：类名与表名的映射、id属性与主鍵的映射、类属性和表列的映射。
Hibernate 学习笔记 知识总结
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知识点总结
Hibernate是目前最流行的开源对象关系映射(ORM)框架。
Hibernate采用低侵入式的设计，也即完全采用普通的Java对象（POJO），而不必继承Hibernate的某个基类，或实现Hibernate的某个接口。
Hibernate是面向对象的程序设计语言和关系数据库之间的桥梁，Hibernate允许程序开发者采用面向对象的方式来操作关系数据库。
因为我们知道hibernate它能支持透明持久化从这个角度来看它没有侵入性所谓侵入性它没有侵入hibernate任何的API所以它叫轻量级框架，轻量级框架的好处是没有侵入性另外的一个好处是为测试带来了好处，测试非常简单测试就行我们写普通的java应用程序一样不需要什么环境只需要几个jar包就可以了写个main函数一侧就可以了它没有侵入性和测试非常简单这是它流行的一个原因。
hibernate的优缺点优点：1、程序更加面向对象；2、提高了生产率；3、方便移植（修改配置文件）；4、无侵入性。
缺点：1、效率比JDBC略差；2、不适合批量操作。
3、只能配置一种关联关系Hibernate有四种查询方案1、get,load方法，根据id查找对象2、HQL--hibernate query language（查询对象：Query)3、Criteria--标准查询语言（查询对象：Criteria，查询条件：Criterion）4、通过sql来查（查询对象：SQLQuery）具体Query/Criteria:1.Query接口封装了Hibernate强大的对象查询能力，同时也支持数据库的更新操作2.提供了动态查询的参数绑定功能3.提供list(),iterator(),scroll()等对象导航方法4.提供uiqueResult()方法获取单独的对象5.提供executeUpdate()方法来执行DML语句6.提供了可移植的分页查询方法Session：1、save，presist保存数据，persist在事务外不会产生insert语句。
有关hibernate相关知识点
关于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基础知识点
DTD文件的位置
该DTD文件在本地硬盘位置： hibernate-core-4.1.4.Final JAR包 org.hibernate包下
XML文件的DTD文件描述了该XML文件包含的元 素（标记）以及元素属性等等
DTD主要用于验证XML文件是否格式正确，如不 正确，则不通过，报错
▪ 比如：以下写法会报错
第一级缓存是Session级别缓存，该缓存必需 第二级缓存是SesionFactory级别缓存，可选，下面语 句表示禁用第二级缓存
<property name = "cache.provider_class"> org.hibernate.cache.internal.NoCacheProvider </property >
概念提示
持久化对象中与数据库表主键对应的属性，称为 “对象标识符”，或“标识符属性”
说明—PO标识符（OID）的类型
假定与PO标识符属性（OID）对应的SQL Server 数据库表主键字段SQL类型为int或long
PO对象中的标识符属性类型可以采用
▪ Java基本类型：int或long ▪ Java包装类型：Integer或Long
XML文件头：指定文档类型声明
<hibernate-configuration> property标记配置相关属性 <session-factory> <property name =" "> </property> <mapping resource =“ "/> </session-factory> mapping标记配置映射文件路径 </hibernate-configuration>
hibernate总结
Hibernate读书笔记-----Hibernate知识总结2012-07-16 11:24:31 我来说两句收藏我要投稿利用一个星期（实际上是两个星期的上午）的时间终于是结束了Hibernate，本来在四月份就可以结束的，但是由于为期一个月的实习，加上各种考试、三个课程设计，hibernate 的学习一直都是断断续续的，等到暑假有时间了，也差不多都忘记了，于是只有从头开始了。
下面是我就这个星期所学的知识的一个简要的总结。
一、Hibernate开发流程Hibernate是一个面向java环境的对象/关系数据库映射工具，用来把对象模型表示的对象映射到基于SQL的关系模型数据结构中去。
主要是完成面向对象的编程语言到关系型数据库的映射Hibernate的开发流程一般有如下几个步骤：1、编写domain对象：持久化类。
2、加入hibernate.jar和其依赖的包。
3、编写XX.hbm.xml映射文件。
4、编写hibernate.cfg.xml配置文件。
必须要提供以下几个参数：connection.driver_class、connection.url、ername、connection.password、dialect、hbm2ddl.auto。
5、编写HibernateUtil工具类、主要用于完成hibernate的初始化过程和提供一个获得session的方法（可选）。
6、编写实现类。
二、Hibernate的体系结构Hibernate有如下三种体系结构：非常简要的Hibernate体系结构的概要图：从这个图可以看出，Hibernate使用数据库和配置信息来为应用程序提供持久化服务（以及持久的对象）。
轻型”的体系结构方案，它要求应用程序提供自己的JDBC 连接并管理自己的事务全面解决”的体系结构方案，将应用层从底层的JDBC/JTA API中抽象出来，而让Hibernate来处理这些细节。
三、Hibernate的持久化类Hibernate采用完全面向对象的方式来操作数据库，通过Hibernate的支持，我们只需要管理对象的状态，无须关心底层数据库系统的细节。
Hibernate 学习总结(star)
Hibernate学习总结目录第一部分：学习总结 (2)一．说明： (2)二．Hibernate开发流程： (2)三．hibernate中对象的三种状态 (3)四．Session讲解： (4)五．SessionFactory讲解 (4)六．Hibernate 数据检索方式 (4)1．HQL(Hibernate Query Language) (4)2．Criteria (5)七．Hibernate查询语言HQL (5)八．hibernate关联映射 (6)九．懒加载 (11)十．Hibernate缓存 (12)一级缓存，Session级共享。
(12)二级缓存，SessionFactory级共享。
(12)十一．hibernate查询缓存 (13)十二．事务管理 (14)十三．hibernate监听器 (15)第二部分：面试问题 (15)1．Hibernate优缺点？ (15)2．Hibernate工作原理及为什么要用？ (16)3．Hibernate是如何延迟加载? (16)4．Hibernate中怎样实现类之间的关系?(如：一对多、多对多的关系) (17)5．说下Hibernate的缓存机制 (17)6．什么样的数据适合放到二级缓存中？ (17)7．Hibernate的查询方式 (18)8．如何优化Hibernate？ (18)9．说说Hibernate中的update()和saveOrUpdate()的区别 (18)10．说说Hibernate中load()和get()的区别。
(18)11．谈谈Hibernate中inverse的作用 (18)12．hibernate中对象的三种状态 (19)13．在数据库中条件查询速度很慢的时候,如何优化? (19)14．在hibernate中进行多表查询,每个表中各取几个字段,也就是说查询出来的结果集并没有一个实体类与之对应,如何解决这个问题? (20)15．事务应该放在业务逻辑中来处理，但是Hibernate的事务却总是在数据访问层才会出现，如果我们既想使用hibernate的事务，又不希望业务逻辑层和数据库访问层写在一起，应该如何处理？ (20)16．悲观锁和乐观锁如何实现？ (20)17．大量操作数据时可能造成内存溢出，如何解决？ (20)18．什么时候会出现N+1次查询？ (21)19．session flush方法主要做了什么事? (21)20．session在什么情况下执行flush ? (21)21．什么时候不使用使用Hibernate? (21)第一部分：学习总结一．说明：1．目前我使用hibernate的版本是3.6.3版本。
hibernate知识点总结
hibernate.cfg.xml 中配置项的说明:
1. 数据库的基本配置信息
驱动
url
-----------------------（采用这个方式来建表，工具类）根据配置生成表结构,通常在生成环境中使用----------
Configuration cfg = new Configuration().configure() ;
SchemaExport schemaExport = new SchemaExport(cfg);
图片二进制格式：
2.特殊的属性:主键
<id name="id" column="id">
<generator class="native"/> 根据情况选择identity,sequence,hilo中的一个
</id>
<generator class="assigned"/> 手工指定
schemaExport.create(true,true);
是否显示sql语句
是否格式化sql语句
3.引入映射文件
映射文件的基本配置：
1.一般的属性:
大文本的时候，最好指定长度：
<property name="desc" type="text" length="5000"/>
Hibernate总结
Hibernate总结HIBERNATE总结 (1)一、HIBERNATE框架及ORM (2)1.1H IBERNATE的定义： (2)1.2ORM的定义： (2)1.3H IBERNATE框架的优点： (2)1.4H IBERNATE框架的缺点： (3)1.5H IBERNATE中J AVA对象的三种状态 (3)2.3三种状态转换的详解 (4)二、HQL实用技术 (5)2.1编写HQL语句 (5)2.2执行HQL语句 (5)2.3在HQL查询语句中绑定参数 (5)三、HIBERNATE关联映射 (7)3.1多对一映射关联（MANY-TO-ONE） (7)3.2一对多映射关联（ONE-TO-MANY） (7)3.3一对一映射关联 (7)3.4多对多关联（MANY-TO-MANY） (8)四、HIBERNATE缓存机制 (9)4.1缓存的概念： (9)4.2H IBERNATE缓存分类： (9)4.3一级缓存详解 (9)4.4二级缓存详解 (10)一、Hibernate框架及ORM1.1Hibernate的定义：Hibernate是数据持久化工具，是一个开放源代码的对象关系映射框架。
Hibernate 内部封装了通过JDBC访问数据库的操作，向上层应用提供面向对象的数据访问API。
1.2ORM的定义：ORM全称“Object/Relation Mapping”即对象关系映射，是一种数据持久化技术。
它在对象模型和关系型数据库之间建立起对应关系，并且提供了一种机制，通过JavaBean对象去操作数据库表中的数据。
(此图暂时省略)1.3Hibernate框架的优点：Hibernate功能强大，是Java应用与关系数据库之间的桥梁，较之JDBC操作数据库，代码量大大减少，提高了持久化代码的开发速度，降低了维护成本。
Hibernate支持许多面向对象的特性，如组合、继承。
使得开发人员不必在面向业务领域的对象模型和面向数据库的关系型数据模型之间来回切换，方便开发人员进行领域驱动的面向对象的设计与开发。
Hibernate 知识点小结
Hibernate 知识点小结Hibernate一, Hibernate 介绍:Hibernate 只是一个将持久化类与数据库表相映射的工具，每个持久化类实例均对应于数据库表中的一个数据行而已。
用户只需直接使用面向对象的方法操作此持久化类实例，即可完成对数据库表数据的插入、删除、修改、读取等操作。
当然实际的Hibernate 框架非常复杂，用分层的概念划分的话，它相当于在业务逻辑处理层和数据库底层JDBC驱动之间的一层，即通常说的持久化层，而用户通过XML 配置文件将具体的持久化类与数据库表映射起来。
Hibernate 的实际过程还需依赖SQL 语言和JDBC 编程接口，但是Hibernate 将原本分散的JDBC 和SQL 配合产生的接口变成了对象化的接口，定义了自己的基于面向对象设计的HQL（Hibernate Query Language）查询语言，通过它生成实际的SQL 语句传递到数据库执行的。
1) ConfigurationConfiguration 类负责管理Hibernate 运行时需要获取一些底层实现的基本配置信息，如：数据库URL、数据库用户、数据库用户密码、数据库JDBC 驱动类、数据库适配器（dialect，用于对特定数据库支持）等。
Hibernate 的配置文件为hibernate.cfg.xml 或者hibernate.properties，缺省在CLASSPATH 路径下，可调用如下进行初始化：Configuration config = new Configuration().configure();2) SessionFactorySessionFactory 负责创建Session 实例，通过Configuation 实例创建它：SessionFactory sessionFactory =config.buildSessionFactory();如果需要访问多个数据库，要分别为其创建对应的SessionFactory 实例。
Hibernate总结
主键生成策略：
Increment:对类型为long,short 或int的主键； Identity：对SQL Server DB2， MySQl等支持表示类的数据库 Sequence：对Oracle DB2 通过子元素 param传入数据库中旭类的名称 Native:由Hibernate根据底层数据库自行判断采用何种主键生成策略 (MySQL) Assigned：逐渐由应用程序负责生成，无需Hibernate参与。
多对多关联
如： ----project配置 <set name=”members” table=”r_emp_proj”> <key column=”r_proj_id”/> <many-to-many class=”accp.entity.Employee” column=”r-emp_id”/> <set> ----Employee配置 <set name=”projects” table=”r_emp_proj” inverse=”true”> <key column=”r_emp_id”/>accp.entity.Project” column=”r_proj_id”/> </set>
双向一对多关联
Cascade属性值： All：对所有操作进行级联操作 Save—update：执行保存和更新操作是进行级联操作 Delete：执行删除操作时进行级联操作 None；对所有操作不进行级联操作 <set name="students" inverse="true" cascade="delete"> <key> <column name="CID" precision="11" scale="0" /> </key> <one-to-many class="org.accp.zhx.pojo.Student" /> </set> Inverse属性： 直译：反转，指定了关联关系中的方向 区别：inverse是关联关系的控制方向 Cascade是层级之间的连锁操作
Hibernate学习总结
一．对象语言和操作数据库不匹配：模型不匹配（阻抗不匹配）①．可以使用JDBC手动转换；sql参数和jdbc中用对象赋值②．使用ORM（Object Relation Mapping对象关系映射）框架：hibernate 二．Hibernate安装配置①．配置文件Hibernate.cfg.xml和Hibernate.properties②．映射文件xxx.hbm.xml：对象模型和关系模型的映射三．开发流程1.由Domain Object -> mapping -> db2.有DB开始，用工具生成mapping和Domain Object3.由配置文件开始四．Domain Object限制1.默认的构造方法（必须的）2.有无意义的标示符id(主键) 可选3.非final的，对懒加载有影响可选Configuration SessionFactory Session Transaction Query CriteriaConfiguration类Configuration类负责配置并启动Hibernate，创建SessionFactory对象。
在Hibernate的启动的过程中，Configuration类的实例首先定位映射文档位置、读取配置，然后创建SessionFactory 对象。
SessionFactory接口SessionFactory接口负责初始化Hibernate。
它充当数据存储源的代理，并负责创建Session对象。
这里用到了工厂模式。
需要注意的是SessionFactory并不是轻量级的，因为一般情况下，一个项目通常只需要一个SessionFactory就够，当需要操作多个数据库时，可以为每个数据库指定一个SessionFactory。
Session接口Session接口负责执行被持久化对象的CRUD操作(CRUD的任务是完成与数据库的交流，包含了很多常见的SQL语句。
Hibernate初级学习总结
Hibernate初级学习总结1.Hibernate是基于是么原因产生的？（Hibernate的有点）答案：实现业务逻辑的代码和数据库访问代码掺杂在一起，使程序结构不清晰，可读性差在程序代码中嵌入面向关系的SQL语句，使开发人员不能完全运用面向对象的思维来编写程序业务逻辑和关系数据模型绑定，如果关系数据模型发生变化，例如修改了CUSTOMERS表的结构，那么必须手工修改程序代码中所有相关的SQL语句，这增加了维护软件的难度如果程序代码中的SQL语句包含语法错误，在编译时不能检查这种错误，只有在运行时才能发现这种错误，这增加了调试程序的难度2.Hibernate是什么？它是连接Java应用程序和关系数据库的中间件它对JDBC API进行了封装，负责Java对象的持久化在分层软件体系结构中它位于持久化层，封装了所有数据访问细节，使业务逻辑层可以专注于实现业务逻辑它是一种ORM映射工具，能够建立面向对象的域模型和关系数据模型之间的映射3.hibernate中进行DML数据库操作时当注意的事项！Public void insertUser(User user){Configuration cfg = new Configuration().configure();SessionFactory sf = cfg.buildSessionFactory();Session s = sf.openSession();Transaction tx = s.beginTransaction();//Transaction tx = s.getTransaction(); tx.beigin();s.save(user);mit();}1).Configuration------这个对象是用来解析和读取hibernate配置文件的对象，进一创建hibernate上下文对象sessionFactory启动hibernate框架。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
多期: 天润4+5名字: 陈宣任日期作业: 2011年12月8日Hibernate课堂讲课知识点总结：一．hibernate基础知识二．hibernate一对一映射三．hibernate一对多(多对一)映射四．hibernate多对多映射五．hibernate的HQL检索学习一．Hibernate基础知识1.hibernate：hibernate就是一个可以自动的根据xml或annotation完成对象关系映射(orm)，并持久化到数据库的开源框架。
是连接java应用程序和关系数据库的中间件，这是对JDBC的封装，主要负责java对象的持久化。
2.ORM(Object Relation Mapping)对象关系映射是一种为了解决面向对象与关系数据库存在的互不匹配的现象的技术。
3.hibernate映射文件：它的作用是描述持久层对象以及让他们的属性和数据库中的表和表的字段之间的对应关系。
没有映射文件，Hibernate系统无法完成Java对象和数据库表中的数据的相互转化。
只有通过映射文件，Hibernate才能知道所操作的对象与哪个表相关联。
4.hibernate.cfg.xml文件中包含了hibernate与数据库的基本连接信息。
在Hibernate工作的初始阶段，由Configuration的对象开启hibernate框架，然后将信息加载到SessionFactory实例中。
5.SessionFactory是Hibernate中的一个类，这个类主要负责保存Hibernate的配置信息，以及对Session的操作。
6.手动创建hibernate框架的步骤：a)拷贝所需Jar包到lib目录下，基本包含(antlr.jar,cglib.jsr,asm.jar,commons-collections.jar,commons-logging.jar,jta.jar,dom4j.jar,hibernate3.jar,hibernate-annotations.jar)b)在src目录下创建一个hibernate.cfg.xml文件，该文件包含了hibernate与数据库连接的基本连接信息。
在Hibernate工作的初始阶段，这些信息被先后加载到Configuration和SessionFactory实例。
c)创建一个User.hbm.xml(类名.hbm.xml)。
包含Hibernate的基本映射信息，即系统中每一个类与其对应的数据库表之间的关联信息，在Hibernate工作的初始阶段，这些信息通过Hibernate.cfg.xml的mapping节点被加载到Configuration和SessionFactory实例。
7.Hibernate关联映射：一对一：由数据库中共享主键实现（A表一行记录对应B表一行记录）。
一对多：由外键约束实现(A表中一行记录对应B表中多行记录)。
多对多：中间表约束实现（需要产生一个中间表，两个表与中间表的关联关系为一对多）。
8.hibernate级联关系映射叫高级映射，Hibernate是用于控制类的而不是表。
级联关系在类中配置由映射文件进行描述。
要想让表有关系，必须让两个类有关系。
9.高级映射第一点：开启Hibernate的级联关系映射。
两个类之间靠互换实例来进行关系访问。
（实例主要用来负责级联操作）。
10.实体对象的三个生命周期：所谓的Hibernate实体对象的生命周期就是指Hibernate的实体对象在整个应用中的存在状态。
实体对象的生命周期中主要存在三种不同的状态，他们分别是：Transient(瞬态)，Persistent（持久态），Detached（游离态），这三种状态的定义与所谓的持久化上下文(persistence context)有关，Hibernate的Session对象就是这个所谓的持久化上下文。
11.Hibernate中load()和get()的异同相同点：功能上是一样的全是通过该对象的标示符来得到一个持久化对象，可以理解为根据id加载一个对象。
不同点：:区别在于返回值的差异，load()如果没有找到该对象的时候它是抛出异常的，而get()如果没有找到该对象将会返回null。
Session.get（）不支持数据缓存，永远查询数据库。
Session.load（）支持数据缓存，查询的内存12.完成一次Hibernate框架启动的七个步骤：1创建Configuration对象（Configuration conf=new Configuration();conf.configure();主要作用配置和启动Hibernate框架，读取Hibernate.cfg.xml核心配置文件）2.创建SessionFactory对象3.通过SessionFactory对象创建Session对象4.通过Session开启一个事物并得到一个Transaction对象（Transaction对象主要适用于事务管理，一个事务对象可能包括多个数据库进行操作）5.通过Session与数据库进行会话及持久化操作6.提交操作结束事物提交事务7.关闭Session释放资源13.hibernate生成数据库表的两种方式：第一种：Configuration cfg = new Configuration().configuration();SchemaExport export = new SchemaExport(cfg);Export.create(true,true);//参数一是否发送Hibernate自定义的建表脚本到数据库中，参数二是否让数据库执行发送过去的脚本。
第二种：通过保存数据用Save(对象名)方法。
14.持久化信息的方法：i.创建一个Configuration对象：Configuration conf = new Configuration();ii.通过Configuration对象的configure()方法加载Hibernate配置文件。
conf.configure();iii.创建一个SessionFactory实例SessionFactory factory = conf.buildSessionFactory();iv.通过SessionFactory实例创建Session实例Session sion = factory.openSession();v.通过Session实例开启事务，得到事务对象。
Transaction tran =sion.beginTransaction();vi.使用Session实例的save()方法，传入实体类对象，将User对象持久化。
Sion.save(Object);mit();vii.在创建Session实例后，不论是否执行事务，最后都需要关闭Session实例，释放Session实力占用的资源。
Session.close();二．Hibernate一对一映射（人与身份证的关系）1.一对一关联映射：可分为主键关联映射和唯一外键关联映射（是多对一的一种特殊表现形式）两种，同时，这两种关联映射又分为单向关联和双向关联。
2.单向一对一主键关联映射：在任意一方存储另一方的实例对象。
一对一级联关系创建及配置的标记用<one-to-one />标签.3.双向一对一主键关联映射：双方需要分别存入对方的实力对象。
4.<one-to-one />标签中的常用属性解析（1）name：<one-to-one />的级联关系需要name指定的成员来实现。
（2）class：为指定的对象类。
（3）constrained=”true”：添加数据库底层约束。
表明A表对象必须和一个B表对象关联，也就是说A对象中的B属性不能为空。
（4）fetch：控制两表连接查询。
三．Hibernate一对多(多对一)映射（班级和学生的关系）1.一对多(save一方)：在多方为一方创建外键。
注意：一对一靠类中的对象实现，一对多需要靠容器(集合)实现，在这里我们选择Set集合，因为Set不能存入重复值。
并且set中有HashSet，可以用Hash算法辅助数据库查询。
一对多级联关系创建及配置的标记用<set />标签中的<one-to-many />标签2.一对多级联配置文件的例子：<set name=”student” cascade=”all”><key column=”classes_id”></key><one-to-many class=”Student”/></set>3.注意：当一方操作多方的时候(级联关系由一方维护)做添加的时候有7个SQL语句(注意此时的SQL语句数量根据你插入的信息数来看，如果你插入两条信息则是5个SQL语句。
如果你插入三条信息则是7个SQL语句)可以用2n+1这个算法来计算产生的SQL语句数。
(n表示添加的信息条数)4.当一方操作多方时有两个问题：第一：当一方操作多方的时候(级联关系由一方维护)做添加的时候有2n+1个SQL语句。
（n表示添加的信息条数）第二：外键不允许为空(null)的时候一方无法操作多方。
5.对多对(save多方)：在多的一方存入一方的类对象。
6.注意：进行多对一操作时，此时多方需要给自己添加一个外键，即在<many-to-one></many-to-one>中加一个column，<many-to-one name=”classes”class=”Classes” column=”classes_id”></many-to-one>，这里的外键(column)的值最好和在一方的映射文件中的<key />标签的column值相同。
7.瞬时状态异常产生的原因(一对多和多对多经常出现)：数据库中无存入的信息。
即操作不级联时会产生瞬时状态异常。
此时应设置cascade属性值为all，注意cascade的属性值应该谨慎设置。
8.当多方操作一方的时候昨天加的时候出现4个SQL语句，因为多方不需要额外拼写修改外键的语句。
9.双向级联关系：（在双向一对多的时候，一方和多方都需要配置外键，并且两个外键的名字相同。
）当双方的关系都存在的时候，Hibernate框架默认选择一方为级联关系的主控方(一对多)。
因此，如果希望让多方来维护，则要在一方的映射配置文件中的<set />标签中添加inverse属性值为true。
10.inverse=”true”属性表示让当前一方反转出级联关系的主控权。
由多方来维护级联关系。