Java设计模式-代理模式分析

博文简介

介绍代理模式的应用场景和实现原理、静态代理和动态代理的区别、CGLib和JDK Proxy的根本区别、手写实现动态代理。

---

代理模式的应用场景

现实生活中，我们经常见到诸如房屋中介、售票黄牛、婚介、HR、快递、 事务代理、非侵入式日志监听等，这些都是代理模式在现实生活的实际体现。代理模式（Proxy Pattern）的定义：是指为其他对象提供一种代理，以控制对这个对象的访问。 代理对象在客服端和目标对象之间起到中介作用，代理模式属于结构型设计模式。使用 代理模式主要有两个目的：一保护目标对象，二增强目标对象。

Java中的代理

Subject 是顶层接口，RealSubject 是真实对象（被代理对象），Proxy 是代理对象，代 理对象持有被代理对象的引用，客户端调用代理对象方法，同时也调用被代理对象的方 法，但是在代理对象前后增加一些处理。在代码中，我们想到代理，就会理解为是代码 增强，其实就是在原本逻辑前后增加一些逻辑，而调用者无感知。代理模式属于结构型 模式，有静态代理和动态代理。

静态代理

举个例子：人到了适婚年龄，父母总是迫不及待希望早点抱孙子。而现在社会的人在各 种压力之下，都选择晚婚晚育。于是着急的父母就开始到处为自己的子女相亲，比子女 自己还着急。这个相亲的过程，就是一种我们人人都有份的代理。我们这里以找工作为例展开，来看代码实现：
顶层接口 Person：

/** * 人有很多行为，要住房子，要购物，要工作 */ 
public interface Person {
	public void findJob(); 
}

你要找工作，实现类Son：

public class Son implements Person{ 
	public void findJob(){ 
		//薪水太低 
		//工作忙 
		System.out.println("你的要求：钱多事少离家近"); 
	} 
}

你老爸利用关系帮你找工作，实现类Father:

public class Father { 
	private Son son; 
	//没办法扩展 
	public Father(Son son){ 
		this.son = son; 
	}
	//目标对象的引用给拿到 
	public void findJob(){ 
		System.out.println("老爸理清关系，挑选合适目标"); 
		this.son.findJob(); 
		System.out.println("与老熟人联系，确认具体工作"); 
	} 
}

接下来上测试代码：

public static void main(String[] args) { 
	//只能帮儿子找工作，不能帮其他人
	Father father = new Father(new Son()); 
	father.findJob(); 
}

这里同学们可能会觉得还是不知道如何讲代理模式应用到业务场景中，那么我们再来举例一个实际的业务场景。在分布式业务场景中，我们通常会对数据库进行分库分表，分库分表之后使用Java操作时，就可能需要配置多个数据源，我们通过设置数据源路由来动态切换数据源。先创建 Order 订单实体：

public class Order { 
	private Object orderInfo; 
	private Long createTime; 
	private String id; 
	public Object getOrderInfo() { 
		return orderInfo; 
	}
	public void setOrderInfo(Object orderInfo) { 
		this.orderInfo = orderInfo; 
	}
	public Long getCreateTime() { 
		return createTime; 
	}
	public void setCreateTime(Long createTime) { 
		this.createTime = createTime; 
	}
	public String getId() { 
		return id; 
	}
	public void setId(String id) { 
		this.id = id; 
	} 
}

创建 OrderDao 持久层操作类：

public class OrderDao { 
	public int insert(Order order){
		System.out.println("OrderDao 创建 Order 成功!"); 
		return 1; 
	} 
}

创建 IOrderService 接口：

public interface IOrderService { 
	int createOrder(Order order); 
}

创建 OrderService 实现类：

public class OrderService implements IOrderService { 
	private OrderDao orderDao; 
	public OrderService(){ 
		//如果使用 Spring 应该是自动注入的,我们为了使用方便，在构造方法中将 orderDao 直接初始化了 
		orderDao = new OrderDao(); 
	}
	@Override 
	public int createOrder(Order order) { 
		System.out.println("OrderService 调用 orderDao 创建订单"); 
		return orderDao.insert(order); 
	} 
}

