typora-copy-images-to: img
代理模式
代理模式（Proxy Pattern）的定义很简单，是指为其他对象提供一种代理，以控制对这个对象的访问。
代理对象在客服端和目标对象之间起到中介作用，代理模式属于结构型设计模式。
使用代理模式主要有两个目的：
- 保护目标对象
- 增强目标对象
静态代理
显式声明被代理对象
静态代理其实在平时的开发当中应用非常广泛，最常见的就是三层架构
- UML类图
- 代码：
顶层接口 Person
package com.pmz.proxy;
public interface Person {
public void getGril();
}
被代理对象 User 实现Person接口
package com.pmz.proxy.staticproxy;
import com.pmz.proxy.Person;
public class User implements Person {
@Override
public void getGril() {
System.out.println("我想找个女朋友");
}
}
代理类 UserStaticProxy，持有被代理对象的引用，以及在调用被代理对象前后进行代码增强
package com.pmz.proxy.staticproxy;
public class UserStaticProxy {
//显示声明被代理对象 user
private User user ;
public UserStaticProxy (User user){
this.user = user;
}
public void getGirl(){
System.out.println("找对象的前提要有房有车");
user.getGril();
System.out.println("一见钟情，准备结婚");
}
}
调用端 UserAction 只需要把被代理对象传给代理类，就可以直接调用执行。
package com.pmz.proxy.staticproxy;
public class UserAction {
public static void main(String[] args) {
UserStaticProxy usp = new UserStaticProxy(new User());
usp.getGirl();
}
}
Person是顶层接口，User是真实对象（被代理对象），UserStaticProxy是代理对象，代
理对象持有被代理对象的引用，客户端调用代理对象方法，同时也调用被代理对象的方
法，但是在代理对象前后增加一些处理。
在代码中，我们想到代理，就会理解为是代码 增强，其实就是在原本逻辑前后增加一些逻辑，而调用者无感知。
缺点：如果再来一个Cat也要找对象，那就没办法调用这个代理，就是说不具备扩展性，这个UserStaticProxy只为User类代理。
动态代理
动态代理和静态对比基本思路是一致的，只不过动态代理功能更加强大，随着业务的扩 展适应性更强。
jdk动态代理
实现动态代理的前提是被代理对象必须要实现接口
- UML类图
- 代码：
Person和User跟上面的静态代理一样，保持不变
UserDynamicProxy
package com.pmz.proxy.dynamic.jdkd;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
public class UserDynamicProxy implements InvocationHandler {
//通用类引用
private Object object ;
public Object getInstance(Object object){
this.object = object;
//通过反射获取被代理类的所有接口实现方法
Class<?> clazz = object.getClass();
//返回对象是新生成的一个以$Proxy0开头的对象，继承UserDynamicProxy代理类
// 并实现顶层接口Person
return Proxy.newProxyInstance(clazz.getClassLoader(),clazz.getInterfaces(),this);
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
before();
Object obj = method.invoke(this.object,args);
after();
return obj;
}
private void before() {
System.out.println("找对象的前提要有房有车");
}
private void after() {
System.out.println("一见钟情，准备结婚");
}
}
UserAction
package com.pmz.proxy.dynamic.jdkd;
import java.lang.reflect.Method;
public class UserAction {
public static void main(String[] args) {
try {
Object obj = new UserDynamicProxy().getInstance(new User());
//通过jdk静态代理拿到的对象已经不是User了
//而是新生成的一个以$Proxy0开头的对象，继承UserDynamicProxy代理类
System.out.println(obj);
//通过反射获取被代理类的指定实现方法
Method method = obj.getClass().getMethod("getGril",null);
method.invoke(obj);
} catch (Exception e) {
e.printStackTrace();
}
}
}
- 输出
JDK动态代理的新生成实现类都是以$Proxy开头，后面的数字是以第几个实现类为基础计算的。
该实现类 继承代理对象UserDynamicProxy，并且实现顶层接口Person
class com.sun.proxy.$Proxy0
找对象的前提要有房有车
我想找个女朋友
一见钟情，准备结婚
JDK Proxy 生成对象的步骤如下：
1、拿到被代理对象的引用，并且获取到它的所有的接口，反射获取。
2、JDK Proxy 类重新生成一个新的类、同时新的类要实现被代理类的所有接口。
3、动态生成 Java 代码，把新加的业务逻辑方法由一定的逻辑代码去调用（在代码中体现）。
4、编译新生成的 Java 代码.class。
5、再重新加载到 JVM 中运行。
cglib动态代理
行业内较为流行的动态代理实现方案，采用继承被代理类的方式。cglib包的底层是通过使用一个小而快的字节码处理框架ASM，来转换字节码并生成新的类
注意：被final修饰的方法不能使用cglib动态代理调用，因为final修饰的方法不能被继承
- UML类图
老规矩看代码
User不需要实现接口，就是一个干净的类
import com.pmz.proxy.Person;
public class User{
public void getGril() {
System.out.println("我想找个女朋友");
}
}
UserDynamicProxy必须实现MethodInterceptor(方法拦截器)接口
import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
public class UserDynamicProxy implements MethodInterceptor {
private Object object ;
public Object getInstance(Class<?> clazz){
//Enhancer为被代理类创建一个子类，
Enhancer enhancer = new Enhancer();
enhancer.setSuperclass(clazz);
enhancer.setCallback(this);
return enhancer.create();
}
private void before() {
System.out.println("找对象的前提要有房有车");
}
@Override
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 after() {
System.out.println("一见钟情，准备结婚");
}
}
UserAction
import net.sf.cglib.core.DebuggingClassWriter;
public class UserAction {
public static void main(String[] args) {
try {
//会把生成的3个class文件，存到E://cglib_proxy_classes目录下面去，便于查看源码
System.setProperty(DebuggingClassWriter.DEBUG_LOCATION_PROPERTY,
"E://cglib_proxy_classes");
User obj = (User) new UserDynamicProxy().getInstance(User.class);
System.out.println(obj.getClass());
obj.getGril();
} catch (Exception e) {
e.printStackTrace();
}
}
}
