Java의 RTTI 및 반사 메커니즘에 대한 자세한 설명

이 기사에서는 주로 Java의 RTTI 및 반사 메커니즘 코드 분석을 소개하면서 해당 예제와 반사 메커니즘이 언제 사용될지 보여줍니다.

RTTI, 즉 런타임 유형 식별, 런타임 유형 식별입니다. 런타임 유형 식별은 Java 런타임 중에 RTTI가 클래스 관련 정보를 유지하는 데 매우 유용한 메커니즘입니다. RTTI는 런타임에 컴파일 시간에 알려진 모든 유형을 자동으로 식별할 수 있습니다.

상향 변환을 수행해야 하는 경우가 많습니다. 예를 들어 Base 클래스는 Derived 클래스를 파생하지만 기존 메서드에는 Base 개체만 매개 변수로 필요하고 실제로 전달되는 것은 파생 클래스에 대한 참조입니다. . 그러면 이때 RTTI가 역할을 합니다. 예를 들어 RTTI는 Derive 클래스가 Base의 파생 클래스임을 식별하여 상위로 Derived로 변환할 수 있습니다. 마찬가지로 인터페이스를 매개변수로 사용하는 경우에는 상향변환(upward Transformation)을 더 많이 사용하는데, 이때 상향변환이 가능한지 RTTI를 통해 판단할 수 있다.

이 유형 정보는 클래스 관련 정보가 포함된 Class 객체(java.lang.Class)의 특수 객체를 통해 완성됩니다. 클래스가 작성되고 컴파일될 때마다 클래스 객체를 보유하는 .class 파일이 생성됩니다. 이 프로그램을 실행하는 JVM(Java Virtual Machine)은 클래스 로더(클래스 로더)라는 하위 시스템을 사용합니다. 클래스 로더는 프로그램이 실행되기 전에 모든 클래스 객체를 로드하지 않습니다. 해당 객체가 로드되지 않은 경우 기본 클래스 로더는 클래스 이름을 기반으로 .class 파일을 검색합니다. 예를 들어 추가 클래스 로더는 다음 단어를 검색할 수 있습니다. bytecode), 이 클래스의 바이트코드는 로드될 때 손상되지 않았는지, 잘못된 Java 코드가 포함되어 있지 않은지 확인됩니다. 이는 Java의 유형 안전 메커니즘 중 하나이기도 합니다. 특정 클래스의 Class 객체가 메모리에 로드되면 해당 클래스의 모든 객체가 생성될 수 있습니다.

package typeinfo;
class Base {
  static { System.out.println("加载Base类"); }
}
class Derived extends Base { 
  static { System.out.println("加载Derived类");}
}
public class Test {
  static void printerInfo(Class c) {
    System.out.println("类名: " + c.getName() +
      "是否接口? [" + c.isInterface() + "]");
  }
  public static void main(String[] args) {
    Class c = null;
    try {
      c = Class.forName("typeinfo.Derived");
    } catch (ClassNotFoundException e) {
      System.out.println("找不到Base类");
      System.exit(1);
    }
    printerInfo(c);
    Class up = c.getSuperclass(); // 取得c对象的基类
    Object obj = null;
    try {
      obj = up.newInstance();
    } catch (InstantiationException e) {
      System.out.println("不能实例化");
      System.exit(1);
    } catch (IllegalAccessException e) {
      System.out.println("不能访问");
      System.exit(1);
    }
    printerInfo(obj.getClass());
  } /* 输出:
  加载Base类
  加载Derived类
  类名: typeinfo.Derived是否接口? [false]
  类名: typeinfo.Base是否接口? [false]
  */
}

위 코드에서 forName 메소드는 정적 메소드입니다. 매개변수는 클래스가 존재하는지 여부를 찾는 데 사용되는 클래스 이름입니다. 그렇지 않으면 클래스 참조가 반환됩니다. ClassNotFoundException 예외가 발생합니다.

클래스가 기본 폴더가 아닌 특정 패키지에 있는 경우 여기에는 typeinfo.Derived와 같이 이전 패키지 이름을 포함해야 합니다.

getSuperclass 메소드를 사용하여 기본 클래스에 해당하는 Class 객체를 반환할 수 있습니다. newInstance 메소드를 사용하여 기본 구성에 따라 인스턴스 객체를 생성하고 인스턴스화할 수 없고 액세스할 수 없는 경우 해당 객체를 던집니다. InstantiationException 및 IllegalAccessException이 발생합니다.

Java는 클래스 객체에 대한 참조, 즉 클래스 리터럴을 생성하는 방법도 제공합니다. 위 프로그램의 경우 up은 Base.class와 동일합니다.

