反射机制(Java)

反射机制

今天闲来无事，对反射机制http://www.cnblogs.com/jqyp/archive/2012/03/29/2423112.html阅读一番，整理了下这方面的知识以及自己的一些心得，希望对大家有帮助！

JAVA反射机制是在运行状态中，可以动态的，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。换句话说就是：对于任意的类动态的获得该类的信息以及动态的调用对象的方法称为java语言的反射机制，在Java中主要靠Class 类来实现动态的获得类或者是对象的信息

反射机制的优点

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

它的缺点

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

Class类里面一些重要的方法

首先得根据传入的类的全名来创建Class对象。

   Class c=Class.forName("className");注明：className必须为全名，也就是得包含包名，比如，cn.netjava.pojo.UserInfo;

   Object obj=c.newInstance();//创建对象的实例

   OK，有了对象就什么都好办了，想要什么信息就有什么信息了。  

    获得构造函数的方法

   Constructor getConstructor(Class[] params)//根据指定参数获得public构造器

   Constructor[] getConstructors()//获得public的所有构造器

   Constructor getDeclaredConstructor(Class[] params)//根据指定参数获得public和非public的构造器

   Constructor[] getDeclaredConstructors()//获得public的所有构造器

    获得类方法的方法

   Method getMethod(String name, Class[] params),根据方法名，参数类型获得方法

   Method[] getMethods()//获得所有的public方法

   Method getDeclaredMethod(String name, Class[] params)//根据方法名和参数类型，获得public和非public的方法

   Method[] getDeclaredMethods()//获得所以的public和非public方法

    获得类中属性的方法

   Field getField(String name)//根据变量名得到相应的public变量

   Field[] getFields()//获得类中所以public的方法

   Field getDeclaredField(String name)//根据方法名获得public和非public变量

Field[]getDeclaredFields()//获得类中所有的public和非public方法

最重要的是怎么去调用获得的函数格式如下：

函数名.invoke (对象,这个函数对应的参数)

这里的函数名是通过上面获得到的，如setName（string name）调用

method.invoke(obj,  set.getString(columnName)); 这样就完成了上面的setName（string name）

    常用的就这些，知道这些，其他的都好办……

反射机制的应用

反射机制就是专门帮我们做那些重复的有规则的事情，所以现在很多的自动生成代码的软件就是运用反射机制来完成的，只要你按照规则进行操作的一般都可以用这种机制，同时写出来的代码一般都是比较通用性，不受数据结构等的影响。

在这里就拿数据库操作来说明下，

在编写访问数据库时，为各种各样的表进行增删改查等操作，而每种表的结构大部分又不一样，然后是对不同的表创建不同的类，同时为每个类编写几乎规则都差不多的数据库操作代码,这样不仅开发速率地，而且代码冗余的厉害，最要命的是看着差不多的，然后直接复制修改，由于容易犯各种低级的错误（大小写啊，多一个或少一个字母啊……）,一个错误就可以让你找半天。

有了java反射机制，什么都好办了，只需要写一个类，四个方法来增删改查，传入不同的对象，就OK啦，但还是要为每一个表都创建类，只是方便存储从表里面获得的数据对象化，反射机制会自动帮我们完成剩下的事情，这就是它的好处。说白了，反射机制就是专门帮我们做那些重复的有规则的事情，所以现在很多的自动生成代码的软件就是运用反射机制来完成的，只要你按照规则输入相关的参数

其中表对应的类结构为

public class UserInfo {

private 属性的数据类型 属性名;

@Override

public String toString() ;

//下面是对属性进行读取以及赋值，方便利用反射机制来获得属性名以及属性值

public 属性数据类型 get属性名();

public void set属性名();

}

接下来讲下具体操作，就来插入来说吧，

如在数据库操作中，比如我们把一条记录（用一个数据结构对象来封装好的）插入一个表里，如果我们知道这个对象的里面的结构还好，可以根据这个对象

的结构来插入，但这也麻烦，一种数据结构要写一个对应的插入方法，这就不体现代码的复用了，像这种我们就可以利用反射机制，我们不需要知道这个类的结构

是怎样，通过反射机制来知道其结构（在这里就是获得该类（表）的属性名），以及通过反射机制动态的调用这个对象里面的方法来获得其想要的值

（在这里就是获得某个属性的值），现在我们知道了属性名以及对应的属性值，就可以完成各种各样的数据库方面的操作，继而来实现这种通用性

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

1. package cn.netjava.factory;

1. import java.sql.Connection;
2. import java.sql.DriverManager;

1. public class Connect2DBFactory {
2.     public staticConnection getDBConnection() {
3.         Connectionconn = null;
4.         try{
5.             Class.forName("com.mysql.jdbc.Driver");
6.             Stringurl = "jdbc:mysql://localhost:3306/blogsystem";
7.             Stringuser = "root";
8.             Stringpassword = "netjava";
9.             conn= DriverManager.getConnection(url, user, password);
10.         }catch (Exception e) {
11.             e.printStackTrace();
12.         }

1.         returnconn;
2.     }
3. }

编写数据库操作类

1. package cn.netjava.session;

1. import java.lang.reflect.Field;
2. import java.lang.reflect.Method;
3. import java.sql.Connection;
4. import java.sql.PreparedStatement;
5. import java.sql.ResultSet;
6. import java.sql.SQLException;
7. import java.sql.Statement;
8. import java.util.ArrayList;
9. import java.util.List;