接下来使用静态代理，主要完成的功能是，根据订单创建时间自动按年进行分库。根据 开闭原则，原来写好的逻辑我们不去修改，通过代理对象来完成。先创建数据源路由对 象，我们使用 ThreadLocal 的单例实现，DynamicDataSourceEntry 类：

/*** 动态切换数据源 */ 
public class DynamicDataSourceEntry { 
	// 默认数据源 
	public final static String DEFAULT_SOURCE = null; 
	private final static ThreadLocal<String> local = new ThreadLocal<String>(); 
	private DynamicDataSourceEntry(){} 
	/*** 清空数据源 */ 
	public static void clear() { 
		local.remove(); 
	}
	/*** 获取当前正在使用的数据源名字 ** @return String */ 
	public static String get() { 
		return local.get(); 
	}
	/*** 还原当前切面的数据源 */ 
	public static void restore() { 
		local.set(DEFAULT_SOURCE); 
	}/*** 设置已知名字的数据源 ** @param source */ 
	public static void set(String source) { 
		local.set(source); 
	}
	/*** 根据年份动态设置数据源 * @param year */ 
	public static void set(int year) { 
		local.set("DB_" + year); 
	} 
}

创建切换数据源的代理 OrderServiceSaticProxy 类：

public class OrderServiceStaticProxy implements IOrderService { 
	private SimpleDateFormat yearFormat = new SimpleDateFormat("yyyy"); 
	private IOrderService orderService; 
	public OrderServiceStaticProxy(IOrderService orderService){ 
		this.orderService = orderService; 
	}
	public int createOrder(Order order) {
		 before(); 
		 Long time = order.getCreateTime(); 
		 Integer dbRouter = Integer.valueOf(yearFormat.format(new Date(time))); 
		 System.out.println("静态代理类自动分配到【DB_" + dbRouter + "】数据源处理数据。"); 
		 DynamicDataSourceEntry.set(dbRouter); 
		 orderService.createOrder(order); 
		 after(); 
		 return 0; 
	 }
	 private void before(){ 
	 	 System.out.println("Proxy before method."); 
	 }
	 private void after(){ 
		 System.out.println("Proxy after method."); 
	 } 
 }

编写测试案例：

public static void main(String[] args) { 
	try {Order order = new Order(); 
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM/dd"); 
		Date date = sdf.parse("2019/12/01"); 
		order.setCreateTime(date.getTime()); 
		IOrderService orderService = new OrderServiceStaticProxy(new OrderService()); 
		orderService.createOrder(order); 
	}catch (Exception e){ 
		e.printStackTrace();
	} 
}

JDK动态代理

动态代理和静态对比基本思路是一致的，只不过动态代理功能更加强大，随着业务的扩展适应性更强。如果还以找对象为例，使用动态代理相当于是能够适应复杂的业务场景。 不仅仅只是父亲给儿子找工作，如果找工作这项业务发展成了一个产业，进而出现了HR、职介所等这样的形式。那么，此时用静态代理成本就更大了，需要一个更加通用的解决方案，要满足任何有志人士找工作的需求。我们升级一下代码，先来看 JDK 实现方式：
JDK 实现方式 创建媒婆（婚介）
JDKHR 类：

public class JDKHR implements InvocationHandler{ 
	//被代理的对象，把引用给保存下来 
	private Object target; 
	public Object getInstance(Object target) throws Exception{ 
		this.target = target; 
		Class<?> clazz = target.getClass(); 
		return Proxy.newProxyInstance(clazz.getClassLoader(),clazz.getInterfaces(),this); 
	}
	public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { 
		before(); 
		Object obj = method.invoke(this.target,args); 
		after(); 
		return obj; 
	}
	private void before(){ 
		System.out.println("我是HR：我要给你找工作，现在已经拿到你的需求"); 
		System.out.println("开始物色"); 
	}
	private void after(){ 
		System.out.println("如果合适的话，就准备办入职"); 
	} 
}

创建找工作客户 Customer 类：

public class Customer implements Person{ 
	public void findJob(){ 
		System.out.println("薪资100K"); 
		System.out.println("每天五小时工作时长"); 
		System.out.println("离家100米以内"); 
	} 
}

