Hibernate工作原理简单实例

一、hibernate所需类库木有必要死记

参照官方手册\hibernate-distribution-3.5.4-Final-dist\hibernate-distribution-3.5.4-Final-dist\hibernate-distribution-3.5.4-Final\documentation\manual\zh-CN\pdf目录下的pdf文档即可帮你很好的完成工作。

在pdf文档中有如下提示：

根据提示可知所加类库分别为：hibernate3.jar核心类库以及\hibernate-distribution-3.5.4-Final-dist\hibernate-distribution-3.5.4-Final-dist\hibernate-distribution-3.5.4-Final\lib\required下边的所有类库如图：

以及和以及\hibernate-distribution-3.5.4-Final-dist\hibernate-distribution-3.5.4-Final-dist\hibernate-distribution-3.5.4-Final\lib\jpa目录下的：和所需的数据库驱动

二、创建实体类：
package com.oraclewdp.entity;

public class User{
private int id;
private String name;
public User() {

}
public int getId() {
 return id;
}
public void setId(int id) {
 this.id = id;
}
public String getName() {
 return name;
}
public void setName(String name) {
 this.name = name;
}
public int getAge() {
 return age;
}
public void setAge(int age) {
 this.age = age;
}
private int age;
}

三、创建User.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">
<!-- Generated 2012-8-11 11:32:10 by Hibernate Tools 3.4.0.CR1 -->
<hibernate-mapping  package="com.oraclewdp.entity" >

<!-- 一个映射文件可以写多个类，通常不建议大家去这样做
 1、多个类情况下，我们可以定义这些类的相同特征在hibernate-mapping
-->
<!-- 这个文件主要用来定义映射：类和表，属性和列，类关联和表关联映射-->
    <class name="User" table="TB_USER" lazy="false">
      <!-- 主键映射： -->
        <id name="id" type="int">
            <column name="id" />
            <!-- generator用来配置序列或自动增长列等 -->
           <generator class="native"></generator>
            <!-- 如果你的数据库是oracle,一般情况下需要配置参数，要不然hibernate会使用一个叫hibernate_sequece的序列
            <generator class="native"> -->
            <!-- 指定序列名
             <param name="sequence">STUDENTS_ID_SEQ</param>
          </generator> -->
           
        </id>
        <!-- 简单属性，
        1、type可以不写，可以写的类型为：全限定名，另外就是Hibernate定义的类型
        2、column可以省略，列名与name一致
        3、name必须写
        -->
        <property name="name" type="java.lang.String">
            <column name="NAME" />
        </property>
        <property name="age" type="int">
            <column name="AGE" />
        </property>
    </class>
</hibernate-mapping>
四、创建hibernate.cfg.xml配置文件

<?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>
<!-- Hibernate的配置文件，"hibernate."可以省略 ,但是"name"中不能有空格并且主要大小写-->
 <session-factory >
 <!-- 连接到数据库需要的信息，以下四个必须配置-->
 <!-- 驱动类，用全限定名 -->
  <property name="connection.driver_class">com.mysql.jdbc.Driver</property>
  <!-- 连接到数据库的密码 -->
  <property name="hibernate.connection.password">root</property>
  <!-- 连接到数据库的ＵＲＬ -->
  <property name="hibernate.connection.url">jdbc:mysql:///test?useUnicode=true&amp;characterEncoding=utf-8</property>
  <!-- 用户名 -->
  <property name="hibernate.connection.username">root</property>
  <!-- sql 方言，jdbc3+就能自动推测出方言，这项可以不配置-->
  <property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>
 <!-- 以下三个都是辅助我们开发，在产品部署后可以禁止 -->
  <!--
  create:如果表已经存在，那么首先删除，然后新建
  update:如果表不存在，那么新建表；反之，根据修改后hbm去更新表结构
  create-drop:如果表存在，删之；不存在则新建，并且在程序结束的时候把表删除:适合于做测试
  validate:不会新建表，根据hbm去验证表的结构，如果符合则什么都不做，反之抛出异常
   -->
  <property name="hibernate.hbm2ddl.auto">update</property>
  <!-- 是否显示Hibernate生成的SQL -->
  <property name="hibernate.show_sql">true</property>
  <!-- 对hibernate生成的Sql进行格式化 -->
  <property name="hibernate.format_sql">true</property>
 
 
  <!-- 告诉Hibernate映射文件在哪里 -->
  <mapping resource="com/oraclewdp/entity/User.hbm.xml"/>
 </session-factory>
</hibernate-configuration>

五、建立测试类Test.java

package com.oraclewdp.test;

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

import com.oraclewdp.entity.User;
import com.oraclewdp.util.HibernateUtil;

public class Test {

 
 public static void main(String[] args) {
  save();
  //读取
  //read();
  //更新
  //update();
  //删除
  //delete();

 }
public static void save(){
  Configuration cfg=null;
  SessionFactory sf=null;
  Session session=null;
  Transaction tx=null;
  User user=null;
  try {
   //1、建立Confi
      // 读取配置文件，如果configure()没有传入配置文件名称，那么就到类路径的根目录去找
    // 名称为hibernate.cfg.xml的文件,如果不满足，则必须指定名称。
    // 这个类不需要读取多次，只需要使用一次
   cfg=new Configuration().configure("hibernate1.cfg.xml");
     //2、建立SessionFactory
    // 1、产生Session的工具，这个对象是重量级的，非常耗费资源
    // 2、一旦工厂建立后，cfg就可以销毁了
    // 3、这个也不需要建立多次
   //  4、它是线程安全
    // 5、建立一个连接池，预先生成SQL语句，如果配置了hbm2ddl，还修改数据库，还有个可选缓存
   System.out.println("sessionFactory starting--------------");
    sf=cfg.buildSessionFactory();
    System.out.println("sessionFactory end--------------");
   //3、建立Session
      session=sf.openSession();
  //4、开启事务
   tx=session.beginTransaction();
   ////瞬时状态
   user=new User();
   user.setId(21);
      user.setAge(23);
   user.setName("zs");
   session.save(user);//持久态：数据库中有一条记录与之对应；处于持久态的对象，如果对象状态发生了改变，那么在事务提交的会同步到数据库
   user.setName("zs3");
   //session.flush();//提交缓存
   user.setName("lisi");
      tx.commit();//Hibernate默认autocommit是false，如果不写，那么就撤销已经保存的对象
  } catch (HibernateException e) {
   if (tx!=null) {
    tx.rollback();
   }
   e.printStackTrace();
  }finally{
   if (session!=null) {
    session.close();
   }
   if (sf!=null) {
    sf.close();
   }
  }
  //session关闭后，这个对象就是游离态:曾经与Session关联，但是现在Session关闭了
  user.setName("wangwu");
 }

public static void update(){
  Configuration cfg=null;
  SessionFactory sf=null;
  Session session=null;
  Transaction tx=null;
  try {
   
   cfg=new Configuration().configure("hibernate1.cfg.xml"); 
    sf=cfg.buildSessionFactory();
  
   //3、建立Session
      session=sf.openSession();
//   //4、开启事务
   tx=session.beginTransaction();
   User user=(User) session.get(User.class, 2);
   user.setName("李四");
   session.save(user);//执行保存操作
      tx.commit();//Hibernate默认autocommit是false，如果不写，那么就撤销已经保存的对象
  } catch (HibernateException e) {
   if (tx!=null) {
    tx.rollback();
   }
   e.printStackTrace();
  }finally{
   if (session!=null) {
    session.close();
   }
   if (sf!=null) {
    sf.close();
   }
  }
 }
 public static void delete(){
  Configuration cfg=null;
  SessionFactory sf=null;
  Session session=null;
  Transaction tx=null;
  try {
   
   cfg=new Configuration().configure("hibernate1.cfg.xml"); 
    sf=cfg.buildSessionFactory();
  
   //3、建立Session
      session=sf.openSession();
//   //4、开启事务
   tx=session.beginTransaction();
   session.delete(session.load(User.class, 2));
      tx.commit();//Hibernate默认autocommit是false，如果不写，那么就撤销已经保存的对象
  } catch (HibernateException e) {
   if (tx!=null) {
    tx.rollback();
   }
   e.printStackTrace();
  }finally{
   if (session!=null) {
    session.close();
   }
   if (sf!=null) {
    sf.close();
   }
  }
 }
 public static void read(){
  Configuration cfg=null;
  SessionFactory sf=null;
  Session session=null;
  try {
   cfg=new Configuration().configure("hibernate.cfg.xml");
   
       sf=cfg.buildSessionFactory();
   //3、建立Session
      session=HibernateUtil.getSession();
//   
   //你要加载的类的对象，第二个通常是id
      //get方法
   //User user=(User) session.get(User.class, 2);
   //System.out.println("name="+user.getName()+":age="+user.getAge());
   //load方法
//   user=(User) session.load(User.class, 2);
//   System.out.println("name="+user.getName()+":age="+user.getAge());
   //两个方法区别是什么？
   //区别一:如果要加载在数据库没有对应的数据，load不抛出异常，get抛异常
     
   //User user=(User) session.load(User.class, 1);
   //class com.oraclewdp.entity.User_$$_javassist_0
   //这个是User的代理类，这类是User的子类
   //System.out.println(user.getClass());
   //User user1=(User) session.get(User.class, 1);
      //区别二：一个懒加载另外一个不懒加载
      //懒加载：除了id外才去加载(<class name="com.oraclewdp.entity.User" table="TB_USER" lazy="false">)
      User user=(User) session.load(User.class, 3);
      User user1=(User) session.load(User.class, 3);
      User user2=(User) HibernateUtil.getSession().load(User.class, 3);
      System.out.println(user==user1);
     System.out.println(user2==user1);
      System.out.println(user.getId());//因为你告诉了它Id是1，不会到数据库查
      System.out.println(user.getName());//这个时间到数据查找,因为目前不知道name
      System.out.println(user.getAge());
     //立即到数据去查询
     // User user1=(User) session.get(User.class, 1);
 
  } catch (HibernateException e) {
   
  }finally{
   if (session!=null) {
    session.close();
   }
   if (sf!=null) {
    sf.close();
   }
  }
 }

}