posts - 30, comments - 5, trackbacks - 0, articles - 0
  BlogJava :: 首页 :: 新随笔 :: 联系 :: 聚合  :: 管理

Hibernate简单介绍与部署

Posted on 2010-05-04 11:29 無所謂 阅读(269) 评论(0)  编辑  收藏 所属分类: Hibernate
    下面开始利用hibernate进行数据库的访问。 需求：实现对用户的增、删、改、查。为了方便，用户就2个属性 用户ID和用户名。

    Hibernate有很多值得学习的地方,这里我们简单介绍一个Hibernate，重点介绍Hibernate部署，希望读者看后受益匪浅。

    一. 什么是hibernate？

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

    二. 快速构建。

    在此先要说明一下。由于本人懒惰，记不住hibernate的配置选项，所以，此系列的实例都是使用myeclipse进行快速开发。各位对myeclipse不齿的，就请见谅。然后，数据库都是mysql。
    下面开始利用hibernate进行数据库的访问。
    需求：实现对用户的增、删、改、查。为了方便，用户就2个属性 用户ID和用户名。实体模型如下：

    预览图片

    建立工程:HibernateQuickUse，并且建立包。如下：

    预览图片

    根据实体，创建类User，代码如下：

     
        
            
      
            
    1. package org.py.hib.quickstart;  
            
    2.  
            
    3. /**  
            
    4.  * User entity.  
            
    5.  * @author MyEclipse Persistence Tools  
            
    6.  */  
            
    7.  
            
    8. @SuppressWarnings("serial")  
            
    9. public class User implements java.io.Serializable  
            
    10. {  
            
    11.  private String id;  
            
    12.  private String name;  
            
    13.  
            
    14.  public User()  
            
    15.  {  
            
    16.  }  
            
    17.  
            
    18.  public String getId()  
            
    19.  {  
            
    20.   return this.id;  
            
    21.  }  
            
    22.  
            
    23.  public void setId(String id)  
            
    24.  {  
            
    25.   this.id = id;  
            
    26.  }  
            
    27.  
            
    28.  public String getName()  
            
    29.  {  
            
    30.   return this.name;  
            
    31.  }  
            
    32.  
            
    33.  public void setName(String name)  
            
    34.  {  
            
    35.   this.name = name;  
            
    36.  }  
            
    37. }  
      38.

    根据hibernate实体，创建数据表。sql如下：

            
      
            
    1. use HibernateQuickUse;  
            
    2. drop table if exists User;  
            
    3.  
            
    4. create table user (  
            
    5.  id varchar(32) primary key,  
            
    6.  name varchar(32)  
            
    7. );  
      8.

    这里的id，我没有采用Integer auto_increment, 原因是为了数据库的数据能方便的导入到另外一种数据库里面，比方说：oracle。当然，这个是以牺牲部分效率为前提的。因为id是integer的，能更加快速查询。不过，从数据库会自动为 primary key 建立 index来看，效率也不会相差太多。
    要想通过hibernate访问数据库。首先要建立描述数据库的文件：hibernate.cfg.xml。放到src下面。内容如下：

            
      
            
    1. xml version='1.0' encoding='UTF-8'?> 
            
    2. 
            
    3.           "-//Hibernate/Hibernate Configuration DTD 3.0//EN"  
            
    4.           "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd"> 
            
    5.  
            
    6. <hibernate-configuration> 
            
    7.  
            
    8.  <session-factory> 
            
    9.   <property name="dialect">org.hibernate.dialect.MySQLDialectproperty> 
            
    10.   <property name="connection.url">jdbc:mysql://localhost:3306/hibernatequickUseproperty> 
            
    11.   <property name="connection.username">rootproperty> 
            
    12.   <property name="connection.password">rootproperty> 
            
    13.   <property name="connection.driver_class">com.mysql.jdbc.Driverproperty> 
            
    14.     
            
    15.   <property name="show_sql">trueproperty> 
            
    16.   <mapping resource="org/py/hib/quickstart/User.hbm.xml" /> 
            
    17.  
            
    18.    
            
    19.  session-factory> 
            
    20.  
            
    21. hibernate-configuration> 
            
    22.  
      23.

    说说上面的 "dialect", 这个对应着hibernate生成哪种数据库的sql。然后是："show_sql", 这个是为了调试时候输出sql语句到屏幕用的。

    注意"mapping resource"部分。这个部分表示你的 实体- 数据库 映射文件的位置。（什么是实体-数据库 映射文件，看下面。）

    实体-数据库映射文件 -- 主要是告诉hibernate，这个User类，对应着哪个table，User类里面的那个属性对应着table里面的哪个字段。我们可以建立 实体-数据库 的xml映射文件，也可以采用Annotations映射，但是目前只说xml映射方式。如下：

            
      
            
    1. xml version="1.0" encoding="utf-8"?> >  <hibernate-mapping>  <class name="org.py.hib.quickstart.User" table="user">                 <id name="id" type="java.lang.String" column="id" length="32">    <generator class="uuid" />   id>    <property name="name"  type="java.lang.String" column="name" length="32" />  class> hibernate-mapping>    
      2.

    上面的xml还是很好理解的。注意一个generator中的class，他可以有很多。我们这用的是uuid。什么是uuid。这个可以google一下。呵呵。google是最好的教科书。还能有很多其他的，比方说：native。具体的同样请教google。有了上面的准备，那么我们开始来测试一下。这里我们用junit。具体怎么使用junit，呵呵。答案我想大家都知道了，也不用我说了。其实我对test 和 使用它也不熟练。

    我把测试用力放到了test/org.py.hib.quickstart下面。代码如下：

            
      
            
    1. package org.py.hib.quickstart;  
            
    2.  
            
    3. import junit.framework.Assert;  
            
    4. import junit.framework.TestCase;  
            
    5.  
            
    6. import org.hibernate.Session;  
            
    7. import org.hibernate.SessionFactory;  
            
    8. import org.hibernate.Transaction;  
            
    9. import org.hibernate.cfg.Configuration;  
            
    10. import org.junit.After;  
            
    11. import org.junit.Before;  
            
    12.  
            
    13. public class QuickStartTest extends TestCase  
            
    14. {  
            
    15.  SessionFactory factory;  
            
    16.  
            
    17.  String m_name = "ryanpoy";  
            
    18.  
            
    19.  String m_name2 = "ryanpoy2";  
            
    20.  
            
    21.  @Before  
            
    22.  public void setUp() throws Exception  
            
    23.  {  
            
    24.   Configuration conf = new Configuration().configure();  
            
    25.   factory = conf.buildSessionFactory();  
            
    26.  }  
            
    27.  
            
    28.  /**  
            
    29.   * 测试添加  
            
    30.   * @throws Exception  
            
    31.   */  
            
    32.  public void testSave() throws Exception  
            
    33.  {  
            
    34.   System.out.println("\n=== test save ===");  
            
    35.   User u = new User();  
            
    36.   u.setName(m_name); // 设置用户名 = m_name  
            
    37.  
            
    38.   Session session = null;  
            
    39.   Transaction tran = null;  
            
    40.   try  
            
    41.   {  
            
    42.    session = factory.openSession();  
            
    43.    tran = session.beginTransaction();  
            
    44.    session.save(u);  
            
    45.    tran.commit();  
            
    46.  
            
    47.    Assert.assertEquals(u.getId() != null, true);  
            
    48.   } catch (Exception ex)  
            
    49.   {  
            
    50.    tran.rollback();  
            
    51.    throw ex;  
            
    52.   } finally  
            
    53.   {  
            
    54.    if (session != null)  
            
    55.    {  
            
    56.     try  
            
    57.     {  
            
    58.      session.close();  
            
    59.     } catch (Exception ex)  
            
    60.     {  
            
    61.      // nothing to do  
            
    62.     } finally  
            
    63.     {  
            
    64.      if (session != null)  
            
    65.       session = null;  
            
    66.     }  
            
    67.    }  
            
    68.   }  
            
    69.  }  
            
    70.  
            
    71.  /**  
            
    72.   * 测试查询  
            
    73.   * @throws Exception  
            
    74.   */  
            
    75.  public void testFind() throws Exception  
            
    76.  {  
            
    77.   System.out.println("\n=== test find ===");  
            
    78.   Session session = null;  
            
    79.   try  
            
    80.   {  
            
    81.    session = factory.openSession();  
            
    82.    User u = (User) session.createQuery("from User").list().get(0);  
            
    83.  
            
    84.    Assert.assertEquals(true, u.getId() != null);  
            
    85.    Assert.assertEquals(m_name, u.getName());  
            
    86.   } catch (Exception ex)  
            
    87.   {  
            
    88.    throw ex;  
            
    89.   } finally  
            
    90.   {  
            
    91.    if (session != null)  
            
    92.    {  
            
    93.     try  
            
    94.     {  
            
    95.      session.close();  
            
    96.     } catch (Exception ex)  
            
    97.     {  
            
    98.      // nothing to do  
            
    99.     } finally  
            
    100.     {  
            
    101.      if (session != null)  
            
    102.       session = null;  
            
    103.     }  
            
    104.    }  
            
    105.   }  
            
    106.  }  
            
    107.  
            
    108.  /**  
            
    109.   * 测试修改  
            
    110.   * @throws Exception  
            
    111.   */  
            
    112.  public void testModify() throws Exception  
            
    113.  {  
            
    114.   System.out.println("\n=== test modify ===");  
            
    115.   Session session = null;  
            
    116.   Transaction tran = null;  
            
    117.   try  
            
    118.   {  
            
    119.    session = factory.openSession();  
            
    120.    tran = session.beginTransaction();  
            
    121.  
            
    122.    User u = (User) session.createQuery("from User").list().get(0);  
            
    123.    u.setName(m_name2);  // 修改用户名 = m_name2.（原来用户名= m_name）  
            
    124.    tran.commit();  
            
    125.  
            
    126.   } catch (Exception ex)  
            
    127.   {  
            
    128.    throw ex;  
            
    129.   } finally  
            
    130.   {  
            
    131.    if (session != null)  
            
    132.    {  
            
    133.     try  
            
    134.     {  
            
    135.      session.close();  
            
    136.     } catch (Exception ex)  
            
    137.     {  
            
    138.      // nothing to do  
            
    139.     } finally  
            
    140.     {  
            
    141.      if (session != null)  
            
    142.       session = null;  
            
    143.     }  
            
    144.    }  
            
    145.   }  
            
    146.  
            
    147.   /*  
            
    148.    * 修改后再查询  
            
    149.    */  
            
    150.   System.out.println("\n=== test find after modify ===");  
            
    151.   try  
            
    152.   {  
            
    153.    session = factory.openSession();  
            
    154.    User u = (User) session.createQuery("from User").list().get(0);  
            
    155.  
            
    156.    Assert.assertEquals(true, u.getId() != null);  
            
    157.    Assert.assertEquals(m_name2, u.getName());  
            
    158.   } catch (Exception ex)  
            
    159.   {  
            
    160.    throw ex;  
            
    161.   } finally  
            
    162.   {  
            
    163.    if (session != null)  
            
    164.    {  
            
    165.     try  
            
    166.     {  
            
    167.      session.close();  
            
    168.     } catch (Exception ex)  
            
    169.     {  
            
    170.      // nothing to do  
            
    171.     } finally  
            
    172.     {  
            
    173.      if (session != null)  
            
    174.       session = null;  
            
    175.     }  
            
    176.    }  
            
    177.   }  
            
    178.  }  
            
    179.  
            
    180.  /**  
            
    181.   * 测试删除  
            
    182.   * @throws Exception  
            
    183.   */  
            
    184.  public void testDelete() throws Exception  
            
    185.  {  
            
    186.   System.out.println("\n=== test delete ===");  
            
    187.   Session session = null;  
            
    188.   Transaction tran = null;  
            
    189.   try  
            
    190.   {  
            
    191.    session = factory.openSession();  
            
    192.    tran = session.beginTransaction();  
            
    193.  
            
    194.    User u = (User) session.createQuery("from User").list().get(0);  
            
    195.    session.delete(u);  
            
    196.    tran.commit();  
            
    197.  
            
    198.   } catch (Exception ex)  
            
    199.   {  
            
    200.    throw ex;  
            
    201.   } finally  
            
    202.   {  
            
    203.    if (session != null)  
            
    204.    {  
            
    205.     try  
            
    206.     {  
            
    207.      session.close();  
            
    208.     } catch (Exception ex)  
            
    209.     {  
            
    210.      // nothing to do  
            
    211.     } finally  
            
    212.     {  
            
    213.      if (session != null)  
            
    214.       session = null;  
            
    215.     }  
            
    216.    }  
            
    217.   }  
            
    218.  
            
    219.   /*  
            
    220.    * 删除后再查询  
            
    221.    */  
            
    222.   System.out.println("\n=== test find after delete ===");  
            
    223.   try  
            
    224.   {  
            
    225.    session = factory.openSession();  
            
    226.    Integer num = (Integer) session.createQuery("from User").list().size();  
            
    227.  
            
    228.    Assert.assertEquals(0, num.intValue());  
            
    229.   } catch (Exception ex)  
            
    230.   {  
            
    231.    throw ex;  
            
    232.   } finally  
            
    233.   {  
            
    234.    if (session != null)  
            
    235.    {  
            
    236.     try  
            
    237.     {  
            
    238.      session.close();  
            
    239.     } catch (Exception ex)  
            
    240.     {  
            
    241.      // nothing to do  
            
    242.     } finally  
            
    243.     {  
            
    244.      if (session != null)  
            
    245.       session = null;  
            
    246.     }  
            
    247.    }  
            
    248.   }  
            
    249.  }  
            
    250.  
            
    251.  /**  
            
    252.   *   
            
    253.   */  
            
    254.  @After  
            
    255.  public void tearDown() throws Exception  
            
    256.  {  
            
    257.   factory.close();  
            
    258.  }  
            
    259.  
            
    260. }  
      261.

    运行后，我们很欣慰的看到一路绿灯，全部通过了。那么测试没有问题。呵呵(这里的测试可能还不完善。请大家指出。前面说过，我对测试这块也不熟)。
    看控制台，会输出如下信息：

            
      
            
    1. === test save ===  
            
    2. Hibernate: insert into hibernatequickuse.user (name, id) values (?, ?)  
            
    3.  
            
    4. === test find ===  
            
    5. Hibernate: select user0_.id as id2_, user0_.name as name2_ from hibernatequickuse.user user0_ 
            
    6.  
            
    7. === test modify ===  
            
    8. Hibernate: select user0_.id as id4_, user0_.name as name4_ from hibernatequickuse.user user0_  
            
    9. Hibernate: update hibernatequickuse.user set name=? where id=?  
            
    10.  
            
    11. === test find after modify ===  
            
    12. Hibernate: select user0_.id as id4_, user0_.name as name4_ from hibernatequickuse.user user0_ 
            
    13.  
            
    14. === test delete ===  
            
    15. Hibernate: select user0_.id as id6_, user0_.name as name6_ from hibernatequickuse.user user0_  
            
    16. Hibernate: delete from hibernatequickuse.user where id=?  
            
    17.  
            
    18. === test find after delete ===  
            
    19. Hibernate: select user0_.id as id6_, user0_.name as name6_ from hibernatequickuse.user user0_  
            
    20.  
      21.

只有注册用户登录后才能发表评论。
网站导航: