spring hibernate custom 封装

hibernate 里面的单词好难记，开发的时候又不能拖后腿，怎们办呢？不能一边写，一边百度查单词吧。 所以，只能偷懒，将关于hibernate的操作进行封装，封装好后，我们就可以将方法命名为我们容易记忆和理解的单词了。

hibernate.config.xml

<?xml version="1.0" encoding="utf-8" ?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:context="http://www.springframework.org/schema/context"
    xmlns:mvc="http://www.springframework.org/schema/mvc"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
    http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.1.xsd
    http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-4.1.xsd"
>
    <bean id="sessionFactory" class="org.springframework.orm.hibernate4.LocalSessionFactoryBean">

        <!-- 数据源组件注入 -->
        <property name="dataSource">
           <ref bean="mysql_driver_manager_dataSource"/>
        </property>

        <!-- hibernate 属性设置 -->
        <property name="hibernateProperties">
           <props>
                <!-- 基本配置区 -->

                <!-- 一个Hibernate Dialect类名允许Hibernate针对特定的关系数据库生成优化的SQL -->
                <prop key="hibernate.dialect">${hibernate.dialect}</prop>

                <!-- 输出所有SQL语句到控制台 -->
                <prop key="hibernate.show_sql">${hibernate.show_sql}</prop>

                <!-- 在log和console中打印出更漂亮的SQL -->
                <prop key="hibernate.format_sql">${hibernate.format_sql}</prop>

                <!-- 缓存配置区 -->

                <!-- 以频繁的读操作为代价,  优化二级缓存来最小化写操作 .  在 Hibernate3 中，这个设置对的集群缓存非常有用 ,  对集群缓存的实现而言，默认是开启的 .  取值  true|false -->
                <!-- 
                    <prop key="hibernate.cache.use_minimal_puts">${hibernate.cache.use_minimal_puts}</prop>
                -->


                <!--  允许查询缓存,  个别查询仍然需要被设置为可缓存的 .  取值  true|false  -->
                <!--
                <prop key="hibernate.cache.use_query_cache">${hibernate.cache.use_query_cache}</prop>
                -->

                <!-- 能用来完全禁止使用二级缓存.  对那些在类的映射定义中指定的类，会默认开启二级缓存 .  取值  true|false -->
                <!--
                <prop key="hibernate.cache.use_second_level_cache">${hibernate.cache.use_second_level_cache}</prop>
                -->

                <!-- 自定义实现QueryCache 接口的类名 ,  默认为内建的 StandardQueryCache.  取值  classname.of.QueryCache -->
                <!--
                <prop key="hibernate.cache.query_cache_factory">${hibernate.cache.query_cache_factory}</prop>
                -->

                <!-- 二级缓存区域名的前缀.  取值  prefix -->
                <!--
                <prop key="hibernate.cache.region_prefix">${hibernate.cache.region_prefix}</prop>
                -->

                <!-- 自定义的CacheProvider 的类名 .  取值  classname.of.CacheProvider -->
                <!--
                <prop key="hibernate.cache.provider_class">${hibernate.cache.provider_class}</prop>
                -->

                <!-- 强制Hibernate 以更人性化的格式将数据存入二级缓存 .  取值  true|false -->
                <!--
                <prop key="hibernate.cache.use_structured_entries">${hibernate.cache.use_structured_entries}</prop>
                -->
           </props>
        </property>

        <!-- 映射实体类 -->
        <property name="annotatedClasses">
            <list>
                <value>hibernate.mapping.table.Student</value>
                <value>hibernate.mapping.table.StudentClass1</value>
                <value>hibernate.mapping.table.StudentOper</value>
            </list>
        </property>
    </bean>
</beans>

接口HibernateComponent

package spring.beans.db.hibernate;

import java.sql.Connection;
import java.util.List;
import java.util.Map;

import org.hibernate.Session;
import org.hibernate.SessionFactory;

public interface HibernateComponent
{
    /**
     * 查询一条数据
     * @param String hql hql语句
     * @return Object obj 实例Object
     * */
    public Object hqlFind(String hql);

    /**
     * 查询一条数据
     * @param String hql hql语句
     * @param Map<String,Object> keyVal 映射对象
     * @return Object obj 实例Object
     * */
    public Object hqlFind(String hql,Map<String,Object> keyVal);

    /**
     * 查询多条数据
     * @param String hql hql语句
     * @return List<Object> list 实例Object List
     * */
    public List<Object> hqlQuery(String hql);

    /**
     * 查询多条数据
     * @param String hql hql语句
     * @param Map<String,Object> keyVal 映射对象
     * @return List<Object> list 实例Object List
     * */
    public List<Object> hqlQuery(String hql,Map<String,Object> keyVal);

    /**
     * 新增数据
     * @param Object obj 新增数据
     * @return boolean bol 是否新增成功
     * */
    public boolean insert(Object obj);

