创建对象

通过反射来生成对象需要先使用 Class 对象获取指定的 Constructor 对象， 再调用 Constructor 对象的 newlnstance()方法来创建该 Class 对象对应类的实例。 通过这种方式可以选择使用指定的构造器来创建实例。

在很多 Java EE (例如Spring)框架中都需要根据配置文件信息来创建 Java 对象,从配置文件读取的只是某个类的字符串类名， 程序需要根据该字符串来创建对应的实例， 就必须使用反射。

下面程序就实现了一个简单的对象池， 该对象池会根据配置文件读取 key-value 对， 然后创建这些对象， 并将这些对象放入一个 HashMap 中:

import java.util.*;
import java.io.*;


public class ObjectPoolFactory {
	// 定义一个对象池，前面是对象名，后面是实际对象
	private Map<String, Object> objectPool = new HashMap<>();

	// 定义一个创建对象的方法
	// 该方法只要传入一个字符串类名，程序可以根据该类名生成Java对象
	private Object createObject(String clazzName) throws Exception, IllegalAccessException, ClassNotFoundException {
		// 根据字符串来获取对应的Class对象
		Class<?> clazz = Class.forName(clazzName);
		// 使用clazz对应类的默认构造器创建实例
		return clazz.getConstructor().newInstance();
	}

	// 该方法根据指定文件来初始化对象池
	// 它会根据配置文件来创建对象
	public void initPool(String fileName)
			throws InstantiationException, IllegalAccessException, ClassNotFoundException {
		try (FileInputStream fis = new FileInputStream(fileName)) {
			Properties props = new Properties();
			props.load(fis);
			for (String name : props.stringPropertyNames()) {
				// 每取出一对key-value对，就根据value创建一个对象
				// 调用createObject()创建对象，并将对象添加到对象池中
				objectPool.put(name, createObject(props.getProperty(name)));
			}
		} catch (Exception ex) {
			System.out.println("读取" + fileName + "异常");
		}
	}

	public Object getObject(String name) {
		// 从objectPool中取出指定name对应的对象
		return objectPool.get(name);
	}

	public static void main(String[] args) throws Exception {
		ObjectPoolFactory pf = new ObjectPoolFactory();
		pf.initPool("obj.txt");
		System.out.println(pf.getObject("a")); // ①
		System.out.println(pf.getObject("b")); // ②
	}
}

程序调用 Class 对象的 newlnstance()方法即可创建一个 Java 对象。 程序中的 initPool()方法会读取属性文件， 对属性文件中每个 key-value 对创建一个 Java 对象， 其中 value 是该 Java 对象的实现类， 而 key 是该 Java 对象放入对象池中的名字。 为该程序提供如下属性配置文件:

a=java.util.Date
b=javax.swing.JFrame

如果不想利用默认构造器来创建 Java 对象， 而想利用指定的构造器来创建 Java 对象， 则需要利用Constructor 对象， 每个 Constructor 对应一个构造器。 为了利用指定的构造器来创建 Java 对象， 需要如下三个步骤：

• 获取该类的 Class 对象：
• 利用 Class 对象的 getConstructor()方法来获取指定的构造器。
• 调用 Constructor 的 newlnstance()方法来创建 Java 对象。

下面程序利用反射来创建一个 JFrame 对象， 而且使用指定的构造器：

import java.lang.reflect.*;

public class CreateJFrame {
	public static void main(String[] args) throws Exception {
		// 获取JFrame对应的Class对象
		Class<?> jframeClazz = Class.forName("javax.swing.JFrame");
		// 获取JFrame中带一个字符串参数的构造器
		Constructor ctor = jframeClazz.getConstructor(String.class);
		// 调用Constructor的newInstance方法创建对象
		Object obj = ctor.newInstance("测试窗口");
		// 输出JFrame对象
		System.out.println(obj);
	}
}

调用方法

