框架学习之Hibernate 第十一节 Hibernate知识补充

1.配置文件 hibernate.cfg.xml

参见官方文档

2.映射文件 hbm.xml

参见官方文档

重点：主键生成方式

native：根据使用的数据库来确定id的生成方式

如果是插入操作的话，在插入之前就会对数据库进行一次访问来生成下一个id，然后才插入，也就是插入了之后才知道id

hilo：高低位方式，一部分是数据库生成的，另一部分是程序生成的，可以保证是不会重复的，这种方式和上面的不同之处在于它不是插入了之后才知道id的[我自己也很糊涂]

采用这种方式数据库中会生成一个表 hibernate-unique-key（默认情况），表中有一个字段 next-hi，意思就是下一个高位

如果是native类型获取主键，对mysql来说是自增长方式的，只有在插入数据库后才能拿到主键；而用hilo方式获取主键，这种方式不用马上插入数据也可以拿到主键

 

foreign：外键引用，通常要和one-to-one标签一起使用

在一对一映射中要指定引用的是哪个表的哪个字段

        <id name="id">
            <generator class="foreign">
                <param name="property">person</param>
            </generator>
        </id>

uuid：UUID的生成方式生成id时不用访问一次数据库，它生成的id肯定是不同的，并且是string

如果插入比较多的话，可以考虑这种方式，但是查询效率会降低，因为比较的是string

 

3.Hibernate的类型

(1)<property name=“name” type=“java.lang.String”/>

type可以是hibernate、java类型或者你自己的类型(需要实现hibernate的一个接口)。

(2)基本类型一般不需要在映射文件(hbm.xml)中说明，只有在一个JAVA类型和多个数据库数据类型相对应时并且你想要的和hibernate缺省映射不一致时，需要在映射文件中指明类型(如:java.util.Date,数据库DATE,TIME,DATATIME,TIMESTAMP，hibernate缺省会把java.util.Date映射成DATATIME型，而如果你想映射成TIME，则你必须在映射文件中指定类型)。

默认的情况下，如果 java.util.Date   ->  datetime(数据库中)

如果只想保存日期，type设置成date

如果只想保存时间，type设置成time

如果两个都想保存，type设置成timestamp

(3)自定义类型，只要实现了接口就行

文档：

数据类型的对应关系：

内置的 basic mapping types 可以大致地分类为：
integer, long, short, float, double, character, byte, boolean, yes_no, true_false
这些类型都对应 Java 的原始类型或者其封装类，来符合（特定厂商的）SQL 字段类型。boolean, yes_no 和 true_false 都是 Java 中 boolean 或者 java.lang.Boolean 的另外说法。

string
从 java.lang.String 到 VARCHAR（或者 Oracle 的 VARCHAR2）的映射。

date, time, timestamp
从 java.util.Date 和其子类到 SQL 类型 DATE，TIME 和 TIMESTAMP（或等价类型）的映射。

calendar, calendar_date
从 java.util.Calendar 到 SQL 类型 TIMESTAMP 和 DATE（或等价类型）的映射。

big_decimal, big_integer
从 java.math.BigDecimal 和 java.math.BigInteger 到 NUMERIC（或者 Oracle 的 NUMBER类型）的映射。

locale, timezone, currency
从 java.util.Locale，java.util.TimeZone 和 java.util.Currency 到 VARCHAR（或者 Oracle 的VARCHAR2 类型）的映射。Locale 和 Currency 的实例被映射为它们的 ISO 代码。TimeZone 的实例被影射为它的 ID。

class
从 java.lang.Class 到 VARCHAR（或者 Oracle 的 VARCHAR2 类型）的映射。Class 被映射为它的全限定名。

binary
把字节数组（byte arrays）映射为对应的 SQL 二进制类型。

text
把长 Java 字符串映射为 SQL 的 CLOB 或者 TEXT 类型。

