hibernate多条件动态查询

在hibernate框架中,常规查询方法是:

        Configuration configuration = new Configuration();
        configuration.configure();
        Session session = configuration.buildSessionFactory().getCurrentSession();
        Transaction transaction = session.beginTransaction();
        Query query = session.createQuery("from Studnet where sid=:sid");
        query.setParameter("sid", 1L);
        List<Student> students = query.list();
        for (Student student : students) {
            //得到Student对象
            System.out.println(student.getName());
        }
        transaction.commit();
    }

但是在项目中,查询条件往往有很多,某些查询条件也不能确定,如果使用上面的方法,那么就要写大量基本重复的查询方法.为了简化工作量,封装了一种通用的查询方法,将查询条件封装到一个Map＜String, Object＞集合中, 动态的生成查询语句发送给数据库得到查询结果

下面这个是查询表或者对象封装的方法．

import java.util.List;
import java.util.Map;
import java.util.Map.Entry;

import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;

public class QueryTable {

    SessionFactory sessionFactory;

    {
        Configuration configuration = new Configuration();
        configuration.configure();
        sessionFactory = configuration.buildSessionFactory();
    }

    /**
     * 单表单条记录查询
     * @param clazz
     * @param varables
     * @return
     */
    public <T> T querySingleResult(Class<T> clazz, Map<String, Object> varables){
        Session session = sessionFactory.getCurrentSession();
        Transaction transaction = session.beginTransaction();
        Query query = selectStatement(clazz, varables, session);
        return (T) query.uniqueResult();
    }

    /**
     * 单表多条记录查询
     * @param className 要查询的对象
     * @param varables 封装查询条件的map
     * @return 返回查询结果的List集合
     */
    public <T> List<T> queryResultList(Class<T> className, Map<String,Object> varables){        
        Session session = sessionFactory.getCurrentSession();
        Transaction transaction = session.beginTransaction();               
        List<T> valueList = selectStatement(className, varables, session).list();
        transaction.commit();
        return valueList;       
    }

    /**
     * 拼接SQL查询字符串,得到Query并赋值查询条件
     * @param className
     * @param varables
     * @param session
     * @return Query
     */
    private <T> Query selectStatement(Class<T> className, Map<String,Object> varables, Session session) {
        StringBuilder stringBuilder = new StringBuilder();
        /*
         * 通过className得到该实体类的字符串形式,
         */
        stringBuilder.append("from " + sessionFactory.getClassMetadata(className).getEntityName());
        stringBuilder.append(" where 1=1 ");
        /*
         * 动态的拼接sql语句,如果一个属性的值为"", 则不往条件中添加.
         */
        for(Entry<String, Object> entry : varables.entrySet()){
            if(!entry.getValue().equals("")){
                stringBuilder.append(" and " + entry.getKey()+"=:" + entry.getKey());
            }
        }

        Query query = session.createQuery(stringBuilder.toString());
        /*
         * 动态的给条件赋值
         */
        for(Entry<String, Object> entry : varables.entrySet()){
            if(!entry.getValue().equals("")){
                query.setParameter(entry.getKey(), entry.getValue());
            }
        }
        return query;
    }


}

上面一共提供了两个方法，一个返回单个结果，一个返回多个结果，Ｄｅｍｏ如下：

import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.junit.Test;

import com.ruinan.domain.Course;
import com.ruinan.domain.Student;

public class testQueryTable {

    QueryTable queryTable = new QueryTable();
    /**
     * 多个结果查询
     * @throws InstantiationException
     * @throws IllegalAccessException
     */
    @Test
    public void testQueryResultList() throws InstantiationException, IllegalAccessException {
        /*
         * 将查询条件封装到map中.
         * 例 description=www
         */
        Map<String, Object> map = new HashMap<String, Object>();
        map.put("description", "www");

//      List<Student> students = queryClass(Student.class, map);
//      for (Student student : students) {
//          System.out.println(student.getName()+ "/" + student.getDescription());
//      }
        /*
         * 得到查询结果,是一个List集合
         */
        List<Course> courses = queryTable.queryResultList(Course.class, map);
        for (Course course : courses) {
            System.out.println(course.getName());
        }
    }

    /**
     * 查询单个结果
     */
    @Test
    public void testQuerySingleResult() {
        /*
         * 将查询条件封装到map中.
         * 例 description=www
         */
        Map<String, Object> map = new HashMap<String, Object>();
        map.put("sid", 3L);
        /*
         * 得到查询结果
         */
        Student student = queryTable.querySingleResult(Student.class, map);
        System.out.println(student.getDescription());
    }
}