Chapter 13 . 反射机制

2018-10-04  本文已影响1人  GeekGray

阅读原文

Chapter 13 . 反射机制

13.1 Java反射机制研究及应用

Java Reflection

​ Reflection（反射）是被视为动态语言的关键，反射机制允许程序在执行期借助于Reflection API取得任何类的内部信息，并能直接操作任意对象的内部属性及方法

Java反射机制提供的功能

反射相关的主要API：

13.2 JavaClass 类

在Object类中定义了以下的方法，此方法将被所有子类继承：

● public final Class getClass()

以上的方法返回值的类型是一个Class类，此类是Java反射的源头，实际上所谓反射从程序的运行结果来看也很好理解，即：可以通过对象反射求出类的名称。

​ image

对照镜子后可以得到的信息：某个类的属性、方法和构造器、某个类到底实现了哪些接口。对于每个类而言，JRE 都为其保留一个不变的 Class 类型的对象。一个 Class 对象包含了特定某个类的有关信息。

Class类的常用方法

image

实例化Class类对象(四种方法)

1)前提：若已知具体的类，通过类的class属性获取，该方法 最为安全可靠，程序性能最高

​ 实例：Class clazz = String.class;

2）前提：已知某个类的实例，调用该实例的getClass()方法获取Class对象

​ 实例：Class clazz = “www.baidu.com”.getClass();

3）前提：已知一个类的全类名，且该类在类路径下，可通过Class类的静态方法forName()获取，可能抛出ClassNotFoundException

​ 实例：Class clazz = Class.forName(“java.lang.String”);

4）其他方式(无要求)

ClassLoader cl = this.getClass().getClassLoader();

Class clazz4 = cl.loadClass(“类的全类名”);

13.3 类的加载过程

当程序主动使用某个类时，如果该类还未被加载到内存中，则系统会通过如下三个步骤来对该类进行初始化。

image image

13.4 ClassLoader

类加载器是用来把类(class)装载进内存的。JVM 规范定义了两种类型的类加载器：启动类加载器(bootstrap)和用户自定义加载器(user-defined class loader)。 JVM在运行时会产生3个类加载器组成的初始化加载器层次结构 ，如下图所示：

image 
       //1.获取一个系统类加载器

       ClassLoader classloader = ClassLoader.getSystemClassLoader();

       System.out.println(classloader);

       //2.获取系统类加载器的父类加载器，即扩展类加载器

       classloader = classloader.getParent();

       System.out.println(classloader);

       //3.获取扩展类加载器的父类加载器，即引导类加载器

       classloader = classloader.getParent();

       System.out.println(classloader);

       //4.测试当前类由哪个类加载器进行加载

       classloader = Class.forName("exer2.ClassloaderDemo").getClassLoader();

       System.out.println(classloader);

       //5.测试JDK提供的Object类由哪个类加载器加载

       classloader = Class.forName("java.lang.Object").getClassLoader();

       System.out.println(classloader);

       //*6.关于类加载器的一个主要方法：getResourceAsStream(String str):获取类路径下的指定文件的输入流

       InputStream in = null;

       in = this.getClass().getClassLoader().getResourceAsStream("exer2\\test.properties");

       System.out.println(in);

13.5 创建类对象并获取类的完整结构

2.1.创建类的对象：调用Class对象的newInstance()方法

要 求：
1）类必须有一个无参数的构造器。

​ 2）类的构造器的访问权限需要足够。

难道没有无参的构造器就不能创建对象了吗？

1）通过Class类的getDeclaredConstructor(Class … parameterTypes)取得本类的指定形参类型的构造器

2）向构造器的形参中传递一个对象数组进去，里面包含了构造器中所需的各个参数。

//1.根据全类名获取对应的Class对象

String name = “example.java.Person";

Class clazz = null;

clazz = Class.forName(name);

//2.调用指定参数结构的构造器，生成Constructor的实例

Constructor con = clazz.getConstructor(String.class,Integer.class);