当获得某个类对应的 Class 对象后， 就可以通过该 Class 对象的 getMethods()方法或者 getMethod()方法来获取全部方法或指定方法—这两个方法的返回值是 Method 数组， 或者 Method 对象。每个 Method 对象对应一个方法， 获得 Method 对象后， 程序就可通过该 Method 来调用它对应的方法。 在 Method 里包含一个 invoke()方法， 该方法的签名如下:

• Object invoke(Object obj,Object...args)： 该方法中的 obj 是执行该方法的主调， 后面的 args 是执行该方法时传入该方法的实参。

下面程序对前面的对象池工厂进行加强， 允许在配置文件中增加配置对象的成员变量的值， 对象池工厂会读取为该对象配置的成员变量值， 并利用该对象对应的 setter 方法设置成员变量的值:

import java.util.*;
import java.io.*;
import java.lang.reflect.*;


public class ExtendedObjectPoolFactory {
	// 定义一个对象池，前面是对象名，后面是实际对象
	private Map<String, Object> objectPool = new HashMap<>();
	private Properties config = new Properties();

	// 从指定属性文件中初始化Properties对象
	public void init(String fileName) {
		try (FileInputStream fis = new FileInputStream(fileName)) {
			config.load(fis);
		} catch (IOException ex) {
			System.out.println("读取" + fileName + "异常");
		}
	}

	// 定义一个创建对象的方法
	// 该方法只要传入一个字符串类名，程序可以根据该类名生成Java对象
	private Object createObject(String clazzName) throws Exception {
		// 根据字符串来获取对应的Class对象
		Class<?> clazz = Class.forName(clazzName);
		// 使用clazz对应类的默认构造器创建实例
		return clazz.getConstructor().newInstance();
	}

	// 该方法根据指定文件来初始化对象池
	// 它会根据配置文件来创建对象
	public void initPool() throws Exception {
		for (String name : config.stringPropertyNames()) {
			// 每取出一个key-value对，如果key中不包含百分号（%）
			// 这就表明是根据value来创建一个对象
			// 调用createObject创建对象，并将对象添加到对象池中
			if (!name.contains("%")) {
				objectPool.put(name, createObject(config.getProperty(name)));
			}
		}
	}

	// 该方法将会根据属性文件来调用指定对象的setter方法
	public void initProperty() throws InvocationTargetException, IllegalAccessException, NoSuchMethodException {
		for (String name : config.stringPropertyNames()) {
			// 每取出一对key-value对，如果key中包含百分号（%）
			// 即可认为该key用于控制调用对象的setter方法设置值
			// %前半为对象名字，后半控制setter方法名
			if (name.contains("%")) {
				// 将配置文件中的key按%分割
				String[] objAndProp = name.split("%");
				// 取出调用setter方法的参数值
				Object target = getObject(objAndProp[0]);
				// 获取setter方法名:set + "首字母大写" + 剩下部分
				String mtdName = "set" + objAndProp[1].substring(0, 1).toUpperCase() + objAndProp[1].substring(1);
				// 通过target的getClass()获取它的实现类所对应的Class对象
				Class<?> targetClass = target.getClass();
				// 获取希望调用的setter方法
				Method mtd = targetClass.getMethod(mtdName, String.class);
				// 通过Method的invoke方法执行setter方法
				// 将config.getProperty(name)的值作为调用setter方法的参数
				mtd.invoke(target, config.getProperty(name));
			}
		}
	}

	public Object getObject(String name) {
		// 从objectPool中取出指定name对应的对象
		return objectPool.get(name);
	}

	public static void main(String[] args) throws Exception {
		ExtendedObjectPoolFactory epf = new ExtendedObjectPoolFactory();
		epf.init("extObj.txt");
		epf.initPool();
		epf.initProperty();
		System.out.println(epf.getObject("a"));
	}
}

为上面程序提供如下配置文件:

ext0bj.text

a=javax.swing.JFrame
b=javax.swing.JLabel
#set the title of a
a%title=Test Title

Spring 框架就是通过这种方式将成员变量值以及依赖对象等都放在配置文件中进行 ，管理的， 从而实现了较好的解耦。 这也是 Spring 框架的 IOC 的原理。

