Hibernate 的原理与配置

hibernate的原理首先在这里给大家讲一讲吧.
其实原理是非常简单的.
我们知道如果用java连接数据库我们首先想到的就是JDBC,那么hibernate是什么呢.
hibernate可以理解为是一个中间件它负责把java程序的sql语句接收过来发送到数据库,
而数据库返回来的信息hibernate接收之后直接生成一个对象传给java.
什么??对象是什么?做什么用的?
java利用对象才可以有效的进行远程的数据传递.
= =java就是一个面向对象的语言啊.这个地方需要大家慢慢体会了.
下面说说hibernate的文件吧.
我们要写一个hibernate的话自然要在数据库里有我们要操作表对吧.不然我们连什么啊.假设是一个student学生表吧.大多数不都喜欢用学生练手么..咱们也用它.
sql语句:
create table student(id Number(10),name varchar2(20))

随便乱建一个了.
这个我们是一定要用的表了.

接下来呢.我们需要有两个hibernate特有的文件.
一个是以.cfg.xml结尾的文件.一个是以.hbm.xml结尾的文件.
这两个文件做什么用的呢?
.cfg.xml的作用就是连接数据库文件内部其实就是一个由user,password,url,driver组成的一个连接库的基本信息.
文件的内容是这样的:
<?xml version='1.0' encoding='UTF-8'?>
<!DOCTYPE hibernate-configuration
  PUBLIC "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
  "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">

<hibernate-configuration>
 <session-factory>
  <property name="connection.username">111</property>
  <property name="connection.url">jdbc:oracle:thin:@127.0.0.1:1521:ris</property>
  <property name="dialect">org.hibernate.dialect.Oracle9Dialect</property>
  <property name="connection.password">111</property>
                <property name="connection.driver_class">oracle.jdbc.driver.OracleDriver</property>

  <mapping resource="Student.hbm.xml"/>
        </session-factory>
</hibernate-configuration>

到这里这个.cfg.xml的文件就结束了这个文件的全称应该是"你的应用名字.cfg.xml"为了让大家好理解.
我建立的项目名称就是one,所以这个cfg的文件全称应该是one.cfg.xml
这里简单再分析一下这个文件.估计先看这个的话不是很明白.但结合程序看就会明白这个文件的含义了.
这个<hibernate-configuration>包含的是程序里面的configuration的实例的信息.通过这个实例的方法configure我们可以
从mapping里得到对应的表的信息和类的信息.
现在再看<session-factory>这个标签.它呢是我们在程序里通过configure的方法BuildSessionFactory所得到的
一个SessionFactory对象这个对象呢可以理解为一个statement我们对数据库的所有操作都是通过它的一系列方法来实现的.
这里面的那些property不用多说啦都是一些连接需要的东西.
其中有个dialect这个一定有不明白吧.这个是hibernate的东西啦.因为咱们不是就用的是hibernate来与数据库连接么.
但数据库不同dialect后面的也就不同.

下面讲这个Student.hbm.xml文件.
这个文件是对数据库的表的映射文件.
我们用这个文件指出哪个类对应着哪个表.
而且还指出哪个类中的属性对应着表中的哪个字段.
我们也来看看内容.

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping
  PUBLIC"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
  "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">

<hibernate-mapping>
 <class name="src.Student" table="student">
  <id name="id" column="id">
   <generator class="increment"/>
  </id>
  <property name="name" column="name"/>
 </class>
</hibernate-mapping>

到此这个文件就结束了.特别说一下这个id的问题.我们看到它里面有个<generator class="increment"/>
这个是什么呢这个是可以实现自动id增加.也就是说如果我们往数据库中插入一个name那么就id自动加1.

这个文件解释一下了<hibernate-mapping>这个所包含的就是我们前一个文件里面说的mapping.
我们在java类中configure得到的mapping就是从这个文件里面读取出来的.
类如果带包的话一定要带包名(推荐一切写的类都要带包).包名和类名要注意.包名小写,类名的第一个大写.
我是怕出错,这里提醒大家一下.
<class name="src.Student" table="student">
这个就是先指定了类对应的表.
然后里面的那些就是指定表中的字段与类中的属性的对应关系了.

到这里这两个特殊的文件就写完了.下面就只是我们的java类了..
要两个.一个是Pojo类.一个是我们的Test类.

我们的Pojo类就是简单的一个javaBean.为什么这么叫??(Plain Old Java Objects, 简单洁净Java对象)<--这个是偶从网上找的.
不过没必要深究这个.直接看代码吧.

package src;

public class Student{

 private int id;
 private String name;