编写测试代码：

public static void main(String[] args) { 
	try {
		Person obj = (Person)new JDKHR().getInstance(new Customer()); 
		obj.findJob(); 
	} catch (Exception e) { 
		e.printStackTrace(); 
	} 
}

上面的案例理解了话，我们再来看数据源动态路由业务，帮助同学们对动态代理加深一下印象。创建动态代理的类 OrderServiceDynamicProxy，代码如下：

public class OrderServiceDynamicProxy implements InvocationHandler { 
	private SimpleDateFormat yearFormat = new SimpleDateFormat("yyyy"); 
	private Object target; 
	public Object getInstance(Object target){ 
		this.target = target; 
		Class<?> clazz = target.getClass(); 
		return Proxy.newProxyInstance(clazz.getClassLoader(),clazz.getInterfaces(),this); 
	}
	public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { 
		before(args[0]); 
		Object object = method.invoke(target,args);
		after(); 
		return object; 
	}
	private void before(Object target){ 
		try {
			System.out.println("Proxy before method."); 
			Long time = (Long) target.getClass().getMethod("getCreateTime").invoke(target); 
			Integer dbRouter = Integer.valueOf(yearFormat.format(new Date(time)));
			System.out.println("静态代理类自动分配到【DB_" + dbRouter + "】数据源处理数据。"); 
			DynamicDataSourceEntry.set(dbRouter); 
		}catch (Exception e){ 
			e.printStackTrace(); 
		} 
	}
	private void after(){ 
		System.out.println("Proxy after method."); 
	} 
}

编写测试代码：

public static void main(String[] args) { 
	try {Order order = new Order(); 
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM/dd"); 
		Date date = sdf.parse("2018/02/01"); 
		order.setCreateTime(date.getTime()); 
		IOrderService orderService = (IOrderService)new OrderServiceDynamicProxy().getInstance(new OrderService()); 
		orderService.createOrder(order); 
	}catch (Exception e){ 
		e.printStackTrace(); 
	} 
}

运行测试案例，依然能够达到相同运行效果。但是，动态代理实现之后，我们不仅能实现 Order 的数据 源动态路由，还可以实现其他任何类的数据源路由。当然，有比较重要的约定，必须要求实现 getCreateTime()方法，因为路由规则是根据时间来运算的。当然，我们可以通过接口规范来达到约束的目的，在此就不再举例。

高仿真 JDK Proxy 手写实现

不仅知其然，还得知其所以然。既然JDK Proxy功能如此强大，那么它是如何实现的，我们现在来探究一下原理，并模仿JDK Proxy自己动手写一个属于自己的动态代理。 我们都知道JDK Proxy采用字节重组，重新生的对象来替代原始的对象以达到动态代理的目的。JDK Proxy生成对象的步骤如下：
1、拿到被代理对象的引用，并且获取到它的所有的接口，反射获取。
2、JDK Proxy类重新生成一个新的类、同时新的类要实现被代理类所有实现的所有的接口。
3、动态生成Java代码，把新加的业务逻辑方法由一定的逻辑代码去调用（在代码中体 现）。
4、编译新生成的Java代码.class。
5、再重新加载到 JVM 中运行。
以上这个过程就叫字节码重组。JDK 中有一个规范，在 ClassPath 下只要是$开头的 class 文件一般都是自动生成的。那么我们有没有办法看到代替后的对象的真容呢？做一个这 样测试，我们从内存中的对象字节码通过文件流输出到一个新的 class 文件，然后，利用 反编译工具查看 class 的源代码。来看测试代码：

public class JDKProxyTest { 
	public static void main(String[] args) { 
		try {
		Person obj = (Person)new JDKHR().getInstance(new Customer());
		obj.findJob(); 
		//通过反编译工具可以查看源代码 
		byte [] bytes = ProxyGenerator.generateProxyClass("$Proxy0",new Class[]{Person.class}); 
		FileOutputStream os = new FileOutputStream("E://$Proxy0.class"); 
		os.write(bytes); 
		os.close(); 
		} catch (Exception e) { 
		e.printStackTrace(); 
		} 
	} 
}