当通过Method的invoke()方法来调用对应的方法时，Java会要求程序必须有调用该方法的权限。 如果程序确实需要调用某个对象的private方法，则可以先调用Method对象的如下方法: * setAccessible(boolean flag)：将Method对象的accessible设置为指定的布尔值。值为true,指示 该Method在使用时应该取消Java语言的访问权限检査；值为false,则指示该Method在使用时 要实施Java语言的访问权限检查。

API:java.lang.reflect.Method

访问成员变量值

通过 Class 对象的 getFields()或 getField()方法可以获取该类所包括的全部成员变量或指定成员变量。
Field 提供了如下两组方法来读取或设置成员变量值:

• getXxx(Object obj)： 获取 obj 对象的该成员变量的值。 此处的 Xxx 对应 8 种基本类型， 如果该成员变量的类型是引用类型， 则取消 get 后面的 Xxx。
• setXxx(Object obj ,Xxx val)： 将 obj 对象的该成员变量设置成 val 值。 此处的 Xxx 对 应 8 种 基 本类型， 如果该成员变量的类型是引用类型， 则取消 set 后面的 Xxx。

使用这两个方法可以随意地访问指定对象的所有成员变量， 包括 private 修饰的成员变量。

import java.lang.reflect.*;

class Person {
	private String name;
	private int age;

	public String toString() {
		return "Person[name:" + name + " , age:" + age + " ]";
	}
}

public class FieldTest {
	public static void main(String[] args) throws Exception {
		// 创建一个Person对象
		Person p = new Person();
		// 获取Person类对应的Class对象
		Class<Person> personClazz = Person.class;
		// 获取Person的名为name的成员变量
		// 使用getDeclaredField()方法表明可获取各种访问控制符的成员变量
		Field nameField = personClazz.getDeclaredField("name");
		// 设置通过反射访问该成员变量时取消访问权限检查
		nameField.setAccessible(true);
		// 调用set()方法为p对象的name成员变量设置值
		nameField.set(p, "Yeeku.H.Lee");
		// 获取Person类名为age的成员变量
		Field ageField = personClazz.getDeclaredField("age");
		// 设置通过反射访问该成员变量时取消访问权限检查
		ageField.setAccessible(true);
		// 调用setInt()方法为p对象的age成员变量设置值
		ageField.setInt(p, 30);
		System.out.println(p);
	}
}

API:java.lang.reflect.Field

操作数组

在 java.lang.reflect 包下还提供了一个 Array 类， Array 对象可以代表所有的数组。 程序可以通过使用 Array 来动态地创建数组， 操作数组元素等。

Array 提供了如下几类方法:

• static Object newInstance(Class<?> componentType,int… length)： 创建一个具有指定的元素类型、指定维度的新数组。
• static xxx getXxx(Object array,int index)： 返回 array 数组中第 index 个元素。 其中 xxx 是各种基本数据类型， 如果数组元素是引用类型， 则该方法变为 get(Object array,int index)。
• static void setXxx(Object array,int index,xxx val): 将 array 数组中第 index 个元素的值设为 val。其中 XXX 是各种基本数据类型， 如果数组元素是引用类型， 则该方法变成 set(Object array, int index,Object val)。

下面程序示范了如何使用 Array 来生成数组， 为指定数组元素赋值， 并获取指定数组元素的方式：

import java.lang.reflect.*;

public class ArrayTest1 {
	public static void main(String args[]) {
		try {
			// 创建一个元素类型为String ，长度为10的数组
			Object arr = Array.newInstance(String.class, 10);
			// 依次为arr数组中index为5、6的元素赋值
			Array.set(arr, 5, "疯狂Java讲义");
			Array.set(arr, 6, "轻量级Java EE企业应用实战");
			// 依次取出arr数组中index为5、6的元素的值
			Object book1 = Array.get(arr, 5);
			Object book2 = Array.get(arr, 6);
			// 输出arr数组中index为5、6的元素
			System.out.println(book1);
			System.out.println(book2);
		} catch (Throwable e) {
			System.err.println(e);
		}
	}
}