serializable
把可序列化的 Java 类型映射到对应的 SQL 二进制类型。你也可以为一个并非默认为基本类型的可序列化 Java 类或者接口指定 Hibernate 类型 serializable。

clob, blob
JDBC 类  java.sql.Clob 和  java.sql.Blob的映射。某些程序可能不适合使用这个类型，因为blob 和 clob 对象可能在一个事务之外是无法重用的。（而且, 驱动程序对这种类型的支持充满着补丁和前后矛盾。）

imm_date, imm_time, imm_timestamp, imm_calendar, imm_calendar_date, imm_serializable, imm_binary
一般来说，映射类型被假定为是可变的 Java 类型，只有对不可变 Java 类型，Hibernate 会采取特定的优化措施，应用程序会把这些对象作为不可变对象处理。比如，你不应该对作为 imm_timestamp 映射的 Date 执行 Date.setTime()。要改变属性的值，并且保存这一改变，应用程序必须对这一属性重新设置一个新的（不一样的）对象。

实体及其集合的唯一标识可以是除了 binary、 blob 和 clob 之外的任何基础类型。

 

4.Session和SessionFactory

Session是非线程安全的，生命周期较短，代表一个和数据库的连接，在B/S系统中一般不会超过一个请求；

内部维护一级缓存和数据库连接，如果session长时间打开，会长时间占用内存和数据库连接。

SessionFactory是线程安全的，一个数据库对应一个SessionFactory，生命周期长，一般在整个系统生命周期内有效；

SessionFactory保存着和数据库连接的相关信息（user，password，url）和映射信息，以及Hibernate运行时要用到的一些信息。

线程安全 意思就是多个地方进行访问同一个数据时，数据是同步的，不会乱的，因为正在访问的那个数据会被锁死，其他人没有办法访问

还有一种线程安全是 static 的，静态的，不会改变的，以及只读的属性，它们的值是不能够被修改的（final）

 

5. flush时将一级缓存与数据库同步，这个方法Hibernate自己会在相应的时间调用，最好不要自己调用，因为这个方法耗时耗资源

一般在查询之前或者提交之前执行

测试代码：[注：Department是 native的id生成器，而Employee是hilo的形式]

/**
* @Author：胡家威  
* @CreateTime：2011-8-15 下午11:18:42
* @Description：
*/

package com.yinger.main;

import java.util.HashSet;
import java.util.Set;

import org.hibernate.Session;
import org.hibernate.Transaction;

import com.yinger.domain.Department;
import com.yinger.domain.Employee;
import com.yinger.util.HibernateUtils;

public class One2Many {

    public static void main(String[] args) {
        add();
    }

    private static void add() {
        Department depart = new Department();
        depart.setName("depart name");
        
        Employee emp1 = new Employee();
        emp1.setName("emp1 name");
        
        Employee emp2 = new Employee();
        emp2.setName("emp2 name");
        
        Set<Employee> emps = new HashSet<Employee>();
        emps.add(emp1);
        emps.add(emp2);
        depart.setEmps(emps);
        
        Session s = null;
        Transaction tr = null;
        try{
            s = HibernateUtils.getSession();
            tr = s.beginTransaction();
            s.save(depart);
            s.save(emp1);
            s.save(emp2);
            s.flush();
            System.out.println("--------------------");
            tr.commit();
        }catch(Exception e){
            if(tr!=null)
                tr.rollback();
        }finally{
            if(s!=null)
                s.close();
        }
    }

}

测试结果： 两条Employee的insert语句是在横线之上的

log4j:WARN No appenders could be found for logger (org.hibernate.cfg.Environment).
log4j:WARN Please initialize the log4j system properly.
Hibernate: insert into Department (name) values (?)
Hibernate: insert into Employee (name, id) values (?, ?)
Hibernate: insert into Employee (name, id) values (?, ?)
Hibernate: update Employee set depart_id=? where id=?
Hibernate: update Employee set depart_id=? where id=?
--------------------

 

