代理模式总结

最新推荐文章于 2022-02-26 11:00:04 发布

画个逗号给明天123

最新推荐文章于 2022-02-26 11:00:04 发布

阅读量189

点赞数

文章标签： java

本文链接：https://blog.csdn.net/qq_46118014/article/details/120712164

版权

代理模式

代理模式在 Java 开发中是一种比较常见的设计模式。设计目的旨在为服务类与客户类之间插入其他功
能，插入的功能对于调用者是透明的，起到伪装控制的作用。如租房的例子：房客、中介、房东。对应
于代理模式中即：客户类、代理类、委托类（被代理类）。
为某一个对象（委托类）提供一个代理（代理类），用来控制对这个对象的访问。委托类和代理类有
一个共同的父类或父接口。代理类会对请求做预处理、过滤，将请求分配给指定对象。
生活中常见的代理情况：
租房中介、婚庆公司等

代理模式的两个设计原则：

代理类与委托类具有相似的行为（共同）
代理类增强委托类的行为

静态代理

静态代理三要素

有共同得行为
目标对象
代理对象

静态代理的特点

目标对象固定
在程序执行前就的到了目标角色
代理对象会增强目标对象的行为

eg

举个例子婚庆公司：你想要结婚找婚庆公司代理

实现相同的接口

public interface Marry {
    public void toMarry();
}

目标对象（你）

public class You implements Marry{
    @Override
    public void toMarry() {
        System.out.println("我要结婚了");
    }
}

婚庆公司

public class Proxy implements Marry{
    Marry marry;

    public Proxy(Marry marry) {
        this.marry = marry;
    }
    @Override
    public void toMarry() {
        before();
        marry.toMarry();
        after();
    }
    //前置增强行为
    public void before(){
        System.out.println("before...");
    }
    //后置增强行为
    public void after(){
        System.out.println("after...");
    }
}

测试类

public static void main(String[] args) {
        //初始化目标对象
        You you = new You();
        //初始化代理对象
        Proxy proxy = new Proxy(you);
        proxy.toMarry();
    }

从测试类可以知道代理对象实现的代理行为

动态代理

相比于静态代理，动态代理在创建代理对象上更加的灵活，动态代理类的字节码在程序运行时，由
Java反射机制动态产生。它会根据需要，通过反射机制在程序运行期，动态的为目标对象创建代理对
象，无需程序员手动编写它的源代码。动态代理不仅简化了编程工作，而且提高了软件系统的可扩展
性，因为反射机制可以生成任意类型的动态代理类。代理的行为可以代理多个方法，即满足生产需要的
同时又达到代码通用的目的。

动态代理的两种实现方式：

JDK 动态代理
CGLIB动态代理

动态代理的特点

目标对象不固定
在应用程序执行时动态创建代理对象
代理对象会增强目标对象的行为

JDK动态代理

代理类

public class JdkHandle implements InvocationHandler {
   //目标对象
    Object target ;

    public JdkHandle(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;
    }
    public Object GetProxy(){
        //通过该方法获取代理对象 
        return  Proxy.newProxyInstance(this.getClass().getClassLoader(), target.getClass().getInterfaces(), this);
    }
}

测试类

public static void main(String[] args) {
    //生成目标对象
    You you = new You();
    //生成代理对象
    JdkHandle jdkHandle = new JdkHandle(you);
    Marry proxy =(Marry) jdkHandle.GetProxy();
    proxy.toMarry();
}

Proxy.newProxyInstance 该方法内部是通过反射实现的，因此是动态创建了代理对象

CGLIB动态代理

JDK的动态代理机制只能代理实现了接口的类，而不能实现接口的类就不能使用JDK的动态代理，cglib
是针对类来实现代理的，它的原理是对指定的目标类生成一个子类，并覆盖其中方法实现增强，但因为
采用的是继承，所以不能对final修饰的类进行代理。

该方法需要添加依赖

依赖坐标如下

<!-- https://mvnrepository.com/artifact/cglib/cglib -->
<dependency>
<groupId>cglib</groupId>
<artifactId>cglib</artifactId>
<version>2.2.2</version>
</dependency>

需要增强的方法（类）

public class User {
    public void show(){
        System.out.println("我要增强行为");
    }
}

CGLIB

public class Cglib implements MethodInterceptor {
    Object target;

    public Cglib(Object target) {
        this.target = target;
    }

    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        System.out.println("before...");
        Object result = method.invoke(target, objects);
        System.out.println("after...");
        return result;
    }
    //这里是与JDK动态代理不同的原因
    public Object GetProxy(){
        Enhancer enhancer = new Enhancer();
        //设置父类
        enhancer.setSuperclass(target.getClass());
        //设置回滚
        enhancer.setCallback(this);
        return enhancer.create();
    }
}