• 欢迎访问 winrains 的个人网站!
  • 本网站主要从互联网整理和收集了与Java、网络安全、Linux等技术相关的文章,供学习和研究使用。如有侵权,请留言告知,谢谢!

Java反射的作用

Java技术 winrains 来源:一杯甜酒 1年前 (2019-09-29) 41次浏览

反射的优点

反射最重要的用途就是开发各种通用框架,比如在spring中,我们将所有的类Bean交给spring容器管理,无论是XML配置Bean还是注解配置,当我们从容器中获取Bean来依赖注入时,容器会读取配置,而配置中给的就是类的信息,spring根据这些信息,需要创建那些Bean,spring就动态的创建这些类。还有在struts2的struts.xml中配置action,也是通过反射调用的action。
还有在我们创建数据库链接时,这句代码Class tc = Class.forName("com.java.dbtest.TestConnection")就是告诉JVM去加载这个类,而加载的过程是在程序执行过程中动态加载的。通过类的全类名让jvm在服务器中找到并加载这个类,而如果是使用别的数据库,那就要换一个类了,如果是传统写死的方法创建,就要修改原来类的代码,而对于反射,则只是传入的参数就变成另一个了而已,可以通过修改配置文件,而不是直接修改代码。
再比如我们有两个程序员,一个程序员在写程序的时候,需要使用第二个程序员所写的类,但第二个程序员并没完成他所写的类。那么第一个程序员的代码能否通过编译呢?这是不能通过编译的。利用Java反射的机制,就可以让第一个程序员在没有得到第二个程序员所写的类的时候,来完成自身代码的编译。只是如果这个类还没有,获取时会获取不到,但不会导致编译错误,更不会导致程序的崩溃。
还有当我们在使用 IDE(如 Eclipse\IDEA)时,当我们输入一个队长或者类并向调用它的属性和方法时,一按 (“.”)点号,编译器就会自动列出她的属性或方法,这里就会用到反射。
(以上内容引自:https://blog.csdn.net/wanderlustLee/article/details/80431305)
我们在第一次接触反射的时候,总会有个很大的疑问,反射看起来好麻烦啊,各种get.get,他究竟有什么好处,能用来做什么呢?
我们先来看一下《编程思想》这本书中是怎么说的.

RTTI和反射之间真正的区别只在于,对RTTI来说,编译器在在编译时打开和检查.class文件.(换句话说,我们可以用”普通”方式调用对象的所有方法).对于反射机制来说,.class文件在编译时是不可获取的,所以在运行时打开和检查.class文件。 –《编程思想》

这段话看起来很叼的样子,有点云里雾里的,首先RTTI的意思就是以普通的方式来创建对象,调用方法,就是我们常用的new关键字。这段话的意思简化版就是:编译器将.java文件编译成.class文件之后,普通方式创建的对象就不能再变了,我只能选择是运行还是不运行这个.class文件。是不是感觉很僵硬,假如现在我有个写好的程序已经放在了服务器上,每天供人家来访问,这时候Mysql数据库宕掉了,改用Oracle,这时候该怎么怎么办呢?假如没有反射的话,我们是不是得修改代码,将Mysql驱动改为Oracle驱动,重新编译运行,再放到服务器上。是不是很麻烦,还影响用户的访问。
假如我们使用反射Class.forName()来加载驱动,只需要修改配置文件就可以动态加载这个类,Class.forName()生成的结果在编译时是不可知的,只有在运行的时候才能加载这个类,换句话说,此时我们是不需要将程序停下来,只需要修改配置文件里面的信息就可以了。这样当有用户在浏览器访问这个网站时,都不会感觉到服务器程序程序发生了变化。
所以在《Mybatis技术原理与实战》是这么说反射的好处的。

配置性大大提高,如同Spring IOC容器,给很多配置设置参数,使得java应用程序能够顺利跑起来,大大提高了Java的灵活性和可配置性,降低模块间的耦合。–《Mybatis技术原理与实战》

(以上内容引自:https://www.cnblogs.com/bihanghang/p/9992237.html)

反射的缺点

尽管反射非常强大,但也不能滥用。如果一个功能可以不用反射完成,那么最好就不用。在我们使用反射技术时,下面几条内容应该牢记于心:

  • 性能第一

反射包括了一些动态类型,所以JVM无法对这些代码进行优化。因此,反射操作的效率要比那些非反射操作低得多。我们应该避免在经常被 执行的代码或对性能要求很高的程序中使用反射。

  • 安全限制

使用反射技术要求程序必须在一个没有安全限制的环境中运行。如果一个程序必须在有安全限制的环境中运行,如Applet,那么这就是个问题了。

  • 内部暴露

由于反射允许代码执行一些在正常情况下不被允许的操作(比如访问私有的属性和方法),所以使用反射可能会导致意料之外的副作用--代码有功能上的错误,降低可移植性。反射代码破坏了抽象性,因此当平台发生改变的时候,代码的行为就有可能也随着变化。
(以上内容引自:http://www.atguigu.com/jsfx/1394.html)

反射介绍

Java除了给我们提供在编译期得到类的各种信息之外,还通过反射让我们可以在运行期间得到类的各种信息。通过反射获取类的信息,得到类的信息之后,就可以获取以下相关内容:
首先放出一个Java类作为反射的研究对象,类的内容如下:

public abstract class FatherObject implements Runnable{
    public void doSomething(){
        System.out.println("做事情......");
    }
}
public class ExampleObject extends FatherObject{
    public int age = 30;
    public String name = "byhieg";
    private Integer score = 60;
    public void printName(){
        System.out.println(name);
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Integer getScore() {
        return score;
    }
    public void setScore(Integer score) {
        this.score = score;
    }
    public ExampleObject(){
    }
    public ExampleObject(String name){
    }
    public ExampleObject(int age,Integer score){
    }
    @Override
    public void doSomething() {
        super.doSomething();
    }
    @Override
    public void run() {
        System.out.println("run......");
    }
}

Class对象

我们应用会用到反射这个知识点,肯定是想要在运行时得到类的信息,根据类的那些信息去做一些特定的操作。那么,首先无疑就是得到类的信息,在JDK中提供了Class对象来保存类的信息。所以,反射的第一步就是得到Class对象。在JDK中提供了两种方式得到Class对象。
第一种,如果编写代码的时候,就知道Class的名字,可以直接用如下方式得到Class对象:

Class exampleObjectClass = ExampleObject.class;

第二种,如果在编写代码的时候,不知道类的名字,但是在运行时的时候,可以得到一个类名的字符串,可以用如下的方式获取Class对象:

Class exampleObjectClass = Class.forName("cn.byhieg.reflectiontutorial.ExampleObject");

注意,此方法需要有2个条件,第一,forName中的字符串必须是全限定名,第二,这个Class类必须在classpath的路径下面,因为该方法会抛出 ClassNotFoundException 的异常。
获取到这个Class对象之后,就可以得到类的各种信息,开头已经提及了一些信息,下面,说几个没提到的类的信息。

得到类的名字

类的名字有两种方式得到,一种是getName(),一种是getSimpleName()。第一种得到的是全限定名,第二种得到的是这个类的名字,不带包名。看下面的例子:Class对象,已经通过上面的代码得到了。

String fullClassName = exampleObjectClass.getName();
String simpleClassName = exampleObjectClass.getSimpleName();
System.out.println(fullClassName);
System.out.println(simpleClassName);

结果如下:

cn.byhieg.reflectiontutorial.ExampleObject
ExampleObject

得到类的包名、父类和实现的接口

类的包名和父类,可以通过如下代码得到。

//得到包信息
Package aPackage = exampleObjectClass.getPackage();
System.out.println(aPackage);
//得到父类
Class superClass = exampleObjectClass.getSuperclass();
System.out.println(superClass.getSimpleName());

结果如下:

package cn.byhieg.reflectiontutorial
FatherObject

很显然,得到父类的返回值也是一个Class对象,那么可以利用这个对象得到父类的一些信息,比如判断父类是不是抽象类
System.out.println("父类是不是抽象类 " + Modifier.isAbstract(superClass.getModifiers()));
getModifiers可以得到类的修饰符,从而得到类的修饰符,当然,这个getModifiers不仅仅Class对象可以调用,Method对象可以调用。
可以使用java.lang.reflect.Modifier类中的方法来检查修饰符的类型:

Modifier.isAbstract(int modifiers);
Modifier.isFinal(int modifiers);
Modifier.isInterface(int modifiers);
Modifier.isNative(int modifiers);
Modifier.isPrivate(int modifiers);
Modifier.isProtected(int modifiers);
Modifier.isPublic(int modifiers);
Modifier.isStatic(int modifiers);
Modifier.isStrict(int modifiers);
Modifier.isSynchronized(int modifiers);
Modifier.isTransient(int modifiers);
Modifier.isVolatile(int modifiers);

此外,我们还可以得到父类实现的接口

//得到接口
Class[] classes = superClass.getInterfaces();
System.out.println("父类的接口" + classes[0]);

因为Java类可以实现很多接口,所以用的数组,但在实际使用的时候,需要先判断数组的长度。
下面,重点讲解上述列出来的内容。

构造器

利用Java反射可以得到一个类的构造器,并根据构造器,在运行时动态的创建一个对象。首先,Java通过以下方式获取构造器的实例:

//构造器
Constructor[] constructors = exampleObjectClass.getConstructors();
for (Constructor constructor : constructors) {
    System.out.println(constructor.toString());
}

结果如下:

public cn.byhieg.reflectiontutorial.ExampleObject(int,java.lang.Integer)
public cn.byhieg.reflectiontutorial.ExampleObject(java.lang.String)
public cn.byhieg.reflectiontutorial.ExampleObject()

如果,事先知道要访问的构造方法的参数类型,可以利用如下方法获取指定的构造方法,例子如下:

Constructor constructor = exampleObjectClass.getConstructor(String.class);
System.out.println(constructor.toString());

结果显然是:

public cn.byhieg.reflectiontutorial.ExampleObject(java.lang.String)

还可以用如下方式得到另一个构造器

Constructor constructor = exampleObjectClass.getConstructor(int.class,Integer.class);
System.out.println(constructor.toString());

此外,如果我们不知道构造器的参数,只能得到所有的构造器对象,那么可以用如下方式得到每一个构造器对想的参数:

Constructor[] constructors = exampleObjectClass.getConstructors();
for (Constructor constructor : constructors) {
    Class[] parameterTypes = constructor.getParameterTypes();
    System.out.println("构造器参数如下========================");
    for (Class clz : parameterTypes) {
        System.out.println("参数类型 " + clz.toString());
    }
}

结果如下:

构造器参数如下========================
参数类型 class java.lang.String
构造器参数如下========================
参数类型 int
参数类型 class java.lang.Integer

这里,可以看出无参构造方法,是不打印出结果的。基本类型的Class对象和引用类型的Class对象toString()方法是不一样的。
现在,可以根据构造器的各种信息,动态创建一个对象。

Object object = constructor.newInstance(1,100);
System.out.println(object.toString());

这个创建对象的方式有2个条件,第一是通过有参构造器创建的,第二,构造器对象必须通过传入参数信息的getConstructor得到。
第一个条件,对于无参构造方法就可以创建的对象,不需要得到构造器对象,直接Class对象调用newInstance()方法就直接创建对象。
第二个条件,构造器对象必须通过 exampleObjectClass.getConstructor(String.class); 这种形式得到。如果通过 getConstructors 得到构造器数组,然后调用指定的构造器对象去创建对象在JDK1.8是会错的。但是JDK1.6是正常的。
变量
利用Java反射可以在运行时得到一个类的变量信息,并且可以根据上面讲的方式,创建一个对象,设置他的变量值。首先,通过如下方法,得到所有public的变量:

Field[] fields = exampleObjectClass.getFields();
for (Field field : fields) {
    System.out.println("变量为: " + field.toString());
}

结果如下:

变量为: public int cn.byhieg.reflectiontutorial.ExampleObject.age
变量为: public java.lang.String cn.byhieg.reflectiontutorial.ExampleObject.name

很显然,得到的都是public的变量,上述的private的变量score,并没有得到。
和构造器一样的得到方式一样,我们可以指定一个参数名,然后得到指定的变量:

Field field = exampleObjectClass.getField("age");
System.out.println("变量为:" + field.toString());

上述的变量的toString方法得到的名字太长,Java对Field类提供了getName的方法,返回类中写的变量名字,上面的代码就可以改成field.getName()
反射不仅提供了得到变量的方法,还提供了设置变量值的方式。通过如下方法可以对一个动态生成的类,改变其变量值:

ExampleObject object = ((ExampleObject) constructor1.newInstance("byhieg"));
System.out.println("原先的age是 " + object.age);
field.set(object,10);
System.out.println("更改之后的age是" + object.age);

结果如下:

原先的age是 30
更改之后的age是10

根据上面的代码,得到名字为ageField对象,然后调用该对象的set方法,传入一个对象与要更改的值,就可以改变该对象的值了。注意,此方法不仅仅对成员变量有用,对静态变量也可以。当然,如果是静态变量,传入null,不用传对象,也是可以的。
方法
Java反射给我们除了给我们提供类的变量信息之外,当然也给我们提供了方法的信息,反射可以让我们得到方法名,方法的参数,方法的返回类型,以及调用方法等功能。
首先,通过如下代码得到方法:

//输出类的public方法
Method[] methods = exampleObjectClass.getMethods();
for (Method method : methods) {
    System.out.println("method = "+ method.getName());
}

和获取变量一样似曾相识的代码,这里直接调用了getName,来得到类中写的方法名。写到这里,大家应该自然想到,Java同样提供了根据参数,得到具体的方法。

Method method = exampleObjectClass.getMethod("setAge",int.class);
System.out.println(method.getName());

这里与得到变量不同的是,getMethod方法还需要传入参数的类型信息,反射提供获取方法参数以及返回类型的方法,得到方法参数的例子如下:

Method method = exampleObjectClass.getMethod("setAge",int.class);
System.out.println(method.getName());
for (Class clz : method.getParameterTypes()) {
    System.out.println("方法的参数" + clz.getName());
}

结果如下:

setAge
方法的参数int

得到方法返回类型的例子如下:

System.out.println(method.getReturnType().getName());

结果如下:

void

此外,Java反射支持通过invoke调用得到的方法。例子如下:

method.invoke(exampleObjectClass.newInstance(),1);

invoke第一个参数是这个对象,第二个参数是变长数组,传入该方法的参数。和Field对象同样,对于静态方法同样,可以传入null,调用静态方法。

私有变量与私有方法

上面的方法只能得到public方法和变量,无法得到非public修饰的方法和变量,Java提供了额外的方法来得到非public变量与方法。即通过 getDeclaredFieldsgetDeclaredMethods 方法得到私有的变量与方法,同样也支持用 getDeclaredField(变量名)getDeclaredMethod(方法名) 的形式得到指定的变量名与方法名。但是这样得到的Field对象与Method对象无法直接运用,必须让这些对象调用setAccessible(true),才能正常运用。之后的方式就可上面讲的一样了。

注解

先写一个包含注解的类:

@MyAnnotation(name = "byhieg", value = "hello world")
public class AnnotationObject {
    @MyAnnotation(name = "field", value = "变量")
    public String field;
    @MyAnnotation(name = "method", value = "方法")
    public void doSomeThing() {
        System.out.println("做一些事情");
    }
    public void doOtherThing(@MyAnnotation(name = "param", value = "参数") String param) {
    }
}
@Retention(RetentionPolicy.RUNTIME)
public @interface MyAnnotation {
    public String name();
    public String value();
}

Java给我们提供了在运行时获取类的注解信息,可以得到类注解,方法注解,参数注解,变量注解。
与上面获取方式一样,Java提供了2种获取方式,一种是获取全部的注解,返回一个数组,第二种是指定得到指定的注解。
我们以一个类注解为例,讲解以下这两种获取方式。

Class clz = AnnotationObject.class;
Annotation[] annotations = clz.getAnnotations();
Annotation annotation = clz.getAnnotation(AnnotationObject.class);

然后,就可以根据得到的注解进行后续的处理,下面是一个处理的例子:

for (Annotation annotation : annotations) {
    if (annotation instanceof MyAnnotation) {
        MyAnnotation myAnnotation = (MyAnnotation) annotation;
        System.out.println("name: " + myAnnotation.name());
        System.out.println("value:" + myAnnotation.value());
    }
}

上面的类注解使用Class对象调用 getAnnotations 得到的,方法注解和变量注解是一样的,分别用method对象与field对象调用 getDeclaredAnnotations 得到注解,没什么多说的。例子看 反射代码
参数注解是比较麻烦的一项,获取方式比较得到,第一步,先取得method对象,调用 getParameterAnnotations ,但是这个返回值是一个二维数组,因为method对象有很多参数,每个参数有可能有很多注解。例子如下:

Method method1 = clz.getMethod("doOtherThing", String.class);
Annotation[][] annotationInParam = method1.getParameterAnnotations();
Class[] params = method1.getParameterTypes();
int i = 0;
for (Annotation[] annotations : annotationInParam) {
    Class para = params[i++];
    for (Annotation annotation : annotations) {
        if (annotation instanceof MyAnnotation) {
            MyAnnotation myAnnotation = (MyAnnotation) annotation;
            System.out.println("param: " + para.getName());
            System.out.println("name : " + myAnnotation.name());
            System.out.println("value :" + myAnnotation.value());
        }
    }
}

泛型

因为Java泛型是通过擦除来实现的,很难直接得到泛型具体的参数化类型的信息,但是我们可以通过一种间接的形式利用反射得到泛型信息。比如下面这个类:

public class GenericObject {
    public List<String> lists;
    public List<String> getLists() {
        return lists;
    }
    public void setLists(List<String> lists) {
        this.lists = lists;
    }
}

如果一个方法返回一个泛型类,我们可以通过method对象去调用 getGenericReturnType 来得到这个泛型类具体的参数化类型是什么。看下面的代码:

Class clz = GenericObject.class;
Method method = clz.getMethod("getLists");
Type genericType = method.getGenericReturnType();
if (genericType instanceof ParameterizedType) {
    ParameterizedType parameterizedType = ((ParameterizedType) genericType);
    Type[] types = parameterizedType.getActualTypeArguments();
    for (Type type : types) {
        Class actualClz = ((Class) type);
        System.out.println("参数化类型为 : " + actualClz);
    }
}

结果如下:

参数化类型为 : class java.lang.String

步骤有点繁琐,下面一步步解释:

  1. 反射得到返回类型为泛型类的方法
  2. 调用 getGenericReturnType 得到方法返回类型中的参数化类型
  3. 判断该type对象能不能向下转型为 ParameterizedType
  4. 转型成功,调用 getActualTypeArguments 得到参数化类型的数组,因为有的泛型类,不只只有一个参数化类型如Map
  5. 取出数组中的每一个的值,转型为Class对象输出。

看结果确实得到了泛型的具体的信息。
如果没有一个方法返回泛型类型,那么我们也可以通过方法的参数为泛型类,来得到泛型的参数化类型,如上面类中的setLists方法。例子如下:

Method setMethod = clz.getMethod("setLists", List.class);
Type[] genericParameterTypes = setMethod.getGenericParameterTypes();
for (Type genericParameterType : genericParameterTypes) {
    System.out.println("GenericParameterTypes为 : " + genericParameterType.getTypeName());
    if (genericParameterType instanceof ParameterizedType) {
        ParameterizedType parameterizedType = ((ParameterizedType) genericParameterType);
        System.out.println("ParameterizedType为 :" + parameterizedType.getTypeName());
        Type types[] = parameterizedType.getActualTypeArguments();
        for (Type type : types) {
            System.out.println("参数化类型为 : " + ((Class) type).getName());
        }
    }
}

执行的结果如下:

GenericParameterTypes为 : java.util.List<java.lang.String>
ParameterizedType为 :java.util.List<java.lang.String>
参数化类型为 : java.lang.String

因为方法的参数为泛型类型的可能不止一个,所以通过 getGenericParameterTypes 得到是一个数组,我们需要确定每一个元素,是否是具有参数化类型。后续的步骤与上面类似,就不多说了。
如果连方法参数都不带泛型类,那么只剩下最后一种情况,通过变量类型,即用Field类。例子如下:

Field field = clz.getField("lists");
Type type = field.getGenericType();
if (type instanceof ParameterizedType) {
    ParameterizedType parameterizedType = ((ParameterizedType) type);
    Type[] types = parameterizedType.getActualTypeArguments();
    for (Type type1 : types) {
        System.out.println("参数化类型 : " + ((Class) type1).getTypeName());
    }
}

原理和上面的一样,只不过Type对象是通过 field.getGenericType() ,剩下的操作类似就不多说了。
关于通过反射获取泛型的参数化类型的信息的介绍就到此为止。

数组

Java反射可以对数组进行操作,包括创建一个数组,访问数组中的值,以及得到一个数组的Class对象。
下面,先说简单的,创建数组以及访问数组中的值:在反射中使用Array这个类,是reflect包下面的。

// 创建一个int类型的数组,长度为3
int[] intArray = (int[]) Array.newInstance(int.class, 3);
// 通过反射的形式,给数组赋值
for (int i = 0; i < intArray.length; i++) {
    Array.set(intArray, i, i + 2);
}
// 通过反射的形式,得到数组中的值
for (int i = 0; i < intArray.length; i++) {
    System.out.println(Array.get(intArray, i));
}

上述就是创建数组,访问数组中的值利用反射方式。
对于得到一个数组的Class对象,简单的可以用 int[].class ,或者利用Class.forName的形式得到,写法比较奇怪:

Class clz = Class.forName("[I");
System.out.println(clz.getTypeName());

结果为:

int[]

这个forName中的字符串, [ 表示是数组, I 表示是int,float就是 F ,double就是 D 等等,如果要得到一个普通对象的数组,则用下面的形式:

Class stringClz = Class.forName("[Ljava.lang.String;");

[ 表示是数组, L 的右边是类名,类型的右边是一个 ; ;
这种方式获取数组的Class对象实在是太繁琐了。
在得到数组的Class对象之后,就可以调用他的一些独特的方法,比如调用 getComponentType 来得到数组成员的类型信息,如int数组就是成员类型就是int。

System.out.println(clz.getComponentType().getTypeName());

结果为 int

作者:一杯甜酒

来源:https://blog.csdn.net/u012562943/article/details/54405941


版权声明:文末如注明作者和来源,则表示本文系转载,版权为原作者所有 | 本文如有侵权,请及时联系,承诺在收到消息后第一时间删除 | 如转载本文,请注明原文链接。
喜欢 (2)