学习Hibernate ,我们首先要知道为什么要学习它？它有什么好处？也就是我们为什么要学习框架技术？

还要知道    什么是Hibernate?    为什么要使用Hibernate？    Hibernate的配置文件的作用是什么？          Hibernate映射文件的作用是什么？     Hibernate持久化对象的状态有哪些？

现在我先上面的问题解决了。

一。我们为什么要学习框架技术？

1.框架技术有哪些？

在Java开发中，我们经常使用Struts、Hibernate和Spring三个主流框架.

我们知道，传统的Java Web应用程序是采用JSP+Servlet+Javabean来实现的，这种模式实现了最基本的MVC分层，使的程序结构分为几层，有负责前台展示的JSP、负责流程逻辑控制的Servlet以及负责数据封装的Javabean。但是这种结构仍然存在问题：如JSP页面中需要使用<%>符号嵌入很多的Java代码，造成页面结构混乱，Servlet和Javabean负责了大量的跳转和运算工作，耦合紧密，程序复用度低等等。

Struts
为了解决这些问题，出现了Struts框架，它是一个完美的MVC实现，它有一个*控制类(一个Servlet)，针对不同的业务，我们需要一个Action类负责页面跳转和后台逻辑运算，一个或几个JSP页面负责数据的输入和输出显示，还有一个Form类负责传递Action和JSP中间的数据。JSP中可以使用Struts框架提供的一组标签，就像使用HTML标签一样简单，但是可以完成非常复杂的逻辑。从此JSP页面中不需要出现一行<%%>包围的Java代码了。
可是所有的运算逻辑都放在Struts的Action里将使得Action类复用度低和逻辑混乱，所以通常人们会把整个Web应用程序分为三层，Struts负责显示层，它调用业务层完成运算逻辑，业务层再调用持久层完成数据库的读写。
使用JDBC连接来读写数据库，我们最常见的就是打开数据库连接、使用复杂的SQL语句进行读写、关闭连接，获得的数据又需要转换或封装后往外传，这是一个非常烦琐的过程。
Hibernate
这时出现了Hibernate框架，它需要你创建一系列的持久化类，每个类的属性都可以简单的看做和一张数据库表的属性一一对应，当然也可以实现关系数据库的各种表件关联的对应。当我们需要相关操作是，不用再关注数据库表。我们不用再去一行行的查询数据库，只需要持久化类就可以完成增删改查的功能。使我们的软件开发真正面向对象，而不是面向混乱的代码。我的感受是，使用Hibernate比JDBC方式减少了80%的编程量。
现在我们有三个层了，可是每层之间的调用是怎样的呢?比如显示层的Struts需要调用一个业务类，就需要new一个业务类出来，然后使用;业务层需要调用持久层的类，也需要new一个持久层类出来用。通过这种new的方式互相调用就是软件开发中最糟糕设计的体现。简单的说，就是调用者依赖被调用者，它们之间形成了强耦合，如果我想在其他地方复用某个类，则这个类依赖的其他类也需要包含。程序就变得很混乱，每个类互相依赖互相调用，复用度极低。如果一个类做了修改，则依赖它的很多类都会受到牵连。 为此，出现Spring框架。
Spring
Spring的作用就是完全解耦类之间的依赖关系，一个类如果要依赖什么，那就是一个接口。至于如何实现这个接口，这都不重要了。只要拿到一个实现了这个接口的类，就可以轻松的通过xml配置文件把实现类注射到调用接口的那个类里。所有类之间的这种依赖关系就完全通过配置文件的方式替代了。所以Spring框架最核心的就是所谓的依赖注射和控制反转。
现在的结构是，Struts负责显示层，Hibernate负责持久层，Spring负责中间的业务层，这个结构是目前国内最流行的Java Web应用程序架构了。另外，由于Spring使用的依赖注射以及AOP(面向方面编程)，所以它的这种内部模式非常优秀，以至于Spring自己也实现了一个使用依赖注射的MVC框架，叫做Spring MVC，同时为了很好的处理事物，Spring集成了Hibernate，使事物管理从Hibernate的持久层提升到了业务层，使用更加方便和强大。
Struts框架是2000年就开始起步了，到目前已经发展了5年，技术相当成熟，目前全球Java开发中Struts框架是显示层技术中当之无愧的王者。它拥有大量的用户群和很好的开发团队。这也是国内大部分Java软件公司对新进员工的基本要求。