运行之后，我们能在 E://盘下找到一个$Proxy0.class 文件。使用Jad反编译，得到 $Proxy0.jad文件，打开可以看到如下内容：

// Decompiled by Jad v1.5.8g. Copyright 2001 Pavel Kouznetsov. 
// Jad home page: http://www.kpdus.com/jad.html 
// Decompiler options: packimports(3) 
import com.my.pattern.proxy.Person; 
import java.lang.reflect.*; 
public final class $Proxy0 extends Proxy implements Person { 
	public $Proxy0(InvocationHandler invocationhandler) { 
		super(invocationhandler); 
	}
    public final boolean equals(Object obj) {
		 try { 
		 return ((Boolean)super.h.invoke(this, m1, new Object[] { obj })).booleanValue(); 
		 }
		 catch(Error _ex) { } 
		 catch(Throwable throwable) { 
		 throw new UndeclaredThrowableException(throwable);
		 } 
	 }
		 public final void findJob() { 
		 try { 
		 	super.h.invoke(this, m3, null); 
			 return; 
		 }
		 catch(Error _ex) { } 
		 catch(Throwable throwable) { 
		 	throw new UndeclaredThrowableException(throwable); 
		 } 
	 }
	 public final String toString() { 
		 try { 
			 return (String)super.h.invoke(this, m2, null); 
		 }
		 catch(Error _ex) { } 
			 catch(Throwable throwable) { 
			 throw new UndeclaredThrowableException(throwable); 
		 } 
	 }
	 public final int hashCode() { 
		 try { 
		 	return ((Integer)super.h.invoke(this, m0, null)).intValue(); 
		 }
		 catch(Error _ex) { } 
			 catch(Throwable throwable) { 
			 throw new UndeclaredThrowableException(throwable); 
		 } 
	 }
	 private static Method m1; 
	 private static Method m3; 
	 private static Method m2; 
	 private static Method m0; 
	 static { 
	 try { 
		 m1 = Class.forName("java.lang.Object").getMethod("equals", new Class[] { 
		 Class.forName("java.lang.Object") }); 
		 m3 = Class.forName("com.my.pattern.proxy.Person").getMethod("findJob", new Class[0]); 
		 m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]); 
		 m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]); 
		 }catch(NoSuchMethodException nosuchmethodexception) { 
			 throw new NoSuchMethodError(nosuchmethodexception.getMessage()); 
		 }catch(ClassNotFoundException classnotfoundexception) { 
			 throw new NoClassDefFoundError(classnotfoundexception.getMessage()); 
		 } 
	 } 
 }

我们发现$Proxy0 继承了Proxy 类，同时还实现了我们的Person 接口，而且重写了findJob()等方法。而且在静态块中用反射查找到了目标对象的所有方法，而且保存了所 有方法的引用，在重写的方法用反射调用目标对象的方法。同学们此时一定在好奇， 这些代码是哪里来的呢？其实是 JDK 帮我们自动生成的。现在，我们不依赖 JDK 自己来 动态生成源代码、动态完成编译，然后，替代目标对象并执行。 创建 MYInvocationHandler 接口：

public interface MyInvocationHandler { 
	public Object invoke(Object proxy, Method method, Object[] args) throws Throwable; 
}

创建 MyProxy 类：

