7.4---SSH之Hibernate初始篇

今天开始学习Hibernate，
使用的是框架官网下载的4.3版本
首先解压下载的压缩包
目录里主要有三个文件夹：
1.documentation:文档类
2.project:一些项目示例
3.lib:jar包
ps:在第一个documentation文件夹中通过->manual->en_US->html_single->index.html
可以查看一些关于Hibernate的一些相关操作

---

建项目

1.什么时候导jar包？
当用到的类不在标准类库中时，需要导jar包
2.jar包里是什么？
jar包里是.class文件，可执行文件
3.怎么导jar包？
直接放到web 项目下WEB-INF的lib文件夹中
ps:JDBC是java唯一访问数据库的方式
4.最后导入ojdbc包

---

完成配置文件

在index.html页面中点击
1.1.2->1.1.3->1.1.4->3.4.1（SQL Dialects）->1.1.6(HibernateUtil.java)
ps:由类->数据库中的表：正向生成
类：私有属性private，封装类类型Integer,属性studentId(两个单词以上为一个)
在Student.hbm.xml中<’id’> <’/id’>是表中的主键
另外写一个测试关键部分为：

Configuration cfg = new Configuration().configure();
 SchemaExport schema = new SchemaExport(cfg);
 schema.create(true,true);

hibernate延迟加载(get和load的区别)

在hibernate中我们知道如果要从数据库中得到一个对象，通常有两种方式，一种是通过session.get()方法，另一种就是通过session.load()方法，然后其实这两种方法在获得一个实体对象时是有区别的，在查询性能上两者是不同的。

一.load加载方式

当使用load方法来得到一个对象时，此时hibernate会使用延迟加载的机制来加载这个对象，即：当我们使用session.load()方法来加载一个对象时，此时并不会发出sql语句，当前得到的这个对象其实是一个代理对象，这个代理对象只保存了实体对象的id值，只有当我们要使用这个对象，得到其它属性时，这个时候才会发出sql语句，从数据库中去查询我们的对象。

　session = HibernateUtil.openSession();

            /*
             * 通过load的方式加载对象时，会使用延迟加载机制，此时并不会发出sql语句，只有当我们需要使用的时候才会从数据库中去查询
             */
            User user = (User)session.load(User.class, 2);

我们看到，如果我们仅仅是通过load来加载我们的User对象，此时从控制台我们会发现并不会从数据库中查询出该对象，即并不会发出sql语句，但如果我们要使用该对象时：

　　　　　　session = HibernateUtil.openSession();
　　　　　　User user = (User)session.load(User.class, 2);
　　　　　　System.out.println(user);

此时我们看到控制台会发出了sql查询语句，会将该对象从数据库中查询出来：

Hibernate: select user0_.id as id0_0_, user0_.username as username0_0_, user0_.password as password0_0_, user0_.born as born0_0_ from user user0_ where user0_.id=?
User [id=2, username=aaa, password=111, born=2013-10-16 00:14:24.0]

这个时候我们可能会想，那么既然调用load方法时，并不会发出sql语句去从数据库中查出该对象，那么这个User对象到底是个什么对象呢？

其实这个User对象是我们的一个代理对象，这个代理对象仅仅保存了id这个属性：

　　　　　　session = HibernateUtil.openSession();
            /*
             * 通过load的方式加载对象时，会使用延迟加载机制，此时得到的User对象其实是一个
             * 代理对象，该代理对象里面仅仅只有id这个属性
             */
            User user = (User)session.load(User.class, 2);
            System.out.println(user.getId());

　　　　　　console:　　2

我们看到，如果我们只打印出这个user对象的id值时，此时控制台会打印出该id值，但是同样不会发出sql语句去从数据库中去查询。这就印证了我们的这个user对象仅仅是一个保存了id的代理对象，但如果我需要打印出user对象的其他属性值时，这个时候会不会发出sql语句呢？答案是肯定的：

            session = HibernateUtil.openSession();
            /*
             * 通过load的方式加载对象时，会使用延迟加载机制，此时得到的User对象其实是一个
             * 代理对象，该代理对象里面仅仅只有id这个属性
             */
            User user = (User)session.load(User.class, 2);
            System.out.println(user.getId());
            // 如果此时要得到user其他属性，则会从数据库中查询
            System.out.println(user.getUsername());            

