hibernate的环境搭建

本文以hibernate来操纵mysql数据库,所以在此之前必须确保mysql数据库已经正确安装好。。。

 

1、导hibernate包的核心jar包。。。

2、导hbm.xml文件

3、导hibernate.cfg.xml文件

以上三个文件为hibernate环境搭建的基础材料…其可以到hibernate的官网去下载…..在这里我为大家准备好了我自己常用的版本http://download.csdn.net/detail/caihongshijie6/6584855

4、编写pojo类(这里以Student类为例)

 

 

[java][/java] view plaincopyprint?在CODE上查看代码片派生到我的代码片

  1. package com.njupt.pojo;
  2. import java.io.Serializable;
  3. public class Student implements Serializable{
  4.     private int id;
  5.     private String name;
  6.     private String pwd;
  7.     private int age;
  8.     public int getId() {
  9.         return id;
  10.     }
  11.     public void setId(int id) {
  12.         this.id = id;
  13.     }
  14.     public String getName() {
  15.         return name;
  16.     }
  17.     public void setName(String name) {
  18.         this.name = name;
  19.     }
  20.     public String getPwd() {
  21.         return pwd;
  22.     }
  23.     public void setPwd(String pwd) {
  24.         this.pwd = pwd;
  25.     }
  26.     public int getAge() {
  27.         return age;
  28.     }
  29.     public void setAge(int age) {
  30.         this.age = age;
  31.     }
  32. }

 

5、HibernateUtil类

 

[java][/java] view plaincopyprint?在CODE上查看代码片派生到我的代码片

  1. package com.njupt.util;
  2. import org.hibernate.Session;
  3. import org.hibernate.SessionFactory;
  4. import org.hibernate.cfg.Configuration;
  5. public class HibernateUtil {
  6. //  创建SessionFactory
  7.     private static SessionFactory sessionFactory;
  8. //  使用静态代码块(只创建一次)来创建sessionFactory
  9.     static{
  10. //      读取配置hibernate.cfg.xml
  11.         try {
  12.             Configuration configuration =
  13.                 new Configuration().configure(“hibernate.cfg.xml”);
  14.             sessionFactory = configuration.buildSessionFactory();
  15.         } catch (Exception e) {
  16.             e.printStackTrace();
  17.         }
  18.     }
  19. //  获得session
  20.     public static Session getSession(){
  21.         return sessionFactory.openSession();
  22.     }
  23. //  关闭session,session总是默认保存数据(save(),get(),load()…)
  24. //  很可能出现内存泄露
  25.     public static void close(Session session){
  26.         if(session!=null){
  27.             if(session.isOpen()){// null.isOpen
  28.                 session.close();
  29.             }
  30.         }
  31.     }
  32. }

 

6、进行测试

编写测试类SessionTest

 

