Java反射机制

1 、什么是Java反射机制

要让Java程序能够运行，就得让Java类被JVM加载。Java类如果不被JVM加载就不能正常运行。正常情况下，我们运行的所有的程序在编译期时候就已经把那个类被加载了。

但是在Java运行时环境中，对于任意一个类，能否知道这个类有哪些属性和方法？对于任意一个对象，能否调用它的任意一个方法？答案是肯定的。这种动态获取类的信息以及动态调用对象的方法的功能来自于Java 反射（Reflection）机制。

Java反射机制容许程序在运行时加载、探知、使用编译期间完全未知的classes。

换言之，Java可以加载一个运行时才得知名称的class，获得其完整结构。

2 、Java 反射机制主要提供了以下功能：

在运行时判断任意一个对象所属的类。
在运行时构造任意一个类的对象。
在运行时判断任意一个类所具有的成员变量和方法。
在运行时调用任意一个对象的方法。
在运行时新建新类对象

3 、Java反射机制API

在JDK中，主要由以下类来实现Java反射机制，这些类都位于java.lang.reflect包中：

Class类：代表一个类。
Field 类：代表类的成员变量（成员变量也称为类的属性）。
Method类：代表类的方法。
Constructor 类：代表类的构造方法。
Array类：提供了动态创建数组，以及访问数组的元素的静态方法。

通过Class类获取成员变量、成员方法、接口、超类、构造方法等

在java.lang.Object 类中定义了getClass()方法，因此对于任意一个Java对象，都可以通过此方法获得对象的类型。Class类是Reflection API 中的核心类，它有以下方法

getName()：获得类的完整名字。

getFields()：获得类的public类型的属性。

getDeclaredFields()：获得类的所有属性。

getMethods()：获得类的public类型的方法。

getDeclaredMethods()：获得类的所有方法。

getMethod(String name, Class[] parameterTypes)：获得类的特定方法，name参数指定方法的名字，parameterTypes 参数指定方法的参数类型。

getConstructors()：获得类的public类型的构造方法。

getConstructor(Class[] parameterTypes)：获得类的特定构造方法，parameterTypes 参数指定构造方法的参数类型。

newInstance()：通过类的不带参数的构造方法创建这个类的一个对象。

//下面给出一个综合运用的例子：public class RefConstructor {    public static void main(String args[]) throws Exception {        RefConstructor ref = new RefConstructor();        ref.getConstructor();    }    public void getConstructor() throws Exception {        Class c = null;        c = Class.forName("java.lang.Long");        Class cs[] = {java.lang.String.class};        System.out.println("\n-------------------------------\n");        Constructor cst1 = c.getConstructor(cs);        System.out.println("1、通过参数获取指定Class对象的构造方法：");        System.out.println(cst1.toString());        Constructor cst2 = c.getDeclaredConstructor(cs);        System.out.println("2、通过参数获取指定Class对象所表示的类或接口的构造方法：");        System.out.println(cst2.toString());        Constructor cst3 = c.getEnclosingConstructor();        System.out.println("3、获取本地或匿名类Constructor 对象，它表示基础类的立即封闭构造方法。");        if (cst3 != null) System.out.println(cst3.toString());        else System.out.println("-- 没有获取到任何构造方法！");        Constructor[] csts = c.getConstructors();        System.out.println("4、获取指定Class对象的所有构造方法：");        for (int i = 0; i < csts.length; i++) {            System.out.println(csts[i].toString());        }        System.out.println("\n-------------------------------\n");        Type types1[] = c.getGenericInterfaces();        System.out.println("1、返回直接实现的接口：");        for (int i = 0; i < types1.length; i++) {            System.out.println(types1[i].toString());        }        Type type1 = c.getGenericSuperclass();        System.out.println("2、返回直接超类：");        System.out.println(type1.toString());        Class[] cis = c.getClasses();        System.out.println("3、返回超类和所有实现的接口：");        for (int i = 0; i < cis.length; i++) {            System.out.println(cis[i].toString());        }        Class cs1[] = c.getInterfaces();        System.out.println("4、实现的接口");        for (int i = 0; i < cs1.length; i++) {            System.out.println(cs1[i].toString());        }        System.out.println("\n-------------------------------\n");        Field fs1[] = c.getFields();        System.out.println("1、类或接口的所有可访问公共字段：");        for (int i = 0; i < fs1.length; i++) {            System.out.println(fs1[i].toString());        }        Field f1 = c.getField("MIN_VALUE");        System.out.println("2、类或接口的指定已声明指定公共成员字段：");        System.out.println(f1.toString());        Field fs2[] = c.getDeclaredFields();        System.out.println("3、类或接口所声明的所有字段：");        for (int i = 0; i < fs2.length; i++) {            System.out.println(fs2[i].toString());        }        Field f2 = c.getDeclaredField("serialVersionUID");        System.out.println("4、类或接口的指定已声明指定字段：");        System.out.println(f2.toString());        System.out.println("\n-------------------------------\n");        Method m1[] = c.getMethods();        System.out.println("1、返回类所有的公共成员方法：");        for (int i = 0; i < m1.length; i++) {            System.out.println(m1[i].toString());        }        Method m2 = c.getMethod("longValue", new Class[]{});        System.out.println("2、返回指定公共成员方法：");        System.out.println(m2.toString());    }}