此时我们看控制台的输出：

2
Hibernate: select user0_.id as id0_0_, user0_.username as username0_0_, user0_.password as password0_0_, user0_.born as born0_0_ from user user0_ where user0_.id=?
aaa

相信通过上述的几个例子，大家应该很好的了解了load的这种加载对象的方式了吧。

二、get加载方式

相对于load的延迟加载方式，get就直接的多，当我们使用session.get()方法来得到一个对象时，不管我们使不使用这个对象，此时都会发出sql语句去从数据库中查询出来：

　　　　　　　session = HibernateUtil.openSession();
            /*
             * 通过get方法来加载对象时，不管使不使用该对象，都会发出sql语句，从数据库中查询
             */
            User user = (User)session.get(User.class, 2);

此时我们通过get方式来得到user对象，但是我们并没有使用它，但是我们发现控制台会输出sql的查询语句：

Hibernate: select user0_.id as id0_0_, user0_.username as username0_0_, user0_.password as password0_0_, user0_.born as born0_0_ from user user0_ where user0_.id=?

因此我们可以看到，使用load的加载方式比get的加载方式性能要好一些，因为load加载时，得到的只是一个代理对象，当真正需要使用这个对象时再去从数据库中查询。

三、使用get和load时的一些小问题

当了解了load和get的加载机制以后，我们此时来看看这两种方式会出现的一些小问题：

①如果使用get方式来加载对象，当我们试图得到一个id不存在的对象时，此时会报NullPointException的异常

　　　　　　  session = HibernateUtil.openSession();
            /*
             * 当通过get方式试图得到一个id不存在的user对象时，此时会报NullPointException异常
             */
            User user = (User)session.get(User.class, 20);
            System.out.println(user.getUsername());

此时我们看控制台的输出信息，会报空指针的异常：

Hibernate: select user0_.id as id0_0_, user0_.username as username0_0_, user0_.password as password0_0_, user0_.born as born0_0_ from user user0_ where user0_.id=?
java.lang.NullPointerException　　.........

这是因为通过get方式我们会去数据库中查询出该对象，但是这个id值不存在，所以此时user对象是null，所以就会报NullPointException的异常了。

②如果使用load方式来加载对象，当我们试图得到一个id不存在的对象时，此时会报ObjectNotFoundException异常：

　　　　　　session = HibernateUtil.openSession();
            /*
             * 当通过get方式试图得到一个id不存在的user对象时，此时会报ObjectNotFoundException异常
             */
            User user = (User)session.load(User.class, 20);
            System.out.println(user.getId());
            System.out.println(user.getUsername());

我们看看控制台的输出：