API:java.lang.reflect.Array

使用反射生成 JDK 动态代理

代理分为静态代理和动态代理，静态代理是在编译时就将接口、实现类、代理类一股脑儿全部手动完成，但如果我们需要很多的代理，每一个都这么手动的去创建实属浪费时间，而且会有大量的重复代码，此时我们就可以采用动态代理，动态代理可以在程序运行期间根据需要动态的创建代理类及其实例，来完成具体的功能。

使用 Proxy 和 InvocationHandler 创建动态代理

---

代理(Proxy)是一种设计模式,提供了对目标对象另外的访问方式;即通过代理对象访问目标对象.这样做的好处是:可以在目标对象实现的基础上,增强额外的功能操作,即扩展目标对象的功能。 这里用到编程中的一个思想:不要随意去修改别人已经写好的代码或者方法,如果需改修改,可以通过代理的方式来扩展该方法。 举个例子来说明代理的作用:假设我们想邀请一位明星,那么并不是直接连接明星,而是联系明星的经纪人,来达到同样的目的.明星就是一个目标对象,他只要负责活动中的节目,而其他琐碎的事情就交给他的代理人(经纪人)来解决.这就是代理思想在现实中的一个例子。

---

Proxy 提供了用于创建动态代理类和代理对象的静态方法， 它也是所有动态代理类的父类。 如果在程序中为一个或多个接口动态地生成实现类， 就可以使用 Proxy 来创建动态代理类； 如果需要为一个或多个接口动态地创建实例， 也可以使用 Proxy 来创建动态代理实例。

Java动态代理UML图

Proxy 提供了如下两个方法来创建动态代理类和动态代理实例:

• static Class getProxyClass(ClassLoader loader,Class… interfaces)： 创建一个动态代理类所对应的 Class 对象， 该代理类将实现 interfaces 所指定的多个接口。 第一个 ClassLoader 参数指定生成动态代理类的类加载器。
• static Object newProxyInstance(ClassLoader loader,Class<?>[]interfaces,InvocationHandler h)： 直接创建一个动态代理对象， 该代理对象的实现类实现了 interfaces 指定的系列接口， 执行代理对象的每个方法时都会被替换执行 InvocationHandler 对象的 invoke 方法。

实际上， 即使采用第一个方法生成动态代理类之后， 如果程序需要通过该代理类来创建对象， 依然需要传入一个 InvocationHandler 对象。 也就是说， 系统生成的每个代理对象都有一个与之关联的InvocationHandler 对象。

程序中可以采用先生成一个动态代理类， 然后通过动态代理类来创建代理对象的方式生成一个动态代理对象。 代码片段如下：

// 创建一个 InvocationHandler 对象
InvocationHandler handler = new MylnvocationHandler ( ...)；
// 使 用 Proxy 生成一个动态代理类 proxyClass
Class proxyClass = Proxy.getProxyClass(Foo.class.getClassLoader()
, new Class[] { Foo.class });
// 会取 proxyClass_中带一个
Constructor ctor = proxyClass. getConstructor(new Class[]
InvocationHandler 参数的构造器
{ InvocationHandler?class });
// 调用 ctor 的 newlnstance 方法来创建动态实例
Foo f (Foo)ctor.newlnstance(new Object[]{handler});

上面代码也可以简化成如下代码:

// 创建一个 InvocationHandler 对象
InvocationHandler handler = new MyInvocationHandler(...);
// 使用 Proxy 直接生成一个动态代理对象
Foo f = (Foo)Proxy.newProxyInstance(Foo.class.getClassLoader()
, new Class[]{Foo.class} , handler);

下面程序示范了使用 Proxy 和 InvocationHandler 来生成动态代理对象：

import java.lang.reflect.*;


interface Person {
	void walk();

	void sayHello(String name);
}