运行时复制对象

示例：ReflectTester类有一个copy(Object object)方法，这个方法能够创建一个和参数object 同样类型的对象，然后把object对象中的所有属性拷贝到新建的对象中，并将它返回
这个例子只能复制简单的JavaBean，假定JavaBean 的每个属性都有public 类型的getXXX()和setXXX()方法。

public class ReflectTester {    public Object copy(Object object) throws Exception {        // 获得对象的类型        Class<?> classType = object.getClass();        System.out.println("Class:" + classType.getName());        // 通过默认构造方法创建一个新的对象        Object objectCopy = classType.getConstructor(new Class[]{}).newInstance(new Object[]{});        // 获得对象的所有属性        Field fields[] = classType.getDeclaredFields();        for (int i = 0; i < fields.length; i++) {            Field field = fields[i];            String fieldName = field.getName();            String firstLetter = fieldName.substring(0, 1).toUpperCase();            // 获得和属性对应的getXXX()方法的名字            String getMethodName = "get" + firstLetter + fieldName.substring(1);            // 获得和属性对应的setXXX()方法的名字            String setMethodName = "set" + firstLetter + fieldName.substring(1);            // 获得和属性对应的getXXX()方法            Method getMethod = classType.getMethod(getMethodName, new Class[]{});            // 获得和属性对应的setXXX()方法            Method setMethod = classType.getMethod(setMethodName, new Class[]{field.getType()});            // 调用原对象的getXXX()方法            Object value = getMethod.invoke(object, new Object[]{});            System.out.println(fieldName + ":" + value);            // 调用拷贝对象的setXXX()方法            setMethod.invoke(objectCopy, new Object[]{value});        }        return objectCopy;    }    public static void main(String[] args) throws Exception {        Customer customer = new Customer("Tom", 21);        customer.setId(new Long(1));        Customer customerCopy = (Customer) new ReflectTester().copy(customer);        System.out.println("Copy information:" + customerCopy.getId() + " " + customerCopy.getName() + " "                + customerCopy.getAge());    }}class Customer {    private Long id;    private String name;    private int age;    public Customer() {    }    public Customer(String name, int age) {        this.name = name;        this.age = age;    }    public Long getId() {        return id;    }    public void setId(Long id) {        this.id = id;    }    public String getName() {        return name;    }    public void setName(String name) {        this.name = name;    }    public int getAge() {        return age;    }    public void setAge(int age) {        this.age = age;    }}

输出结果：

Class:com.langsin.reflection.Customer
id:1
name:Tom
age:21
Copy information:1 Tom 21

解说：
ReflectTester 类的copy(Object object)方法依次执行以下步骤
（1）获得对象的类型：
Class classType=object.getClass();
System.out.println(“Class:”+classType.getName());

（2）通过默认构造方法创建一个新对象：
Object objectCopy=classType.getConstructor(new Class[]{}).newInstance(new Object[]{});
以上代码先调用Class类的getConstructor()方法获得一个Constructor 对象，它代表默认的构造方法，然后调用Constructor对象的newInstance()方法构造一个实例。

（3）、获得对象的所有属性：
Field fields[]=classType.getDeclaredFields();
Class 类的getDeclaredFields()方法返回类的所有属性，包括public、protected、默认和private访问级别的属性

（4）获得每个属性相应的getXXX()和setXXX()方法，然后执行这些方法，把原来对象的属性拷贝到新的对象中

思考：4、Java反射机制好在哪里？

增加程序的灵活性

为什么要用反射机制？直接创建对象不就可以了吗?

这就涉及到了动态与静态的概念

• 静态编译：在编译时确定类型，绑定对象,即通过。
• 动态编译：运行时确定类型，绑定对象。动态编译最大限度发挥了java的灵活性，体现了多态的应用，有以降低类之间的藕合性。

一句话，反射机制的优点就是可以实现动态创建对象和编译，体现出很大的灵活性，特别是在J2EE的开发中.它的灵活性就表现的十分明显。

• 比如，一个大型的软件，不可能一次就把把它设计的很完美，当这个程序编译后，发布了，当发现需要更新某些功能时，我们不可能要用户把以前的卸载，再重新安装新的版本，假如这样的话，这个软件肯定是没有多少人用的。采用静态的话，需要把整个程序重新编译一次才可以实现功能的更新，而采用反射机制的话，它就可以不用卸载，只需要在运行时才动态的创建和编译，就可以实现该功能。

• 它的缺点是对性能有影响。使用反射基本上是一种解释操作，我们可以告诉JVM，我们希望做什么并且它满足我们的要求。这类操作总是慢于只直接执行相同的操作。

JDBC上的使用

Class.forName(“com.mysql.jdbc.Driver.class”).newInstance();

在使用jdbc时侯，在编写访问数据库时写到想吐，有八个表，每个表都有增删改查中操作那时候还不知道有反射机制这个概念，所以就对不同的表创建不同的dao类,这样不仅开发速率低，而且代码冗余的厉害，最要命的是看着差不多的，然后直接复制修改，由于容易犯各种低级的错误（大小写啊，多一个或少一个字母啊……）,一个错误就可以让你找半天。

有了java反射机制，什么都好办了，只需要写一个dao类，四个方法，增删改查，传入不同的对象，就OK啦，无需为每一个表都创建dao类，反射机制会自动帮我们完成剩下的事情，这就是它的好处。说白了，反射机制就是专门帮我们做那些重复的有规则的事情，所以现在很多的自动生成代码的软件就是运用反射机制来完成的

数据连接类：

/** * 数据连接类 */public class UtilDao {    static Properties properties = null;    public UtilDao(){        //读取属性文件        properties = new Properties();        java.io.InputStream in = (java.io.InputStream) this.getClass()                .getResourceAsStream("/mysqlDB.properties");        try {            properties.load(in);        } catch (IOException ex) {              System.out.println(ex.getMessage());            ex.printStackTrace();        }    }    public Connection getConn(){        Connection connection = null;        try{            Class.forName(properties.getProperty("DBDriver"));            connection = DriverManager.getConnection(properties.getProperty("url"),properties.getProperty("name"),properties.getProperty("pass"));        }catch (Exception err) {            System.out.println("连接ConDB-->getCon()____JDBC错误!");            err.printStackTrace();              return null;           }        return connection;    }    /**     * 以下是关闭重载方法     */    public void closeAll(ResultSet rs,Statement st ,CallableStatement cs ,Connection conn) throws SQLException{        if(rs!=null){            rs.close();        }        if(st!=null){            st.close();        }        if(cs!=null){            cs.close();        }        if(conn!=null){              conn.close();        }    }    public void closeAll(ResultSet rs,Statement st,Connection conn) throws SQLException{        if(rs!=null){            rs.close();        }        if(st!=null){            st.close();        }        if(conn!=null){              conn.close();        }    }    public void closeAll(ResultSet rs,PreparedStatement ps,Connection conn) throws SQLException{        if(rs!=null){            rs.close();        }        if(ps!=null){            ps.close();        }        if(conn!=null){              conn.close();        }      }    public void closeAll(PreparedStatement ps,Connection conn) throws SQLException{        if(ps!=null){            ps.close();        }        if(conn!=null){              conn.close();        }      }    public void closeAll(Statement st,Connection conn) throws SQLException{        if(st!=null){            st.close();        }        if(conn!=null){              conn.close();        }      }    public void closeAll(Connection conn) throws SQLException{        if(conn!=null){              conn.close();        }      }}

属性文件

DBDriver=com.mysql.jdbc.Driverurl=jdbc\:mysql\://localhost\:3306/hzwname=rootpass=rootcharacterEncoding=utf8

数据层接口：

/** * 访问数据方法接口 */@SuppressWarnings("unchecked")public interface IDao<T> {    /**     * 分页查询方法     * @param objClass 类对象     * @param sql 查询语句     * @param params 参数     * @return 分页数据     * @throws Exception     */    public List<T> findList(Object objClass,String sql, List params)throws Exception;    /**     * 查询一条数据     * @param objClass 类对象     * @param sql 查询语句     * @param params 参数     * @return 一条数据信息     * @throws Exception     */    public T findInfo(Object objClass,String sql ,List params)throws Exception;}

数据层接口实现：

/** * 访问数据方法实现类 */@SuppressWarnings({"unchecked","unused"})public class DaoImpl<T> implements IDao<T> {    private UtilDao dao = new UtilDao();    private Connection conn = null;    private ResultSet rs = null;    private PreparedStatement ps = null;    /*     * 查询一条数据     */    public T findInfo(Object objClass,String sql, List params) throws Exception {        Class c = objClass.getClass();         try{            conn = dao.getConn();            ps = conn.prepareStatement(sql);            for (int i = 0; i < params.size(); i++) {                if(params.get(i)!=null){                    Object obj = params.get(i);                    if(obj.getClass().getName().equals("java.lang.String")){                        ps.setString(i+1, obj.toString());                    }else if(obj.getClass().getName().equals("java.lang.Integer")){                        ps.setInt(i+1, Integer.valueOf(obj.toString()));                    }else{                        ps.setObject(i+1, obj);                        }                }            }            rs = ps.executeQuery();            Class type = null ; //属性类型            if(rs.next()){                objClass = c.newInstance();                List<String> list = Reflect003.getKeys(c);                Method method = null;                for (int i = 0; i < list.size(); i++) {                    String key = list.get(i);                    String mName = "set"+key.substring(0,1).toUpperCase()+key.substring(1);                    String typeName = c.getDeclaredField(key).getType().getName();                    if(typeName.equals("int")){                        type = int.class;                        method = c.getMethod(mName, type);                        method.invoke(objClass, rs.getInt(key));                      }else if(typeName.equals("java.lang.String")){                        type = java.lang.String.class;                           method = c.getMethod(mName, type);                        method.invoke(objClass, rs.getString(key));                        }                }            }        }catch(Exception e){            System.out.println("访问数据方法实现类findInfo方法出错");            e.printStackTrace();         }finally{               dao.closeAll(rs,ps,conn);        }          return (T)objClass;     }     /*     * 分页查询方法     */    public List<T> findList(Object objClass,String sql, List params)    throws Exception {        /*         * 创建返回值对象         */        List<Object> info = new ArrayList<Object>();          //获得Class对象        Class c = objClass.getClass();         try{            conn = dao.getConn();            ps = conn.prepareStatement(sql);            for (int i = 0; i < params.size(); i++) {                if(params.get(i)!=null){                    Object obj = params.get(i);                    /*                     * 判断参数的原始类型                     * 暂时判断Integer跟String类型                     */                    if(obj.getClass().getName().equals("java.lang.String")){                        ps.setString(i+1, obj.toString());                    }else if(obj.getClass().getName().equals("java.lang.Integer")){                        ps.setInt(i+1, Integer.valueOf(obj.toString()));                    }else{                        ps.setObject(i+1, obj);                        }                }            }            rs = ps.executeQuery();            Class type = null ; //属性类型            while(rs.next()){                //创建一个实例                objClass = c.newInstance();                //获取所有的字段名称                List<String> list = Reflect003.getKeys(c);                Method method = null;//声明Method对象                for (int i = 0; i < list.size(); i++) {                    String key = list.get(i);                    String mName = getSetMethodName(key); //组装set方法名称                    String typeName = c.getDeclaredField(key).getType().getName();  //获取字段类型名称                    /*                     * 判断字段类型                     */                    if(typeName.equals("int")){                        type = int.class; //赋值属性类型                        method = c.getMethod(mName, type); //获得Method实例                        method.invoke(objClass, rs.getInt(key));  //调用该set方法                    }else if(typeName.equals("java.lang.String")){                        type = java.lang.String.class;                           method = c.getMethod(mName, type);                        method.invoke(objClass, rs.getString(key));                        }                }                info.add(objClass);            }          }catch(Exception e){            System.out.println("访问数据方法实现类findList方法出错");            e.printStackTrace();        }finally{            dao.closeAll(rs,ps,conn);          }        return (List<T>)info;      }    /**     * 组装set方法     * @param columnName 字段名     * @return     */    private static String getSetMethodName(String columnName) {        return "set" + columnName.substring(0, 1).toUpperCase()        + columnName.toLowerCase().substring(1);    }}

获取所有字段的方法：

/** * 获取字段名称类 */public class Reflect003 {    public static List<String> getKeys(Class<?> c){        List<String> list = new ArrayList<String>();        try{            //根据Class的静态方法获取所以字段名称、不包括继承字段            Field[] fs = c.getDeclaredFields();            for (int i = 0; i < fs.length; i++) {                list.add(fs[i].getName());            }        }catch(Exception e){            e.printStackTrace();        }        return list;    }}

java 反射机制构建JSON字符串

import java.lang.reflect.Field;import java.lang.reflect.InvocationTargetException;import java.lang.reflect.Method;import java.util.ArrayList;import java.util.List;import com.test.hzw.bean.test_user;import com.test.hzw.dao.impl.DaoImpl;/** * Json转换测试类 */@SuppressWarnings({"unchecked","unused"})public class Reflect004 {    /**     * @param args     * @throws Exception      */    public static void main(String[] args) throws Exception {        DaoImpl dao = new DaoImpl();        test_user u = new test_user();        String sqlPage = "SELECT * FROM test_user WHERE id <= ";        sqlPage += " (SELECT id FROM test_user ORDER BY id LIMIT "+(2-1)*20+", 1) ";        sqlPage += " ORDER BY id LIMIT 20 " ;          /*         * 从数据库查询并获得集合         */        List<test_user> listT = (List<test_user>)dao.findList(u, sqlPage, new ArrayList());        String s = ToJsonByList(listT);        System.out.println(s);          System.out.println(ToJsonByAll(listT.get(0)).toString());    }     /**     * 根据List集合生成Json数组格式字符串(只支持bean方式)     */    public static <T> String ToJsonByList(List<T> list){        StringBuffer b = new StringBuffer("[");        if(list!=null&&list.size()>0){            for (int i = 0; i < list.size(); i++){                Object o = list.get(i);                try {                    //调用ToJsonByBean方法                    StringBuffer s = ToJsonByBean(o);                    if(s!=null&&!s.equals("")){                        b.append(s).append(",");                     }                } catch (Exception e) {                         e.printStackTrace();                }             }           }        b.append("]");        return b.replace(b.lastIndexOf(","),b.lastIndexOf(",") + 1 ,"").toString();    }    /**      * 根据javaBean生成Json对象格式字符串      * @param object 任意javaBean类型对象      * @return 拼接好的StringBuffer对象      */      public static StringBuffer ToJsonByBean(Object object) throws Exception{          Class clazz = object.getClass();  //获得Class对象        Field[] fields = clazz.getDeclaredFields();  //获得Class对象的字段数组        StringBuffer sb = new StringBuffer("{");         /*         * 循环字段数组         */        for (Field field : fields) {                String fieldName = field.getName(); //获得字段名称               //获得字段对应的get方法对象            Method method = clazz.getMethod("get" + change(fieldName), null);              //调用get方法获得字段的值            Object property = method.invoke(object, null);              /*             * 生成json字符串数据             */            if(property == null){                  sb.append("\""+fieldName+"\":\"\",");                }else{                if (field.getType().getName().equals("java.lang.Boolean"))                    sb.append("\""+fieldName+"\":"+Boolean.valueOf(property.toString())+",");                   else                    sb.append("\""+fieldName+"\":\""+property+"\",");             }          }                     sb.append("}");                  return sb.replace(sb.lastIndexOf(","),sb.lastIndexOf(",") + 1 ,"");      }      /**      * @param src 源字符串      * @return 字符串，将src的第一个字母转换为大写，src为空时返回null      */      public static String change(String src) {          if (src != null) {              StringBuffer sb = new StringBuffer(src);              sb.setCharAt(0, Character.toUpperCase(sb.charAt(0)));              return sb.toString();          } else {              return null;          }      }      /**      * 生成Json数组格式字符串      * @param object 任意类型对象      * @return 拼接好的StringBuffer对象      */      public static StringBuffer ToJsonByAll(Object object) throws Exception{          Class clazz = object.getClass();          Field[] fields = clazz.getDeclaredFields();          StringBuffer sb = new StringBuffer("{[");          for (Field field : fields) {              String fieldName = field.getName();              Method method = clazz.getMethod("get" + change(fieldName), null);              Object property = method.invoke(object, null);              if(property == null){                    sb.append("\"\",");              }else{                  sb.append("\"" + property + "\",");              }          }                 sb.append("]}");                  return sb.replace(sb.lastIndexOf(","),sb.lastIndexOf(",") + 1 ,"");      }}

用反射机制实现对数据库数据的增、查例子

基本原理；保存数据时，把需要保存的对象的属性值全部取出来再拼凑sql语句
查询时，将查询到的数据全部包装成一个java对象。
游戏规则：俗话说的好，无规矩不成方圆，特别是程序来说，它只能做有规则的事情，没有规则的它干不了，好，那就
先定规则
1）数据库的每一个表对象一个pojo类，表中的每一个字段对应pojo类的中的一个属性。
并且pojo类的名字和表的名字相同，属性名和字段名相同，大小写没有关系，因为数据库一般不区分大小写
2）为pojo类中的每一个属性添加标准的set和get方法。
有了游戏规则，那么开始游戏吧。

1、首先数据库的有一个表，假设数据库名称为：blogsystem,里面的一个表名userinfo。如图：

2、创建对应的pojo类：

package cn.netjava.pojo;public class UserInfo {private int id;private String name;private String pwd;private int age;@Overridepublic String toString() {    return "UserInfo [id=" + id + ", name=" + name + ", pwd=" + pwd + ", age="            + age + "]";}public int getId() {    return id;}public void setId(int id) {    this.id = id;}public String getName() {    return name;}public void setName(String name) {    this.name = name;}public String getPwd() {    return pwd;}public void setPwd(String pwd) {    this.pwd = pwd;}public int getAge() {    return age;}public void setAge(int age) {    this.age = age;}}

3、编写获得数据库连接的工厂类：

package cn.netjava.factory;import java.sql.Connection;import java.sql.DriverManager;public class Connect2DBFactory {    public static Connection getDBConnection() {        Connection conn = null;        try {            Class.forName("com.mysql.jdbc.Driver");            String url = "jdbc:mysql://localhost:3306/blogsystem";            String user = "root";            String password = "netjava";            conn = DriverManager.getConnection(url, user, password);        } catch (Exception e) {            e.printStackTrace();        }        return conn;    }}

4、编写操作数据库的dao类

package cn.netjava.session;import java.lang.reflect.Field;import java.lang.reflect.Method;import java.sql.Connection;import java.sql.PreparedStatement;import java.sql.ResultSet;import java.sql.SQLException;import java.sql.Statement;import java.util.ArrayList;import java.util.List;import cn.netjava.factory.Connect2DBFactory;import cn.netjava.pojo.UserInfo;public class NetJavaSession {    /**     * 解析出保存对象的sql语句     *      * @param object     *            ：需要保存的对象     * @return：保存对象的sql语句     */    public static String getSaveObjectSql(Object object) {        // 定义一个sql字符串        String sql = "insert into ";        // 得到对象的类        Class c = object.getClass();        // 得到对象中所有的方法        Method[] methods = c.getMethods();        // 得到对象中所有的属性        Field[] fields = c.getFields();        // 得到对象类的名字        String cName = c.getName();        // 从类的名字中解析出表名        String tableName = cName.substring(cName.lastIndexOf(".") + 1,                cName.length());        sql += tableName + "(";        List<String> mList = new ArrayList<String>();        List vList = new ArrayList();        for (Method method : methods) {            String mName = method.getName();            if (mName.startsWith("get") && !mName.startsWith("getClass")) {                String fieldName = mName.substring(3, mName.length());                mList.add(fieldName);                System.out.println("字段名字----->" + fieldName);                try {                    Object value = method.invoke(object, null);                    System.out.println("执行方法返回的值：" + value);                    if (value instanceof String) {                        vList.add("\"" + value + "\"");                        System.out.println("字段值------>" + value);                    } else {                        vList.add(value);                    }                } catch (Exception e) {                    e.printStackTrace();                }            }        }        for (int i = 0; i < mList.size(); i++) {            if (i < mList.size() - 1) {                sql += mList.get(i) + ",";            } else {                sql += mList.get(i) + ") values(";            }        }        for (int i = 0; i < vList.size(); i++) {            if (i < vList.size() - 1) {                sql += vList.get(i) + ",";            } else {                sql += vList.get(i) + ")";            }        }        return sql;    }    public static List getDatasFromDB(String tableName, int Id) {        return null;    }    /**     * 将对象保存到数据库中     *      * @param object     *            ：需要保存的对象     * @return：方法执行的结果;1:表示成功，0:表示失败     */    public int saveObject(Object object) {        Connection con = Connect2DBFactory.getDBConnection();        String sql = getSaveObjectSql(object);        try {            // Statement statement=(Statement) con.createStatement();            PreparedStatement psmt = con.prepareStatement(sql);            psmt.executeUpdate();            return 1;        } catch (SQLException e) {            e.printStackTrace();            return 0;        }    }    /**     * 从数据库中取得对象     *      * @param arg0     *            ：对象所属的类     * @param id     *            ：对象的id     * @return:需要查找的对象     */    public Object getObject(String className, int Id) {        // 得到表名字        String tableName = className.substring(className.lastIndexOf(".") + 1,                className.length());        // 根据类名来创建Class对象        Class c = null;        try {            c = Class.forName(className);        } catch (ClassNotFoundException e1) {            e1.printStackTrace();        }        // 拼凑查询sql语句        String sql = "select * from " + tableName + " where Id=" + Id;        System.out.println("查找sql语句：" + sql);        // 获得数据库链接        Connection con = Connect2DBFactory.getDBConnection();        // 创建类的实例        Object obj = null;        try {            Statement stm = con.createStatement();            // 得到执行查寻语句返回的结果集            ResultSet set = stm.executeQuery(sql);            // 得到对象的方法数组            Method[] methods = c.getMethods();            // 遍历结果集            while (set.next()) {                obj = c.newInstance();                // 遍历对象的方法                for (Method method : methods) {                    String methodName = method.getName();                    // 如果对象的方法以set开头                    if (methodName.startsWith("set")) {                        // 根据方法名字得到数据表格中字段的名字                        String columnName = methodName.substring(3,                                methodName.length());                        // 得到方法的参数类型                        Class[] parmts = method.getParameterTypes();                        if (parmts[0] == String.class) {                            // 如果参数为String类型，则从结果集中按照列名取得对应的值，并且执行改set方法                            method.invoke(obj, set.getString(columnName));                        }                        if (parmts[0] == int.class) {                            method.invoke(obj, set.getInt(columnName));                        }                    }                }            }        } catch (Exception e) {            e.printStackTrace();        }        return obj;    }}

5、测试

package cn.netjava.tester;import cn.netjava.pojo.UserInfo;import cn.netjava.session.NetJavaSession;public class Tester {    public static void main(String args[]) {        //获得NetJavaSession对象        NetJavaSession session = new NetJavaSession();        //创建一个UserInfo对象        UserInfo user = new UserInfo();        //设置对象的属性        user.setId(6988);        user.setAge(44);        user.setPwd("pwd");        user.setName("champion");        //将对象保存到数据库中        String sql = session.getSaveObjectSql(user);        System.out.println("保存对象的sql语句：" + sql);        //查找对象        UserInfo userInfo = (UserInfo) session.getObject(                "cn.netjava.pojo.UserInfo", 6988);        System.out.println("获取到的信息：" + userInfo);    }}

总的来说，java反射机制是一个很好用的东西，用它可以解决很多死的东西，因为反射机制的灵活行很大，有了他，我们就不要花太多的时间来写操做数据库的代码了，而是方法更多的时间在项目的逻辑功能上，这个可以很大的减少开发时间，而且代码的可读性好。先在的很多开源框架都是才用的反射机制，它只要配置文件，然后按规则来调用他的方法就可以了。