浅谈：java泛型与dao重用

在进入今天的主题之前，我们先理解一下什么是泛型：

泛型是java中一种类型，泛型是被参数化的类型。

类型-->class

参数化-->class类型可以是任意参数

泛型存在的意义：泛型可以在编译的时候，告诉class传递的参数是什么类型，如果类型发送错误，在编译的时候，就会报错。

泛型所表现的形式：

1、java的list，set等集合所表现的。

　　　　//这里面的E表示的就是泛型，
        List<E> list = new ArrayList<E>();
        //下面传入泛型的具体实例
        List<Department> departmentList = new ArrayList<Department>();
        //这个说明，在departmentList集合中，只能存放Department这一种类型

2、在类中的体现

package cn.ygh.boke;

public interface PersonDao<T> {
    //这里的T也是泛型
}

package cn.ygh.boke;

public class PersonDaoImpl<T> implements PersonDao<T> {
    //PersonDaoImpl这个类实现了PersonDao这个泛型类，那么他就要赋值给这个泛型类的泛型传值
    /*
     * PersonDaoImpl<T>的这个泛型T相当于给PersonDao<T>的T传值
     * 总之，谁加泛型，谁给值
　　　　这种方式也是我们下面主要介绍的方式
     */
}

3、

public class Person <T extends Collection<E>>{

}

介绍了什么三种泛型的表现形式，我们在介绍一下泛型的用法：泛型可以使用在某个类的属性或者方法(包括方法的参数和返回值)上

下面我来举一个比较实用的例子：例子基于hibernate，spring框架。

需求：要求写一个泛型的dao类，完成对所有对象进行简单的增删改查。

分析：我们在使用java操作数据库，因为hibernate的操作是基于对象，而我们从数据库中获取一行数据，也是需要把这行数据变成一个对象的

如果对每个不同的对象写一个xxxDao的类，把数据库的关系模型变成java的对象模型，实在是太过麻烦，能不能就写一个类，在类里面传入泛型，

让类根据泛型，泛型一个实例对象呢？

答案是可以的。

首先我们来写一个接口BaseDao,里面有增删改查的一些方法

//在这个类中，我们引入了泛型T，代表需要返回或者操作的java对象
public interface BaseDao<T> {
    public Collection<T> getAllEntries();
    public T getEntryById(Serializable id);
    public void saveEntry(T t);
    public void updateEntry(T t);
    public void deleteEntryById(Serializable id);
}

然后我们再一个类BaseDaoImpl实现它，

import java.io.Serializable;
import java.lang.reflect.ParameterizedType;
import java.util.Collection;

import org.springframework.orm.hibernate3.HibernateTemplate;

import cn.itcast.oa.dao.base.BaseDao;

//子类里面的T是给父类里面T赋值，子类里面的T是实参，父类里面的t是形参
public class BaseDaoImpl<T> implements BaseDao<T> {

    public HibernateTemplate hibernateTemplate;
    private Class classt;//泛型的Class
    /*
     * 在父类中，要执行一段代码，执行的时间是在子类创建对象的时候，那么有两种解决方案
     * 1、使用static代码块
     * 2、利用父类的构造函数
     *
     * 分析：如果需要使用到this，那么就要使用父类的构造函数，如果不需要使用daothis，可以使用static代码块
     * 因为下面需要使用this，获取ParameterizedType，所以使用父类的构造函数
     * 如何获取泛型里面的class
     */
    public BaseDaoImpl(){//使用父类的构造函数来实现对获取泛型的Class
        //ParameterizedType,就是泛型，这里的this不是BaseDaoImpl，而是BaseDaoImpl的子类的this，
　　　　 //也就是一个类会继承BaseDaoImpl，然后通过它来获取其父类BaseDaoImpl的泛型T
        ParameterizedType type = (ParameterizedType) this.getClass().getGenericSuperclass();
        //获取到泛型的Class
        this.classt = (Class) type.getActualTypeArguments()[0];
    }

　　/* 
　　有人会问，为什么要获取泛型的Class，对应hibernate操作数据库来说，获取一个泛型的实例，需要通过泛型的Class来获取
　　说白了，没有泛型的Class,就无法获取泛型的实例对象，也就没办法返回给service层实例对象
   */
    public Collection<T> getAllEntries() {
        return this.getHibernateTemplate().find("from "+this.classt.getName());
    }

　　 //很明显的可以看出，我们的返回值使用的是T类型，不依赖任何的实例对象
    public T getEntryById(Serializable id) {
        // TODO Auto-generated method stub
        return (T) this.hibernateTemplate.get(this.classt, id);

    }
　　 //这个方法也是，下面的方法都是这个特地，我就不异议介绍了
    public void saveEntry(T t) {
        // TODO Auto-generated method stub
        this.hibernateTemplate.save(t);
    }

