现在的位置: 首页 > 综合 > 正文

Hiberante3学习之路第一节 原创

2014年02月04日 ⁄ 综合 ⁄ 共 21327字 ⁄ 字号 小 中 大 ⁄ 评论关闭

   最近在忙于Hibernate3授课的讲解,闲来之余对每一次授课的内容做个总结,供正在或将要学习Hibernate3框架技术的学员参考,愿从中有所收获......

一、Hibernate环境搭建
1、建立一个普通的java项目，首先进行数据库连接，选择myeclipse Database Explorer 界面，在空白处右键new新建连接，连接的驱动模型Driver template选择MySQL Connector,加载驱动，下一步选择你要加载的数据库，连接后台成功后回到java界面。
2、安装配置的三项准备工作
1、添加hibernate库
 

Java代码 复制代码
  1. 将下载目录/hibernate3.jar和/lib下的hibernate运行时必须的包加入classpath中：antlr.jar, cglib.jar , asm.jar , commons-collections.jar , commons-logging.jar , jta.jar , dom4j.jar   
  2. 将hibernatejar包文件添加到java项目中    

2、添加hibernate配置文件
配置文件hibernate.cfg.xml和hibernate.properties，XML和properties两种，这两个文件的作用一样，提供一个即可，推荐XML格式，下载目录/etc下是示例配置文件。
可以在配置文件指定：数据库的URL、用户名、密码、JDBC驱动类、方言等。
启动时Hibernate会在CLASSPATH里找这个配置文件。
命名的语法格式，名字是固定的并且位于src目录下

Java代码 复制代码
  1. hibernate.cfg.xml   
  2. <hibernate-configuration>   
  3. <session-factory>   
  4.     <!-- 连接数据库名称 是在myeclipse中设置的 -->   
  5.     <property name="myeclipse.connection.profile">localhost</property>   
  6.     <!-- 数据库连接的URL -->   
  7.     <property name="connection.url">   
  8.         jdbc:mysql://localhost:3306/houtai   
  9.     </property>   
  10.     <!-- 数据库的用户名和密码 -->   
  11.     <property name="connection.username">root</property>   
  12.     <property name="connection.password">root</property>   
  13.     <!-- 数据库的驱动 -->   
  14.     <property name="connection.driver_class">   
  15.         com.mysql.jdbc.Driver   
  16.     </property>   
  17.     <!-- 数据库的方言 -->   
  18.     <property name="dialect">   
  19.         org.hibernate.dialect.MySQLDialect   
  20.     </property>   
  21.      <!-- 显示sql语句的操作 -->   
  22.     <property name="show_sql">true</property>   
  23.     <!-- 创建表    
  24.     <property name="hibernate.hbm2ddl.auto">create</property>   
  25.     -->   
  26.     <!-- 添加映射文件 -->   
  27.     <mapping resource="edu/hiber/User.hbm.xml" />   
  28. </session-factory>   
  29. </hibernate-configuration>  

3、添加对应表的实体类和映射文件
映射文件(hbm.xml，对象模型和关系模型的映射)。在/eg目录下有完整的hibernate示例。
实体类和数据库表是通过hbm.xml配置文件来完成
命名语法格式：

Java代码 复制代码
  1. 类名.hbm.xml 与实体类在同一个包中   
  2. User.hbm.xml   
  3. <hibernate-mapping package="hiber">   
  4.     <!—name实体类名，table对应数据库表的表名-->   
  5.     <class name="User" table="user" catalog="hoteldb">   
  6.         <id name="id"><!—user表中有一个id的属性-->   
  7.             <!—generator 引用  native代表主键自动增长 -->   
  8.             <generator class="native" />   
  9.         </id>   
  10. <!—property成员属性-->   
  11.         <property name="name" length="40" />         
  12. <property name="pass" />   
  13.         <property name="birthday" />   
  14.     </class>   
  15. </hibernate-mapping>  

