Java 反射机制示例

89 阅读 0 评论 59 点赞

我是靠谱客的博主伶俐狗，最近开发中收集的这篇文章主要介绍Java 反射机制示例，觉得挺不错的，现在分享给大家，希望可以做个参考。

概述

实现借助于4个类:

1.class 类对象

2.Constructor 构造器对象

3.Field 类的属性对象

4.Method 方法对象

Java反射的作用：

在Java运行时环境中，对于任意一个类，可以知道这个类有哪些属性和方法。

对于任意一个对象，可以调用它的任意一个方法。

这种动态获取类的信息以及动态调用对象的方法的功能来自于Java 语言的反射（Reflection）机制。

1、得到构造器的方法

Constructor getConstructor(Class[] params) -- 获得使用特殊的参数类型的公共构造函数，

Constructor[] getConstructors() -- 获得类的所有公共构造函数

Constructor getDeclaredConstructor(Class[] params) -- 获得使用特定参数类型的构造函数(与接入级别无关)

Constructor[] getDeclaredConstructors() -- 获得类的所有构造函数(与接入级别无关)

2、获得字段信息的方法

Field getField(String name) -- 获得命名的公共字段

Field[] getFields() -- 获得类的所有公共字段

Field getDeclaredField(String name) -- 获得类声明的命名的字段

Field[] getDeclaredFields() -- 获得类声明的所有字段

3、获得方法信息的方法

Method getMethod(String name, Class[] params) -- 使用特定的参数类型，获得命名的公共方法

Method[] getMethods() -- 获得类的所有公共方法

Method getDeclaredMethod(String name, Class[] params) -- 使用特写的参数类型，获得类声明的命名的方法

Method[] getDeclaredMethods() -- 获得类声明的所有方法

举例:

业务方法1类:

package fanshe;
public class Service1 {
public void doService1(){
System.out.println("业务方法1");
}
}

业务方法2类:

package fanshe;
public class Service2 {
public void doService2(){
System.out.println("业务方法2");
}
}





测试类:


package fanshe;
public class FansheTest {
public static void main(String[] args) {
Service1 S1=new Service1();
S1.doService1();
//Service2 S2=new Service2();
//S2.doService2();
}
}
当需要从第一个业务方法切换到第二个业务方法的时候，使用非反射方式，必须修改代码，并且重新编译运行，才可以达到效果.




反射方式:





 使用反射方式，首先准备一个配置文件，就叫做spring.txt吧, 放在src目录下。 里面存放的是类的名称，和要调用的方法名。

在测试类Test中，首先取出类名称和方法名，然后通过反射去调用这个方法。


当需要从调用第一个业务方法，切换到调用第二个业务方法的时候，不需要修改一行代码，也不需要重新编译，只需要修改配置文件spring.txt，再运行即可。
配置文件spring.txt



业务方法1类:



package fanshe;
public class Service1 {
public void doService1(){
System.out.println("业务方法1");
}
}


业务方法2类:




package fanshe;
public class Service2 {
public void doService2(){
System.out.println("业务方法2");
}
}
测试类:


package fanshe;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.Properties;
public class FansheTest {
public static void main(String[] args) throws FileNotFoundException, IOException, ClassNotFoundException, NoSuchMethodException, SecurityException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
//1.获取配置文件
File SpringConfigFile=new File("/Users/zhang/Desktop/spring.txt");
Properties SpringConfig=new Properties();
SpringConfig.load(new FileInputStream(SpringConfigFile));
//获取配置文件类名
String ClassName=(String) SpringConfig.get("class");
System.out.println("类名===="+ClassName);
//获取方法名
String MethodName=(String) SpringConfig.get("method");
System.out.println("方法名===="+MethodName);
//根据类名创建对象
Class clazzz=Class.forName(ClassName);
//根据方法名称,获取方法
Method m=clazzz.getMethod(MethodName);
//获取构造器
Constructor c=clazzz.getConstructor();
//根据构造器实例化对象
Object service=c.newInstance();
m.invoke(service);
/*　可以看到Method.invoke()实际上并不是自己实现的反射调用逻辑，而是委托给sun.reflect.MethodAccessor来处理。
每个实际的Java方法只有一个对应的Method对象作为root。
这个root是不会暴露给用户的，而是每次在通过反射获取Method对象时新创建Method对象把root包装起来再给用户。
在第一次调用一个实际Java方法对应得Method对象的invoke()方法之前，实现调用逻辑的MethodAccessor对象还没创建；
等第一次调用时才新创建MethodAccessor并更新给root，然后调用MethodAccessor.invoke()真正完成反射调用。
*/
}
}打印结果:


类名====fanshe.Service1
方法名====doService1
业务方法1