注释掉 s.flush() 方法之后，insert语句在横线的下面

log4j:WARN No appenders could be found for logger (org.hibernate.cfg.Environment).
log4j:WARN Please initialize the log4j system properly.
Hibernate: insert into Department (name) values (?)
--------------------
Hibernate: insert into Employee (name, id) values (?, ?)
Hibernate: insert into Employee (name, id) values (?, ?)
Hibernate: update Employee set depart_id=? where id=?
Hibernate: update Employee set depart_id=? where id=?

 

前者调用了flush方法，使得一级缓存和数据库进行了同步，这样就可以立即插入Employee对象了

后者则不会，Hibernate默认情况下都会对数据库操作进行优化，一般都会在最后的时刻进行数据库操作，也就是批量的进行数据库的CURD

这样可以提高数据库操作的效率

 

6.大批量处理

大量操作数据时可能造成内存溢出，解决办法如下：

①清除session中的数据

for(int i=0;i<100000;i++)      session.save(obj);

for(int i=0;i<100000;i++){

         session.save(obj);

         if(i% 50 == 0){

                   session.flush(); // 一般要在clear之前进行一次flush操作，因为并不知道什么时候修改了数据，所以要在清除缓存之前和数据库进行一次同步

                   session.clear();

         }

}

②用StatelessSession接口：它不和一级缓存、二级缓存交互，也不触发任何事件、监听器、拦截器，通过该接口的操作会立刻发送给数据库，与JDBC的功能一样。

StatelessSession s = sessionFactory.openStatelessSession();该接口的方法与Session类似。

③Query.executeUpdate()执行批量更新，会清除相关联的类二级缓存(sessionFactory.evict(class))

缺点：可能会造成级联和乐观锁定问题，因为二级缓存中的数据已被清空了

测试代码：

    public static void main(String[] args) {
        People p = addPeople();
        System.out.println("---------");
        excuteUpdateTest();
    }
    
    public static void excuteUpdateTest() {
        // hibernate 3.0 之前，批量更新只能是把数据一个个取出来然后更新
        Session session = HibernateUtils.getSession();
        Transaction tx = session.beginTransaction();
        SQLQuery query = session.createSQLQuery("select {p.*} from people p").addEntity("p", People.class);
        List<People> list = query.list();
        for(People people:list) {
            people.getName().setFirstName("new firstName");
        }
        // hibernate 3.0 之后，有了 excuteUpdate 方法 update Customer set name = :newName
        Query query2 = session.createQuery("update People set first_name=:newName");
        query2.setString("newName", "new name");
        query2.executeUpdate();
        tx.commit();
    }

 

测试结果：

log4j:WARN No appenders could be found for logger (org.hibernate.cfg.Environment).
log4j:WARN Please initialize the log4j system properly.
Hibernate: insert into People (version, first_name, last_name, id) values (?, ?, ?, ?)
---------
Hibernate: select p.id as id0_, p.version as version8_0_, p.first_name as first3_8_0_, p.last_name as last4_8_0_ from people p
Hibernate: update People set version=?, first_name=?, last_name=? where id=? and version=?
Hibernate: update People set first_name=?

数据库中的数据：

id  version  first_name  last_name

1    1    new name    lastName

 

7.拦截器和事件监听

拦截器与事件都是hibernate的扩展机制（类似过滤器），Interceptor接口是老的实现机制，现在改成事件监听机制；

他们都是hibernate的回调接口，hibernate在save,delete,update…等会回调这些类。

测试代码：Hibernate 3.0 之后将拦截器改成了事件监听！当然，拦截器还是有的

[ 这部分内容我测试失败，估计是我的Hibernate的版本的问题，实现的方法的返回值都是不同的，以下摘自百度]

以下摘自：http://hi.baidu.com/sonmeika/blog/item/b83d1c12aa687449f819b8b2.html   传智播客hibernate视频教程(十五)：其他问题汇总

// 示例：
 // 在hibernate.cfg.xml中添加：