在这里有一个面试常考的题就是数据库的主键生成策略
数据库的主键:
代理主键:  没有业务逻辑含义
自然主键:  有业务逻辑含义
主键生成策略：
Hibernate 提供的内置标识符生成器OID

Java代码 复制代码
  1. increment: 适用于代理主键, 由Hibernate自动以递增的方式生成标识符, 每次递增为1  
  2. identity:  适用于代理主键, 由底层数据库生成标识符. 前提是底层数据库支持自动增长字段类型   
  3. sequence:  适用于代理主键, Hibernate根据底层数据库的序列生成标识符. 前提是底层数据库支持序列   
  4. hilo:      适用于代理主键, Hibernate根据hi/low算法生成标识符. Hibernate把特定的字段作为"high".默认情况下选用hibernate_unique_key表的next_hi字段   
  5. native:    适用于代理主键, 根据底层数据库对自动生成标识符的支持能力, 来选择identify, sequence, 或hilo   
  6. uuid.hex:  适用于代理主键, Hibernate采用128位的UUID(Universal Identification)算法生成标识符. UUID算法能够在网络环境中生成唯一的字符串标识符. 这种标识符生成策略并不流行, 因为字符串类型的主键比整数类型的主键占用更大的数据库空间               
  7. assigned:  适用于自然主键, 由Java应用程序生成标识符.为了能让Java应用程序设置OID,不要把方法声明为private类型.  

二、创建数据库
1、在hibernate.cfg.xml配置文件中写创建数据库命令

Java代码 复制代码
  1. <!—创建表 -->   
  2. <property name="hibernate.hbm2ddl.auto">create</property>   
  3. 它有4个属性：   
  4.     create : 会根据你的model类来生成表,但是每次运行都会删除上一次的表,重新生成表,哪怕2次没有任何改变   
  5. create-drop : 根据model类生成表,但是sessionFactory一关闭,表就自动删除   
  6. update : 最常用的属性，也根据model类生成表,即使表结构改变了,表中的行仍然存在,不会删除以前的行   
  7. validate : 只会和数据库中的表进行比较,不会创建新表,但是会插入新值  

2、添加实体类和数据库表的映射

Java代码 复制代码
  1. <!-- 添加映射文件 -->   
  2.     <mapping resource="edu/hiber/User.hbm.xml" />   
  3. 同时添加show_sql属性   
  4. <!-- 显示sql语句的操作 -->   
  5. <property name="show_sql">true</property>  

3、创建表

Java代码 复制代码
  1. /**解析配置文件configure()默认解析hibernate.cfg.xml文件并返回Configuration的对象*/  
  2. Configuration cfg=new Configuration().configure();   
  3. /**根据cfg对象创建一个SchemaExport的对象*/  
  4. SchemaExport se=new SchemaExport(cfg);   
  5. /**创建表的操作*/  
  6. se.create(true, true);  

三、操作数据库
操作表（增删改查）

