Spring-hibernate-BaseDao

<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:aop="http://www.springframework.org/schema/aop"
     xmlns:tx="http://www.springframework.org/schema/tx"
     xsi:schemaLocation="http://www.springframework.org/schema/beans
         http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
         http://www.springframework.org/schema/context
         http://www.springframework.org/schema/context/spring-context-3.0.xsd
            http://www.springframework.org/schema/aop
         http://www.springframework.org/schema/aop/spring-aop.xsd
           http://www.springframework.org/schema/tx
         http://www.springframework.org/schema/tx/spring-tx.xsd">

   <!--1, 打开Spring的annotation -->
   <context:annotation-config/>
   <!-- 2, 设定Spring去那些包中找annotation -->
   <context:component-scan base-package="com.yangw.spring" />

   <!--
           使用dbcp没有成功, 加的是commons-dbcp-1.4.jar
        class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
    -->
   <bean id="dataSource"

               class="org.springframework.jdbc.datasource.DriverManagerDataSource" >
        <property name="driverClassName" value="${jdbc.driverClassName}"/>
        <property name="url" value="${jdbc.url}"/>
        <property name="username" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>
    </bean>

    <context:property-placeholder location="jdbc.properties"/> 

    <!--创建sessionFactory -->
  <bean id="sessionFactory"
        class="org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean" >
       <!-- class="org.springframework.orm.hibernate3.LocalSessionFactoryBean" -->
    <property name="dataSource" ref="dataSource"/>
    <!--  基于XML配置文件的形式
    <property name="mappingResources">
      <list>
        <value>product.hbm.xml</value>
      </list>
    </property>
    -->
    <!-- 自动去包中找hbm文件或者设置了annotation的类-->
    <property name="packagesToScan" value="com.yangw.spring.model" />
    <!-- 将hibernate配置文件放到单独的配置文件中的方式-->
    <!--
    <property name="configLocation" value="classpath:hibernate.cfg.xml" />
    -->
    <property name="hibernateProperties">
      <value>
        hibernate.dialect=org.hibernate.dialect.MySQLDialect
        hibernate.show_sql=true
        hibernate.hbm2ddl.auto=update
        hibernate.format_sql=false
      </value>
    </property>
  </bean>

    <!-- 配置Spring事务处理 -->
    <!-- 1,创建事务管理器 -->
      <bean id="transactionManager"
        class="org.springframework.orm.hibernate3.HibernateTransactionManager">
        <property name="sessionFactory" ref="sessionFactory" />
    </bean>
    <!-- 2, 配置AOP，Spring是通过AOP进行事务管理的-->
   <aop:config>
       <!-- 设置PointCut表示哪些方法要加入事务-->
    <aop:pointcut id="allMethods"
            expression="execution(* com.yangw.spring.dao.*.*(..))"/>
    <!-- 通过advisor来确定具体加入事务控制的方法 -->
    <aop:advisor advice-ref="txAdvice" pointcut-ref="allMethods"/>
  </aop:config>
    <!--3, 配置哪些方法要加入事务 -->

    <tx:advice id="txAdvice" transaction-manager="transactionManager">
        <tx:attributes>
            <tx:method name="get*" read-only="true" />
            <tx:method name="count*" read-only="true" />
            <tx:method name="is*" read-only="true" />
            <tx:method name="has*" read-only="true" />
            <!-- 所有方法都加入事务 -->
            <tx:method name="*"  />
        </tx:attributes>
    </tx:advice>
</beans>

package com.yangw.spring.dao;

import java.util.List;
/**
 * IBaseDao接口是所有Dao公共的操作
 * @author Administrator
 * @param <T>
 */
public interface IBaseDao<T> {

    public void add(T t);

    public void update(T t);

    public void delete(int id);

    public T load(int id);

    public List<T> list(String hql,Object[] args);

}

package com.yangw.spring.dao;

import java.lang.reflect.Field;
import java.lang.reflect.ParameterizedType;
import java.util.ArrayList;
import java.util.List;

import javax.annotation.Resource;

import org.hibernate.Query;
import org.hibernate.SessionFactory;
import org.springframework.orm.hibernate3.support.HibernateDaoSupport;
/**
 *
 * 把所有公共方法都写到BaseDao，所有Dao都继承 BaseDao即可，这样就实现了大量的基础方法
 * 如果Dao中有特殊的方法，再次具体的Dao中进行实现
 * @author Administrator
 *
 * @param <T>
 */
public class BaseDao<T> extends HibernateDaoSupport implements IBaseDao<T> {