기본 데이터 유형의 래퍼 클래스의 경우 char.class는 Character.TYPE과 동일하고 int.class는 Integer.TYPE과 동일합니다. 나머지 ab.class는 Ab.TYPE과 동일합니다. (예를 들어 void.class는 Void.TYP와 동일합니다.) 또한 Java SE5부터는 int.class와 Integer.class도 동일합니다.

일반화된 클래스 참조, 아래 코드 참조

    Class intClass = int.class;
    Class<Integer> genericIntClass = int.class;
    genericIntClass = Integer.class; // 等价
    intClass = double.class; // ok
    // genericIntClass = double.class; // Illegal!

Classc0f559cc8d56b43654fcbe4aa9df7b4a객체의 참조는 Integer 객체를 지정하므로 참조가 double.class를 가리킬 수 없습니다. 제한을 완화하기 위해 와일드카드 문자 ?, 즉 Class6b3d0130bba23ae47fe2b8e8cddf0195를 사용할 수 있습니다. 효과는 Class와 동일하지만 Class6b3d0130bba23ae47fe2b8e8cddf0195를 사용하면 코드가 더 우아해집니다. 우연이나 부주의로 인해 불특정 클래스 참조를 사용합니다. 동시에 상속되는 클래스를 제한할 수 있습니다.

class Base {}
class Derived extends Base {}
class Base2 {}
public class Test {
  public static void main(String[] args) {
    Class<? extends Base> cc = Derived.class; // ok
    // cc = Base2.class; // Illegal
  } 
}

클래스 참조에 일반 구문을 추가하는 이유는 단지 컴파일 시 유형 오류를 찾을 수 있도록 컴파일 시간 유형 검사를 제공하기 위한 것입니다. 시간.

알려진 RTTI 형식은 다음과 같습니다.

1. RTTI는 잘못된 유형 변환이 수행되면 ClassCastException이 발생합니다. 클래스 객체는 객체의 종류를 나타내며 런타임에 필요한 정보는 Class 객체를 쿼리(즉, Class 클래스의 메소드 호출)하여 얻을 수 있습니다.

C++의 클래식 유형 변환은 RTTI를 사용하지 않습니다. 자세한 내용은 C++의 RTTI 섹션을 참조하세요. (여담으로 C++를 배울 때 RTTI 챕터를 무심코 훑어봤던 기억이 나네요. 이제 타입 안전성을 위해 특별히 Dynamic_cast 등이 추가된 게 기억나네요. C++도 Java처럼 안전성 측면에서 선택성을 제공할 수 있습니다. StringBuilder와 StringBuffer, 안전성과 효율성을 동시에 달성할 수 없습니까? x = 1 표현식이 암시적으로 부울 유형으로 변환될 수 없는 것처럼 유형 안전성 측면에서 Java가 더 중요합니다.

Java에는 RTTI의 세 번째 형태가 있는데, 인스턴스of라는 키워드는
부울 값

을 반환하여 객체가 특정 유형의 예인지 여부를 알려줍니다. 다음 코드를 참조하세요.

class Base {}
class Derived extends Base {}
public class Test {
  public static void main(String[] args) {
    Derived derived = new Derived();
    System.out.println(derived instanceof Base); // 输出true
  } 
}

instanceof를 사용하여 특정 유형을 결정할 수 있습니다. 예를 들어 기본 클래스인 Shape는 다양한 클래스(Circle, Rectangle 등)를 파생합니다. 이제 특정 메서드는 모든 원에 색상을 지정하려고 하며 입력 매개 변수는 다음과 같습니다. Shape 객체 묶음. Instandof를 사용하여 Shape 객체가 Circle 객체인지 확인할 수 있습니다.

RTTI可以识别程序空间的所有类，但是有时候需要从磁盘文件或网络文件中读取一串字节码，并且被告知这些字节代表一个类，就需要用到反射机制。

比如在IDE中创建图形化程序时会使用到一些控件，只需要从本地的控件对应class文件中读取即可，然后再主动修改这些控件的属性。（题外话：大概.net组件就是这样的？学C#时总听到反射，但总没感觉用过，前几天做.net项目的同学也跟我说他从来都没用过委托和事件……）

Class类与java.lang.reflect类库一起对反射的概念进行了支持，该类库包含Field、Method和Constructor类（每个类都实现了Member接口），这些类型的对象都是JVM在运行时创建的，用以表示未知类里对应成员。

这样就可以用Constructor创建未知对象，用get()和set()方法读取和修改与Field对象关联的字段，用invoke方法调用与Method对象关联的字段，等等。

// 使用反射展示类的所有方法, 即使方法是在基类中定义的
package typeinfo;
// Print类的print方法等价于System.Out.Println，方便减少代码量
import static xyz.util.Print.*;
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
import java.util.regex.Pattern;
// {Args: typeinfo.ShowMethods}
public class ShowMethods {
  private static String usage = 
    "usage:\n" +
    "ShowMethods qualified.class.name\n" +
    "To show all methods in class or:\n" +
    "ShowMethods qualified.class.name word\n" +
    "To search for methods involving 'word'";
  // 去掉类名前面的包名
  private static Pattern p = Pattern.compile("\\w+\\.");
  public static void main(String[] args) {
    if (args.length < 1) {
      print(usage);
      System.exit(0);
    }
    int lines = 0;
    try {
      Class<?> c = Class.forName(args[0]);
      // 反射获得对象c所属类的方法
      Method[] methods = c.getMethods();
      // 反射获得对象c所属类的构造
      Constructor[] ctors = c.getConstructors();
      if (args.length == 1) {
        for (Method method : methods)
          print(p.matcher(method.toString()).replaceAll(""));
        for (Constructor ctor : ctors)
          print(p.matcher(ctor.toString()).replaceAll(""));
      }
    } catch (ClassNotFoundException e) {
      print("No such class: " + e);
    }
  } /*
  public static void main(String[])
  public final void wait() throws InterruptedException
  public final void wait(long,int) throws InterruptedException
  public final native void wait(long) throws InterruptedException
  public boolean equals(Object)
  public String toString()
  public native int hashCode()
  public final native Class getClass()
  public final native void notify()
  public final native void notifyAll()
  public ShowMethods()
  */
}

简单来说，反射机制就是识别未知类型的对象。反射常用于动态代理中。举例如下：

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
class DynamicProxyHandler implements InvocationHandler {
  private Object proxied; // 代理对象
  public DynamicProxyHandler(Object proxied) {
    // TODO Auto-generated constructor stub
    this.proxied = proxied;
  }
  @Override
  public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    // TODO Auto-generated method stub
    System.out.println("代理类: " + proxy.getClass() + "\n"
        + "代理方法: " + method + "\n"
        + "参数: " + args);
    if (args != null)
      for (Object arg : args)
        System.out.println(" " + arg);
    return method.invoke(proxied, args);
  }
}
interface Interface { void doSomething(); }