20
Hibernate: select user0_.id as id0_0_, user0_.username as username0_0_, user0_.password as password0_0_, user0_.born as born0_0_ from user user0_ where user0_.id=?
org.hibernate.ObjectNotFoundException: No row with the given identifier exists: [com.xiaoluo.bean.User#20]......

为什么使用load的方式和get的方式来得到一个不存在的对象报的异常不同呢？？其原因还是因为load的延迟加载机制，使用load时，此时的user对象是一个代理对象，仅仅保存了当前的这个id值，当我们试图得到该对象的username属性时，这个属性其实是不存在的，所以就会报出ObjectNotFoundException这个异常了。

③org.hibernate.LazyInitializationException异常

接下来我们再来看一个例子：

public class UserDAO
{
    public User loadUser(int id)
    {
        Session session = null;
        Transaction tx = null;
        User user =  null;
        try
        {
            session = HibernateUtil.openSession();
            tx = session.beginTransaction();
            user = (User)session.load(User.class, 1);
            tx.commit();
        }
        catch (Exception e)
        {
            e.printStackTrace();
            tx.rollback();
        }
        finally
        {
            HibernateUtil.close(session);
        }
        return user;
    }
}

　　@Test
    public void testLazy06()
    {
        UserDAO userDAO = new UserDAO();
        User user = userDAO.loadUser(2);
        System.out.println(user);
    }

模拟了一个UserDAO这样的对象，然后我们在测试用例里面来通过load加载一个对象，此时我们发现控制台会报LazyInitializationException异常

org.hibernate.LazyInitializationException: could not initialize proxy - no Session　　………….

这个异常是什么原因呢？？还是因为load的延迟加载机制，当我们通过load()方法来加载一个对象时，此时并没有发出sql语句去从数据库中查询出该对象，当前这个对象仅仅是一个只有id的代理对象，我们还并没有使用该对象，但是此时我们的session已经关闭了，所以当我们在测试用例中使用该对象时就会报LazyInitializationException这个异常了。

所以以后我们只要看到控制台报LazyInitializationException这种异常，就知道是使用了load的方式延迟加载一个对象了，解决这个的方法有两种，一种是将load改成get的方式来得到该对象，另一种是在表示层来开启我们的session和关闭session。

至此，hibernate的两种加载方式get和load已经分析完毕！！！

---

hql:凡是针对的操作写的是类名；凡是针对列的操作写的是属性名。

整合以上完成基本的Hibernate框架与Oracle数据库相连，代码如下：
首先建立一个实类Student.java

package com.hb.domain;

public class Student {
    private Integer stuId;
    private String stuName;
    private String stuGender;
    private Integer stuAge;
    public Integer getStuId() {
        return stuId;
    }
    public void setStuId(Integer stuId) {
        this.stuId = stuId;
    }
    public String getStuName() {
        return stuName;
    }
    public void setStuName(String stuName) {
        this.stuName = stuName;
    }
    public String getStuGender() {
        return stuGender;
    }
    public void setStuGender(String stuGender) {
        this.stuGender = stuGender;
    }
    public Integer getStuAge() {
        return stuAge;
    }
    public void setStuAge(Integer stuAge) {
        this.stuAge = stuAge;
    }



}

映射文件Student.hbm.xml如下

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

<hibernate-mapping package="com.hb.domain">

    <class name="Student" table="STU_TAB">
        <id name="stuId" column="STU_ID">
            <generator class="native"/>
        </id>
        <property name="stuName" column="STU_NAME"/>
        <property name="stuGender" column="STU_GENDER"/>
         <property name="stuAge" column="STU_AGE"/>
    </class>

</hibernate-mapping>

再建立一个dao包，内含HibernateUtile.java和StudentDao.java

package com.hb.dao;

import org.hibernate.SessionFactory;
import org.hibernate.boot.registry.StandardServiceRegistryBuilder;
import org.hibernate.cfg.Configuration;

public class HibernateUtil {

    private static final SessionFactory sessionFactory = buildSessionFactory();

    private static SessionFactory buildSessionFactory() {
        try {
            // Create the SessionFactory from hibernate.cfg.xml
            Configuration cfg = new  Configuration().configure();
            SessionFactory sf= cfg.buildSessionFactory(new StandardServiceRegistryBuilder()
                                .applySettings(cfg.getProperties()).build());
            return sf;
        }
        catch (Throwable ex) {
            // Make sure you log the exception, as it might be swallowed
            System.err.println("Initial SessionFactory creation failed." + ex);
            throw new ExceptionInInitializerError(ex);
        }
    }

    public static SessionFactory getSessionFactory() {
        return sessionFactory;
    }


}

下面是StudentDao.java

package com.hb.dao;


import java.util.List;

import com.hb.domain.Student;

public interface StudentDao {

    public void addStudent(Student stu);

    public void updateStudent(Student stu);

    public void deleteStudent(Student stu);

    public Student findStudentById(Integer stuId);

    public List<Student> findAllStudent();
}

---

建立一个实现类StudentDaoImpl.java

package com.hb.dao.impl;

import java.util.ArrayList;
import java.util.List;

import org.hibernate.Query;
import org.hibernate.Session;

import com.hb.dao.HibernateUtil;
import com.hb.dao.StudentDao;
import com.hb.domain.Student;

public class StudentDaoImpl implements StudentDao {

    @Override
    public void addStudent(Student stu) {
        // TODO Auto-generated method stub
        try{
            Session session = HibernateUtil.getSessionFactory().openSession();
            session.beginTransaction();

            session.save(stu);

            session.getTransaction().commit();

        }catch(Exception e){
            e.printStackTrace();
        }

    }

    @Override
    public void updateStudent(Student stu) {
        // TODO Auto-generated method stub
        try{
            Session session = HibernateUtil.getSessionFactory().openSession();
            session.beginTransaction();

            session.update(stu);

            session.getTransaction().commit();

        }catch(Exception e){
            e.printStackTrace();
        }


    }

    @Override
    public void deleteStudent(Student stu) {
        // TODO Auto-generated method stub
        try{
            Session session = HibernateUtil.getSessionFactory().openSession();
            session.beginTransaction();

            session.delete(stu);

            session.getTransaction().commit();

        }catch(Exception e){
            e.printStackTrace();
        }


    }

    @Override
    public Student findStudentById(Integer stuId) {
        // TODO Auto-generated method stub
        Student stu = null;
        try{
            Session session = HibernateUtil.getSessionFactory().openSession();
            session.beginTransaction();
            stu = (Student)session.get(Student.class, stuId);

            session.getTransaction().commit();

        }catch(Exception e){
            e.printStackTrace();
        }

        return stu;
    }

    @Override
    public List<Student> findAllStudent() {
        // TODO Auto-generated method stub
        List<Student> list = new ArrayList<Student>();
        try{
            Session session = HibernateUtil.getSessionFactory().openSession();
            session.beginTransaction();

//          String hql="from Student s";
//          Query query = session.createQuery(hql);
//          list = query.list();

            list = session.createQuery("from Student s").list();

            session.getTransaction().commit();

        }catch(Exception e){
            e.printStackTrace();
        }


        return list;
    }

}

---

最后写一个测试类TestStudentDao.java就可以了

package com.hb.test;



import java.util.List;

import com.hb.dao.StudentDao;
import com.hb.dao.impl.StudentDaoImpl;
import com.hb.domain.Student;

public class TestStudentDao {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        StudentDao stuDao = new StudentDaoImpl();
//      Student stu = new Student();   //增加信息
//      stu.setStuName("苏");
//      stu.setStuGender("男");
//      stu.setStuAge(21);
//      
//      stuDao.addStudent(stu);

//      Student stu = stuDao.findStudentById(2); //通过id查询
//      System.out.println(stu.getStuName());

        List<Student> list = stuDao.findAllStudent();  //列出全部信息
        for(Student stu : list){
            System.out.println(stu.getStuName());
        }

    }

}