<hibernate-configuration>
 <session-factory name="sessionFactory">
......
  <!-- 映射文件存放位置 -->
  <mapping resource="cn/itcast/hibernate/domain/User.hbm.xml"/>
  <mapping resource="cn/itcast/hibernate/domain/Department.hbm.xml"/>
  <mapping resource="cn/itcast/hibernate/domain/Employee.hbm.xml"/>
  <mapping resource="cn/itcast/hibernate/domain/Person.hbm.xml"/>
  <mapping resource="cn/itcast/hibernate/domain/IdCard.hbm.xml"/>
  <mapping resource="cn/itcast/hibernate/domain/Teacher.hbm.xml"/>
  <mapping resource="cn/itcast/hibernate/domain/Student.hbm.xml"/>
  <!-- 定义监听器 -->
  <event type="save">
   <listener class="cn.itcast.hibernate.SaveListener"/>
  </event>
 </session-factory>
</hibernate-configuration>

SaveListener.java：
package cn.itcast.hibernate;
import org.hibernate.HibernateException;
import org.hibernate.event.SaveOrUpdateEvent;
import org.hibernate.event.SaveOrUpdateEventListener;
import cn.itcast.hibernate.domain.User;
public class SaveListener implements SaveOrUpdateEventListener {
 private static final long serialVersionUID = -5774832715365370704L;
 @Override
 public void onSaveOrUpdate(SaveOrUpdateEvent event)
   throws HibernateException {
  if (event.getObject() instanceof cn.itcast.hibernate.domain.User) {
   User user = (User) event.getObject();
   System.out.println("--"+user.getId()); //如果有id值，就证明已经保存了
   System.out.println("--"+user.getName());
  }
 }
}
这样在保存user时都会先经过onSaveOrUpdate。例如：
  User user = new User();
  user.setBirthday(new Date());
  user.setName("name");
  System.out.println("before save");
  addUser(user);
  System.out.println("after save");
输出如下：
before save
--0
--name
after save
在输出内容中看不到insert语句了，并且库里也没有添加记录。这是因为我们自定义的监听器覆盖了原有的监听器，hibernate认为已经定义了更好的监听器，就不执行默认的了。如果要继续执行默认的，则需要在hibernate.cfg.xml中增加如下：
  <!-- 定义监听器 -->
  <event type="save">
   <listener class="cn.itcast.hibernate.SaveListener"/>
   <listener class="org.hibernate.event.def.DefaultSaveEventListener"/><!-- 注意：是DefaultSaveEventListener，而不是DefaultSaveOrUpdateEventListener -->
   </event>
监听器的调用顺序与此处的顺序有关，先调用SaveListener，后调用DefaultSaveEventListener。
修改后的输出如下：
before save
--0  // ID是0，说明此时还没有保存
Hibernate: select hibernate_sequence.nextval from dual
Hibernate: insert into Persons (name, birthday, id) values (?, ?, ?)
after save
调整监听器的顺序如下：
  <event type="save">
   <listener class="org.hibernate.event.def.DefaultSaveEventListener"/><!-- 注意：是DefaultSaveEventListener，而不是DefaultSaveOrUpdateEventListener -->
   <listener class="cn.itcast.hibernate.SaveListener"/>
   </event>
输出如下：
before save
Hibernate: select hibernate_sequence.nextval from dual
--1  // ID是1，说明对象已保存
Hibernate: insert into Persons (name, birthday, id) values (?, ?, ?)
after save

 

8. SQL查询 和 命名查询

s.createSQLQuery：建议不要使用，因为兼容性不好，对于数据库的移植会造成影响

s.getNamedQuery：写在映射文件中的HQL，统一的管理，便于以后使用的方便

命名的sql放置在映射文件中，放置的位置不同（class内或者class外），传递的字符串的参数是不同的

测试代码：

在People的映射文件中添加：放在class外面

<query name="getFirstNameById">
        <![CDATA[from People where id=:id]]>