//3.通过Constructor的实例创建对应类的对象，并初始化类属性

Person p2 = (Person)      con.newInstance("Peter",20);

System.out.println(p2);

通过反射调用类的完整结构

**Field、Method、Constructor、Superclass、Interface、Annotation

使用反射可以取得：

1.实现的全部接口

确定此对象所表示的类或接口实现的接口。

2.所继承的父类

返回表示此 Class 所表示的实体（类、接口、基本类型）的父类的 Class。

3.全部的构造器

返回此 Class 对象所表示的类的所有public构造方法。

返回此 Class 对象表示的类声明的所有构造方法。

Constructor类中：

4.全部的方法

返回此Class对象所表示的类或接口的全部方法

返回此Class对象所表示的类或接口的public的方法

Method类中：

5.全部的Field

返回此Class对象所表示的类或接口的public的Field。

返回此Class对象所表示的类或接口的全部Field。

Field方法中：

6. Annotation相关

7.泛型相关

获取父类泛型类型：Type getGenericSuperclass()

泛型类型：ParameterizedType

获取实际的泛型类型参数数组：getActualTypeArguments()

8类所在的包 Package getPackage()

13.6 通过反射调用类中的指定方法、指定属性

1.调用指定方法

通过反射，调用类中的方法，通过Method类完成。步骤：

1.通过Class类的getMethod(String name,Class…parameterTypes)方法取得一个Method对象，并设置此方法操作时所需要的参数类型。

2.之后使用Object invoke(Object obj, Object[] args)进行调用，并向方法中传递要设置的obj对象的参数信息。

image

3.Object invoke(Object obj, Object … args)

​ 1.Object 对应原方法的返回值，若原方法无返回值，此时返回null

​ 2.若原方法若为静态方法，此时形参Object obj可为null

​ 3.若原方法形参列表为空，则Object[] args为null

​ 4.若原方法声明为private,则需要在调用此invoke()方法前，显式调用方法对象的setAccessible(true)方法，将可访问private的方法。

2.****调用指定属性

在反射机制中，可以直接通过Field类操作类中的属性，通过Field类提供的set()和get()方法就可以完成设置和取得属性内容的操作。

在Field****中：

注：在类中属性都设置为private的前提下，在使用set()和get()方法时，首先要使用Field类中的setAccessible(true)方法将需要操作的属性设置为可以被外部访问。

13.7 Java动态代理

静态代理，特征是代理类和目标对象的类都是在编译期间确定下来，不利于程序的扩展。同时，每一个代理类只能为一个接口服务，这样一来程序开发中必然产生过多的代理。

动态代理

动态代理使用场合:

代理设计模式的原理:

​ 使用一个代理将对象包装起来, 然后用该代理对象取代原始对象. 任何对原始对象的调用都要通过代理. 代理对象决定是否以及何时将方法调用转到原始对象上

动态代理步骤

1.创建一个实现接口InvocationHandler的类，它必须实现invoke方法，以完成代理的具体操作。

**public Object invoke(Object theProxy, Method method, Object[] params) throws Throwable{**

​        try

​        {

​         Object retval = method.invoke(targetObj, params);

​         // Print out the result

​           System.out.println(retval);

​            return retval;

​        }

​      catch (Exception exc){}

2.创建被代理的类以及接口

image

3.通过Proxy的静态方法

newProxyInstance(ClassLoader loader, Class[] interfaces, InvocationHandler h) 创建一个Subject接口代理

   RealSubject target = new RealSubject();

// Create a proxy to wrap the original implementation

​            DebugProxy proxy = new DebugProxy(target);

 // Get a reference to the proxy through the Subject interface

​          Subject sub = (Subject) Proxy.newProxyInstance(

​            Subject.class.getClassLoader(),

​            new Class[] { Subject.class }, proxy);

4.通过 Subject代理调用RealSubject实现类的方法

​     String info = sub.say(“Peter", 24);

​     System.out.println(info);
上一篇 下一篇

猜你喜欢

热点阅读