上面我只是简单的介绍了框架的出现原因，以及它们的优势。

下面才是我要对Hibernate的精讲。

1.什么是Hibernate?

Hibernate是一个开放源代码的对象关系映射框架，它对JDBC进行了非常轻量级的对象封装，它将POJO与数据库表建立映射关系，是一个全自动的orm框架，hibernate可以自动生成SQL语句，自动执行，使得Java程序员可以随心所欲的使用对象编程思维来操纵数据库。 Hibernate可以应用在任何使用JDBC的场合，既可以在Java的客户端程序使用，也可以在Servlet/JSP的Web应用中使用，最具革命意义的是，Hibernate可以在应用EJB的J2EE架构中取代CMP，完成数据持久化的重任。

也可以这样讲：

01.它是连接Java应用程序和关系数据的中间件（组件）

中间件就是一种软件的半成品，Hibernate就是帮忙我们解决操作数据库的问题。以后我们就不需要用JAVA的CONNECTION等对象

由Hibernate操作JDBC，简化我们操作数据库，提高开发效率。

02.它对JDBC API进行了封装，负责JAVA对象的持久化（就是保持到数据库里）

03.在分层软件体系中它位于持久化层，封装了所有数据访问细节，使业务逻辑层可以专注于实现业务逻辑

04.它是一种ORM映射工具，能够建立面向对象的域模型和关系数据模型之间的映射。

2,为什么要使用Hibernate？

Hibernate是一个开放源代码的对象关系映射框架，它对JDBC进行了非常轻量级的对象封装，使得Java程序员可以随心所欲的使用对象编程思维来操纵数据库.

Hibernate工作原理： 
    01、读取并解析配置文件 
    02、读取并解析映射文件，创建SessionFactory 
    03、打开Session 
    04、创建事务Transaction 
    05、持久化操作 
    06、提交事务 
    07、关闭Session 
    08、关闭SessionFactory

至于我们为什么要用Hibernate，就从Hibernate的四个优点来说：

首先、Hibernate对JDBC访问数据库的代码做了封装，大大简化了数据访问层繁琐的重复性代码。

其次、Hibernate是一个基于jdbc的主流持久化框架，是一个优秀的orm实现，它很大程度的简化了dao层编码工作。

再次、Hibernate使用java的反射机制，而不是字节码增强程序类实现透明性

最后、Hibernate的性能非常好，因为它是一个轻量级框架。映射的灵活性很出色。它支持很多关系型数据库，从一对一到多对多的各种复杂关系。

3.Hibernate的配置文件的作用是什么？

01.映射java类和关系型数据库的表。
02.使得对该类对象的操作可以映射到数据库记录的操作。

4.Hibernate的配置文件的参数的作用

在Hibernate配置文件中使用<set>, <list>, <map>, <bag>, <array> 和 <primitive-array>等元素来定义集合.
<set
name="propertyName" (1)
table="table_name" (2)
schema="schema_name" (3)
lazy="true|false" (4)
inverse="true|false" (5)
cascade="all|none|save-update|delete|all-delete-orphan" (6)
sort="unsorted|natural|comparatorClass" (7)
order-by="column_name asc|desc" (8)
where="arbitrary sql where condition" (9)
outer-join="true|false|auto" (10)
batch-size="N" (11)
access="field|property|ClassName" (12)
>
<key .... />
<index .... />
<element .... />
</set>

(1) name 集合属性的名称

(2) table （可选——默认为属性的名称）这个集合表的名称(不能在一对多的关联关系中使用)

(3) schema (可选) 表的schema的名称, 他将覆盖在根元素中定义的schema

(4) lazy (可选——默认为false) lazy(可选--默认为false) 允许延迟加载（lazy initialization ）(不能在数组中使用)