 public void setId(int id){
  this.id=id;
 }
 public void setName(String name){
  this.name=name;
 }

 public int getId(){
  return id;
 }

 public String getName(){
  return name;
 }
}
完了.就是这么简单的一个类.不用想太难.它就是和数据库的字段对应然后取值的

下面是我们关键的Test类

package src;

import org.hibernate.*;
import org.hibernate.cfg.*;

public class Test{
 public static void main(String bb[]){
  try{
   SessionFactory sf=new Configuration().configure().BuildSessionFactory();
   Session s=sf.opension();
   Transaction ts=s.beginTransaction();
   for(int i=0;i<3;i++){
    Student st=new Student();
    st.setName("begin go "+ i);
    s.save(st);
    }
   ts.commit();
   s.close();
  }catch(Exception e){
   e.printStackTrace();
  }
 }
}

这里的第一句SessionFactory sf=new Configuration().configure().BuildSessionFactory();
得到configuration的实例.这个开始要和最前面的哪个.cfg.xml对应着看了.
我们取得实例.然后通过configure()读取mapping对应的.hbm.xml文件的信息.
然后我们通过BuildSessionFactory得到SessionFactory对象
然后我们在通过opensession()建立连接.Session就是指一个session被建立.这个需要有servlet的基础理解.
这里等于是一个connection被建立好.
下面通过session对象开启事务(Transaction)这个相当于conn.setAutoCommit(false);先不递交最后通过另外一个方法递交.
我们看到下面我们循环里把咱们写好的Student实例化了.
既然实例化了我们就能用里面的方法了.看到set方法了吧.就是这么简单.
每次都要session来save一下.一个对象set之后要保存.很好理解吧.保存在了session中.
最后递交commit();
这个方法实际上是实现了两个作用.
conn.commit(); 
conn.setAutoCommit(true);
这样才能把我们的数据放进数据库中.
很奇怪没有sql语句吧.最后提醒一下.想想hibernate的特性.我们对数据库的操作就是对对象的操作.这就是OR-Mapping.