    public void updateEntry(T t) {
        // TODO Auto-generated method stub
        this.hibernateTemplate.update(t);
    }

    public void deleteEntryById(Serializable id) {
        T t = this.getEntryById(id);
        this.getHibernateTemplate().delete(t);

    }

    public HibernateTemplate getHibernateTemplate() {
        return hibernateTemplate;
    }

    public void setHibernateTemplate(HibernateTemplate hibernateTemplate) {
        this.hibernateTemplate = hibernateTemplate;
    }
}

下面来具体实现这个类，首先我们创建一个JavaBean:Department

import java.io.Serializable;
import java.util.Set;

public class Department implements Serializable{

    private Long did;//部门id
    private String dname;//部门名称
    private String description;//部门描述
    private Set<User> users;//部门里面所有的用户

    public Long getDid() {
        return did;
    }
    public void setDid(Long did) {
        this.did = did;
    }
    public String getDname() {
        return dname;
    }
    public void setDname(String dname) {
        this.dname = dname;
    }
    public String getDescription() {
        return description;
    }
    public void setDescription(String description) {
        this.description = description;
    }
    public Set<User> getUsers() {
        return users;
    }
    public void setUsers(Set<User> users) {
        this.users = users;
    }

}

创建一个接口DepartmentDao<T>接口，里面有对Department操作的方法，让它继承BaseDao<T>这个接口

import java.io.Serializable;
import java.util.Collection;

import cn.itcast.oa.dao.base.BaseDao;
import cn.itcast.oa.domain.Department;

public interface DepartmentDao<T> extends BaseDao<T>{
     //对department操作的各种方法
    public void saveDepartment(Department department);
    public void updateDepartment(Department department);
    public void deleteDepartmentById(Serializable id,String deleteMode);
    public Collection<Department> getAllDepartments();
    public Department getDepartmentById(Serializable id);
}

在创建DepartmentDao的一个子类DepartmentDaoImpl，实现DepartmentDao，继承BaseDaoImpl，把泛型传递过去

这样这个DepartmentDaoImpl，就可以操作对department的增删改查(只是简单的实现)。

到这里，我们可以发现，BaseDaoImpl<Department> 和DepartmentDao<Department>可以无限次重用，只要往这两个类传递泛型

那么就可以直接完成对泛型对象的增删改查的操作。

import java.io.Serializable;
import java.util.Collection;
import java.util.Set;

import org.springframework.orm.hibernate3.support.HibernateDaoSupport;

import cn.itcast.oa.dao.DepartmentDao;
import cn.itcast.oa.dao.base.impl.BaseDaoImpl;
import cn.itcast.oa.domain.Department;
import cn.itcast.oa.domain.User;
import cn.itcast.oa.utils.DeleteModel;

//传递泛型
public class DepartmentDaoImpl extends BaseDaoImpl<Department> implements DepartmentDao<Department>{

    public void saveDepartment(Department department) {
        //直接使用父类的泛型方法进行操作
        // TODO Auto-generated method stub
        this.saveEntry(department);
    }

    public void updateDepartment(Department department) {
        //直接使用父类的泛型方法进行操作
        // TODO Auto-generated method stub
        this.updateEntry(department);
    }

    public void deleteDepartmentById(Serializable id,String deleteMode) {
        // TODO Auto-generated method stub
        Department department = (Department) this.getHibernateTemplate().get(Department.class, id);
        if(DeleteModel.DEL.equals(deleteMode)){
            this.getHibernateTemplate().delete(department);
        }else if(DeleteModel.DEL_PRE_RELEASE.equals(deleteMode)){
            Set<User> users = department.getUsers();
            for(User user:users){
                user.setDepartment(null);//解除关系
            }
            this.getHibernateTemplate().flush();
            this.getHibernateTemplate().delete(department);
        }else{//进行级联删除
            Set<User> users = department.getUsers();
            for(User user:users){
                user.setDepartment(null);//解除关系部门关系
                user.setPosts(null);//解除岗位关系
                this.getHibernateTemplate().flush();
                this.getHibernateTemplate().delete(user);
            }
            //删除部门
            this.getHibernateTemplate().delete(department);
        }

    }

    public Collection<Department> getAllDepartments() {
        //直接使用父类的泛型方法进行操作
        return this.getAllEntries();
    }

    public Department getDepartmentById(Serializable id) {
        //直接使用父类的泛型方法进行操作
        return this.getEntryById(id);
    }

}

泛型的知识到这里就已经结束了，下面赋上hibernate配置文件和spring配置文件，让大家可以更好的理解