Java代码 复制代码
  1. package hiber;   
  2.   
  3. import java.util.Date;   
  4.   
  5. import org.hibernate.SessionFactory;   
  6. import org.hibernate.Transaction;   
  7. import org.hibernate.cfg.Configuration;   
  8. import org.hibernate.Session;   
  9.   
  10. public class TestHiber {   
  11.     /**插入的方法*/  
  12.     public boolean insert() {   
  13.         boolean flag = false;   
  14.         /**  
  15.          * 采用Configuration对象configure方法解析hibernate.cfg.  
  16.          * xml文件并返回一个Configuration的对象  
  17.          */  
  18.         Configuration cfg = new Configuration().configure();   
  19.         /** 根据cfg对中的buildSessionFactory()方法来创一个SessionFactory工厂 */  
  20.         SessionFactory sf = cfg.buildSessionFactory();   
  21.         /** 采用sf对象中的openSession的方法创建连接并打开操作的session */  
  22.         Session session = sf.openSession();   
  23.         /** 定义个事务对象 */  
  24.         Transaction tx = null;   
  25.         try {   
  26.             // 开始事务   
  27.             tx = session.beginTransaction();   
  28.             User entity=new User("sha","123",new Date());   
  29.             //执行事务   
  30.             session.save(entity);   
  31.             //提交事务   
  32.             tx.commit();   
  33.             flag=true;   
  34.         } catch (Exception e) {   
  35.             //如果出现导常则回滚事务   
  36.             if(tx!=null){   
  37.                 tx.rollback();   
  38.             }   
  39.             e.printStackTrace();   
  40.         }finally{   
  41.             //不管事务执行成功与否都要关闭session   
  42.             session.close();   
  43.         }   
  44.         return flag;   
  45.     }   
  46.     /**查询的方法*/  
  47.     public User findById(int id){   
  48.         User user = new User();   
  49.         /**  
  50.          * 采用Configuration  
  51.          * 对象configure方法解析hibernate.cfg.xml文件并返回一个Configuration的对象  
  52.          */  
  53.         Configuration cfg = new Configuration().configure();   
  54.         /** 根据cfg对中的buildSessionFactory()方法来创一个SessionFactory工厂 */  
  55.         SessionFactory sf = cfg.buildSessionFactory();   
  56.         /** 采用sf对象中的openSession的方法创建连接并打开操作的session */  
  57.         Session session = sf.openSession();   
  58.         try{   
  59.             user = (User)session.load(User.class, id);   
  60.         }catch(Exception ex){   
  61.             ex.printStackTrace();   
  62.         }   
  63.         return user;   
  64.     }   
  65.        
  66.        
  67.        
  68.     /**查询的方法*/  
  69.     public User findByGId(int id){   
  70.         User user = new User();   
  71.         /**  
  72.          * 采用Configuration  
  73.          * 对象configure方法解析hibernate.cfg.xml文件并返回一个Configuration的对象  
  74.          */  
  75.         Configuration cfg = new Configuration().configure();   
  76.         /** 根据cfg对中的buildSessionFactory()方法来创一个SessionFactory工厂 */  
  77.         SessionFactory sf = cfg.buildSessionFactory();   
  78.         /** 采用sf对象中的openSession的方法创建连接并打开操作的session */  
  79.         Session session = sf.openSession();   
  80.         try{   
  81.             user = (User)session.get(User.class, id);   
  82.         }catch(Exception ex){   
  83.             ex.printStackTrace();   
  84.         }finally{   
  85.           session.close();   
  86.         }   
  87.         return user;   
  88.     }   
  89.        
  90.     /**更新的方法*/  
  91.   
  92.     public boolean  update(User entity) {   
  93.         boolean flag = false;   
  94.         /**  
  95.          * 采用Configuration  
  96.          * 对象configure方法解析hibernate.cfg.xml文件并返回一个Configuration的对象  
  97.          */  
  98.         Configuration cfg = new Configuration().configure();   
  99.         /** 根据cfg对中的buildSessionFactory()方法来创一个SessionFactory工厂 */  
  100.         SessionFactory sf = cfg.buildSessionFactory();   
  101.         /** 采用sf对象中的openSession的方法创建连接并打开操作的session */  
  102.         Session session = sf.openSession();   
  103.         /** 定义个事务对象 */  
  104.         Transaction tx = null;   
  105.         try {   
  106.             // 开始事务   
  107.             tx = session.beginTransaction();   
  108.             entity.setName("lihui");   
  109.             // 执行事务   
  110.             session.update(entity);   
  111.             // 提交事务   
  112.             tx.commit();   
  113.             flag =true;   
  114.         } catch (Exception ex) {   
  115.             /** 如果出现异常则回滚事务 */  
  116.             if (tx != null) {   
  117.                 tx.rollback();   
  118.             }   
  119.             ex.printStackTrace();   
  120.         }finally{   
  121.             /**不管事务执行成功与否都要关闭session*/  
  122.             session.close();   
  123.         }   
  124.   
  125.         return flag;   
  126.     }   
  127.        
  128.     /**删除操作*/  
  129.     public boolean  delete(User entity) {   
  130.         boolean flag = false;   
  131.         /**  
  132.          * 采用Configuration  
  133.          * 对象configure方法解析hibernate.cfg.xml文件并返回一个Configuration的对象  
  134.          */  
  135.         Configuration cfg = new Configuration().configure();   
  136.         /** 根据cfg对中的buildSessionFactory()方法来创一个SessionFactory工厂 */  
  137.         SessionFactory sf = cfg.buildSessionFactory();   
  138.         /** 采用sf对象中的openSession的方法创建连接并打开操作的session */  
  139.         Session session = sf.openSession();   
  140.         /** 定义个事务对象 */  
  141.         Transaction tx = null;   
  142.         try {   
  143.             // 开始事务   
  144.             tx = session.beginTransaction();   
  145.             // 执行事务   
  146.             session.delete(entity);   
  147.             // 提交事务   
  148.             tx.commit();   
  149.             flag =true;   
  150.         } catch (Exception ex) {   
  151.             /** 如果出现异常则回滚事务 */  
  152.             if (tx != null) {   
  153.                 tx.rollback();   
  154.             }   
  155.             ex.printStackTrace();   
  156.         }finally{   
  157.             /**不管事务执行成功与否都要关闭session*/  
  158.             session.close();   
  159.         }   
  160.   
  161.         return flag;   
  162.     }   
  163.        
  164.     public static void main(String[] args) {   
  165.         TestHiber th = new TestHiber();   
  166.         boolean insert=th.insert();   
  167.         if(insert){   
  168.             System.out.println("插入成功");   
  169.         }   
  170.         User entity = th.findById(1);   
  171.         boolean flag  = th.delete(entity);   
  172.         if(flag){   
  173.             System.out.println("删除成功");   
  174.         }else{   
  175.             System.out.println("删除失败");   
  176.         }   
  177.     }   
  178. }  