    /**
     * 新增数据
     * @param List<Object> list 新增数据List
     * @return boolean bol 是否新增成功
     * */
    public boolean insert(List<Object> list);

    /**
     * 删除指定数据
     * @param Object obj 删除数据
     * @return boolean bol 是否删除成功
     * */
    public boolean delete(Object obj);

    /**
     * 删除指定数据
     * @param List<Object> list 数据删除List
     * @return boolean bol 是否删除成功
     * */
    public boolean delete(List<Object> list);

    /**
     * 更新数据
     * @param Object obj 需要更新的数据
     * @return boolean bol 是否更新成功
     * */
    public boolean update(Object obj);

    /**
     * 更新数据
     * @param List<Object> list 需要更新的数据List
     * @return boolean bol 是否更新成功
     * */
    public boolean update(List<Object> list);

    /**
     * get Connection
     * */
    public Connection getConnection();

    /**
     * get Session
     * */
    public Session getSession();

    /**
     * get sessionFactory
     * */
    public SessionFactory getSessionFactory();

    /**
     * 原声sql查询 查询一条数据
     * @param String sql 原生sql查询
     * @return Object
     * */
    public Object sqlFindQuery(String sql);

    /**
     * 原声sql查询
     * @param String sql 原生sql查询
     * @param Class objClass 需要装载的数据对象class
     * @return List<Object>
     * */
    public Object sqlFindQuery(String sql,Class objClass);

    /**
     * 原声sql查询 查询一条数据
     * @param String sql 原生sql查询
     * @param Class objClass 需要装载的数据对象class
     * @param Map<String,Object> keyVal 映射关系对象
     * @return List<Object>
     * */
    public Object sqlFindQuery(String sql,Class objClass,Map<String,Object> keyVal);

    /**
     * 原声sql查询 查询list 数据集合
     * @param String sql 原生sql查询
     * @return List<Object>
     * */
    public List<Object> sqlQuery(String sql);

    /**
     * 原声sql查询 查询list 数据集合
     * @param String sql 原生sql查询
     * @param Class objClass 需要装载的数据对象class
     * @return List<Object>
     * */
    public List<Object> sqlQuery(String sql,Class objClass);

    /**
     * 原声sql查询 查询list 数据集合
     * @param String sql 原生sql查询
     * @param Class objClass 需要装载的数据对象class
     * @param Map<String,Object> keyVal 映射关系对象
     * @return List<Object>
     * */
    public List<Object> sqlQuery(String sql,Class objClass,Map<String,Object> keyVal);

    /**
     * 关闭该session
     * */
    public void closeSession();
}

HibernateRealization 对 接口 HibernateComponent 的实现

package spring.beans.db.hibernate;

import java.sql.Connection;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;

import javax.annotation.PreDestroy;

import org.hibernate.Query;
import org.hibernate.SQLQuery;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Component;

/**
 * 数据库操作服务
 * */
@Component("hibernate_db_component")
@Scope("request")
public class HibernateRealization implements HibernateComponent
{
    protected SessionFactory sessionFactory;

    protected Session session;

    public void setSession(Session session)
    {
        this.session = session;
    }

    @Override
    public Session getSession()
    {
        return session;
    }

    @Value(value="#{sessionFactory}")
    public void setSessionFactory(SessionFactory sessionFactory)
    {
        this.sessionFactory = sessionFactory;

        this.setSession(sessionFactory.openSession());
    }

    @Override
    public SessionFactory getSessionFactory()
    {
        return sessionFactory;
    }

    @Override
    public boolean insert(Object obj)
    {
        Transaction trans = null;

        boolean executeClient = true;

        try{
            trans = session.beginTransaction();

            session.save(obj);

            trans.commit();
        }catch(Exception e)
        {
            executeClient = false;

            if(trans != null)trans.rollback();
        }

        return executeClient;
    }

    @Override
    public boolean insert(List<Object> list)
    {
        Transaction trans = null;

        boolean executeClient = true;

        try{
            trans = session.beginTransaction();

            for(Object obj : list)
            {
                session.persist(obj);
            }
            trans.commit();
        }catch(Exception e)
        {
            executeClient = false;

            if(trans != null)trans.rollback();
        }

        return executeClient;
    }

    @Override
    public boolean delete(Object obj)
    {
        Transaction trans = null;

        boolean executeClient = true;

        try{
            trans = session.beginTransaction();

            session.delete(obj);

            trans.commit();
        }catch(Exception e)
        {
            executeClient = false;

            if(trans != null)trans.rollback();
        }

        return executeClient;
    }

    @Override
    public boolean delete(List<Object> list)
    {
        Transaction trans = null;

        boolean executeClient = true;

        try{
            trans = session.beginTransaction();

            for(Object obj : list)
            {
                session.delete(obj);
            }

            trans.commit();
        }catch(Exception e)
        {
            executeClient = false;

            if(trans != null)trans.rollback();
        }

        return executeClient;
    }

