Java反射的常见用法

转载自:https://www.cnblogs.com/JavaArchitect/p/12244680.html

 反射的常见用法有三类，第一类是“查看”，比如输入某个类的属性方法等信息，第二类是“装载“，比如装载指定的类到内存里，第三类是“调用”，比如通过传入参数，调用指定的方法。

1 查看属性的修饰符、类型和名字

    通过反射机制，我们能从.class文件里看到指定类的属性，比如属性的修饰符，属性和类型和属性的变量名。通过下面的ReflectionReadVar.java，我们看演示下具体的做法。    

1
2
3
4
5
6
1   import java.lang.reflect.Field;
2   import java.lang.reflect.Modifier;
3   class MyValClass{
4       private int val1;
5       public String val2;
6       final protected String val3 = "Java";

    我们在第3行定义了一个MyValCalss的类，并在第4到第6行里，定义了三个属性变量。    

1
2
3
4
5
6
7
8
9
10
11
12
13
14
8   public class ReflectionReadVar {
9       public static void main(String[] args) {
10          Class<MyValClass> clazz = MyValClass.class;
11          //获取这个类的所有属性
12          Field[] fields = clazz.getDeclaredFields();
13          for(Field field : fields) {
14                 //输出修饰符             System.out.print(Modifier.toString(field.getModifiers()) + "\t");
15                 //输出属性的类型
16             System.out.print(field.getGenericType().toString() + "\t");
17                 //输出属性的名字
18                 System.out.println(field.getName());
19            }
20      }
21  }

    在main函数的第10行里，通过MyValClass.class，得到了Class<MyValClass>类型的变量clazz，在这个变量中，存储了MyValClass这个类的一些信息。

    在第12行里，通过了clazz.getDeclaredFields()方法得到了MyValClass类里的所有属性的信息，并把这些属性的信息存入到Field数组类型的fields变量里。

    通过了第13行的for循环依次输出了这些属性信息。具体来讲，通过第14行的代码输出了该属性的修饰符，通过第16行的代码输出了该属性的类型，通过第18行的代码输出了该属性的变量名。这段代码的输出如下，从中我们能看到各属性的信息。

          1      private    int val1

          2      public class java.lang.String   val2

          3      protected final   class java.lang.String   val3   

2 查看方法的返回类型，参数和名字

    通过ReflectionReadFunc.java，我们能通过反射机制看到指定类的方法。    

1
2
3
4
5
6
7
8
1   import java.lang.reflect.Constructor;
2   import java.lang.reflect.Method;
3   class MyFuncClass{
4       public MyFuncClass(){}
5       public MyFuncClass(int i){}
6       private void f1(){}
7       protected int f2(int i){return 0;}
8       public String f2(String s) {return "Java";}

    在第3行定义的MyFuncClass这个类里，我们定义了2个构造函数和3个方法。　

1
2
3
4
5
6
7
8
9
10
11
12
13
10  public class ReflectionReadFunc {
11      public static void main(String[] args) {
12          Class<MyFuncClass> clazz = MyFuncClass.class;
13          Method[] methods = clazz.getDeclaredMethods();
14          for (Method method : methods)
15          { System.out.println(method); }
16          //得到所有的构造函数
17          Constructor[] c1 = clazz.getDeclaredConstructors();
18          //输出所有的构造函数
19          for(Constructor ct : c1)
20          { System.out.println(ct);  }
21      }
22  }

    在main函数的第12行，我们同样是通过了类名.class的方式（也就是MyFuncClass.class的方式）得到了Class<MyFuncClass>类型的clazz对象。

    在第13行里，是通过了getDeclaredMethods方法得到了MyFuncClass类的所有方法，并在第14行的for循环里输出了各方法。在第17行里，是通过了getDeclaredConstructors方法得到了所有的构造函数，并通过第19行的循环输出。

    本代码的输出结果如下所示，其中第1到第3行输出的是类的方法，第4和第5行输出的是类的构造函数。    

1
2
3
4
5
1   private void MyFuncClass.f1()
2   protected int MyFuncClass.f2(int)
3   public java.lang.String MyFuncClass.f2(java.lang.String)
4   public MyFuncClass()
5   public MyFuncClass(int)

    不过在实际的项目里，我们一般不会仅仅“查看”类的属性和方法，在更多的情况里，我们是通过反射装载和调用类里的方法。

3 通过forName和newInstance方法加载类

    在前文JDBC操作数据库的代码里，我们看到在创建数据库连接对象（Connection）之前，需要通过Class.forName("com.mysql.jdbc.Driver");的代码来装载数据库（这里是MySQL）的驱动。

    可以说，Class类的forName方法最常见的用法就是装载数据库的驱动，以至于不少人会错误地认为这个方法的作用是“装载类”。

    其实forName方法的作用仅仅是返回一个Class类型的对象，它一般会和newInstance方法配套使用，而newInstance方法的作用才是加载类。

    通过下面的ForClassDemo.java这段代码，我们来看下综合使用forName和newInstance这两个方法加载对象的方式。    

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
1   class MyClass{
2       public void print()
3       {   System.out.println("Java"); }
4   }
5   public class ForClassDemo {
6       public static void main(String[] args)  {
7           //通过new创建类和使用类的方式
8           MyClass myClassObj = new MyClass();
9           myClassObj.print();//输出是Java
10          //通过forName和newInstance加载类的方式  
11          try {
12              Class<?> clazz = Class.forName("MyClass");
13              MyClass myClass = (MyClass)clazz.newInstance();
14              myClass.print();//输出是Java
15          } catch (ClassNotFoundException e) {
16              e.printStackTrace();
17          } catch (InstantiationException e) {
18              e.printStackTrace();
19          } catch (IllegalAccessException e) {
20              e.printStackTrace();
21          }      
22      }
23  }

    在第1行定义的MyClass这个类里，我们在其中的第2行定义了一个print方法。

    Main函数的第8和第9行里，我们演示了通过常规new的方式创建和使用类的方式，通过第9行，我们能输出“Java”这个字符串。

    在第12行，我们通过Class.forName("MyClass")方法返回了一个Class类型的对象，请注意，forName方法的作用不是“加载MyClass类”，而是返回一个包含MyClass信息的Class类型的对象。这里我们是通过第13行的newInstance方法，加载了一个MyClass类型的对象，并在第14行调用了其中的print方法。

    既然forName方法的作用仅仅是“返回Class类型的对象”，那么在JDBC部分的代码里，为什么我们能通过Class.forName("com.mysql.jdbc.Driver");代码来装载MySQL的驱动呢？在MySQL的com.mysql.jdbc.Driver驱动类中有如下的一段静态初始化代码。   

1
2
3
4
5
6
7
1   static {
2   try {
3      java.sql.DriverManager.registerDriver(new Driver());
4   } catch (SQLException e) {
5   throw new RuntimeException(“Can’t register driver!”);
6   }
7   }

    也就是说，当我们调用Class.forName方法后，会通过执行这段代码会新建一个Driver的对象，并调用第3行的DriverManager.registerDriver把刚创建的Driver对象注册到DriverManager里。

    在上述的代码里，我们看到了除了new之外，我们还能通过newInstance来创建对象。

    其实这里说“创建”并不准确，虽然说通过new和newInstance我们都能得到一个可用的对象，但newInstance的作用其实是通过Java虚拟机的类加载机制把指定的类加载到内存里。

    我们在工厂模式中，经常会通过newInstance方法来加载类，但这个方法只能是通过调用类的无参构造函数来加载类，如果我们在创建对象时需要传入参数，那么就得使用new来调用对应的带参的构造函数了。

4 通过反射机制调用类的方法

    如果我们通过反射机制来调用类的方式，那么就得解决三个问题，第一，通过什么方式来调？第二，如何传入参数，第三，如何得到返回结果？

    通过下面的CallFuncDemo.java代码，我们将通过反射来调用类里的方法，在其中我们能看下上述三个问题的解决方法。    

1
2
3
4
5
6
7
8
9
10
11
12
13
1   import java.lang.reflect.Constructor;
2   import java.lang.reflect.InvocationTargetException;
3   import java.lang.reflect.Method;
4   class Person {
5       private String name;
6       public Person(String name)
7       {this.name = name;}
8       public void saySkill(String skill) {
9         System.out.println("Name is:"+name+",skill is:" + skill);
10      }
11      public int addSalary(int current)
12      {   return current + 100;}
13  }

    在第4行里，我们定义了一个Person类，在其中的第6行里，我们定义了一个带参的构造函数，在第8行里，我们定义了一个带参但无返回值得saySkill方法，在第11行里，我们定义了一个带参而且返回int类型的addSalary方法。    

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
14  public class CallFuncDemo {
15      public static void main(String[] args) {
16          Class c1azz = null;
17          Constructor c = null;
18          try {
19              c1azz = Class.forName("Person");
20              c = c1azz.getDeclaredConstructor(String.class);
21              Person p = (Person)c.newInstance("Peter");
22              //output: Name is:Peter, skill is:java
23              p.saySkill("Java");
24              // 调用方法，必须传递对象实例，同时传递参数值
25              Method method1 = c1azz.getMethod("saySkill", String.class);
26              //因为没返回值，所以能直接调
27              //输出结果是Name is:Peter, skill is:C#
28              method1.invoke(p, "C#");            
29              Method method2 = c1azz.getMethod("addSalary", int.class);
30              Object invoke = method2.invoke(p, 100);
31              //输出200
32              System.out.println(invoke);
33          } catch (ClassNotFoundException e) {
34              e.printStackTrace();
35          } catch (NoSuchMethodException e1) {
36              e1.printStackTrace();
37          } catch (InstantiationException e) {
38              e.printStackTrace();
39          } catch (IllegalAccessException e) {
40              e.printStackTrace();
41          } catch (InvocationTargetException e) {
42              e.printStackTrace();
43          }
44      }
45  }

    在第19行里，我们通过Class.forName得到了一个Class类型的对象，其中包含了Person类的信息。在第20行里，通过传入String.class参数，得到了Person类的带参的构造函数，并通过了第21行的newInstance方法，通过这个带参的构造函数创建了一个Person类型的对象。随后在第23行里调用了saySkill方法。这里我们演示通过反射调用类的构造函数来创建对象的方式。

    在第25行里，我们通过了getMethod方法，得到了带参的saySkill方法的Method类型的对象，随后通过第28行的invoke方法调用了这个saySkill方法，这里第一个参数是由哪个对象来调用，通过第二个参数，我们传入了saySkill方法的String类型的参数。

    用同样的方式，我们在第29和30行通过反射调用了Person类的addSalary方法，由于这个方法有返回值，所以我们在30行用了一个Object类型的invoke对象来接收返回值，通过第32行的打印语句，我们能看到200这个执行结果。

posted @ 2020-01-31 17:47  jiangwg  阅读(741)  评论(0)  编辑  收藏  举报