代理模式
在学习Spring Aop时,使用了动态代理,所以学习了代理模式,静态代理,动态代理,Cglib动态代理,整理blog记录自己的学习笔记
静态代理
1.定义
为其他对象提供一种代理以控制对这个对象的访问。在某些情况下，一个对象不适合或者不能直接引用另一个对象，而代理对象可以在客户端和目标对象之间起到中介的作用。通过代理对象访问目标对象,防止直接访问目标对象造成系统复杂性提升.
2.原理
Subject : 接口,为RealSubject和ProxySubject提供一致性的接口
RealSubject : 目标访问类,实际的主体,实现Subject接口的类
ProxySubject : 代理类,处理Client的请求,只有当代理类无法回复请求时,才会调用目标访问类
Client : 请求者
3.适用场景
Virtual Proxy : 对于一些占用系统资源较多或者加载时间较长的对象，可以给这些对象提供一个虚拟代理。在真实对象创建成功之前虚拟代理扮演真实对象的替身，而当真实对象创建之后，虚拟代理将用户的请求转发给真实对象。
Remote Proxy : 远程代理使得客户端可以访问远程主机上的对象,远程代理可以把网络的细节隐藏起来,使得客户端不必考虑网络的存在,客户端完全可以认为调用的远程代理对象在本地,而不是在远程
Cache Proxy : 某一个操作的结果提供临时的缓存存储空间，以便在后续使用中能够共享这些结果，从而可以避免某些方法的重复执行，优化系统性能。
Access Proxy : 可以在调用RealSubject时做访问限制,通过代理过滤不可以访问的对象
4.实现
Printable.java
public interface Printable {
void setPrintName(String name);
String getPrintName();
void print(String str);
}
Printer.java
public class Printer implements Printable {
private String name;
public Printer() {
heavyJob("正在生成Printer的实例");
}
public Printer(String name) {
this.name = name;
heavyJob("正在生成(Printer)" + name + "的实例");
}
@Override
public void setPrintName(String name) {
this.name = name;
}
@Override
public String getPrintName() {
return this.name;
}
@Override
public void print(String str) {
System.out.println("==" + name + "==");
System.out.println(str);
}
public void heavyJob(String msg) {
System.out.println(msg);
for (int i = 0; i < 5; i++) {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.print(".");
}
System.out.println("over");
}
}
PrintProxy.java
public class PrintProxy implements Printable {
private String name;
private Printer real;
public PrintProxy(String name) {
this.name = name;
}
@Override
public synchronized void setPrintName(String name) {
if (real != null) {
real.setPrintName(name);
}
this.name = name;
}
@Override
public String getPrintName() {
return this.name;
}
@Override
public void print(String str) {
realize();
real.print(str);
}
public synchronized void realize() {
if (real == null) {
real = new Printer(name);
}
}
}
Main.java
public class Main {
public static void main(String[] args) {
Printable p = new PrintProxy("kristin");
System.out.println("name: " + p.getPrintName());
p.setPrintName("kkk");
System.out.println("new name: " + p.getPrintName());
p.print("hello world");
}
}
Printable相当于Subject
Printer相当于RealSubject
PrinterProxy相当于ProxySubject
Main相当于Client
5.优缺点
优点:
协调调用者与被调用者,降低耦合度
作为客户端对象与目标对象的中介,可以有效地保护目标对象
缺点:
在客户端与目标对象之间增加了代理对象,处理请求的速度可能会变慢
如果代理的实现复杂,可能会增加系统实现的复杂性
如果想要为多个类进行代理,需要创建多个代理类,维护难度加大
JDK动态代理
1.定义
代理类在程序运行时被创建,并不是在Java代码中定义的，而是在运行时根据我们在Java代码中的“指示”动态生成的.
2.原理
在java的java.lang.reflect包下提供了一个Proxy类和一个InvocationHandler接口，通过这个类和这个接口可以生成JDK动态代理类和动态代理对象。
3.实现
UserDao.java
public interface UserDao {
void add();
}
UserDaoImpl.java
public class UserDaoImpl implements UserDao {
@Override
public void add() {
System.out.println("------------add------------");
}
}
MyInvocationHandler.java
public class MyInvocationHandler implements InvocationHandler {
private Object target;
public void setProxy(Object target) {
this.target = target;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("-------------before-------------");
Object result = method.invoke(target, args);
System.out.println("-------------after-------------");
return result;
}
}
MyProxy.java
public class MyProxy {
public static void main(String[] args) {
UserDao user = new UserDaoImpl();
MyInvocationHandler handler = new MyInvocationHandler();
handler.setProxy(user);
// UserDao userDao = (UserDao) Proxy.newProxyInstance(user.getClass().getClassLoader(), user.getClass().getInterfaces(), handler);
UserDao userDao = (UserDao) Proxy.newProxyInstance(UserDao.class.getClassLoader(), new Class[]{UserDao.class}, handler);
userDao.add();
}
}
Output
-------------before------------- ------------add------------ -------------after-------------
4.应用
如果想对代理类的所有方法都加上日志,可以通过动态代理可以对代理类的所有方法进行统一的处理,而不用一一更改每一个方法.
Cglib动态代理
1.定义
cglib是针对类来实现代理的，它的原理是对指定的目标类生成一个类，并覆盖其中方法实现增强
2.原理
代理类将委托类作为自己的父类并为其中的非final委托方法创建两个方法，一个是与委托方法签名相同的方法，它在方法中会通过super调用委托方法；另一个是代理类独有的方法。在代理方法中，它会判断是否存在实现了MethodInterceptor接口的对象，若存在则将调用intercept方法对委托方法进行代理.
3.应用
UserDao.java
public interface UserDao {
void add();
}
UserDaoImpl.java
public class UserDaoImpl implements UserDao {
public void add() {
System.out.println("the method is running");
}
}
Interceptor.java
public class Interceptor implements MethodInterceptor {
@Override
public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
System.out.println("-------------------before------------------");
proxy.invokeSuper(obj, args);
System.out.println("--------------------after-------------------");
return null;
}
}
Main.java
public class Main {
@org.junit.jupiter.api.Test
public void test() {
System.setProperty(DebuggingClassWriter.DEBUG_LOCATION_PROPERTY, "E:\\code");
Enhancer enhancer = new Enhancer();
enhancer.setSuperclass(UserDaoImpl.class);
enhancer.setCallback(new Interceptor());
UserDao userDao = (UserDao) enhancer.create();
userDao.add();
}
}
Output
CGLIB debugging enabled, writing to 'E:\code' -------------------before------------------ the method is running --------------------after-------------------