(5) inverse (可选——默认为false) 标记这个集合作为双向关联关系中的方向一端。

(6) cascade (可选——默认为none) 让操作级联到子实体

(7) sort(可选)指定集合的排序顺序, 其可以为自然的(natural)或者给定一个用来比较的类。
(8) order-by (可选, 仅用于jdk1.4) 指定表的字段(一个或几个)再加上asc或者desc(可选), 定义Map,Set和Bag的迭代顺序

(9) where (可选) 指定任意的SQL where条件, 该条件将在重新载入或者删除这个集合时使用(当集合中的数据仅仅是所有可用数据的一个子集时这个条件非常有用)

(10) outer-join(可选)指定这个集合,只要可能,应该通过外连接(outer join)取得。在每一个SQL语句中, 只能有一个集合可以被通过外连接抓取(译者注: 这里提到的SQL语句是取得集合所属类的数据的Select语句)

(11) batch-size (可选, 默认为1) 指定通过延迟加载取得集合实例的批处理块大小（"batch size"）。

(12) access(可选-默认为属性property):Hibernate取得属性值时使用的策略

5. Hibernate映射文件的作用是什么？

Hibernate的持久化类和关系数据库之间的映射通常是用一个XML文档来定义的。该文档通过一系列XML元素的配置，来将持久化类与数据库表之间建立起一一映射。这意味着映射文档是按照持久化类的定义来创建的，而不是表的定义。

它设定数据库表与实体类进行关联，让用户以面向对象的方式去操作持久化类(也就是实体bean)，而不再是操作数据库表，免去了用户频繁书写sql语句的麻烦

01、根元素：<hibernate-mapping>，每一个hbm.xml文件都有唯一的一个根元素，包含一些可选的属性

1）package：指定一个包前缀，如果在映射文档中没有指定全限定的类名，就使用这个作为包名,如

<hibernate-mapping package="com.demo.hibernate.beans">

<class name="User" ...>

</hibernate-mapping>

<hibernate-mapping>

<class name="com.demo.hibernate.beans.User" ...>

</hibernate-mapping>

2）schema：数据库schema的名称

3）catalog：数据库catalog的名称

4）default-cascade：默认的级联风格,默认为none

5）default-access：Hibernate用来访问属性的策略

6）default-lazy：指定了未明确注明lazy属性的Java属性和集合类，Hibernate会采取什么样的默认加载风格,默认为true

7）auto-import：指定我们是否可以在查询语言中使用非全限定的类名,默认为true,如果项目中有两个同名的持久化类,则最好在这两个类的对应的映射文件中配置为false

02、<class>定义类：根元素的子元素，用以定义一个持久化类与数据表的映射关系,如下是该元素包含的一些可选的属性

1）name：持久化类(或者接口)的Java全限定名,如果这个属性不存在,则Hibernate将假定这是一个非POJO的实体映射

2）table：对应数据库表名

3）discriminator-value：默认和类名一样，一个用于区分不同的子类的值，在多态行为时使用

4）mutable：表明该类的实例是可变的或者是不可变的

5）schema：覆盖根元素<hibernate-mapping>中指定的schema名字

6）catalog：覆盖根元素<hibernate-mapping>中指定的catalog名字

7）proxy：指定一个接口，在延迟装载时作为代理使用

8）dynamic-update：指定用于UPDATE的SQL将会在运行时动态生成，并且只更新那些改变过的字段

9）dynamic-insert：指定用于INSERT的SQL将会在执行时动态生成，并且只包含那些非空值字段

10）select-before-update：指定HIbernate除非确定对象真正被修改了（如果该值为true）,否则不会执行SQL UPDATE操作。在特定场合（实际上，它只在一个瞬时对象关联到一个新的Session中时执行的update()中生效）,这说明Hibernate会在UPDATE之前执行一次额外的SQL SELECT操作，来决定是否应该执行UPDATE

11）polymorphism：多态，界定是隐式还是显式的多态查询

12）where：指定定个附加的SQLWHERE条件，在抓取这个类的对象时会增加这个条件