/*** 用来生成源代码的工具类  */ 
public class MyProxy { 
	public static final String ln = "\r\n"; 
	public static Object newProxyInstance(GPClassLoader classLoader, Class<?> [] interfaces, GPInvocationHandler h){ 
		try {
			//1、动态生成源代码.java 文件 
			String src = generateSrc(interfaces); 
			// System.out.println(src); 
			//2、Java 文件输出磁盘 
			String filePath = GPProxy.class.getResource("").getPath(); 
			// System.out.println(filePath); 
			File f = new File(filePath + "$Proxy0.java"); 
			FileWriter fw = new FileWriter(f); 
			fw.write(src); 
			fw.flush(); 
			fw.close(); 
			//3、把生成的.java 文件编译成.class 文件 
			JavaCompiler compiler = ToolProvider.getSystemJavaCompiler(); 
			StandardJavaFileManager manage = compiler.getStandardFileManager(null,null,null); 
			Iterable iterable = manage.getJavaFileObjects(f);
			JavaCompiler.CompilationTask task = compiler.getTask(null,manage,null,null,null,iterable); 
			task.call(); 
			manage.close(); 
			//4、编译生成的.class 文件加载到 JVM 中来 
			Class proxyClass = classLoader.findClass("$Proxy0"); 
			Constructor c = proxyClass.getConstructor(GPInvocationHandler.class); 
			f.delete(); 
			//5、返回字节码重组以后的新的代理对象 
			return c.newInstance(h); 
		}catch (Exception e){ 
			e.printStackTrace(); 
		}
		return null; 
	}
	private static String generateSrc(Class<?>[] interfaces){ 
		StringBuffer sb = new StringBuffer(); 
		sb.append("package com.my.pattern.proxy.dynamicproxy.myproxy;" + ln); 
		sb.append("import com.my.pattern.proxy.Person;" + ln); 
		sb.append("import java.lang.reflect.*;" + ln); 
		sb.append("public class $Proxy0 implements " + interfaces[0].getName() + "{" + ln); 	
		sb.append("MyInvocationHandler h;" + ln); 
		sb.append("public $Proxy0(MyInvocationHandler h) { " + ln); 
		sb.append("this.h = h;"); 
		sb.append("}" + ln); 
		for (Method m : interfaces[0].getMethods()){ 
			Class<?>[] params = m.getParameterTypes(); 
			StringBuffer paramNames = new StringBuffer(); 
			StringBuffer paramValues = new StringBuffer(); 
			StringBuffer paramClasses = new StringBuffer(); 
			for (int i = 0; i < params.length; i++) { 
				Class clazz = params[i]; String type = clazz.getName(); 
				String paramName = toLowerFirstCase(clazz.getSimpleName()); 
				paramNames.append(type + " " + paramName); 
				paramValues.append(paramName); 
				paramClasses.append(clazz.getName() + ".class"); 
				if(i > 0 && i < params.length-1){ 
					paramNames.append(",");
					paramClasses.append(","); 
					paramValues.append(","); 
				} 
			}
			sb.append("public " + m.getReturnType().getName() + " " + m.getName() + "(" + paramNames.toString() + ") {" + ln); 
			sb.append("try{" + ln); 
			sb.append("Method m = " + interfaces[0].getName() + ".class.getMethod(\"" + m.getName() + "\",new Class[]{" + paramClasses.toString() + "});" + ln); 
			sb.append((hasReturnValue(m.getReturnType()) ? "return " : "") + getCaseCode("this.h.invoke(this,m,new Object[]{" + paramValues + "})",m.getReturnType()) + ";" + ln); 
			sb.append("}catch(Error _ex) { }"); 
			sb.append("catch(Throwable e){" + ln); 
			sb.append("throw new UndeclaredThrowableException(e);" + ln); 
			sb.append("}"); 
			sb.append(getReturnEmptyCode(m.getReturnType())); 
			sb.append("}"); 
		} 
		sb.append("}" + ln); 
		return sb.toString(); 
	}
	private static Map<Class,Class> mappings = new HashMap<Class, Class>(); 
	static { 
		mappings.put(int.class,Integer.class); 
	}
	private static String getReturnEmptyCode(Class<?> returnClass){ 
		if(mappings.containsKey(returnClass)){ 
			return "return 0;"; 
		}else if(returnClass == void.class){
		 	return ""; 
		 }else { 
		 	return "return null;"; 
		 } 
	 }
	 private static String getCaseCode(String code,Class<?> returnClass){ 
		 if(mappings.containsKey(returnClass)){ 
			 return "((" + mappings.get(returnClass).getName() + ")" + code + ")." + returnClass.getSimpleName() + "Value()"; 
		 } 
		 return code; 
	 }
	 private static boolean hasReturnValue(Class<?> clazz){ 
	 	return clazz != void.class; 
	 }
	 private static String toLowerFirstCase(String src){ 
		 char [] chars = src.toCharArray(); 
		 chars[0] += 32; 
		 return String.valueOf(chars); 
	 } 
 }

