Hibernate学习---第十三节：hibernate过滤器和拦截器的实现

一、hibernate 过滤器

1、在持久化映射文件中配置过滤器，代码如下：

<?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="learn.hibernate.bean">
    <!-- 定义过滤器，并指定参数 -->
    <filter-def name="password_filter">
        <filter-param name="ps" type="integer"/>
        <filter-param name="ps2" type="integer"/>
    </filter-def>

    <class name="Person" table="t_person">
        <id name="id" column="person_id">
            <generator class="native"/>
        </id>
        <property name="name" column="t_name"/>
        <property name="age"/>
        <property name="passwork"/>
        <property name="birthday"/>
        <filter name="password_filter" condition="password between :ps and :ps2"/>
    </class>
</hibernate-mapping>

2、测试过滤器：

@Test
public void testQuery(){
    // 启用指定名称对应的过滤器
    Filter filter = session.enableFilter("password_filter");
    // 过滤器参数绑定(过滤条件的绑定)
    filter.setParameter("ps", 123458);
    filter.setParameter("ps2", 123464);
    Query query = session.createQuery("from Person");
    List<Person> list = query.list();
    for(Person p : list){
        System.out.println(p);
    }

    System.out.println("--------------------------");
    // 停用指定的过滤器
    // 如果在一个有开启开启过滤器的 session 中进行对应的持久化类的查询操作都会自动加上过滤条件
    // session.disableFilter("password_filter");
    Query query2 = session.createQuery("from Person where id in (:ids)");
    query2.setParameter("ids", new Object[]{4,5});
    List<Person> list2 = query2.list();
    for(Person p : list2){
        System.out.println(p);
    }

    System.out.println("--------------------------");
    // 通过以下实验证明过滤器只是加在 create* 方法上
    session.clear();
    Person person = (Person)session.get(Person.class, 6);
    System.out.println(person);
}

二、hibernate 拦截器

1、写一个继承 EmptyInterceptor 类实现相关的方法，代码如下：

package learn.hibernate.interceptor;

import java.io.Serializable;
import java.util.Arrays;
import java.util.Date;

import learn.hibernate.bean.Person;

import org.hibernate.EmptyInterceptor;
import org.hibernate.type.Type;

/**
 * 自定义拦截器
 * 在执行某个动作之前或之后加一个自己的业务操作
 * @author Administrator
 *
 */
public class MyInterceptor extends EmptyInterceptor{

    @Override
    public boolean onSave(Object entity, Serializable id, Object[] state,
            String[] propertyNames, Type[] types) {
        System.out.println("-------------拦截保存-------------");
        System.out.println("entity："+entity);
        System.out.println("id："+id);
        System.out.println("state："+Arrays.toString(state));
        System.out.println("propertyNames："+Arrays.toString(propertyNames));
        System.out.println("types："+Arrays.toString(types));

        if(entity.getClass() == Person.class){
            for(int i = 0, len = propertyNames.length; i < len; i++){
                if(propertyNames[i].equals("birthday")){
                    if(state[i]==null){
                        Person p = (Person) entity;
                        p.setBirthday(new Date());
                    }
                }
            }
        }

        return super.onSave(entity, id, state, propertyNames, types);
    }
}

以上的类实现了 EmptyInterceptor 类的 onSave() 方法，也就是说在保存数据的时候调用该方法可做相关的拦截

2、测试类代码如下：

/**
 * 批量写入数据
 */
@Test
public void testAdd(){
    // 开启拦截器(局部拦截器)
    session = factory.withOptions().interceptor(new MyInterceptor()).openSession();
    tx = session.beginTransaction();

    Person person = new Person("admin", 22, 123456, null);
    session.persist(person);

    tx.commit();
}