---

在src下的配置文件hibernate.cfg.xml内容如下：

<?xml version='1.0' encoding='utf-8'?>
<!DOCTYPE hibernate-configuration PUBLIC
        "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
        "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">

<hibernate-configuration>

    <session-factory>

        <!-- Database connection settings -->
        <property name="connection.driver_class">oracle.jdbc.driver.OracleDriver</property>
        <property name="connection.url">jdbc:oracle:thin:@localhost:1521:xe</property>
        <property name="connection.username">su</property>
        <property name="connection.password">1573</property>

        <!-- JDBC connection pool (use the built-in) -->
        <property name="connection.pool_size">1</property>

        <!-- SQL dialect -->
        <property name="dialect">org.hibernate.dialect.Oracle10gDialect</property>

        <!-- Enable Hibernate's automatic session context management -->
        <property name="current_session_context_class">thread</property>

        <!-- Disable the second-level cache  -->
        <property name="cache.provider_class">org.hibernate.cache.internal.NoCacheProvider</property>

        <!-- Echo all executed SQL to stdout -->
        <property name="show_sql">true</property>

        <!-- Drop and re-create the database schema on startup -->
        <property name="hbm2ddl.auto">update</property>

        <mapping resource="com/hb/domain/Student.hbm.xml"/>
        <mapping resource="com/hb/domain/Teacher.hbm.xml"/>

    </session-factory>

</hibernate-configuration>

---

到此完结！

Author:su1573