1. importcn.netjava.factory.Connect2DBFactory;
2. import cn.netjava.pojo.UserInfo;

1. public class NetJavaSession {
2.     /**
3.      * 解析出保存对象的sql语句
4.      *
5.      * @paramobject
6.      *           ：需要保存的对象
7.      * @return：保存对象的sql语句
8.      */
9.     public static StringgetSaveObjectSql(Object object) {
10.         //定义一个sql字符串
11.         Stringsql = "insert into ";
12.         //得到对象的类
13.         Classc = object.getClass();
14.         //得到对象中所有的方法
15.         Method[]methods = c.getMethods();
16.         //得到对象中所有的属性
17.         Field[]fields = c.getFields();
18.         //得到对象类的名字
19.         StringcName = c.getName();
20.         //从类的名字中解析出表名
21.         StringtableName = cName.substring(cName.lastIndexOf(".") + 1,
22.                 cName.length());
23.         sql+= tableName + "(";
24.         List<String>mList = new ArrayList<String>();
25.         ListvList = new ArrayList();
26.         for(Method method : methods) {
27.             StringmName = method.getName();
28.             if(mName.startsWith("get") &&!mName.startsWith("getClass")) {
29.                 StringfieldName = mName.substring(3, mName.length());
30.                 mList.add(fieldName);
31.                 System.out.println("字段名字----->"+ fieldName);
32.                 try{
33.                     Objectvalue = method.invoke(object, null);
34.                     System.out.println("执行方法返回的值："+ value);
35.                     if(value instanceof String) {
36.                         vList.add("\""+ value + "\"");
37.                         System.out.println("字段值------>"+ value);
38.                     }else {
39.                         vList.add(value);
40.                     }
41.                 }catch (Exception e) {
42.                     e.printStackTrace();
43.                 }
44.             }
45.         }
46.         for(int i = 0; i < mList.size(); i++) {
47.             if(i < mList.size() - 1) {
48.                 sql+= mList.get(i) + ",";
49.             }else {
50.                 sql+= mList.get(i) + ") values(";
51.             }
52.         }
53.         for(int i = 0; i < vList.size(); i++) {
54.             if(i < vList.size() - 1) {
55.                 sql+= vList.get(i) + ",";
56.             }else {
57.                 sql+= vList.get(i) + ")";
58.             }
59.         }

1.         returnsql;
2.     }

1.     public static ListgetDatasFromDB(String tableName, int Id) {

1.         returnnull;

1.     }

1.     /**
2.      * 将对象保存到数据库中
3.      *
4.      * @paramobject
5.      *           ：需要保存的对象
6.      * @return：方法执行的结果;1:表示成功，0:表示失败
7.      */
8.     public intsaveObject(Object object) {
9.         Connectioncon = Connect2DBFactory.getDBConnection();
10.         Stringsql = getSaveObjectSql(object);
11.         try{
12.             //Statement statement=(Statement) con.createStatement();
13.             PreparedStatementpsmt = con.prepareStatement(sql);
14.             psmt.executeUpdate();
15.             return1;
16.         }catch (SQLException e) {
17.             e.printStackTrace();
18.             return0;
19.         }
20.     }

1.     /**
2.      * 从数据库中取得对象
3.      *
4.      * @paramarg0
5.      *           ：对象所属的类
6.      * @param id
7.      *           ：对象的id
8.      * @return:需要查找的对象
9.      */
10.     public ObjectgetObject(String className, int Id) {
11.         //得到表名字
12.         StringtableName = className.substring(className.lastIndexOf(".") + 1,
13.                 className.length());
14.         //根据类名来创建Class对象
15.         Classc = null;
16.         try{
17.             c= Class.forName(className);

1.         }catch (ClassNotFoundException e1) {

1.             e1.printStackTrace();
2.         }
3.         //拼凑查询sql语句
4.         Stringsql = "select * from " + tableName + " where Id=" + Id;
5.         System.out.println("查找sql语句："+ sql);
6.         //获得数据库链接
7.         Connectioncon = Connect2DBFactory.getDBConnection();
8.         //创建类的实例
9.         Objectobj = null;
10.         try{

1.             Statementstm = con.createStatement();
2.             //得到执行查寻语句返回的结果集
3.             ResultSetset = stm.executeQuery(sql);
4.             //得到对象的方法数组
5.             Method[]methods = c.getMethods();
6.             //遍历结果集
7.             while(set.next()) {
8.                 obj= c.newInstance();
9.                 //遍历对象的方法
10.                 for(Method method : methods) {
11.                     StringmethodName = method.getName();
12.                     //如果对象的方法以set开头
13.                     if(methodName.startsWith("set")) {
14.                         //根据方法名字得到数据表格中字段的名字
15.                         StringcolumnName = methodName.substring(3,
16.                                 methodName.length());
17.                         //得到方法的参数类型
18.                         Class[]parmts = method.getParameterTypes();
19.                         if(parmts[0] == String.class) {
20.                             //如果参数为String类型，则从结果集中按照列名取得对应的值，并且执行改set方法
21.                             method.invoke(obj,set.getString(columnName));
22.                         }
23.                         if(parmts[0] == int.class) {
24.                             method.invoke(obj,set.getInt(columnName));
25.                         }
26.                     }

1.                 }
2.             }

1.         }catch (Exception e) {
2.             e.printStackTrace();
3.         }
4.         returnobj;
5.     }
6. }

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

原文：http://www.cnblogs.com/Hailong-Said/p/4468911.html