利用反射及JDBC元数据编写通用的查询方法

    public static void main(String[] args){  
            String sql = "SELECT IDCARD,examcard,"  
                    + "studentname,"  
                      
                    + "lacation LoCATION,grade "  
                    + " FROM student WHERE IDCARD = ?";  
            Student s = get(Student.class,sql,7);  
            System.out.println(s);  
        }  
      
        //String sql = "SELECT id,name,email,birth "  
    <span style="white-space:pre">    </span>//<span style="white-space:pre">         </span>+ "FROM customers WHERE id = ?";  
          
        public static <T> T get(Class<T> clazz,String sql,Object... args) {  
            T entity = null;  
      
            Connection connection = null;  
            PreparedStatement preparedStatement = null;  
            ResultSet resultSet = null;  
      
            try {  
                //1. 得到 ResultSet 对象  
                connection = JDBC_Tools.getConnection();  
                preparedStatement = connection.prepareStatement(sql);  
                for (int i = 0; i < args.length; i++) {  
                    preparedStatement.setObject(i + 1,args[i]);  
                }  
                resultSet = preparedStatement.executeQuery();  
      
                //2. 得到 ResultSetMetaData 对象  
                ResultSetMetaData rsmd = resultSet.getMetaData();  
                  
                //3. 创建一个 Map<String,Object> 对象,键: SQL 查询的列的别名,//值: 列的值  
                Map<String,Object> values = new HashMap<>();  
                  
                //4. 处理结果集. 利用 ResultSetMetaData 填充 3 对应的 Map 对象  
                if(resultSet.next()){  
                    for(int i = 0; i < rsmd.getColumnCount(); i++){  
                        //从 ResultSetMetaData 获取列的别名  
                        String columnLabel = rsmd.getColumnLabel(i + 1);  
                        //从 结果集 中获取列的值  
                        Object columnValue = resultSet.getObject(i + 1);  
                          
                        values.put(columnLabel,columnValue);  
                    }  
                }  
                //5. 若 Map 不为空集,利用反射创建 clazz 对应的对象  
                if(values.size() > 0){  
                    entity = clazz.newInstance();  
                      
                    //5. 遍历 Map 对象,利用反射为 Class 对象的对应的属性赋值.   
                    for(Map.Entry<String,Object> entry: values.entrySet()){  
                        String fieldName = entry.getKey();  
                        Object value = entry.getValue();  
                        //System.out.println(fieldName+":"+value);  
                    ReflectionUtils.setFieldValue(entity,fieldName,value); //出问题  
                        //System.out.println(ReflectionUtils.getDeclaredField(entity,fieldName));  
                    }  
                }  
            } catch (Exception e) {  
                e.printStackTrace();  
            } finally {  
                JDBC_Tools.relaseSource(resultSet,connection,preparedStatement);  
            }  
            return entity;  
        }  
    }     

    package xuezaipiao3;  
      
    import java.lang.reflect.Field;  
    import java.lang.reflect.InvocationTargetException;  
    import java.lang.reflect.Method;  
    import java.lang.reflect.Modifier;  
    import java.lang.reflect.ParameterizedType;  
    import java.lang.reflect.Type;  
      
    /** 
     * 反射的 Utils 函数集合 
     * 提供访问私有变量,获取泛型类型 Class,提取集合中元素属性等 Utils 函数 
     * @author Administrator 
     * 
     */  
    public class ReflectionUtils {  
      
          
        /** 
         * 通过反射,获得定义 Class 时声明的父类的泛型参数的类型 
         * 如: public EmployeeDao extends BaseDao<Employee,String> 
         * @param <T> 
         * @param clazz 
         * @param index 
         * @return 
         */  
        @SuppressWarnings("unchecked")  
        public static  Class getSuperClassGenricType(Class clazz,int index){  
            Type genType = clazz.getGenericSuperclass();  
              
            if(!(genType instanceof ParameterizedType)){  
                return Object.class;  
            }  
              
            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];  
        }  
          
        /** 
         * 通过反射,获得 Class 定义中声明的父类的泛型参数类型 
         * 如: public EmployeeDao extends BaseDao<Employee,String> 
         * @param <T> 
         * @param clazz 
         * @return 
         */  
        @SuppressWarnings("unchecked")  
        public static<T> Class<T> getSuperGenericType(Class<T> clazz){  
            return getSuperClassGenricType(clazz,0);  
        }  
          
        /** 
         * 循环向上转型,获取对象的 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;  
        }  
          
        /** 
         * 使 filed 变为可访问 
         * @param field 
         */  
        public static void makeAccessible(Field field){  
            if(!Modifier.isPublic(field.getModifiers())){  
                field.setAccessible(true);  
            }  
        }  
          
        /** 
         * 循环向上转型,获取对象的 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 e) {  
                    //Field 不在当前类定义,继续向上转型  
                }  
            }  
            return null;  
        }  
          
        /** 
         * 直接调用对象方法,而忽略修饰符(private,protected) 
         * @param object 
         * @param methodName 
         * @param parameterTypes 
         * @param parameters 
         * @return 
         * @throws InvocationTargetException  
         * @throws IllegalArgumentException  
         */  
        public static Object invokeMethod(Object object,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);  
              
            try {  
                return method.invoke(object,parameters);  
            } catch(IllegalAccessException e) {  
                System.out.println("不可能抛出的异常");  
            }   
              
            return null;  
        }  
          
        /** 
         * 直接设置对象属性值,忽略 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 + "]");  
              
            makeAccessible(field);  
              
            try {  
                  
                field.set(object,value);  
            } catch (IllegalAccessException e) {  
                System.out.println("不可能抛出的异常");  
            }  
        }  
          
        /** 
         * 直接读取对象的属性值,也不经过 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 (IllegalAccessException e) {  
                System.out.println("不可能抛出的异常");  
            }  
              
            return result;  
        }  
    }