##前言

這兩天在看以前寫的ssh專案時，遇到一個問題就是封裝的BaseDaoImpl抽象類，構造方法裡面是這樣寫的

	Class<T> clazz;

	public BaseDaoImpl(){
		ParameterizedType pt = (ParameterizedType)getClass().getGenericSuperclass();
		clazz = (Class<T>)pt.getActualTypeArguments()[0];
	}

當時看到還真不知道里面到底是什麼意思，記得以前寫時是參考網上寫的 ，於是我只有再去網上找答案了，一番搜尋終於知道了。

##ParameterizedType

• getClass().getGenericSuperclass()
  返回表示此 Class 所表示的實體（類、介面、基本型別或 void）的直接超類的 Type，然後將其轉換ParameterizedType。
• getActualTypeArguments()
  返回表示此型別實際型別引數的 Type 物件的陣列。[0]就是這個陣列中第一個了。簡而言之就是獲得超類的泛型引數的實際型別。

看意思可能不是很懂，我們直接看例子

package com.chen.demo;

import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;

class param<T1, T2> {  
	
    class A {}  
    class B extends A {}  
      
    private Class<T1> entityClass;  
    public param (){  
        Type type = getClass().getGenericSuperclass();  
        System.out.println("getClass() == " + getClass());  
        System.out.println("type = " + type);  
        Type trueType = ((ParameterizedType)type).getActualTypeArguments()[0];  
        System.out.println("trueType1 = " + trueType);  
        trueType = ((ParameterizedType)type).getActualTypeArguments()[1];  
        System.out.println("trueType2 = " + trueType);  
        this.entityClass = (Class<T1>)trueType;  
        System.out.println("entityClass = " + entityClass);
        
        B t = new B();  
        type = t.getClass().getGenericSuperclass();  
      
        System.out.println("A is B's super class :" + ((ParameterizedType)type).getActualTypeArguments().length);  
    }  
      
}  

public class ClassDemo extends param<MyClass, MyInvoke>{
	public static void main(String[] args) {
		ClassDemo classDemo = new ClassDemo();
	}
}


package com.chen.demo;

public class MyClass {

}

package com.chen.demo;

public class MyInvoke {

}


 

我們再看列印結果

getClass() == class com.chen.demo.ClassDemo
type = com.chen.demo.param<com.chen.demo.MyClass, com.chen.demo.MyInvoke>
trueType1 = class com.chen.demo.MyClass
trueType2 = class com.chen.demo.MyInvoke
entityClass = class com.chen.demo.MyInvoke
A is B's super class :0

從上面結果我們可以總結如下，通過ParameterizedType獲取泛型引數Class型別，然後我們就可以通過Class幹一系列事情了。。。。。

比如資料庫基本CRUD的工具類，直接看工具程式碼如下：

public abstract class BaseDaoImpl<T> extends HibernateDaoSupport implements BaseDao<T> {

	Class<T> clazz;
	
	public BaseDaoImpl(){
		//getClass().getGenericSuperclass()返回表示此 Class 
		//所表示的實體（類、介面、基本型別或 void）的直接超類的 Type
		//然後將其轉換ParameterizedType
		//getActualTypeArguments()返回表示此型別實際型別引數的 Type 物件的陣列
		//[0]就是這個陣列中第一個了。
		
		ParameterizedType pt = (ParameterizedType)getClass().getGenericSuperclass();
		clazz = (Class<T>)pt.getActualTypeArguments()[0];
	}
	
	@Override
	public void save(T entity) {
		getHibernateTemplate().save(entity);
	}

	@Override
	public void delete(Serializable id) {
		getHibernateTemplate().delete(findObjectById(id));
	}

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

	@Override
	public T findObjectById(Serializable id) {
		return getHibernateTemplate().get(clazz, id);
	}

	@Override
	public List<T> findObjects() {
		Query query = (Query) getSession().createQuery("from " + clazz.getSimpleName());
		return query.list();
	}
	
	@Override
	public List<T> findObjects(QueryHelper queryHelper){
		Query listQuery = getSession().createQuery(queryHelper.getHql());
		List<Object> parameters = queryHelper.getParameters();
		
		if(parameters != null){
			for(int i = 0; i<parameters.size(); i++){
				listQuery.setParameter(i, parameters.get(i));
			}
		}
		return listQuery.list();
	}

工具類用到了Spring的orm模組，其次我們最重用的就是可以通過ParameterizedType封裝通用的CRUD工具類，在實際的專案中，我們讓不同的業務模組繼承至該工具類，然後就可以直接使用其CRUD方法了。

##參考