JDBC----ReflectionUtils

1.如何利用反射的机制得到泛型的类型的理解：  注意反射时候 新建的对象的属性名 与反射时候的反射字符串必须保持一致

package com.tetsReflection;

/**JDBC 查询得到属性字段 反射机制返回到 JavaBean中相同类属性名的对象中
 * */
import java.lang.reflect.*;
public class ReflectionUtils {

    /**
     * 使 filed 变为可访问
     * @param field
     */
    public static void makeAccessible(Field field){
        if(!Modifier.isPublic(field.getModifiers())){
            field.setAccessible(true);
        }
    }
    /**
     * 直接设置对象的属性，忽略 private/protected 修饰符, 也不经过 setter
     * @param object
     * @param fieldName 属性名称
     * @param value*/
    public static void setFieldValue(Object object, String fieldName, Object value){
    
         Field field=getDeclaredField(object,fieldName);
         if(field==null)
                throw new IllegalArgumentException("Could not find field [" + fieldName + "] on target [" + object + "]");
        
         // 让 private 元素变得可以访问,field.setAccessible();
         makeAccessible(field);
         
         try {
            field.set(object, value);
        } catch (IllegalArgumentException | IllegalAccessException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
    
    /**
     * 循环向上转型, 获取对象的 DeclaredField
     * @param object
     * @param filedName
     * @return
     */
    public static Field getDeclaredField(Object object, String filedName)
    {
        // 一步步的循环得到 获取声明对象的祖宗类
        for(Class<?> superClass=object.getClass() ; superClass!=Object.class;superClass=superClass.getSuperclass())
        {
               try {
                return superClass.getDeclaredField(filedName);
            } catch (NoSuchFieldException | SecurityException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
        return null;
    }
    
    /**
     * 直接读取对象的属性值, 忽略 private/protected 修饰符, 也不经过 getter
     * @param object
     * @param fieldName
     * @return
     */
    public static Object getFieldValue(Object object, String fieldName){
        Field field=getDeclaredField(object,fieldName);
        
        if (field == null)
            throw new IllegalArgumentException("Could not find field [" + fieldName + "] on target [" + object + "]");
        
        makeAccessible(field);
        Object result=null;
        
        try {
            result=field.get(object);
        } catch (IllegalArgumentException | IllegalAccessException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return result;
    }
    /**
     * 循环向上转型, 获取对象的 DeclaredMethod
     * @param object
     * @param methodName
     * @param parameterTypes: 指定特定成员方法有重载可能性，必须指定特定的类型变量
     * @return
     */
    public static Method getDeclaredMethod(Object object, String methodName, Class<?>[] parameterTypes)
    {
        for(Class<?> superClass = object.getClass(); superClass != Object.class; superClass = superClass.getSuperclass()){
            try {
                //superClass.getMethod(methodName, parameterTypes);
                return superClass.getDeclaredMethod(methodName, parameterTypes);
            } catch (NoSuchMethodException e) {
                //Method 不在当前类定义, 继续向上转型
            }
            //..
        }
        
        return null;
    }
    /**
     * 直接调用对象方法, 而忽略修饰符(private, protected)
     * @param object
     * @param methodName
     * @param parameterTypes
     * @param parameters
     * @return
     * @throws InvocationTargetException 
     * @throws IllegalArgumentException 
     */
    public static Object invokeMethod(Object object, String methodName, Class<?> [] parameterTypes,
            Object [] parameters) throws InvocationTargetException{
        Method method=getDeclaredMethod(object,methodName, parameterTypes);
        
        if(method==null)
            throw new IllegalArgumentException("Could not find method [" + methodName + "] on target [" + object + "]");
        method.setAccessible(true);
        
        // 使用 method.invoke()方法进行运行
        try {
            method.invoke(object, parameters);
        } catch (IllegalAccessException | IllegalArgumentException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return method;
    }
    
    /**
     * 通过反射, 获得定义 Class 时声明的父类的泛型参数的类型
     * 如: public EmployeeDao extends BaseDao<Employee, String>
     * @param clazz
     * @param index
     * @return
     */
    public static Class getSuperClassGenricType(Class clazz,int index)
    {
        Type genType=clazz.getGenericSuperclass();
        
        // 判定s是否是ParameterType相对应的
        if(!(genType instanceof  ParameterizedType) )
            return Object.class;
        
        // 强制转换 获取超类泛型参数实际类型，返回genType 是类的接口，基本类型或者void
        Type []params=((ParameterizedType)genType).getActualTypeArguments();
        
        if(index>=params.length || index<0)
            return Object.class;
        
        if(!(params[index] instanceof Class))
            return Object.class;
        return (Class) params[index];
    }
}

 2.

package com.atguigu.mvcapp;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.util.HashMap;
import java.util.Map;

import org.junit.Test;

public class JDBCTest {

    @Test
    public void testGet()
    {
        String sql=null;
        sql="select id studentid,username studentname,address studentaddress,phone studentphone from EMP where id=?";
        
        Student student=get(Student.class,sql,2);
        System.out.println(student);
        
    }
    public <T> T get(Class <T>clazz,String sql,Object...args)
    {
        // 不清楚对象是什么 
        T entiry=null;
        Connection conn=null;
        PreparedStatement ps=null;
        ResultSet rs=null;
        
        try {
             conn=JDBCUtils.getMysqlConn();
             
             ps=conn.prepareStatement(sql);
             
             for(int i=0;i<args.length;i++)
                {
                    ps.setObject(i+1,args[i]);
                    
                }
             rs=ps.executeQuery();
             
             // 将 rs 的属性存储到Map 对象
             Map<String,Object> map=new HashMap<String,Object>();
             
            while(rs.next())
             {
                 entiry= clazz.newInstance();
                 
                 // 不清楚从SQL 返回几个字段 采用SQL语句解析选择哪些列 
                 // 得到对哪些属性进行赋值
                 
                 // 1. 得到SQLMetaData columnname;数据库别名与类的属性对应
                 ResultSetMetaData rsmd=rs.getMetaData();
                 
                 int countCoumn=rsmd.getColumnCount();
                 // 每一条记录就是一个对象，rs.next()多条记录就有多个对象
                 for(int i=0;i<countCoumn;i++)
                 {
                     String columnLabel=rsmd.getColumnLabel(i+1);
                     Object columnValue=rs.getObject(i+1);
                     map.put(columnLabel, columnValue);
                 }
             }
                 // 利用反射机制进行 创建新的对象
                 if(!map.isEmpty())
                 {
                    
                     for(Map.Entry<String, Object> entiry1:map.entrySet())
                     {
                           String property=entiry1.getKey();
                            Object value=entiry1.getValue();
                            // c测试打印一下
                            System.out.println(property +": "+value);
                            // 注意 反射时 属性名反射的value 保持一致
                            ReflectionUtils.setFieldValue(entiry,property, value);
                     }
                 }
             
             
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        finally{
            JDBCUtils.closeMysql(rs, ps, conn);
        }
        return entiry;
        
    
        
    }
}

 3. getClass（）--这是一个非静态的方法得到Class clazz---

问题一：反射过程中 如果不知道 原先类，怎么样去确定clazz=***.class

    由于 反射条件中Class clazz=Person.class，写DAO中事先不清楚clazz属于什么类型的.clazz ，下面的构造器中 初始化过程中 确定 clazz=***.class

   知识：

         我们一般使用对象简介的继承Object类，在Object类中包含一个 getClass的方法，利用这个方法获取一个实体的类型类，类型类 表示这个实体属于哪个类，  同时所有的类型类都是 Class类的实体， getClass()获取本子类属于的类型

Type surperclass= getClass().getGenericSuperclass();
     //// getClass() 表示本子类,得到父类的泛型
     if(surperclass instanceof ParameterizedType)
     {
         ParameterizedType param=(ParameterizedType)surperclass;
         Type[] typeargs=param.getActualTypeArguments();
         
         if(typeargs!=null && typeargs.length>0 )
         {
              if(typeargs[0] instanceof Class)
                  this.clazz=(Class<T>) typeargs[0];
         }
     }