    @Override
    public boolean update(Object obj)
    {
        Transaction trans = null;

        boolean executeClient = true;

        try{
            trans = session.beginTransaction();

            session.update(obj);

            trans.commit();
        }catch(Exception e)
        {
            executeClient = false;

            if(trans != null)trans.rollback();
        }

        return executeClient;
    }

    @Override
    public boolean update(List<Object> list)
    {
        Transaction trans = null;

        boolean executeClient = true;

        try{
            trans = session.beginTransaction();

            for(Object obj : list)
            {
                session.update(obj);
            }

            trans.commit();
        }catch(Exception e)
        {
            executeClient = false;

            if(trans != null)trans.rollback();
        }

        return executeClient;
    }

    @Override
    public Connection getConnection()
    {
        WorkConnection work = new WorkConnection();
        session.doWork(work);
        return work.getConnection();
    }

    /**
     * 对象注销
     * */
    @PreDestroy
    public void closeDb()
    {
        closeSession();
    }

    @Override
    public Object hqlFind(String hql)
    {
        return hqlFind(hql,null);
    }

    @Override
    public Object hqlFind(String hql, Map<String, Object> keyVal)
    {
        Transaction trans = null;

        Object result;

        try{
            trans = session.beginTransaction();

            Query query = session.createQuery(hql);

            if(keyVal != null && !keyVal.isEmpty())
            {
                Set<String> keySet = keyVal.keySet();

                Iterator<String> iter = keySet.iterator();

                while(iter.hasNext())
                {
                    String key = iter.next();

                    query.setParameter(key, keyVal.get(key));
                }
            }

            result = query.uniqueResult();

            trans.commit();
        }catch(Exception e)
        {
            result = null;

            if(trans != null)trans.rollback();
        }

        return result;
    }

    @Override
    public List<Object> hqlQuery(String hql)
    {
        return hqlQuery(hql,null);
    }

    @Override
    public List<Object> hqlQuery(String hql, Map<String, Object> keyVal)
    {
        Transaction trans = null;

        List<Object> list;

        try{
            trans = session.beginTransaction();

            Query query = session.createQuery(hql);

            if(keyVal != null && !keyVal.isEmpty())
            {
                Set<String> keySet = keyVal.keySet();

                Iterator<String> iter = keySet.iterator();

                while(iter.hasNext())
                {
                    String key = iter.next();

                    query.setParameter(key, keyVal.get(key));
                }
            }
            list = query.list();

            trans.commit();
        }catch(Exception e)
        {
            list = null;

            if(trans != null)trans.rollback();
        }

        return list;
    }

    @Override
    public List<Object> sqlQuery(String sql)
    {
        return sqlQuery(sql,null,null);
    }

    @Override
    public List<Object> sqlQuery(String sql,Class objClass)
    {
        return sqlQuery(sql,objClass,null);
    }

    @Override
    public List<Object> sqlQuery(String sql,Class objClass,Map<String,Object> keyVal)
    {
        Transaction trans = null;

        List<Object> list = null;

        try{
            trans = session.beginTransaction();

            SQLQuery sqlQuery = session.createSQLQuery(sql);

            if(objClass != null)
            {
                sqlQuery.addEntity(objClass);
            }

            if(keyVal != null && !keyVal.isEmpty())
            {
                Set<String> keySet = keyVal.keySet();

                Iterator<String> iter = keySet.iterator();

                while(iter.hasNext())
                {
                    String key = iter.next();

                    sqlQuery.setParameter(key, keyVal.get(key));
                }
            }
            list = sqlQuery.list();

            trans.commit();
        }catch(Exception e)
        {
            if(trans != null) trans.rollback(); 
        }

        return list;
    }

    @Override
    public Object sqlFindQuery(String sql)
    {
        return sqlFindQuery(sql,null,null);
    }

    @Override
    public Object sqlFindQuery(String sql,Class objClass)
    {
        return sqlFindQuery(sql,objClass,null);
    }

    @Override
    public Object sqlFindQuery(String sql,Class objClass,Map<String,Object> keyVal)
    {
        Transaction trans = null;

        Object Obj = null;

        try{
            trans = session.beginTransaction();

            SQLQuery sqlQuery = session.createSQLQuery(sql);

            if(objClass != null)
            {
                sqlQuery.addEntity(objClass);
            }

            if(keyVal != null && !keyVal.isEmpty())
            {
                Set<String> keySet = keyVal.keySet();

                Iterator<String> iter = keySet.iterator();

                while(iter.hasNext())
                {
                    String key = iter.next();

                    sqlQuery.setParameter(key, keyVal.get(key));
                }
            }
            Obj = sqlQuery.uniqueResult();

            trans.commit();
        }catch(Exception e)
        {
            if(trans != null) trans.rollback(); 
        }

        return Obj;
    }

    @Override
    public void closeSession()
    {
        session.close();
    }
}