[java][/java] view plaincopyprint?在CODE上查看代码片派生到我的代码片

  1. package com.njupt.util;
  2. import java.util.Iterator;
  3. import java.util.List;
  4. import org.hibernate.Hibernate;
  5. import org.hibernate.HibernateException;
  6. import org.hibernate.Query;
  7. import org.hibernate.Session;
  8. import org.hibernate.Transaction;
  9. import org.junit.Test;
  10. import com.njupt.pojo.Student;
  11. import com.njupt.util.HibernateUtil;
  12. public class SessionTest {
  13.     // public void testSave(){
  14.     // // System.out.println(“保存”);
  15.     // String str =null;
  16.     // System.out.println(str.length());
  17.     // }
  18.     // 1 保存操作
  19.     @Test
  20.     public void testSave() {
  21.         Session session = null;
  22.         Transaction transaction = null;
  23.         try {
  24.             // 首先获得session
  25.             session = HibernateUtil.getSession();
  26.             // 获得Transaction
  27.             transaction = session.getTransaction();
  28.             // 开启事务
  29.             transaction.begin();
  30.             // 创建person对象
  31.             Student person = new Student();
  32.             person.setName(“zzt_love_hjd”);
  33.             person.setAge(21);
  34.             person.setPwd(“123321”);
  35.             // 使用session保存person对象
  36.             session.save(person);
  37.             // 提交事务
  38.             transaction.commit();
  39.         } catch (Exception e) {
  40.             // 打印异常信息
  41.             e.printStackTrace();
  42.             // 回滚
  43.             transaction.rollback();
  44.         } finally {
  45.             // 关闭session
  46.             HibernateUtil.close(session);
  47.         }
  48.     }
  49.     // 查询id=2的person对象
  50.     @Test
  51.     public void testGet1() {
  52.         Session session = null;
  53.         // 查询操作,对数据库的表没有任何修改,不用开启事务
  54.         try {
  55.             session = HibernateUtil.getSession();
  56.             // session.get()
  57.             Student person = (Student) session.get(Student.class, 3);
  58.             System.out.println(“——————————-“);
  59.             System.out.println(person.getId() + “,” + person.getName());
  60.         } catch (Exception e) {
  61.             // TODO: handle exception
  62.             e.printStackTrace();
  63.         } finally {
  64.             HibernateUtil.close(session);
  65.         }
  66.     }
  67.     // 使用load加载对象
  68.     @Test
  69.     public void testLoad1() {
  70.         Session session = null;
  71.         try {
  72.             session = HibernateUtil.getSession();
  73.             // 没有发出sql语句
  74.             // load():不会立刻去查询数据库,hibernate会返回一个代理对象
  75.             // 暂时代替person对象(避免对数据库过于频繁的访问,
  76.             // 提高系统性能)
  77.             // hibernate 返回代理对象是cglib动态代理
  78.             // cglib返回是目标对象(Person)的子类对象
  79.             Student person = (Student) session.load(Student.class, 1);
  80.             System.out.println(“——————-“);
  81.             // 真正需要访问数据的时候
  82.             // 发出了sql语句,person发出的sql语句
  83.             // hibernate返回的代理对象发出对应sql语句
  84.             System.out.println(person.getName());
  85.         } catch (Exception e) {
  86.             // TODO: handle exception
  87.             e.printStackTrace();
  88.         } finally {
  89.             HibernateUtil.close(session);
  90.         }
  91.     }
  92.     // get()查询的数据,在数据库中不存在
  93.     // 返回null
  94.     @Test
  95.     public void testGet2() {
  96.         Session session = null;
  97.         try {
  98.             session = HibernateUtil.getSession();
  99.             Student person = (Student) session.get(Student.class, 2);
  100.             System.out.println(person);
  101.         } catch (Exception e) {
  102.             // TODO: handle exception
  103.             e.printStackTrace();
  104.         } finally {
  105.             HibernateUtil.close(session);
  106.         }
  107.     }
  108.     // load()查询数据库中没有的数据
  109.     // 如果数据库中没有与之对应的数据,则抛出
  110.     // ObjectNotFoundException
  111.     // 常见异常:SQLException / HibernateException / NestableRuntimeException
  112.     @Test
  113.     public void testLoad2() {
  114.         Session session = null;
  115.         try {
  116.             session = HibernateUtil.getSession();
  117.             Student person = (Student) session.load(Student.class, 2);
  118.             System.out.println(person);
  119.         } catch (Exception e) {
  120.             // TODO: handle exception
  121.             e.printStackTrace();
  122.         } finally {
  123.             HibernateUtil.close(session);
  124.         }
  125.     }
  126.     // load:需要的时候才发出sql语句,去数据库中真实的查询
  127.     // 这叫做延迟加载/懒加载(预习)
  128.     // proxy:代理
  129.     // org.hibernate.LazyInitializationException:
  130.     // could not initialize proxy – no Session
  131.     // hibernate.load()返回的代理对象的生命周期跟session保持一致
  132.     // 关闭session,代理对象也不能使用了,不能发出sql语句
  133.     @Test
  134.     public void testLoad3() {
  135.         Session session = null;
  136.         Student person = null;
  137.         try {
  138.             session = HibernateUtil.getSession();
  139.             person = (Student) session.load(Student.class, 1);
  140.         } catch (Exception e) {
  141.             e.printStackTrace();
  142.         } finally {
  143.             HibernateUtil.close(session);
  144.         }
  145.         System.out.println(person.getName());
  146.     }
  147.     // 修改操作
  148.     @Test
  149.     public void testUpdate() {
  150.         Session session = null;
  151.         try {
  152.             session = HibernateUtil.getSession();
  153.             session.beginTransaction();// 直接开启一个事务
  154.             Student person = (Student) session.get(Student.class, 1);
  155.             person.setName(“cangsong”);
  156.             person.setAge(30);
  157.             session.update(person);
  158.             // getTransaction().commit();获得开启的事务,并提交
  159.             session.getTransaction().commit();
  160.         } catch (Exception e) {
  161.             // TODO: handle exception
  162.             e.printStackTrace();
  163.             // session.getTransaction().rollback();获得开启的事务,并回滚
  164.             session.getTransaction().rollback();
  165.         } finally {
  166.             HibernateUtil.close(session);
  167.         }
  168.     }
  169.     // 删除操作
  170.     @Test
  171.     public void testDelete() {
  172.         Session session = null;
  173.         try {
  174.             session = HibernateUtil.getSession();
  175.             session.beginTransaction();
  176.             Student person = (Student) session.get(Student.class, 2);
  177.             session.delete(person);
  178.             session.getTransaction().commit();
  179.         } catch (Exception e) {
  180.             // TODO: handle exception
  181.             e.printStackTrace();
  182.             session.getTransaction().rollback();
  183.         } finally {
  184.             HibernateUtil.close(session);
  185.         }
  186.     }
  187.     // 查询t_person中所有的对象
  188.     @Test
  189.     public void testQuery3() {
  190.         Session session = null;
  191.         try {
  192.             session = HibernateUtil.getSession();
  193.             // createQuery(“hql语句”):用session来创建一个Query对象
  194.             // 封装hql语句
  195.             Query query = session.createQuery(“from Person”);
  196.             // 使用query做查询操作,返回的结果保存到了一个list集合当中
  197.             List list = query.list();
  198.             // 对集合的遍历
  199.             Iterator<Student> iterator = list.iterator();
  200.             while (iterator.hasNext()) {
  201.                 Student person = iterator.next();
  202.                 System.out.println(person.getId() + “,” + person.getName());
  203.             }
  204.         } catch (Exception e) {
  205.             // TODO: handle exception
  206.             e.printStackTrace();
  207.         } finally {
  208.             HibernateUtil.close(session);
  209.         }
  210.     }
  211. }

 

经过以上的6步这时候,你便能在通过hibernate来操作数据库了…………………………..

!!!!特别提醒:要想使用hibernate的自动建表功能,可以在hibernate.cfg.xml中按如下配置:

<property name=”hbm2ddl.auto”>update</property>

标签