三、通过Myeclipse工具自动添加hibernate类库文件,利用Myeclipse工具反向生成配置文件与Domain Class
1、项目右键，添加类库文Myeclipse，选择Add HibernateCapabilites，选择hibernate核心文件，自动在src目录下创建hibernate的默认配置文件，在DBDriver选择自己配置的链接地址，会自动创建一个hibernateSessionFactroy，我们只需添加一个路径（包）完成。就会自动创建一个hibernate.cfg.xml配置文件，里面自动配置好数据库链接的属性，还会自动创建一个hibernateSessionFactroy的类。
2、反向生产Domain Class和User.hbm.xml文件
首先到myeclipse Database Explorer窗口，选择uesr表右键选择hibernateReverseEngineering反向工程，选择反向的项目，选择创建user对应的javabean，下一步选择主键生成策略Id Generator这里选择native，完成，切换到java窗口。
3、操作表（增删改查）

Java代码 复制代码
  1. package hiber.test;   
  2.   
  3. import java.sql.Timestamp;   
  4. import java.util.Date;   
  5.   
  6. import org.hibernate.Session;   
  7. import org.hibernate.Transaction;   
  8.   
  9. import hiber.bean.User;   
  10. import hiber.sf.HibernateSessionFactory;   
  11.   
  12. public class TestUser {   
  13.   
  14.     /**插入方法*/  
  15.     public void insert() {   
  16.         /** 直接利用HibernateSessionFactory得到session对象 */  
  17.         Session session = HibernateSessionFactory.getSession();   
  18.         Transaction tx = null;   
  19.         try {   
  20.             /** 获取当前session的事务 */  
  21.             tx = session.getTransaction();   
  22.             /** 开始事务 */  
  23.             tx.begin();   
  24.             /** 瞬时状态对象 */  
  25.             User entity = new User("yq", "123", new Timestamp(System   
  26.                     .currentTimeMillis()));   
  27.   
  28.             /** 执行插入操作 */  
  29.             session.save(entity);   
  30.             /** 持久状态对象 */  
  31.   
  32.             /** 事务提交 */  
  33.             tx.commit();   
  34.         } catch (Exception ex) {   
  35.             if (tx != null)   
  36.                 tx.rollback();/**事务回滚*/  
  37.             ex.printStackTrace();   
  38.   
  39.         } finally {   
  40.             /**关闭session*/  
  41.             session.close();   
  42.         }   
  43.         /** 脱管状态对象..... */  
  44.     }   
  45.         /**查询的方法*/  
  46.     public User findByLId(int id){   
  47.         User entity = new User();   
  48.         /**获取session对象*/  
  49.         Session session = HibernateSessionFactory.getSession();   
  50.         try{   
  51.         /**执行操作*/  
  52.             entity = (User)session.load(User.class, id);   
  53.         }catch(Exception ex){   
  54.             ex.printStackTrace();   
  55.         }finally{   
  56.             /**关闭session*/  
  57.             session.close();   
  58.         }   
  59.         return entity;   
  60.     }   
  61.   
  62.         /**查询的方法*/  
  63.     public User findByGId(int id){   
  64.         User entity = new User();   
  65.         /**获取session对象*/  
  66.         Session session = HibernateSessionFactory.getSession();   
  67.         try{   
  68.         /**执行操作*/  
  69.             entity = (User)session.get(User.class, id);   
  70.         }catch(Exception ex){   
  71.             ex.printStackTrace();   
  72.         }finally{   
  73.             /**关闭session*/  
  74.             session.close();   
  75.         }   
  76.         return entity;   
  77.     }   
  78.        
  79.         /**更新方法*/  
  80.     public void update(User entity) {   
  81.         /** 直接利用HibernateSessionFactory得到session对象 */  
  82.         Session session = HibernateSessionFactory.getSession();   
  83.         Transaction tx = null;   
  84.         try {   
  85.             /** 获取当前session的事务 */  
  86.             tx = session.getTransaction();   
  87.             /** 开始事务 */  
  88.             tx.begin();   
  89.                
  90.             /** 执行更新操作 */  
  91.             session.update(entity);   
  92.             /** 持久状态对象 */  
  93.   
  94.             /** 事务提交 */  
  95.             tx.commit();   
  96.         } catch (Exception ex) {   
  97.             if (tx != null)   
  98.                 tx.rollback();/**事务回滚*/  
  99.             ex.printStackTrace();   
  100.   
  101.         } finally {   
  102.             /**关闭session*/  
  103.             session.close();   
  104.         }   
  105.         /** 脱管状态对象..... */  
  106.     }   
  107.        
  108.         /**删除的方法*/  
  109.     public void delete(User entity) {   
  110.         /** 直接利用HibernateSessionFactory得到session对象 */  
  111.         Session session = HibernateSessionFactory.getSession();   
  112.         Transaction tx = null;   
  113.         try {   
  114.             /** 获取当前session的事务 */  
  115.             tx = session.getTransaction();   
  116.             /** 开始事务 */  
  117.             tx.begin();   
  118.                
  119.             /** 执行更新操作 */  
  120.             session.delete(entity);   
  121.             /** 持久状态对象 */  
  122.   
  123.             /** 事务提交 */  
  124.             tx.commit();   
  125.         } catch (Exception ex) {   
  126.             if (tx != null)   
  127.                 tx.rollback();/**事务回滚*/  
  128.             ex.printStackTrace();   
  129.   
  130.         } finally {   
  131.             /**关闭session*/  
  132.             session.close();   
  133.         }   
  134.         /** 脱管状态对象..... */  
  135.     }   
  136.        
  137.     public static void main(String[] args) {   
  138.         TestUser tu = new TestUser();   
  139.         User entity = tu.findByLId(2);   
  140.         entity.setName("redarmy");   
  141.         tu.delete(entity);   
  142.        
  143.     }   
  144.   
  145. }  

*

这里也有一个面试常考的问题就是对象的状态

Java代码
返回
【上篇】
【下篇】

作者:

抱歉!评论已关闭.

返回首页

Copyright © 2013-2018 学步园  保留所有权利.
软文销售 QQ客服：2265327166 点击这里给我发消息（其他合作也可洽谈）