`

什么是反射机制?

    博客分类:
  • Java
 
阅读更多

(注:本文摘自网络,仅用于自身学习)

 

反射的概念是由Smith1982年首次提出的,主要是指程序可以访问、检测和修改它本身状态或行为的一种能力。这一概念的提出很快引发了计算机科学领域关于应用反射性的研究。它首先被程序语言的设计领域所采用,并在Lisp和面向对象方面取得了成绩。其中LEAD/LEAD++ OpenC++ MetaXaOpenJava等就是基于反射机制的语言。最近,反射机制也被应用到了视窗系统、操作系统和文件系统中。

反射本身并不是一个新概念,它可能会使我们联想到光学中的反射概念,尽管计算机科学赋予了反射概念新的含义,但是,从现象上来说,它们确实有某些相通之处,这些有助于我们的理解。在计算机科学领域,反射是指一类应用,它们能够自描述和自控制。也就是说,这类应用通过采用某种机制来实现对自己行为的描述(self-representation)和监测(examination),并能根据自身行为的状态和结果,调整或修改应用所描述行为的状态和相关的语义。可以看出,同一般的反射概念相比,计算机科学领域的反射不单单指反射本身,还包括对反射结果所采取的措施。所有采用反射机制的系统(即反射系统)都希望使系统的实现更开放。可以说,实现了反射机制的系统都具有开放性,但具有开放性的系统并不一定采用了反射机制,开放性是反射系统的必要条件。一般来说,反射系统除了满足开放性条件外还必须满足原因连接(Causally-connected)。所谓原因连接是指对反射系统自描述的改变能够立即反映到系统底层的实际状态和行为上的情况,反之亦然。开放性和原因连接是反射系统的两大基本要素。

Java中,反射是一种强大的工具。它使您能够创建灵活的代码,这些代码可以在运行时装配,无需在组件之间进行源代表链接。反射允许我们在编写与执行时,使我们的程序代码能够接入装载到JVM中的类的内部信息,而不是源代码中选定的类协作的代码。这使反射成为构建灵活的应用的主要工具。但需注意的是:如果使用不当,反射的成本很高。

二、Java中的类反射:

Reflection Java 程序开发语言的特征之一,它允许运行中的 Java 程序对自身进行检查,或者说自审,并能直接操作程序的内部属性。Java 的这一能力在实际应用中也许用得不是很多,但是在其它的程序设计语言中根本就不存在这一特性。例如,PascalC 或者 C++ 中就没有办法在程序中获得函数定义相关的信息。

1.检测类:

1.1 reflection的工作机制

考虑下面这个简单的例子,让我们看看 reflection 是如何工作的。

import java.lang.reflect.*;
public class DumpMethods {
     public static void main(String args[]) {
         try {
             Class c = Class.forName(args[0]);
             Method m[] = c.getDeclaredMethods();
             for (int i = 0; i < m.length; i++)
                 System.out.println(m[i].toString());
         } catch (Throwable e) {
             System.err.println(e);
         }
     }
}

按如下语句执行:

java DumpMethods java.util.Stack

它的结果输出为:

public java.lang.Object java.util.Stack.push(java.lang.Object)

public synchronized java.lang.Object java.util.Stack.pop()

public synchronized java.lang.Object java.util.Stack.peek()

public boolean java.util.Stack.empty()

public synchronized int java.util.Stack.search(java.lang.Object)

这样就列出了java.util.Stack 类的各方法名以及它们的限制符和返回类型。

这个程序使用 Class.forName 载入指定的类,然后调用 getDeclaredMethods 来获取这个类中定义了的方法列表。java.lang.reflect.Methods 是用来描述某个类中单个方法的一个类。

1.2 Java类反射中的主要方法

对于以下三类组件中的任何一类来说 -- 构造函数、字段和方法 -- java.lang.Class 提供四种独立的反射调用,以不同的方式来获得信息。调用都遵循一种标准格式。以下是用于查找构造函数的一组反射调用:

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

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

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

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

获得字段信息的Class 反射调用不同于那些用于接入构造函数的调用,在参数类型数组中使用了字段名:

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

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

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

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

用于获得方法信息函数:

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

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

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

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

 

1.3开始使用 Reflection

用于 reflection 的类,如 Method,可以在 java.lang.relfect 包中找到。使用这些类的时候必须要遵循三个步骤:第一步是获得你想操作的类的 java.lang.Class 对象。在运行中的 Java 程序中,用 java.lang.Class 类来描述类和接口等。

下面就是获得一个 Class 对象的方法之一:

Class c = Class.forName("java.lang.String");

这条语句得到一个 String 类的类对象。还有另一种方法,如下面的语句:

Class c = int.class;

或者

Class c = Integer.TYPE;

它们可获得基本类型的类信息。其中后一种方法中访问的是基本类型的封装类 ( Integer) 中预先定义好的 TYPE 字段。

第二步是调用诸如 getDeclaredMethods 的方法,以取得该类中定义的所有方法的列表。

一旦取得这个信息,就可以进行第三步了——使用 reflection API 来操作这些信息,如下面这段代码:

Class c = Class.forName("java.lang.String");

Method m[] = c.getDeclaredMethods();

System.out.println(m[0].toString());

它将以文本方式打印出 String 中定义的第一个方法的原型。

2.处理对象:

如果要作一个开发工具像debugger之类的,你必须能发现filed values,以下是三个步骤:

a.创建一个Class对象
b.
通过getField 创建一个Field对象
c.
调用Field.getXXX(Object)方法(XXXInt,Float等,如果是对象就省略;Object是指实例).

例如:
import java.lang.reflect.*;
import java.awt.*;

class SampleGet {

    public static void main(String[] args) {
       Rectangle r = new Rectangle(100, 325);
       printHeight(r);

    }

    static void printHeight(Rectangle r) {
       Field heightField;
       Integer heightValue;
       Class c = r.getClass();
       try {
         heightField = c.getField("height");
         heightValue = (Integer) heightField.get(r);
         System.out.println("Height: " + heightValue.toString());
       } catch (NoSuchFieldException e) {
           System.out.println(e);
       } catch (SecurityException e) {
           System.out.println(e);
       } catch (IllegalAccessException e) {
           System.out.println(e);
       }
    }
}

 

三、安全性和反射

在处理反射时安全性是一个较复杂的问题。反射经常由框架型代码使用,由于这一点,我们可能希望框架能够全面接入代码,无需考虑常规的接入限制。但是,在其它情况下,不受控制的接入会带来严重的安全性风险,例如当代码在不值得信任的代码共享的环境中运行时。

由于这些互相矛盾的需求,Java编程语言定义一种多级别方法来处理反射的安全性。基本模式是对反射实施与应用于源代码接入相同的限制:

n          从任意位置到类公共组件的接入

n          类自身外部无任何到私有组件的接入

n          受保护和打包(缺省接入)组件的有限接入

不过至少有些时候,围绕这些限制还有一种简单的方法。我们可以在我们所写的类中,扩展一个普通的基本类java.lang.reflect.AccessibleObject 类。这个类定义了一种setAccessible方法,使我们能够启动或关闭对这些类中其中一个类的实例的接入检测。唯一的问题在于如果使用了安全性管理器,它将检测正在关闭接入检测的代码是否许可了这样做。如果未许可,安全性管理器抛出一个例外。

下面是一段程序,在TwoString 类的一个实例上使用反射来显示安全性正在运行:

public class ReflectSecurity {

     public static void main(String[] args) {

         try {

             TwoString ts = new TwoString("a", "b");

             Field field = clas.getDeclaredField("m_s1");

//           field.setAccessible(true);

             System.out.println("Retrieved value is " +

                 field.get(inst));

         } catch (Exception ex) {

             ex.printStackTrace(System.out);

         }

     }

}

如果我们编译这一程序时,不使用任何特定参数直接从命令行运行,它将在field .get(inst)调用中抛出一个IllegalAccessException异常。如果我们不注释field.setAccessible(true)代码行,那么重新编译并重新运行该代码,它将编译成功。最后,如果我们在命令行添加了JVM参数-Djava.security.manager以实现安全性管理器,它仍然将不能通过编译,除非我们定义了ReflectSecurity类的许可权限。

四、反射性能

反射是一种强大的工具,但也存在一些不足。一个主要的缺点是对性能有影响。使用反射基本上是一种解释操作,我们可以告诉JVM,我们希望做什么并且它满足我们的要求。这类操作总是慢于只直接执行相同的操作。

下面的程序是字段接入性能测试的一个例子,包括基本的测试方法。每种方法测试字段接入的一种形式 -- accessSame 与同一对象的成员字段协作,accessOther 使用可直接接入的另一对象的字段,accessReflection 使用可通过反射接入的另一对象的字段。在每种情况下,方法执行相同的计算 -- 循环中简单的加/乘顺序。

程序如下:

public int accessSame(int loops) {

     m_value = 0;

     for (int index = 0; index < loops; index++) {

         m_value = (m_value + ADDITIVE_VALUE) *

             MULTIPLIER_VALUE;

     }

     return m_value;

}

 

public int accessReference(int loops) {

     TimingClass timing = new TimingClass();

     for (int index = 0; index < loops; index++) {

         timing.m_value = (timing.m_value + ADDITIVE_VALUE) *

             MULTIPLIER_VALUE;

     }

     return timing.m_value;

}

 

public int accessReflection(int loops) throws Exception {

     TimingClass timing = new TimingClass();

     try {

         Field field = TimingClass.class.

             getDeclaredField("m_value");

         for (int index = 0; index < loops; index++) {

             int value = (field.getInt(timing) +

                 ADDITIVE_VALUE) * MULTIPLIER_VALUE;

             field.setInt(timing, value);

         }

         return timing.m_value;

     } catch (Exception ex) {

         System.out.println("Error using reflection");

         throw ex;

     }

}

在上面的例子中,测试程序重复调用每种方法,使用一个大循环数,从而平均多次调用的时间衡量结果。平均值中不包括每种方法第一次调用的时间,因此初始化时间不是结果中的一个因素。下面的图清楚的向我们展示了每种方法字段接入的时间:

1:字段接入时间

我们可以看出:在前两副图中(Sun JVM),使用反射的执行时间超过使用直接接入的1000倍以上。通过比较,IBM JVM可能稍好一些,但反射方法仍旧需要比其它方法长700倍以上的时间。任何JVM上其它两种方法之间时间方面无任何显著差异,但IBM JVM几乎比Sun JVM快一倍。最有可能的是这种差异反映了Sun Hot Spot JVM的专业优化,它在简单基准方面表现得很糟糕。反射性能是Sun开发1.4 JVM时关注的一个方面,它在反射方法调用结果中显示。在这类操作的性能方面,Sun 1.4.1 JVM显示了比1.3.1版本很大的改进。

如果为为创建使用反射的对象编写了类似的计时测试程序,我们会发现这种情况下的差异不象字段和方法调用情况下那么显著。使用newInstance()调用创建一个简单的java.lang.Object实例耗用的时间大约是在Sun 1.3.1 JVM上使用new Object()12倍,是在IBM 1.4.0 JVM的四倍,只是Sun 1.4.1 JVM上的两部。使用Array.newInstance(type, size)创建一个数组耗用的时间是任何测试的JVM上使用new type[size]的两倍,随着数组大小的增加,差异逐步缩小。

结束语

Java语言反射提供一种动态链接程序组件的多功能方法。它允许程序创建和控制任何类的对象(根据安全性限制),无需提前硬编码目标类。这些特性使得反射特别适用于创建以非常普通的方式与对象协作的库。例如,反射经常在持续存储对象为数据库、XML或其它外部格式的框架中使用。Java reflection 非常有用,它使类和数据结构能按名称动态检索相关信息,并允许在运行着的程序中操作这些信息。Java 的这一特性非常强大,并且是其它一些常用语言,如 CC++Fortran 或者 Pascal 等都不具备的。

但反射有两个缺点。第一个是性能问题。用于字段和方法接入时反射要远慢于直接代码。性能问题的程度取决于程序中是如何使用反射的。如果它作为程序运行中相对很少涉及的部分,缓慢的性能将不会是一个问题。即使测试中最坏情况下的计时图显示的反射操作只耗用几微秒。仅反射在性能关键的应用的核心逻辑中使用时性能问题才变得至关重要。

许多应用中更严重的一个缺点是使用反射会模糊程序内部实际要发生的事情。程序人员希望在源代码中看到程序的逻辑,反射等绕过了源代码的技术会带来维护问题。反射代码比相应的直接代码更复杂,正如性能比较的代码实例中看到的一样。解决这些问题的最佳方案是保守地使用反射——仅在它可以真正增加灵活性的地方——记录其在目标类中的使用。

 

 

利用反射实现的动态加载
<!--[if !supportLineBreakNewLine]-->
<!--[endif]-->

Bromon原创 请尊重版权

最近在成都写一个移动增值项目,俺负责后台server端。功能很简单,手机用户通过GPRS打开Socket与服务器连接,我则根据用户传过来的数据做出响应。做过似项目的兄弟一定都知道,首先需要定义一个似于MSNP的通讯协议,不过今天的话题是如何把这个系统设计得具有高度的扩展性。由于这个项目本身没有进行过较为完善的客户沟通和需求分析,所以以后肯定会有很多功能上的扩展,通讯协议肯定会越来越庞大,而我作为一个不那么勤快的人,当然不想以后再去修改写好的程序,所以这个项目是实践面向对象设计的好机会。

首先定义一个接口来隔离

package org.bromon.reflect;

public interface Operator

{

public java.util.List act(java.util.List params)

}

根据设计模式的原理,我们可以为不同的功能编写不同的,每个都继承Operator接口,客户端只需要针对Operator接口编程就可以避免很多麻烦。比如这个

package org.bromon.reflect.*;

public class Success implements Operator

{

public java.util.List act(java.util.List params)

{

List result=new ArrayList();

result.add(new String(“操作成功”));

return result;

}

}

我们还可以写其他很多,但是有个问题,接口是无法实例化的,我们必须手动控制具体实例化哪个,这很不爽,如果能够向应用程序传递一个参数,让自己去选择实例化一个,执行它的act方法,那我们的工作就轻松多了。

很幸运,我使用的是Java,只有Java才提供这样的反射机制,或者说内省机制,可以实现我们的无理要求。编写一个配置文件emp.properties:

#成功响应

1000=Success

#向客户发送普通文本消息

2000=Load

#客户向服务器发送普通文本消息

3000=Store

文件中的键名是客户将发给我的消息头,客户发送1000给我,那么我就执行Successact方法,似的如果发送2000给我,那就执行Loadact方法,这样一来系统就完全符合开闭原则了,如果要添加新的功能,完全不需要修改已有代码,只需要在配置文件中添加对应规则,然后编写新的,实现act方法就ok,即使我弃这个项目而去,它将来也可以很好的扩展。这样的系统具备了非常良好的扩展性和可插入性。

下面这个例子体现了动态加载的功能,程序在执行过程中才知道应该实例化哪个

package org.bromon.reflect.*;

import java.lang.reflect.*;

public class TestReflect

{

//加载配置文件,查询消息头对应的

private String loadProtocal(String header)

{

String result=null;

try

{

Properties prop=new Properties();

FileInputStream fis=new FileInputStream("emp.properties");

prop.load(fis);

result=prop.getProperty(header);

fis.close();

}catch(Exception e)

{

System.out.println(e);

}

return result;

}

//针对消息作出响应,利用反射导入对应的

public String response(String header,String content)

{

String result=null;

String s=null;

try

{

/*

* 导入属性文件emp.properties,查询header所对应的的名字

* 通过反射机制动态加载匹配的,所有的都被Operator接口隔离

* 可以通过修改属性文件、添加新的(继承MsgOperator接口)来扩展协议

*/

s="org.bromon.reflect."+this.loadProtocal(header);

//加载

Class c=Class.forName(s);

//创建的事例

Operator mo=(Operator)c.newInstance();

//构造参数列表

Class params[]=new Class[1];

params[0]=Class.forName("java.util.List");

//查询act方法

Method m=c.getMethod("act",params);

Object args[]=new Object[1];

args[0]=content;

//调用方法并且获得返回

Object returnObject=m.invoke(mo,args);

}catch(Exception e)

{

System.out.println("Handler-response:"+e);

}

return result;

}

public static void main(String args[])

{

TestReflect tr=new TestReflect();

tr.response(args[0],”消息内容”);

}

}

测试一下:java TestReflect 1000

这个程序是针对Operator编程的,所以无需做任何修改,直接提供LoadStore,就可以支持20003000做参数的调用。

有了这样的内省机制,可以把接口的作用发挥到极至,设计模式也更能体现出威力,而不仅仅供我们饭后闲聊。

 

反射机制指的是程序在运行时能够获取自身的信息。例如一个对象能够在运行时知道自
己有哪些方法和属性,这属于高级的面向对象程序设计的功能。在C#中,利用程序集中的
元数据来实现反射,能够在运行时动态判断和调用自己的属性或方法。

 

分享到:
评论

相关推荐

    关于反射机制的面试题.

    1.什么是反射机制?如何实现反射机制? 2.如何使用反射机制来动态地调用一个类的方法? 3.如何使用反射机制来动态地访问一个类的字段? 4.如何使用反射机制来动态地加载一个类? 六、结论 反射机制是 Java 中的一...

    Java反射机制的使用心得

    * 什么是反射机制? * 反射机制有哪些应用场景? * 反射机制会对程序的性能造成影响吗?

    C++反射机制实现

    在讨论C++反射机制实现的过程中,我们首先需要明确反射机制的概念和分类。反射的定义源自人工智能领域,它主要涉及到两种反射结构:结构反射和计算反射。结构反射侧重于元类与类之间的关系,计算反射则关注于计算...

    java反射机制.zip

    java反射机制java反射机制.zipjava反射机制.zipjava反射机制.zipjava反射机制.zipjava反射机制.zipjava反射机制.zipjava反射机制.zipjava反射机制.zipjava反射机制.zipjava反射机制.zipjava反射机制.zipjava反射机制...

    C++反射机制

    ### C++反射机制详解 #### 引言:C++与反射机制 在现代软件开发领域,反射机制(Reflection)作为一种强大的编程技术,被广泛应用于多种编程语言中,如C#、Java等。它允许程序在运行时检查和修改自身结构与行为,...

    java面试题--反射机制

    ### Java反射机制详解 #### 一、引言 在Java面试中,经常会出现与反射机制相关的题目。这是因为Java反射机制不仅是Java语言的一项重要特性,也是理解Java动态特性的关键所在。通过本文,我们将深入探讨Java反射...

    详解JAVA 反射机制

    什么是反射机制? 反射机制是指在程序运行状态中,对于任意一个类,都能够获取这个类的所有属性和方法;对于任意一个对象,都能够调用它的任意一个方法和属性。这种动态获取信息以及动态调用对象的方法的功能称为 ...

    反射机制和类加载机制学习总结

    ### 反射机制详解 #### 一、反射机制概述 反射是Java的一项核心特性,它使得Java程序在运行时能够动态地获取类的信息,并且能够直接操作这些信息。这种能力在许多其他编程语言中并不常见,例如在Pascal、C或C++中...

    java反射机制讲解

    Java反射机制是Java语言提供的一种强大的能力,它允许我们在运行时检查类的信息并动态地创建和操作对象。这种机制使得程序具有更高的灵活性和扩展性,尤其是在框架开发中有着广泛的应用。 首先,我们要理解反射的...

    java反射机制原理

    Java反射机制是Java编程语言中的一个核心特性,它允许运行中的Java程序对自身进行检查并且可以直接操作程序的内部属性。这一机制使得Java具备了高度的灵活性和动态性,尤其是在处理元数据、创建对象、调用方法和访问...

    反射机制反射Dao 反射机制

    在Java编程语言中,反射机制是一项强大的工具,它允许程序在运行时检查和操作类、接口、对象等的内部结构。反射机制的核心在于`java.lang.reflect`包中的类,如Class、Constructor、Method和Field。标题"反射机制...

    Java中的反射机制

    ### Java中的反射机制 #### 一、反射的概念 反射的概念最早由Smith于1982年提出,是指程序能够访问、检测和修改其自身状态或行为的能力。这一概念的引入促进了计算机科学领域对反射性的研究,并迅速被应用于程序...

    java反射机制详解

    #### 一、反射机制是什么 反射机制是Java编程语言的一个核心特性,它允许程序在运行时动态地获取类的信息,并且能够动态地创建对象和调用对象的方法。简单来说,反射机制使得Java程序可以自我检查、自我调整。 在...

    07JVM是如何实现反射的?1

    JVM 反射机制的实现和优化 Java 反射机制是 Java 语言中一个相当重要的特性,它允许正在运行的 Java 程序观测、甚至是修改程序的动态行为。Java 反射机制广泛应用于 IDE、调试器、Web 开发框架等领域。 反射机制的...

    反射机制例子及反射方法调用

    反射机制例子及反射方法调用 反射机制是一种非常强大的机制,它允许我们在运行时动态地加载和使用类、方法、变量等,这种机制可以使我们的程序更加灵活和可扩展。在Java中,反射机制是通过java.lang.reflect包来...

    Java反射机制 Java反射机制

    ### Java反射机制详解 #### 一、Java反射机制概述 Java反射机制是Java语言的一个重要特性,它允许程序在运行时获取类的信息并操作对象。Java反射机制的主要作用包括:获取类的所有属性和方法、构造动态实例、调用...

    2023版Java面试题.pdf

    1. 什么是反射机制?:反射机制是 Java 语言提供的一种机制,可以在运行时动态地访问和修改类的信息。 2. 如何使用反射?:可以使用反射机制来动态地创建对象、调用方法、访问变量等。 3. 反射有什么优缺点?:反射...

    Qt 使用QMetaObject实现反射机制代码demo

    在编程领域,反射机制是一种强大的特性,允许程序在运行时检查自身的行为,包括类的信息、对象的状态以及函数的调用等。在C++的世界里,Qt框架提供了一种实现反射的手段,即QMetaObject系统。这个系统允许我们动态地...

Global site tag (gtag.js) - Google Analytics