13）persister：指定一个定制的ClassPersister

14）batch-size：指定一个用于根据标识符(identifier)抓取实例时使用的'batch size'(批次抓取数量)

15）optimistic-lock：乐观锁定，决定乐观锁定的策略

16）lazy：通过设置lazy="false",所有的延迟加载(Lazy fetching)功能将未被激活(disabled)

17）entity-name

18）check：这是一个SQL表达式，用于为自动生成的schema添加多行(multi-row)约束检查

19）rowid

20）subselect

21）abstract：用于在<union-subclass>的继承结构(hierarchies)中标识抽象超类

03、<id>定义主键：Hibernate使用OID(对象标识符)来标识对象的唯一性，OID是关系数据库中主键在Java对象模型中的等价物,在运行时,Hibernate根据OID来维持Java对象和数据库表中记录的对应关系

1）name：持久化类的标识属性的名字

2）type：标识Hibernate类型的名字

3）column：数据库表的主键这段的名字

4）unsaved-value：用来标志该实例是刚刚创建的，尚未保存。可以用来区分对象的状态

5）access：Hibernate用来访问属性值的策略

如果表使用联合主键，那么你可以映射类的多个属性为标识符属性。<composite-id>元素接受<key-property>属性映射和<key-many-to-one>属性映射作为子元素：

以下定义了两个字段作为联合主键：

<composite-id>

<key-property name="username" />

<key-property name="password" />

</composite-id>

04、<generator>设置主键生成方式

该元素的作用是指定主键的生成器，通过一个class属性指定生成器对应的类。(通常与<id>元素结合使用)

<id name="id" column="ID" type="integer">

<generator class="native" />--native是Hibernate主键生成器的实现算法之一，由Hibernate根据底层数据库自行判断采用identity、hilo、sequence其中一种作为主键生成方式。

</id>

Hibernate提供的内置生成器：

1）assigned算法

2）hilo算法

3）seqhilo算法

4）increment算法

5）identity算法

6）sequence算法

7）native算法

8）uuid.hex算法

9）uuid.string算法

10）foregin算法

11）select算法

05、<property>定义属性

用于持久化类的属性与数据库表字段之间的映射,包含如下属性：

1）name：持久化类的属性名，以小写字母开头

2）column：数据库表的字段名

3）type：Hibernate映射类型的名字

4）update：表明用于UPDATE的SQL语句中是否包含这个被映射的字段，默认为true

5）insert：表明用于INSERT的SQL语句中是否包含这个被映射是否包含这个被映射的字段，默认为true

6）formula：一个SQL表达式，定义了这个计算属性的值

7）access：Hibernate用来访问属性值的策略

8）lazy：指定实例变量第一次被访问时，这个属性是否延迟抓取，默认为false

9）unique：使用DDL为该字段添加唯一的约束，此外，这也可以用做property-ref的目标属性

10）not-null：使用DDL为该字段添加可否为空的约束

11）optimistic-lock：指定这个属性在进行更新时是否需要获得乐观锁定（换句话说，它决定这个属性发生脏数据时版本version的值是否增长）

access属性用来让你控制Hibernate如何在运行时访问属性。默认情况下，Hibernate会使用属性的get/set方法对。如果你指明access="field"，则Hibernate会忽略get/set方法对，直接使用反射来访问成员变量。

formula属性是个特别强大的的特征。这些属性应该定义为只读，属性值在装载时计算生成。用一个SQL表达式生成计算的结果，它会在这个实例转载时翻译成一个SQL查询的SELECT子查询语句。如：

<property name="totalPrice" formula="(SELECT SUM(*) FROM user)" />

6.Hibernate持久化对象的状态有哪些？

持久化对象的三种状态

Hibernate中的对象有3中状态，瞬时对象（TransientObjects）、持久化对象（PersistentObjects）和离线对象（DetachedObjects也叫做脱管对象）。

