代理设计模式
1.介绍
Spring 框架中AOP底层使用动态代理设计模式。通过学习动态代理设计模式可以很好的理解Spring框架AOP底层
代理模式(Proxy)是GoF23种设计模式之一。所谓代理模式是指客户端并不直接调用实际的对象,而是通过调用代理,来间接的调用实际的对象。
代理设计模式包括:静态代理和动态代理。
静态代理:代理对象由程序员自己编写,里面提供硬编码方式来访问调用者
动态代理:
- JDK动态代理:一种基于接口的代理实现
- Cglib动态代理:一种基于继承的代理实现
代理设计模式优点:
- 保护代理对象。客户不能直接访问真实对象。只能通过代理对象进行访问
- 可扩展性。复合开闭原则,可以实现在不修改真实代理对象情况下,进行扩展。
- 对于一些访问困难的真实对象,可以使用代理对象,更轻松的访问。
代理设计模式缺点:
- 系统复杂性增加。类的数目增加,代码相对更复杂一点。
- 性能降低。每次访问真实对象,只能通过代理对象。
2.静态代理示例
以房屋买卖为例子(简易流程),客户想要买房,找中介,由中介带看房东的房子。
客户看好了,想要买,房东也同意买了,中介收取客户的中介费。
创建房东(真实对象)
新建com.spring.proxy.staticproxy.Fangdong
public class Fangdong {public void bigHouse(){System.out.println("房东的大房子");}
}
创建中介类(代理对象)
新建com.spring.proxy.staticproxy.Zhongjie
public class Zhongjie {public void zhongjie(){System.out.println("约谈客户,进行带看");// 扩展功能Fangdong fangdong = new Fangdong();fangdong.bigHouse();System.out.println("交易成功,收取中介费"); // 扩展功能}
}
创建客户类(调用者)
com.spring.proxy.staticproxy.Kehu
public class Kehu {public static void main(String[] args) {Zhongjie zhongjie = new Zhongjie();zhongjie.zhongjie();}
}
3.动态代理示例
3.1JDK动态代理
JDK动态代理是基于接口来实现的,底层是基于Java 反射技术实现的。
创建接口
创建接口com.spring.proxy.jdkproxy.House
因为JDK动态代理要求调用者必须实现接口。所以先建立接口
public interface bigHouse {void bighose();
}
创建真实对象类
创建类com.spring.proxy.jdkproxy.Fangdong
/*** JDK动态代理强制要求:真实的被调用的类必须实现接口*/
public class FangDong implements bigHouse{@Overridepublic void bighose() {System.out.println("大房子");}
}
创建代理类
创建com.spring.proxy.jdkproxy.Zhongjie
/*** 在JDK动态代理底层是基于java的反射机制实现的。本质上就是方法的调用** 负责调用真实对象方法的类,必须实现InvocationHandler接口*/
public class ZhongJie implements InvocationHandler {private FangDong fangDong;public ZhongJie(FangDong fangDong) {this.fangDong = fangDong;}/**** @param proxy 产生的代理对象* @param method 真实对象中被调用的方法对象* @param args 被调用方法的参数* @return 被调用方法的返回值,都当做invoke方法的返回值* @throws Throwable*/@Overridepublic Object invoke(Object proxy, Method method, Object[] args) throws Throwable {System.out.println("带看");//坑:千万不要用invoke方法的第一个参数proxy,他是代理对象,而不是真实对象Object result = method.invoke(fangDong, args);System.out.println("中介费");return result;}
}
创建客户类
创建com.spring.proxy.jdkproxy.Kehu
public class KeHu {public static void main(String[] args) {/*** 参数1:ClassLoader 在当前程序中,所有类的类加载器都是同一个对象* 作用:让生成的代理对象立即生效,(invoke中的proxy对象)* 参数2:Class[],放接口,告诉编译器,调用的是哪个方法* 作用:数组中放哪个接口,接口中的方法对象就会传递给invoke中的method方法对象* 参数3:InvocationHandler对象,负责调用真实对象的处理类,就是ZhongJie*///动态代理:动态:不是就调用某个对象的方法,而是想调哪个对象都可以InvocationHandler zhongJie = new ZhongJie(new FangDong());bigHouse bigHouse = (bigHouse) Proxy.newProxyInstance(Kehu.class.getClassLoader(), new Class[]{bigHouse.class}, zhongJie);bigHouse.bighose();}
}
第二例子
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;// 定义接口
interface Hello {void sayHello();
}// 实现接口的类
class HelloImpl implements Hello {@Overridepublic void sayHello() {System.out.println("Hello, World!");}
}// 创建InvocationHandler实例,用于处理代理逻辑
class HelloProxy implements InvocationHandler {private Object target;public HelloProxy(Object target) {this.target = target; // 保存目标对象的引用}@Overridepublic Object invoke(Object proxy, Method method, Object[] args) throws Throwable {System.out.println("Before invoking"); // 在调用目标方法前执行一些逻辑Object result = method.invoke(target, args); // 调用目标对象的方法System.out.println("After invoking"); // 在调用目标方法后执行一些逻辑return result; // 返回结果}
}public class Main {public static void main(String[] args) {// 创建目标对象Hello hello = new HelloImpl();// 创建代理对象Hello proxy = (Hello) Proxy.newProxyInstance(hello.getClass().getClassLoader(), // 使用目标对象的类加载器hello.getClass().getInterfaces(), // 获取目标对象实现的接口列表new HelloProxy(hello) // 指定InvocationHandler实例);// 调用代理方法proxy.sayHello();}
}
3.2Cglib动态代理
Cglig是基于继承的,是第三方提供的技术,需要导入jar包,并且。
<dependencies><dependency><groupId>cglib</groupId><artifactId>cglib</artifactId><version>3.3.0</version></dependency></dependencies>
创建房东类
/*** 真实被调用对象*/
public class FangDong {public void bigHouse(){System.out.println("大房子");}
}
创建中介类
/*** 作用:调用真实对象的方法*/
public class ZhongJie implements MethodInterceptor {/**** @param o 目标对象:即FangDong对象* @param method 目标方法* @param objects 目标方法参数* @param methodProxy 生成的代理对象(即FangDong的子类)* @return 目标方法返回值* @throws Throwable*/@Overridepublic Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {System.out.println("带看");Object result = methodProxy.invokeSuper(o, objects);System.out.println("中介费");return result;}
}
创建客户类
public class KeHu {public static void main(String[] args) {//所有方法都在Enhancer中Enhancer enhancer = new Enhancer();//1.setSuperClass(真实是哪个类) 真实是哪个类,根据这个类创建代理对象,即FangDong的子类enhancer.setSuperclass(FangDong.class);//2.setCallBack(对象) 设置由哪个类作为增强实现类enhancer.setCallback(new ZhongJie());//3.create() 创建代理对象,返回值为object类型,本质为代理对象FangDong fangDong = (FangDong) enhancer.create();fangDong.bigHouse();}}
测试结果,发现出现异常,这是因为Java 17版本中的Java Platform Module System(java 9就开始有了)引起的,特别是强封装的实现。
Caused by: java.lang.reflect.InaccessibleObjectException: Unable to make protected final java.lang.Class java.lang.ClassLoader.defineClass(java.lang.String,byte[],int,int,java.security.ProtectionDomain) throws java.lang.ClassFormatError accessible: module java.base does not "opens java.lang" to unnamed module @1376c05c
把代码原封不动的放在Java 11的环境中就可以使用。
如果必须要在Java17中使用添加JVM参数,表示允许使用未命名模块。
--add-opens java.base/java.lang=ALL-UNNAMED
使用CGLib实现动态代理需要引入相关的依赖库。在示例中,我们将使用cglib-nodep库来创建代理对象。下面是一个使用CGLib实现动态代理的示例代码:
首先,确保已添加CGLib的依赖。对于Maven项目,可以在pom.xml文件中添加以下依赖:
<dependencies><dependency><groupId>cglib</groupId><artifactId>cglib-nodep</artifactId><version>3.3.0</version></dependency>
</dependencies>
然后,编写以下示例代码:
import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;import java.lang.reflect.Method;// 目标类
class Hello {public void sayHello() {System.out.println("Hello, World!");}
}// 创建MethodInterceptor实例,用于处理代理逻辑
class HelloInterceptor implements MethodInterceptor {@Overridepublic Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {System.out.println("Before invoking"); // 在调用目标方法前执行一些逻辑Object result = proxy.invokeSuper(obj, args); // 调用目标方法System.out.println("After invoking"); // 在调用目标方法后执行一些逻辑return result; // 返回结果}
}public class Main {public static void main(String[] args) {// 创建Enhancer对象Enhancer enhancer = new Enhancer();enhancer.setSuperclass(Hello.class); // 设置父类为目标类enhancer.setCallback(new HelloInterceptor()); // 设置回调对象// 创建代理对象Hello proxy = (Hello) enhancer.create();// 调用代理方法proxy.sayHello();}
}
在上述示例中,我们首先定义了一个Hello类作为目标类。然后,创建了一个HelloInterceptor类实现MethodInterceptor接口,用于在代理对象的方法执行前后进行处理。接下来,使用Enhancer类创建代理对象,并设置目标类和回调对象。最后,通过调用代理对象的方法来触发代理逻辑。
运行以上代码,输出结果将会是:
Before invoking
Hello, World!
After invoking
这就是一个使用CGLib实现的动态代理的例子。注意,在使用CGLib时,需要引入相应的依赖并设置目标类和回调对象。