class RealObject implements Interface {
  
  @Override
  public void doSomething() {
    // TODO Auto-generated method stub
    System.out.println("doSomething");
  }
}
public class DynamicProxyDemo {
  public static void consumer(Interface iface) {
    iface.doSomething();
  }
  public static void main(String[] args) {
    RealObject realObject = new RealObject();
    // 使用动态代理
    Interface proxy = (Interface)Proxy.newProxyInstance(
        Interface.class.getClassLoader(),
        new Class[] { Interface.class }, 
        new DynamicProxyHandler(realObject));
    consumer(proxy);
  } /* 输出：
  代理类: class $Proxy0
  代理方法: public abstract void Interface.doSomething()
  参数: null
  doSomething
  */
}

代理是基本的设计模式之一，即用代理类为被代理类提供额外的或不同的操作。而动态代理则需要一个类加载器，就像Java实现RTTI时需要类加载器加载类的信息，这样就可以知道类的相关信息。

关键方法是：

Object java.lang.reflect.Proxy.newProxyInstance(ClassLoader loader, Class6b3d0130bba23ae47fe2b8e8cddf0195[] interfaces, InvocationHandler h) throws IllegalArgumentException

传入三个参数：代理接口的加载器（通过Class对象的getClassLoader方法获取），代理的方法接口，代理对象

前两个参数很好理解，就是要代理的方法所属的接口对应的Class对象（主语）的加载器和Class对象本身,主要是参数3，要设计一个实现InvocationHandler接口的类，作为代理对象，一般命名以Handler结尾，Handler翻译为处理者，很形象，就是代替原对象进行处理的处理者（即代理），在程序设计中经常被翻译成“句柄”。

这个类通过传入代理对象来构造，比如这里传入的是Object对象。然后必须覆盖invoke方法。

通过最后输出和invoke方法的具体实现可以发现，return method.invoke(proxied, args);是相当于原对象调用该方法（类似C++的回调函数？）

由于有类加载器，所以代理对象可以知道原对象的具体类名、方法、参数，本示例在调用方法前就输出了这些。

实际应用中可能会针对类名而有所选择。比如接口中有好多个类，你可以选择性的对特定的类、方法、参数进行处理

比如 if(proxied instanceof RealObject) {} 或者 if(method.getName.equals("doSomething")) {}

总结

위 내용은 Java의 RTTI 및 반사 메커니즘에 대한 자세한 설명의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!