临时状态：由java的new命令开辟内存空间的java对象也就是普通的java对象，如果没有变量引用它它将会被JVM收回。临时对象在内存中是孤立存在的，它的意义是携带信息载体，不和数据库中的数据由任何的关联。通过Session的save（）方法和saveOrUpdate（）方法可以把一个临时对象和数据库相关联，并把临时对象携带的信息通过配置文件所做的映射插入数据库中，这个临时对象就成为持久化对象。

持久化状态：持久化对象在数据库中有相应的记录，持久化对象可以是刚被保存的，或者刚被加载的，但都是在相关联的session声明周期中保存这个状态。如果是直接数据库查询所返回的数据对象，则这些对象和数据库中的字段相关联，具有相同的id，它们马上变成持久化对象。如果一个临时对象被持久化对象引用，也立马变为持久化对象。

如果使用delete（）方法，持久化对象变为临时对象，并且删除数据库中相应的记录，这个对象不再与数据库有任何的联系。

持久化对象总是与Session和Transaction关联在一起，在一个session中，对持久化对象的操作不会立即写到数据库，只有当Transaction（事务）结束时，才真正的对数据库更新，从而完成持久化对象和数据库的同步。在同步之前的持久化对象成为脏对象。

当一个session（）执行close（）、clear（）、或evict（）之后，持久化对象就变为离线对象，这时对象的id虽然拥有数据库的识别值，但已经不在Hibernate持久层的管理下，他和临时对象基本上一样的，只不过比临时对象多了数据库标识id。没有任何变量引用时，jvm将其回收。

游离态或脱管态：Session关闭之后，与此Session关联的持久化对象就变成为脱管对象，可以继续对这个对象进行修改，如果脱管对象被重新关联到某个新的Session上，会在此转成持久对象。

脱管对象虽然拥有用户的标识id，所以通过update（）、saveOrUpdate（）等方法，再次与持久层关联。

Session对各种状态实体对象进行操作的可能结果如下表所示。

在项目开发中，通常使用工具类来管理SessionFactory和Session

当我们建立Session都要实例化SessionFactory，所以我们把重复的代码进行封装，并且session是单线程的。我们把对session的管理，打开session，关闭session等封装到工具类中，代码如下所示。

package cn.hibernate.util;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;

public class HibernateUtil {
    //1.初始化一个 ThreadLocal 对象
 private static final ThreadLocal<Session> sessionTL=new ThreadLocal<Session>();
 private static Configuration configuration;
 private final static SessionFactory sessionFactory;
 static{
     configuration=new Configuration().configure();
     sessionFactory=configuration.buildSessionFactory();
 }

 public static Session currentSession(){
     //2.返回当前的线程其对应的线程内部变量
     Session session=sessionTL.get();
     //如果当前线程是session 为空=null ，则打开一个新的Session
     if(session==null){
         //创建一个session对象
         session=sessionFactory.openSession();
         //保存该Sessioon对象到ThreadLocal中
         sessionTL.set(session);
     }
     return session;
 }
 //关闭Session
 public  static void closeSessio(){
     Session session=sessionTL.get();
     sessionTL.set(null);
     session.close();

 }
}

Hibernate的重要的核心类和接口

分别为:Session、SessionFactory、Transaction、Query、Criteria和Configuration。这6个核心类和接口在任何开发中都会用到。通过这些接口，不仅可以对持久化对象进行存取，还能够进行事务控制

<id name="deptNo" column="DEPTNO">
            <generator class="Assigned"/>

        </id>

<!--序列化  -->
        <property name="hbm2ddl.auto">update</property>

 <id name="gradeId" column="GRADEID">
            <generator class="sequence">
               <param name="sequence">SEQ_NUM</param>
            </generator>
        </id>

<!--序列化  -->
        <property name="hbm2ddl.auto">update</property>

 <!--name对应的是实体类的属性  -->
        <!--column对应的是数据库里面 的列  -->
        <id name="deptNo" column="DEPTNO">
            <generator class="native"/>
        </id>

<!--序列化  -->
        <property name="hbm2ddl.auto">update</property>

最后呢，还有很多知识没有写上去，有时间我继续补上去的！！！

谢谢大家的浏览