Department.hbm.xml:Department的映射文件

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">

<hibernate-mapping>
    <class name="cn.itcast.oa.domain.Department" table="department">
        <id name="did" type="java.lang.Long" length="5">
            <generator class="increment"></generator>
        </id>
        <property name="dname" type="java.lang.String" length="20"></property>
        <property name="description" type="java.lang.String" length="500"></property>
        <set name="users" inverse="true">
            <key>
                <column name="did"></column>
            </key>
            <one-to-many class="cn.itcast.oa.domain.User"/>
        </set>
    </class>
</hibernate-mapping>

applicationContext.xml：spring的总的配置文件

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:aop="http://www.springframework.org/schema/aop"
    xmlns:context="http://www.springframework.org/schema/context"
    xmlns:tx="http://www.springframework.org/schema/tx"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
           http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
           http://www.springframework.org/schema/aop
           http://www.springframework.org/schema/aop/spring-aop-2.5.xsd
           http://www.springframework.org/schema/context
               http://www.springframework.org/schema/context/spring-context-2.5.xsd
               http://www.springframework.org/schema/tx
               http://www.springframework.org/schema/tx/spring-tx-2.5.xsd">
       <!-- 导入其他的spring配置文件-->
    <import resource="applicationContext-db.xml"/>
    <import resource="applicationContext-person.xml"/>
    <import resource="applicationContext-department.xml"/>
</beans>

applicationContext-db.xml：spring的关于hibernate和数据库的配置文件

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:aop="http://www.springframework.org/schema/aop"
    xmlns:context="http://www.springframework.org/schema/context"
    xmlns:tx="http://www.springframework.org/schema/tx"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
           http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
           http://www.springframework.org/schema/aop
           http://www.springframework.org/schema/aop/spring-aop-2.5.xsd
           http://www.springframework.org/schema/context
               http://www.springframework.org/schema/context/spring-context-2.5.xsd
               http://www.springframework.org/schema/tx
               http://www.springframework.org/schema/tx/spring-tx-2.5.xsd">

        <bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
            <property name="configLocation">
                <value>classpath:hibernate/hibernate.cfg.xml</value>
            </property>
        </bean>
        <bean id="transactionManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager">
            <property name="sessionFactory">
                <ref bean="sessionFactory"/>
            </property>
        </bean>

        <bean id="hibernateTemplate" class="org.springframework.orm.hibernate3.HibernateTemplate">
            <property name="sessionFactory">
                <ref bean="sessionFactory"/>
            </property>
        </bean>

        <tx:advice transaction-manager="transactionManager" id="tx">
            <tx:attributes>
                <tx:method name="save*" read-only="false"/>
                <tx:method name="update*" read-only="false"/>
                <tx:method name="delete*" read-only="false"/>
                <tx:method name="*" read-only="true"/>
            </tx:attributes>
        </tx:advice>

        <aop:config>
            <aop:pointcut expression="execution(* cn.itcast.oa.service.impl.*.*(..))" id="perform"/>
            <aop:advisor advice-ref="tx" pointcut-ref="perform"/>
        </aop:config>

        <!-- <bean id="baseDdaoImpl" class="cn.itcast.oa.dao.base.impl.BaseDaoImpl" abstract="true">
             <property name="hibernateTemplate">
                 <ref bean="hibernateTemplate"/>
             </property>
         </bean> -->
</beans>

applicationContext-department.xml：spring的关于department的配置文件。

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:aop="http://www.springframework.org/schema/aop"
    xmlns:context="http://www.springframework.org/schema/context"
    xmlns:tx="http://www.springframework.org/schema/tx"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
           http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
           http://www.springframework.org/schema/aop
           http://www.springframework.org/schema/aop/spring-aop-2.5.xsd
           http://www.springframework.org/schema/context
               http://www.springframework.org/schema/context/spring-context-2.5.xsd
               http://www.springframework.org/schema/tx
               http://www.springframework.org/schema/tx/spring-tx-2.5.xsd">
         <bean id="departmentDao" class="cn.itcast.oa.dao.impl.DepartmentDaoImpl">
             <property name="hibernateTemplate">
                 <ref bean="hibernateTemplate"/>
             </property>
         </bean>

         <bean id="departmentService" class="cn.itcast.oa.service.impl.DepartmentServiceImpl">
             <property name="departmentDao">
                 <ref bean="departmentDao"/>
             </property>
         </bean>
         <bean id="departmentAction" class="cn.itcast.oa.struts.action.DepartmentAction" scope="prototype">
             <property name="departmentService">
                 <ref bean="departmentService"/>
             </property>
         </bean>

</beans>

希望对大家有帮助。