class MyInvokationHandler implements InvocationHandler {
	/*
	 * 执行动态代理对象的所有方法时，都会被替换成执行如下的invoke方法 其中： proxy：代表动态代理对象 method：代表正在执行的方法
	 * args：代表调用目标方法时传入的实参。
	 */
	public Object invoke(Object proxy, Method method, Object[] args) {
		System.out.println("----正在执行的方法:" + method);
		if (args != null) {
			System.out.println("下面是执行该方法时传入的实参为：");
			for (Object val : args) {
				System.out.println(val);
			}
		} else {
			System.out.println("调用该方法没有实参！");
		}
		return null;
	}
}

public class ProxyTest {
	public static void main(String[] args) throws Exception {
		// 创建一个InvocationHandler对象
		InvocationHandler handler = new MyInvokationHandler();
		// 使用指定的InvocationHandler来生成一个动态代理对象
		Person p = (Person) Proxy.newProxyInstance(Person.class.getClassLoader(), new Class[] { Person.class },
				handler);
		// 调用动态代理对象的walk()和sayHello()方法
		p.walk();
		p.sayHello("孙悟空");
	}
}

上面程序首先提供了一个 Person 接口， 该接口中包含了 walk()和 sayHello()两个抽象方法， 接着定义了一个简单的 InvocationHandler 实现类， 定义该实现类时需要重写 invoke()方法—调用代理对象的所有方法时都会被替换成调用该 invoke()方法。 该 invoke()方法中的三个参数解释如下。

• proxy：代表动态代理对象。
• method： 代表正在执行的方法。
• args： 代表调用目标方法时传入的实参。

API:java.lang.reflect.Proxy
API:java.lang.reflect.InvocationHandler

动态代理和 AOP

根据前面介绍的 Proxy 和 InvocationHandler, 实在很难看出这种动态代理的优势。 下面介绍一种更实用的动态代理机制。

开发实际应用的软件系统时， 通常会存在相同代码段重复出现的情况， 在这种情况下， 对于许多刚开始从事软件开发的人而言， 他们的做法是： 选中那些代码， 一路“ 复制“ 、“ 粘贴”， 立即实现了系统功能， 如果仅仅从软件功能上来看， 他们确实己经完成了软件开发。通过这种“ 复制”、 “ 粘贴” 方式开发出来的软件如图a所示。

图 a:多个地方包含相同代码的软件

采用图 a所示结构实现的软件系统， 在软件开发期间可能会觉得无所谓， 但如果有一天需要修改程序的深色代码的实现， 则意味着打开三份源代码进行修改。 如果有 100 个地方甚至 1000 个地方使用了这段深色代码段， 那么修改、 维护这段代码的工作量将变成噩梦。

在这种情况下， 大部分稍有经验的开发者都会将这段深色代码段定义成一个方法， 然后让另外三段代码段直接调用该方法即可。 在这种方式下， 软件系统的结构如图 b 所示。

图 b:通过方法调用实现代码复用

对于如图 b 所示的软件系统， 如果需要修改深色部分的代码， 则只要修改一个地方即可， 而调用该方法的代码段， 不管有多少个地方调用了该方法， 都完全无须任何修改， 只要被调用方法被修改了，所有调用该方法的地方就会自然改变——通过这种方式， 大大降低了软件后期维护的复杂度。

但采用这种方式来实现代码复用依然产生一个重要问题： 代码段 1、 代码段 2、 代码段 3 和深色代码段分离开了， 但代码段 1、 代码段 2 和代码段 3 又和一个特定方法耦合了！ 最理想的效果是： 代码块1、 代码块 2 和代码块 3 既可以执行深色代码部分， 又无须在程序中以硬编码方式直接调用深色代码的方法， 这时就可以通过动态代理来达到这种效果。

由于 JDK 动态代理只能为接口创建动态代理， 所以下面先提供一个 Dog 接口， 该接口代码非常简单， 仅仅在该接口里定义了两个方法。

public interface Dog {
	// info方法声明
	void info();

	// run方法声明
	void run();
}

上面接口里只是简单地定义了两个方法， 并未提供方法实现。 如果直接使用 Proxy 为该接口创建动态代理对象， 则动态代理对象的所有方法的执行效果又将完全一样。 实际情况通常是， 软件系统会为该Dog 接口提供一个或多个实现类。 此处先提供一个简单的实现类： GunDog:

public class GunDog implements Dog {
	// 实现info()方法，仅仅打印一个字符串
	public void info() {
		System.out.println("我是一只猎狗");
	}

	// 实现run()方法，仅仅打印一个字符串
	public void run() {
		System.out.println("我奔跑迅速");
	}
}

Dog 的实现类为每个方法提供了一个简单实现。 再看需要实现的功能： 让代码段 1、 代码段 2 和代码段 3 既可以执行深色代码部分， 又无须在程序中以硬编码方式直接调用深色代码的方法。 此处假设 info()、 run()两个方法代表代码段 1、 代码段 2， 那么要求： 程序执行 info()、 nm()方法时能调用某个通用方法， 但又不想以硬编码方式调用该方法。

下面提供一个 DogUtil类， 该类里包含两个通用方法：

public class DogUtil {
	// 第一个拦截器方法
	public void method1() {
		System.out.println("=====模拟第一个通用方法=====");
	}

	// 第二个拦截器方法
	public void method2() {
		System.out.println("=====模拟通用方法二=====");
	}
}

借助于 Proxy 和 InvocationHandler 就可以实现 当程序调用 info()方法和 run()方法时， 系统可以“自动” 将 methodl()和 method2()两个通用方法插入 info()和 run()方法中执行。

这个程序的关键在于下面的 MylnvokationHandler 类， 该类是一个 InvocationHandler 实现类， 该实现类的 invoke()方法将会作为代理对象的方法实现：

import java.lang.reflect.*;

public class MyInvokationHandler implements InvocationHandler {
	// 需要被代理的对象
	private Object target;

	public void setTarget(Object target) {
		this.target = target;
	}

	// 执行动态代理对象的所有方法时，都会被替换成执行如下的invoke方法
	public Object invoke(Object proxy, Method method, Object[] args) throws Exception {
		DogUtil du = new DogUtil();
		// 执行DogUtil对象中的method1。
		du.method1();
		// 以target作为主调来执行method方法
		Object result = method.invoke(target, args);
		// 执行DogUtil对象中的method2。
		du.method2();
		return result;
	}
}

上面程序实现 invoke()方法时包含了一行关键代码， 这行代码通过反射以 target作为主调来执行 method 方法， 这就是回调了 target 对象的原有方法。 在粗体字代码之前调用 DogUtil对象的 methodl()方法， 在粗体字代码之后调用 DogUtil 对象的 method2()方法。

下面再为程序提供一个 MyProxyFactory 类， 该对象专为指定的 target 生成动态代理实例：

import java.lang.reflect.*;


public class MyProxyFactory {
	// 为指定target生成动态代理对象
	public static Object getProxy(Object target) throws Exception {
		// 创建一个MyInvokationHandler对象
		MyInvokationHandler handler = new MyInvokationHandler();
		// 为MyInvokationHandler设置target对象
		handler.setTarget(target);
		// 创建、并返回一个动态代理
		return Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), handler);
	}
}

上面的动态代理工厂类提供了一个 getProxy()方法， 该方法为 target 对象生成一个动态代理对象，这个动态代理对象与 target 实现了相同的接口， 所以具有相同的 public 方法—从这个意义上来看， 动态代理对象可以当成 target 对象使用。 当程序调用动态代理对象的指定方法时，实际上将变为执行MylnvokationH andler 对象的 invoke()方法。

例如， 调用动态代理对象的 info()方法， 程序将幵始执行invoke()方法， 其执行步骤如下:

• 创建 DogUtil 实例
• 执行 DogUtil 实例的 method1()方法。
• 使用反射以 target 作为调用者执行 info()方法。
• 执行 DogUtil 实例的 method2()方法。

通过上面的执行过程可以发现： 当使用动态代理对象来代替 target 对象时， 代理对象的方法就实现了前面的要求—程序执行 info()、 nm()方法时既能“ 插入” methodl()、 method2()通用方法，但 GunDog 的方法中又没有以硬编码方式调用 methodl()和 method2()方法。