创建MyClassLoader 类：

public class MyClassLoader extends ClassLoader{ 
	private File classPathFile; 
	public MyClassLoader(){ 
		String classPath = MyClassLoader.class.getResource("").getPath(); 
		this.classPathFile = new File(classPath); 
	}
	protected Class<?> findClass(String name) throws ClassNotFoundException { 
		String className = GPClassLoader.class.getPackage().getName() + "." + name; 
		if(classPathFile != null){ File classFile = new File(classPathFile,name.replaceAll("\\.","/") + ".class"); 
			if(classFile.exists()){ 
				FileInputStream in = null; 
				ByteArrayOutputStream out = null; 
				try{
					in = new FileInputStream(classFile); 
					out = new ByteArrayOutputStream(); 
					byte [] buff = new byte[1024]; 
					int len; 
					while ((len = in.read(buff)) != -1){ 
					out.write(buff,0,len); 
					}
					return defineClass(className,out.toByteArray(),0,out.size()); 
				}catch (Exception e){ 
					e.printStackTrace(); 
				}finally { 
					if(null != in){ 
						try {
							in.close(); 
						} catch (IOException e) { 
							e.printStackTrace(); 
						} 
					}
					if(out != null){ 
						try {
							out.close(); 
						} catch (IOException e) {
							e.printStackTrace(); 
						} 
					 } 
				 } 
			 } 
		 }
	 	return null; 
	 } 
 }

创建 MyHR类：

public class MyHR implements MyInvocationHandler { 
	//被代理的对象，把引用给保存下来 
	private Object target; 
	public Object getInstance(Object target) throws Exception{ 
	this.target = target; 
	Class<?> clazz = target.getClass(); 
		return MyProxy.newProxyInstance(new MyClassLoader(),clazz.getInterfaces(),this); 
	}
	public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { 
		before(); 
		method.invoke(this.target,args); 
		after(); 
		return null; 
	}
	private void before(){
		System.out.println("我是HR：我要给你找工作，现在已经拿到你的需求"); 
		System.out.println("开始物色"); 
	}
	private void after(){ 
		System.out.println("如果合适的话，就准备办入职"); 
	} 
}

编写客户端测试代码：

public static void main(String[] args) { 
	try {
		Person obj = (Person)new MyHR().getInstance(new Customer());
		System.out.println(obj.getClass()); 
		obj.findJob(); 
	} catch (Exception e) { 
		e.printStackTrace(); 
	} 
}

到此，手写 JDK 动态代理就完成了。

CGLib 调用 API 及原理分析

简单看一下CGLib代理的使用,还是以HR为例，创建 CglibHR 类：

public class CglibHR implements MethodInterceptor{ 
	public Object getInstance(Class<?> clazz) throws Exception{ 
		Enhancer enhancer = new Enhancer(); 
		//要把哪个设置为即将生成的新类父类 
		enhancer.setSuperclass(clazz); 
		enhancer.setCallback(this); 
		return enhancer.create(); 
	}
	public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable { 
		//业务的增强 
		before(); 
		Object obj = methodProxy.invokeSuper(o,objects); 
		after(); 
		return obj; 
	}
	private void before(){ 
		System.out.println("我是HR：我要给你找工作，现在已经拿到你的需求"); 
		System.out.println("开始物色"); 
	}
	private void after(){ 
		System.out.println("如果合适的话，就准备办入职"); 
	} 
}

创建单身客户 Customer 类：

public class Customer { 
	public void findJob(){ 
		System.out.println("钱多事少离家近"); 
	} 
}

细心地同学会发现，CGLib代理的目标对象不需要实现任何接口，它是通过动态继承目标对象实现的动态代理。来看测试代码：

public class CglibTest { 
	public static void main(String[] args) { 
		try {
			Customer obj = (Customer)new CglibHR().getInstance(Customer.class); 
			obj.findJob(); 
		} catch (Exception e) { 
			e.printStackTrace(); 
		} 
	} 
}

CGLib 的实现原理又是怎样的，我们可以在测试代码中加上一句代码，将CGLib 代理后的class写入到磁盘，然后我们再反编译一探究竟，代码如下：

public static void main(String[] args) { 
	try {
		//利用 cglib 的代理类可以将内存中的 class 文件写入本地磁盘 
		System.setProperty(DebuggingClassWriter.DEBUG_LOCATION_PROPERTY, "E://cglib_proxy_class/"); 
		Customer obj = (Customer)new CglibHR().getInstance(Customer.class); 
		obj.findJob(); 
	} catch (Exception e) { 
		e.printStackTrace(); 
	} 
}

重新执行代码，我们会发现在 E://cglib_proxy_class 目录下多了三个 class 文件，通过调试跟踪，我们发现 Customer$$EnhancerByCGLIB$$3feeb52a.class 就是 CGLib 生成的代理类，继承了 Customer 类。通过分析反编译后代码发现重写了 Customer 类的所有方法。我们通过代理类的源码可以看到，代理类会获得所有 在 父 类 继 承 来 的 方 法 ， 并 且 会 有 MethodProxy 与 之 对 应 ， 比 如 Method CGLIB$findJob$0$Method、MethodProxy CGLIB$findJob$0$Proxy;这些方法在代 理类的 findJob()中都有调用。调 用 过 程 ： 代 理 对 象 调 用 this.findJob() 方 法 -> 调 用 拦 截 器 ->methodProxy.invokeSuper->CGLIB$findJob$0->被代理对象 findJob()方法。 此时，我们发现拦截器 MethodInterceptor 中就是由 MethodProxy 的 invokeSuper 方法调用代理方法的，MethodProxy 非常关键，我们分析一下它具体做了什么。

public class MethodProxy { 
	private Signature sig1; 
	private Signature sig2; 
	private MethodProxy.CreateInfo createInfo; 
	private final Object initLock = new Object(); 
	private volatile MethodProxy.FastClassInfo fastClassInfo; 
	public static MethodProxy create(Class c1, Class c2, String desc, String name1, String name2) { 
		MethodProxy proxy = new MethodProxy(); 
		proxy.sig1 = new Signature(name1, desc); 
		proxy.sig2 = new Signature(name2, desc); 
		proxy.createInfo = new MethodProxy.CreateInfo(c1, c2); return proxy; 
	}
	
	... 
	
	private static class CreateInfo { 
		Class c1; 
		Class c2; 
		NamingPolicy namingPolicy; 
		GeneratorStrategy strategy; 
		boolean attemptLoad; 
		public CreateInfo(Class c1, Class c2) { 
			this.c1 = c1; 
			this.c2 = c2; 
			AbstractClassGenerator fromEnhancer = AbstractClassGenerator.getCurrent(); 
			if(fromEnhancer != null) { 
				this.namingPolicy = fromEnhancer.getNamingPolicy(); 
				this.strategy = fromEnhancer.getStrategy(); 
				this.attemptLoad = fromEnhancer.getAttemptLoad(); 
			} 
		} 
	}
	
	... 

}

继续看 invokeSuper()方法：

public Object invokeSuper(Object obj, Object[] args) throws Throwable { 
	try {
		this.init(); 
		MethodProxy.FastClassInfo fci = this.fastClassInfo; 
		return fci.f2.invoke(fci.i2, obj, args); 
	} catch (InvocationTargetException var4) { 
		throw var4.getTargetException(); 
	} 
}
	
	... 
	
private static class FastClassInfo { 
	FastClass f1; 
	FastClass f2; 
	int i1; 
	int i2; 
	private FastClassInfo() { 
	} 
}

上面代码调用过程就是获取到代理类对应的 FastClass，并执行了代理方法。还记得之前 生成三个 class 文件, Customer$$EnhancerByCGLIB$$3feeb52a$$FastClassByCGLIB$$6aad62f1.class就 是代理类的 FastClass， Customer$$FastClassByCGLIB$$2669574a.class 就是被代理类的 FastClass。 CGLib 动态代理执行代理方法效率之所以比 JDK 的高是因为 Cglib 采用了 FastClass 机 制，它的原理简单来说就是：为代理类和被代理类各生成一个 Class，这个 Class 会为代 理类或被代理类的方法分配一个 index(int 类型)。这个 index 当做一个入参，FastClass 就可以直接定位要调用的方法直接进行调用，这样省去了反射调用，所以调用效率比 JDK 动态代理通过反射调用高。FastClass 并不是跟代理类一块生成的，而是在第一次执行 MethodProxy invoke/invokeSuper 时生成的并放在了缓存中。