    //注入SessionFactory
    @Resource(name="sessionFactory")
    public void setSuperSessionFactory(SessionFactory sessionFactory){
        super.setSessionFactory(sessionFactory);
    }

    private Class<T> entityClass;
   /**
    * 获取T对象的Class
    * @return
    */
    @SuppressWarnings({ "unused", "unchecked" })
    private Class<T> getEntityClass(){
        if(entityClass==null){
            entityClass = (Class<T>) ((ParameterizedType) getClass().getGenericSuperclass()).getActualTypeArguments()[0];
        }
        return entityClass;

    }

    @Override
    public void add(T t) {
        super.getHibernateTemplate().save(t);
    }

    @Override
    public void update(T t) {
        super.getHibernateTemplate().update(t);
    }

    @Override
    public void delete(int id) {
        //先加载对象再删除
        super.getHibernateTemplate().delete(this.load(id));
    }

    @Override
    public T load(int id) {
        return super.getHibernateTemplate().get(getEntityClass(), id);

    }

    /**
     * 这个方法的弊端：
     * 1， select * from User 这样的语句不行
     * 2， 查询结果是Object[],需要自己额外处理
     */
    @SuppressWarnings("unchecked")
    @Override
    public List<T> list(String hql, Object[] args) {

        //select * 的处理，可以利用反射来做

        Query query=this.getSession().createQuery(hql);
        for(int i=0;i<args.length;i++){
            query.setParameter(i, args[i]);
        }
        return listToBean(query.list(),hql);
    //    return query.list();
    }

    /**
     * 自己写代码，作映射
     * @param list
     * @param hql
     * @return
     */
    private  List<T> listToBean(List<Object[]> list,String hql){

        //"select "占7个长度
        String[] columns=hql.substring(7, hql.indexOf("from")).split("\\s*,\\s*");
        List<T> resultList=new ArrayList<T>();

        List<Field> fields=new ArrayList<Field>();
        //测试发现：getDeclaredField(column)获取的是基本类型值
        //测试发现：getField(column)获取的是非基本类型值
        Field[] fieldsTemp=getEntityClass().getDeclaredFields(); //获取所有的列

        //得到每次需要的列

        for(int i=0;i<fieldsTemp.length;i++){
            String temp=fieldsTemp[i].getName(); //属性名
            boolean flag=false; //假设当前这个不是要或者的属性名
            for(String column:columns){
                if(column.equals(temp)){
                    flag=true;
                    break;
                }
            }
            if(flag){
                fields.add(fieldsTemp[i]);
            }
        }

        try {
                for(int i=0;i<list.size();i++){
                    Object[] objs=list.get(i);
                    T tclass=getEntityClass().newInstance();
                    for(int j=0;j<fields.size();j++){
                        fields.get(j).setAccessible(true);
                        fields.get(j).set(tclass,objs[j]);
                    }
                    resultList.add(tclass);
                }
        } catch (SecurityException e) {
            e.printStackTrace();
        } catch (IllegalArgumentException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }

        return resultList;
    }

}

package com.yangw.spring.dao;

import com.yangw.spring.model.User;

public interface IUserDao extends IBaseDao<User>{

    //此时的IUserDao只需要写特殊的一些方法，让子类去实现
    //假设下面这个是IUserDao中的特殊方法
    public void add(User user,int gid);
}

package com.yangw.spring.dao;

import org.springframework.stereotype.Repository;

import com.yangw.spring.model.User;

@Repository("userDao")
public class UserDao extends BaseDao<User> implements IUserDao {

    @Override
    public void add(User user, int gid) {

        System.out.println("cccc");
    }

}

package com.yangw.spring.test;

import java.util.List;

import javax.annotation.Resource;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import com.yangw.spring.dao.IUserDao;
import com.yangw.spring.model.User;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("/beans.xml")
/**
 * 当使用了@RunWith,@ContextConfiguration注解之后，就可以直接在Test中进行依赖注入
 * @author Administrator
 */
public class TestHibernate {

    @Resource(name="userDao")
    private IUserDao userDao;

    @Test
    public void testAdd(){

       User user=new User();
       user.setName("zhaoliu");
       user.setAge(22);
       userDao.add(user);
    }

    @Test
    public void testLoad(){

      User user = (User) userDao.load(4);
      System.out.println(user);
    }

    @Test
    public void testList(){

      List<User> lists = userDao.list("select age, name from User where name=?", new  Object[]{"wangwu"});

      for(int i=0;i<lists.size();i++){
          System.out.println("-->"+lists.get(i).getAge());
      }
    }

}