Hibernate 的原理与配置（二）。

     列表2：示例程序的对象－关系映射表
    ＜?xml version="1.0"?＞
    ＜!DOCTYPE hibernate-mapping PUBLIC
    "-//Hibernate/Hibernate Mapping DTD//EN"
    "http://hibernate.sourceforge.net/hibernate-mapping-2.0.dtd"＞
    ＜hibernate-mapping＞
    ＜class name="hello.Message" table="MESSAGES"＞
    ＜id name="id" column="MESSAGE_ID"＞
    ＜generator class="increment"/＞
    ＜/id＞
    ＜property name="text" column="MESSAGE_TEXT"/＞
    ＜many-to-one name="nextMessage" cascade="all" column="NEXT_MESSAGE_ID"/＞
    ＜/class＞
    ＜/hibernate-mapping＞
    以上这个文档告诉Hibernate怎样将Message类映射到MESSAGES表中，其中Message类的id属性与表的MESSAGE_ID字段对应，text属性与表的MESSAGE_TEXT字段对应，nextMessage属性是一个多对一的关系，它与表中的NEXT_MESSAGE_ID相对应。

    相对于有些开源项目来说，Hibernate的配置文件其实是很容易理解的。你可以轻松地修改与维护它。只要你定义好了持久类与数据库中表字段的对应关系就行了，Hibernate会自动帮你生成SQL语句来对Message对象进行插入、更新、删除、查找工作，你可以不写一句SQL语句，甚至不需要懂得SQL语言！

    现在让我们做一个新的试验，我们先取出第一个Message对象，然后修改它的消息正文，最后我们再生成一个新的Message对象，并将它作为第一个Message对象的下一条消息，其代码如下：

    列表3更新一条消息
    Session session = getSessionFactory().openSession();
    Transaction tx = session.beginTransaction();
    // 1 is the generated id of the first message
    Message message =(Message) session.load( Message.class, new Long(1) );
    message.setText("Greetings Earthling");
    Message nextMessage = new Message("Take me to your leader (please)");
    message.setNextMessage( nextMessage );
    tx.commit();
    session.close();
    以上这段代码在调用时，Hibernate内部自动生成如下的SQL语句：

    select m.MESSAGE_ID, m.MESSAGE_TEXT, m.NEXT_MESSAGE_ID
    from MESSAGES m
    where m.MESSAGE_ID = 1
    insert into MESSAGES (MESSAGE_ID, MESSAGE_TEXT, NEXT_MESSAGE_ID)

    values (2, 'Take me to your leader (please)', null)

    update MESSAGES
    set MESSAGE_TEXT = 'Greetings Earthling', NEXT_MESSAGE_ID = 2
    where MESSAGE_ID = 1
    当第一个Message对象的text属性和nextMessage被程序修改时，请注意Hibernate是如何检测到这种变化，并如何在数据库中自动对它更新的。这实际上是Hibernate的一个很有价值的特色，我们把它称为“自动脏数据检测”，Hibernate的这个特色使得当我们修改一个持久对象的属性后，不必显式地通知Hibernate去将它在数据库中进行更新。同样的，当第一个Message对象调用setNextMessage()方法将第二个Message对象作为它的下一条消息的引用时，第二条消息会无需调用save()方法，便可以自动地保存在数据库中。这种特色被称为“级联保存”，它也免去了我们显式地对第二个Message对象调用save()方法之苦。

    如果我们再运行先前的那段将数据库中所有的Message对象都打印出来的代码，那它的运行结果如下：

    2 message(s) found:

    Greetings Earthling
    Take me to your leader (please)

    “Hello world”示例程序现在介绍完毕。我们总算对Hibernate有了一个简单的认识，下面我们将回过头来，对Hibernate的主要API调用作一下简要的介绍：

    理解Hibernate的架构
    当你想用Hibernate开发自己的基于持久层的应用时，第一件事情应当是熟悉它的编程接口。Hibernate的API接口设计得尽量简洁明了，以方便开发人员。然而实际上由于ORM的复杂性，它的API一般都不可能设计得很简单。但是别担心，你没有必要一下子了解所有的Hibernate的API接口。

    我们将应用层放在了持久层的上部，实际上在传统的项目中，应用层充当着持久层的一个客户端角色。但对于一些简单的项目来说，应用层和持久层并没有区分得那么清楚，这也没什么，在这种情况下你可以将应用层和持久层合并成了一层。

    Hibernate的接口大致可以分为以下几种类型：

    ? 一些被用户的应用程序调用的，用来完成基本的创建、读取、更新、删除操作以及查询操作的接口。这些接口是Hibernate实现用户程序的商业逻辑的主要接口，它们包括Session、Transaction和Query。

    ? Hibernate用来读取诸如映射表这类配置文件的接口，典型的代表有Configuration类。

    ? 回调(Callback)接口。它允许应用程序能对一些事件的发生作出相应的操作，例如Interceptor、Lifecycle和Validatable都是这一类接口。

    ? 一些可以用来扩展Hibernate的映射机制的接口，例如UserType、CompositeUserType和IdentifierGenerator。这些接口可由用户程序来实现（如果有必要）。

    Hibernate使用了J2EE架构中的如下技术：JDBC、JTA、JNDI。其中JDBC是一个支持关系数据库操作的一个基础层；它与JNDI和JTA一起结合，使得Hibernate可以方便地集成到J2EE应用服务器中去。

    在这里，我们不会详细地去讨论Hibernate API接口中的所有方法，我们只简要讲一下每个主要接口的功能，如果你想了解得更多的话，你可以在Hibernate的源码包中的net.sf.hibernate子包中去查看这些接口的源代码。下面我们依次讲一下所有的主要接口：

    核心接口
    以下5个核心接口几乎在任何实际开发中都会用到。通过这些接口，你不仅可以存储和获得持久对象，并且能够进行事务控制。

    Session接口
    Session接口对于Hibernate 开发人员来说是一个最重要的接口。然而在Hibernate中，实例化的Session是一个轻量级的类，创建和销毁它都不会占用很多资源。这在实际项目中确实很重要，因为在客户程序中，可能会不断地创建以及销毁Session对象，如果Session的开销太大，会给系统带来不良影响。但值得注意的是Session对象是非线程安全的，因此在你的设计中，最好是一个线程只创建一个Session对象。

    在Hibernate的设计者的头脑中，他们将session看作介于数据连接与事务管理一种中间接口。我们可以将session想象成一个持久对象的缓冲区，Hibernate能检测到这些持久对象的改变，并及时刷新数据库。我们有时也称Session是一个持久层管理器，因为它包含这一些持久层相关的操作，诸如存储持久对象至数据库，以及从数据库从获得它们。请注意，Hibernate 的session不同于JSP应用中的HttpSession。当我们使用session这个术语时，我们指的是Hibernate中的session，而我们以后会将HttpSesion对象称为用户session。

    SessionFactory 接口
    这里用到了一个设计模式――工厂模式，用户程序从工厂类SessionFactory中取得Session的实例。

    令你感到奇怪的是SessionFactory并不是轻量级的！实际上它的设计者的意图是让它能在整个应用中共享。典型地来说，一个项目通常只需要一个SessionFactory就够了，但是当你的项目要操作多个数据库时，那你必须为每个数据库指定一个SessionFactory。

    SessionFactory在Hibernate中实际起到了一个缓冲区的作用，它缓冲了Hibernate自动生成的SQL语句和一些其它的映射数据，还缓冲了一些将来有可能重复利用的数据。

    Configuration 接口
    Configuration接口的作用是对Hibernate进行配置，以及对它进行启动。在Hibernate的启动过程中，Configuration类的实例首先定位映射文档的位置，读取这些配置，然后创建一个SessionFactory对象。

    虽然Configuration接口在整个Hibernate项目中只扮演着一个很小的角色，但它是启动hibernate时你所遇到的每一个对象。

    Transaction 接口
    Transaction接口是一个可选的API，你可以选择不使用这个接口，取而代之的是Hibernate的设计者自己写的底层事务处理代码。 Transaction接口是对实际事务实现的一个抽象，这些实现包括JDBC的事务、JTA中的UserTransaction、甚至可以是CORBA事务。之所以这样设计是能让开发者能够使用一个统一事务的操作界面，使得自己的项目可以在不同的环境和容器之间方便地移值。

    Query和Criteria接口
    Query接口让你方便地对数据库及持久对象进行查询，它可以有两种表达方式：HQL语言或本地数据库的SQL语句。Query经常被用来绑定查询参数、限制查询记录数量，并最终执行查询操作。

    Criteria接口与Query接口非常类似，它允许你创建并执行面向对象的标准化查询。

    值得注意的是Query接口也是轻量级的，它不能在Session之外使用。

    Callback 接口
    当一些有用的事件发生时――例如持久对象的载入、存储、删除时，Callback接口会通知Hibernate去接收一个通知消息。一般而言，Callback接口在用户程序中并不是必须的，但你要在你的项目中创建审计日志时，你可能会用到它。

    一个重要的术语：Type

    Hibernate的设计者们发明了一个术语：Type，它在整个构架中是一个非常基础、有着强大功能的元素。一个Type对象能将一个Java类型映射到数据库中一个表的字段中去（实际上，它可以映射到表的多个字段中去）。持久类的所有属性都对应一个type。这种设计思想使用Hibernate有着高度的灵活性和扩展性。

    Hibernate内置很多type类型，几乎包括所有的Java基本类型，例如Java.util.Currency、Java.util.calendar、byte[]和Java.io.Serializable。

    不仅如此，Hibernate还支持用户自定义的type，通过实现接口UserType和接口CompositeUserType，你可以加入自己的type。你可以利用这种特色让你的项目中使用自定义的诸如Address、Name这样的type，这样你就可以获得更大的便利，让你的代码更优雅。自定义type在Hibernate中是一项核心特色，它的设计者鼓励你多多使用它来创建一个灵活、优雅的项目！

    策略接口
    Hibernate与某些其它开源软件不同的还有一点――高度的可扩展性，这通过它的内置策略机制来实现。当你感觉到Hibernate的某些功能不足，或者有某些缺陷时，你可以开发一个自己的策略来替换它，而你所要做的仅仅只是继承它的某个策略接口，然后实现你的新策略就可以了，以下是它的策略接口：

    ? 主键的生成 (IdentifierGenerator 接口)

    ? 本地SQL语言支持 (Dialect 抽象类)

    ? 缓冲机制 (Cache 和CacheProvider 接口)

    ? JDBC 连接管理 (ConnectionProvider接口)

    ? 事务管理 (TransactionFactory, Transaction, 和 TransactionManagerLookup 接口)

    ? ORM 策略 (ClassPersister 接口)

    ? 属性访问策略 (PropertyAccessor 接口)

    ? 代理对象的创建 (ProxyFactory接口)

    Hibernate为以上所列的机制分别创建了一个缺省的实现，因此如果你只是要增强它的某个策略的功能的话，只需简单地继承这个类就可以了，没有必要从头开始写代码。

    以上就是Hibernate的一些核心接口，但当我们真正开始用它进行开发时，你的脑海里可能总会有一个疑问：我是通过什么方式，并从哪里取得Session的呢？以下我们就解答这个问题。

    基础配置
    现在回顾一下我们先前的内容：我们写出了一个示例程序，并简要地讲解了Hibernate的一些核心类。但要真正使你的项目运行起来，还有一件事必须要做：配置。Hibernate可以配置成可在任何Java环境中运行，一般说来，它通常被用在2－3层的C/S模式的项目中，并被部署在服务端。在这种项目中，Web浏览器、或Java GUI程序充当者客户端。尽管我们的焦点主要是集中在多层web应用，但实际上在一些基于命令行的应用中也可以使用Hibernate。并且，对Hibernate的配置在不同的环境下都会不同，Hibernate运行在两种环境下：可管理环境和不可管理环境
    ? 可管理环境――这种环境可管理如下资源：池资源管理，诸如数据库连接池和，还有事务管理、安全定义。一些典型的J2EE服务器（JBoss、Weblogic、WebSphere）已经实现了这些。

    ? 不可管理环境――只是提供了一些基本的功能，诸如像Jetty或Tomcat这样的servlet容器环境。一个普通的Java桌面应用或命令行程序也可以认为是处于这种环境下。这种环境不能提供自动事务处理、资源管理或安全管理，这些都必须由应用程序自己来定义。

    Hibernate的设计者们将这两种环境设计了一个统一的抽象界面，因此对于开发者来说只有一种环境：可管理环境。如果实际项目是建立在诸如Tomcat这类不可管理的环境中时，那Hibernate将会使用它自己的事务处理代码和JDBC连接池，使其变为一个可管理环境。

    对于可管理的环境而言，Hibernate会将自己集成在这种环境中。对于开发者而言，你所要做的工作非常简单：只需从一个Configuration类中创建一个SessionFactory类就可以了。

    创建一个SessionFactory对象
    为了能创建一个SessionFactory对象，你必须在Hibernate初始化时创建一个Configuration类的实例，并将已写好的映射文件交由它处理。这样，Configuration对象就可以创建一个SessionFactory对象，当SessionFactory对象创建成功后，Configuration对象就没有用了，你可以简单地抛弃它。如下是示例代码：

    Configuration cfg = new Configuration();
    cfg.addResource("hello/Message.hbm.xml");
    cfg.setProperties( System.getProperties() );
    SessionFactory sessions = cfg.buildSessionFactory();
    在以上代码中，Message.hb.xml这个映射文件的位置比较特殊，它与当前的classpath相关。例如classpath包含当前目录，那在上述代码中的Message.hbm.xml映射文件就可以保存在当前目录下的hello目录中。

    作为一种约定，Hibernate的映射文件默认以.htm.xml作为其扩展名。另一个约定是坚持为每一个持久类写一个配置文件，想一想如果你将所有持久类的映射写入一个单独的配置文件中的话，那这个配置文件肯定非常庞大，不易维护。但这里又出现了一个新问题：如果为每个类写一个配置文件的话，这么多的配置文件应该存放在哪里呢？

    Hibernate推荐你将每个映射文件保存在与持久类相同的目录下，并且与持久类同名。例如我们第一个示例程序中的Message持久类放在hello目录下，那你必须在这个目录下存放名为Message.hbm.xml的映射文件。这样一个持久类都有自己的一个映射文件，避免了出现像struts项目中的“struts-config.xml地狱”的情况。如果你不遵循这种规定，那你必须手动地用addResource()方法将一个个的映射文件载入；但你如果遵循这种规定，那你可以方便地用addClass()方法同时将持久类和它的映射文件载入，以下是体现这种便利性的示例代码：

    SessionFactory sessions = new Configuration()

    .addClass(org.hibernate.auction.model.Item.class)

    .addClass(org.hibernate.auction.model.Category.class)

    .addClass(org.hibernate.auction.model.Bid.class)

    .setProperties( System.getProperties() )

    .buildSessionFactory();
    当然，Hibernate的映射文件还有很多其它的配置选项，比如数据库连接的设定，或是能够改变Hibernate运行时行为的一些设定。所有的设置可能是非常庞杂的，足以让你喘不过气来，但是不必担心，因为Hibernate为绝大多数值都设定了一个合理缺省值，你只需要修改这些配置文件中的极小一部分值。

    你可以通过以下几种方式来修改Hibernate的系统配置参数：

    ? 将一个Java.util.Properties实例作为参数传给Configuration类的setProperties()方法。

    ? 在Hibernate启动时用Java –Dproperty=value的方式设置值。

    ? 在classpath可以找到的路径下创建一个名为hibernate.properties的配置文件。

    ? 在classpath可以找到的路径下创建一个名为hibernate.cfg.xml的文件，并在其＜property＞标签中定义属性值。

    以上就是对Hibernate的一个大致介绍，如果你想知道得更多，那本文还是远远不够的，我将陆续推出更多关于Hibernate的资料。但有一点是毫无疑问的：它的确是一个非常优秀的持久层解决方案！