以一个主程序来测试这种动态代理的效果。

public class Test {
	public static void main(String[] args) throws Exception {
		// 创建一个原始的GunDog对象，作为target
		Dog target = new GunDog();
		// 以指定的target来创建动态代理
		Dog dog = (Dog) MyProxyFactory.getProxy(target);
		dog.info();
		dog.run();
	}
}

上面程序中的 dog 对象实际上是动态代理对象， 只是该动态代理对象也实现了 Dog 接口， 所以也可以当成 Dog 对象使用。 程序执行 dog 的 info()和 run()方法时， 实际上会先执行 DogUtil 的 method1()方法， 再执行 target 对象的 info()和 run()方法， 最后执行 DogUtil 的 method2()方法。

运行上面程序， 会看到如图 c 所示的运行结果：

图 c:运行结果

通过图 c 所示的运行结果来看， 可以发现采用动态代理可以非常灵活地实现解耦。 通常而言，使用 Proxy 生成一个动态代理时， 往往并不会凭空产生一个动态代理， 这样没有太大的实际意义。 通常都是为指定的目标对象生成动态代理。

这种动态代理在 AOP ( Aspect Orient Programming, 面向切面编程） 中被称为 AOP 代理， AOP 代理可代替目标对象， AOP 代理包含了目标对象的全部方法。 但 AOP 代理中的方法与目标对象的方法存在差异： AOP 代理里的方法可以在执行目标方法之前、 之后插入一些通用处理。

AOP 代理包含的方法与目标对象包含的方法示意图如图 d所示。

图d AOP 代理的方法与目标对象的方法示意图

CGLIB动态代理:
JDK中提供的生成动态代理类的机制有个鲜明的特点是：
某个类必须有实现的接口，而生成的代理类也只能代理某个类接口定义的方法。
比如：如果上面例子的GunDog实现了继承自Dog接口的方法外，另外实现了方法eat(),则在产生的动态代理类中不会有这个方法了！更极端的情况是：如果某个类没有实现接口，那么这个类就不能用JDK产生动态代理了！
这时候就应该引入CGLIB动态代理了，“CGLIB（Code Generation Library），是一个强大的，高性能，高质量的Code生成类库，它可以在运行期扩展Java类与实现Java接口。”
CGLIB创建某个类A的动态代理类的模式是：
?1.查找A上的所有非final的public类型的方法定义；
?2.将这些方法的定义转换成字节码；
?3.将组成的字节码转换成相应的代理的class对象；
?4.实现 MethodInterceptor接口，用来处理对代理类上所有方法的请求（这个接口和JDK动态代理InvocationHandler的功能和角色是一样的）

参考：
【1】：程序员圈子里，有哪些高颜值程序媛? ?? 路人甲的回答
【2】：程序员圈子里，有哪些高颜值程序媛?
【3】：身边有个漂亮的女程序员是什么体验？
【3】：《疯狂Java讲义》
【4】：《深入理解Java虚拟机：JVM高级特性与最佳实践》
【5】：JVM内存模型——JAVA的根基
【6】：《揭秘Java虚拟机-JVM设计原理与实现》
【7】：纯洁的微笑：Jvm 系列(一):Java 类的加载机制
【8】：JAVA类加载机制全解析
【9】：廖雪峰的官方网站：Class类
【10】：Java技术驿站：Java基础系列-静态代理和动态代理
【11】：廖雪峰的官方网站：动态代理
【12】：Spring系列之IOC的原理及手动实现
【13】：菜鸟教程：工厂模式
【14】：犀利豆的博客：徒手撸框架--实现IOC
【15】：Java代理模式
【16】：Java的三种代理模式
【17】：从代理机制到Spring AOP

Java Review（三十九、类加载机制与反射）

标签：check   高级特性   代理模式   abs   http   顺序   time()   warning   工厂   

原文地址：https://www.cnblogs.com/three-fighter/p/13053111.html