</query>

测试类中的方法：

package com.yinger.main;

import java.util.List;

import org.hibernate.Query;
import org.hibernate.SQLQuery;
import org.hibernate.Session;
import org.hibernate.Transaction;

import com.yinger.domain.Name;
import com.yinger.domain.People;
import com.yinger.util.HibernateUtils;

public class QueryTest {

    public static void main(String[] args) {
        People p = addPeople();
        System.out.println("---------");
        sqlTest();
        System.out.println("---------");
        namedSqlTest(p.getId());
    }

    public static void sqlTest() {
        Session session = HibernateUtils.getSession();
        SQLQuery query = session.createSQLQuery("select {p.*} from people p").addEntity("p", People.class); // 注意这里是SQLQuery，不是Query
        List<People> list = query.list();
        for(People people:list) {
            System.out.println(people.getName().getFirstName());
        }
    }
    
    public static void namedSqlTest(int id) {
        Session session = HibernateUtils.getSession();
        Query query = session.getNamedQuery("getFirstNameById");
        query.setInteger("id", id);
        List<People> list = query.list();
        for(People people:list) {
            System.out.println(people.getName().getFirstName());
        }
    }

    public static People addPeople() {
        People p = new People();
        Name n = new Name();
        n.setFirstName("firstName");
        n.setLastName("lastName");
        p.setName(n);
        HibernateUtils.add(p);
        return p;
    }

    private static void testTransaction(int id) {
        Session s1 = HibernateUtils.getSession();
        Transaction tx1 = s1.beginTransaction();//一个事务开启了
        People p1 = (People)s1.get(People.class, id);
        
        Session s2 = HibernateUtils.getSession();;
        Transaction tx2 = s2.beginTransaction();//又开启了另一个事务，并且操作的是同一条数据
        People p2 = (People)s2.get(People.class, id);
        
        p2.getName().setFirstName("firstName 2");
        p1.getName().setFirstName("firstName 1");
        
        tx2.commit();
        tx1.commit();
        s1.close();
        s2.close();
    }

}

测试结果：

log4j:WARN No appenders could be found for logger (org.hibernate.cfg.Environment).
log4j:WARN Please initialize the log4j system properly.
Hibernate: insert into People (version, first_name, last_name) values (?, ?, ?)
---------
Hibernate: select p.id as id0_, p.version as version8_0_, p.first_name as first3_8_0_, p.last_name as last4_8_0_ from people p
firstName
---------
Hibernate: select people0_.id as id, people0_.version as version8_, people0_.first_name as first3_8_, people0_.last_name as last4_8_ from People people0_ where (people0_.id=?)
firstName

 

9. 不合适使用 Hibernate的场景

①不适合OLAP(On-Line Analytical Processing 联机分析处理)，以查询分析数据为主的系统；适合OLTP（on-line transaction processing 联机事务处理）。

联机分析处理 系统总是进行查询统计，没有很好的对象和关系模型，不适合使用 Hibernate

②对于些关系模型设计不合理的老系统，也不能发挥hibernate优势。

③数据量巨大，性能要求苛刻的系统，hibernate也很难达到要求, 批量操作数据的效率也不高。

 

10. 与 JPA 集成 (annotation方式)

①需要添加的包ejb3-persistence.jar, hibernate-entitymanager.jar, hibernate-annotations.jar, hibernate-commons-annotations.jar, jboss-archive-browsing.jar, javassist.jar

②配置文件%CLASSPATH%/META-INF/persistence.xml

③JAVA代码：

    EntityManagerFactory emf = Persistence.createEntityManagerFactory(name);
    //(Name:在persistence.xml中指定。)
    EntityManager em = emf.createEntityManager();
    EntityTransaction tx = em.getTransaction();
    Tx.begin();
    Em.persist(entity);//remove,merge,find
    Tx.commit();
    Em.close();
    Emf.close();

 

相关的PPT：