//MethodProxy invoke/invokeSuper 都调用了 init() 
private void init() { 
	if(this.fastClassInfo == null) { 
	Object var1 = this.initLock; 
	synchronized(this.initLock) { 
		if(this.fastClassInfo == null) { 
			MethodProxy.CreateInfo ci = this.createInfo; 
			MethodProxy.FastClassInfo fci = new MethodProxy.FastClassInfo(); 
			fci.f1 = helper(ci, ci.c1);//如果缓存中就取出，没有就生成新的 
			FastClass fci.f2 = helper(ci, ci.c2); 
			fci.i1 = fci.f1.getIndex(this.sig1);//获取方法的 
			index fci.i2 = fci.f2.getIndex(this.sig2); 
			this.fastClassInfo = fci; 
			} 
		} 
	} 
}

至此，Cglib 动态代理的原理就基本搞清楚了，如果对代码细节有兴趣的同学可以再自行深入研究。

CGLib 和 JDK 动态代理对比

1.JDK动态代理是实现了被代理对象的接口，CGLib是继承了被代理对象。
2.JDK和CGLib都是在运行期生成字节码，JDK是直接写 Class 字节码，CGLib使用ASM框架写Class字节码，Cglib代理实现更复杂，生成代理类比JDK效率低。
3.JDK 调用代理方法，是通过反射机制调用，CGLib 是通过FastClass机制直接调用方法， CGLib执行效率更高。

代理模式在 Spring 源码中的应用

先看 ProxyFactoryBean 核心的方法就是 getObject()方法，我们来看一下源码：

public Object getObject() throws BeansException { 
	initializeAdvisorChain(); 
	if (isSingleton()) { 
		return getSingletonInstance(); 
	}else { 
		if (this.targetName == null) { 
			logger.warn("Using non-singleton proxies with singleton targets is often undesirable. " + "Enable prototype proxies by setting the 'targetName' property."); 
		}
		return newPrototypeInstance(); 
	} 
}

在 getObject()方法中，主要调用 getSingletonInstance()和 newPrototypeInstance()；在 Spring 的配置中，如果不做任何设置，那么 Spring 代理生成的 Bean 都是单例对象。 如果修改 scope 则每次创建一个新的原型对象。newPrototypeInstance()里面的逻辑比 较复杂，我们后面的课程再做深入研究，这里我们先做简单的了解。 Spring 利用动态代理实现 AOP 有两个非常重要的类，一个是 JdkDynamicAopProxy 类 和 CglibAopProxy 类。

Spring 中的代理选择原则
1、当 Bean 有实现接口时，Spring 就会用 JDK 的动态代理。
2、当 Bean 没有实现接口时，Spring 选择 CGLib。
3、Spring 可以通过配置强制使用 CGLib，只需在 Spring 的配置文件中加入如下代码：

<aop:aspectj-autoproxy proxy-target-class="true"/>

总结

静态代理和动态的本质区别

1、静态代理只能通过手动完成代理操作，如果被代理类增加新的方法，代理类需要同步 新增，违背开闭原则。
2、动态代理采用在运行时动态生成代码的方式，取消了对被代理类的扩展限制，遵循开 闭原则。
3、若动态代理要对目标类的增强逻辑扩展，结合策略模式，只需要新增策略类便可完成， 无需修改代理类的代码。

代理模式的优缺点

使用代理模式具有以下几个优点：
1、代理模式能将代理对象与真实被调用的目标对象分离。
2、一定程度上降低了系统的耦合度，扩展性好。
3、可以起到保护目标对象的作用。
4、可以对目标对象的功能增强。
代理模式缺点：
1、代理模式会造成系统设计中类的数量增加。
2、在客户端和目标对象增加一个代理对象，会造成请求处理速度变慢。
3、增加了系统的复杂度。