代理模式--Proxy Pattern

Posted 2021-08-16 高高for 循环

代理模式

首先回顾:

反射–05–动态代理:https://blog.csdn.net/weixin_48052161/article/details/116862418

Spring–03–AOP简介:https://blog.csdn.net/weixin_48052161/article/details/108651671

定义:

代理模式有两个英文名字：Proxy Pattern 和 Surrogate Pattern。代理模式的定义为：为其他对象提供一种代理以控制对这个对象的访问

• 代理对象在客户端和目标对象之间起到中介作用。
• 代理模式属于结构型设计模式，属于GOF23种设计模式之一
• 代理模式可以分为静态代理和动态代理两种类型，而动态代理中又分为JDK动态代理和CGLIB代理两种。

结构:

静态代理:

特点：代理类和被代理类在编译期间，就确定下来了

接口

interface ClothFactory{
    void produceCloth();
}

被代理类

class NikeClothFactory implements ClothFactory{

    @Override
    public void produceCloth() {
        System.out.println("Nike工厂生产一批运动服");
    }
}

代理类

class ProxyClothFactory implements ClothFactory{

    private ClothFactory factory;//用被代理类对象进行实例化

    public ProxyClothFactory(ClothFactory factory){
        this.factory = factory;
    }

    @Override
    public void produceCloth() {
        System.out.println("代理工厂做一些准备工作");

        factory.produceCloth();

        System.out.println("代理工厂做一些后续的收尾工作");

    }
}

测试

public class StaticProxyTest {
    public static void main(String[] args) {
        //创建被代理类的对象
        ClothFactory nike = new NikeClothFactory();
        //创建代理类的对象
        ClothFactory proxyClothFactory = new ProxyClothFactory(nike);

        proxyClothFactory.produceCloth();

    }
}

动态代理:

要想实现动态代理，需要解决的问题？

问题一：如何根据加载到内存中的被代理类，动态的创建一个代理类及其对象。

问题二：当通过代理类的对象调用方法a时，如何动态的去调用被代理类中的同名方法a。

• 问题一 :通过bean工厂ProxyFactory
• 问题二：通过反射获取代理对象,的方法对象 Method

jdk提供的相关ApI

• (package java.lang.reflect)

动态代理案例 1 :JDK代理

接口:

interface Human{
    String getBelief();
    void eat(String food);
}

被代理类

//被代理类
class SuperMan implements Human{

    @Override
    public String getBelief() {
        return "I believe I can fly!";
    }

    @Override
    public void eat(String food) {
        System.out.println("我喜欢吃" + food);
    }
}

扩展方法:

class HumanUtil{

    public void method1(){
        System.out.println("====================通用方法一====================");

    }

    public void method2(){
        System.out.println("====================通用方法二====================");
    }

}

bean代理工厂

调用此方法，返回一个代理类的对象。解决问题

class ProxyFactory{
    //调用此方法，返回一个代理类的对象。解决问题一
    public static Object getProxyInstance(Object obj){//obj:被代理类的对象
        MyInvocationHandler handler = new MyInvocationHandler();

        handler.bind(obj);

        return Proxy.newProxyInstance(obj.getClass().getClassLoader(),obj.getClass().getInterfaces(),handler);
    }

}

动态代理实际上是: 多态+反射的应用

1.obj.getClass().getClassLoader(), ==>为了获取Class对象 进行反射

2.obj.getClass().getInterfaces() ==> 根据需要实现的接口信息，在代码中动态创建 该Proxy类的字节码；

多态+反射 ==>代理对象能够动态的去调用被代理类中的同名方法。

调用处理器 InvocationHandler

1. 当我们通过代理类的对象，调用方法a时，就会自动的调用如下的方法：invoke()

2. 将被代理类要执行的方法a的功能就声明在invoke()中

• 实现InvocationHandler接口,重写invoke()方法

class MyInvocationHandler implements InvocationHandler{

    private Object obj;//需要使用被代理类的对象进行赋值

    public void bind(Object obj){
        this.obj = obj;
    }

    //当我们通过代理类的对象，调用方法a时，就会自动的调用如下的方法：invoke()
    //将被代理类要执行的方法a的功能就声明在invoke()中
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

        HumanUtil util = new HumanUtil();
        util.method1();

        //method:即为代理类对象调用的方法，此方法也就作为了被代理类对象要调用的方法
        //obj:被代理类的对象
        Object returnValue = method.invoke(obj,args);

        util.method2();

        //上述方法的返回值就作为当前类中的invoke()的返回值。
        return returnValue;

    }
}

调用处理器 类比 AOP当中的切面对象

测试类:

1. 通过代理工厂创建代理类对象
2. 通过代理类对象调用方法时，会自动的调用被代理类中同名的方法

public class ProxyTest {

    public static void main(String[] args) {
        SuperMan superMan = new SuperMan();
        //proxyInstance:代理类的对象
        Human proxyInstance = (Human) ProxyFactory.getProxyInstance(superMan);
        //当通过代理类对象调用方法时，会自动的调用被代理类中同名的方法
        String belief = proxyInstance.getBelief();
        System.out.println(belief);
        
        proxyInstance.eat("火锅");

    }
}

解析：

• 让代理类显示出来

System.getProperties().put(“sun.misc.ProxyGenerator.saveGeneratedFiles”, “true”);

System.getProperties().put(“jdk.proxy.ProxyGenerator.saveGeneratedFiles”,“true”);

public class ProxyTest {
    public static void main(String[] args) {
        SuperMan superMan = new SuperMan();

        // System.getProperties().put("jdk.proxy.ProxyGenerator.saveGeneratedFiles","true");
        System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles", "true");

        //proxyInstance:代理类的对象
        Human proxyInstance = (Human) ProxyFactory.getProxyInstance(superMan);
        //当通过代理类对象调用方法时，会自动的调用被代理类中同名的方法
        String belief = proxyInstance.getBelief();
        System.out.println(belief);

        proxyInstance.eat("火锅");

    }

}

$Proxy0

package com.sun.proxy;

import Proxy.Human;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.lang.reflect.UndeclaredThrowableException;

public final class $Proxy0 extends Proxy implements Human {
    private static Method m1;
    private static Method m2;
    private static Method m4;
    private static Method m3;
    private static Method m0;

    public $Proxy0(InvocationHandler var1) throws  {
        super(var1);
    }

    public final boolean equals(Object var1) throws  {
        try {
            return (Boolean)super.h.invoke(this, m1, new Object[]{var1});
        } catch (RuntimeException | Error var3) {
            throw var3;
        } catch (Throwable var4) {
            throw new UndeclaredThrowableException(var4);
        }
    }

    public final String toString() throws  {
        try {
            return (String)super.h.invoke(this, m2, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    public final void eat(String var1) throws  {
        try {
            super.h.invoke(this, m4, new Object[]{var1});
        } catch (RuntimeException | Error var3) {
            throw var3;
        } catch (Throwable var4) {
            throw new UndeclaredThrowableException(var4);
        }
    }

    public final String getBelief() throws  {
        try {
            return (String)super.h.invoke(this, m3, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    public final int hashCode() throws  {
        try {
            return (Integer)super.h.invoke(this, m0, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    static {
        try {
            m1 = Class.forName("java.lang.Object").getMethod("equals", Class.forName("java.lang.Object"));
            m2 = Class.forName("java.lang.Object").getMethod("toString");
            m4 = Class.forName("Proxy.Human").getMethod("eat", Class.forName("java.lang.String"));
            m3 = Class.forName("Proxy.Human").getMethod("getBelief");
            m0 = Class.forName("java.lang.Object").getMethod("hashCode");
        } catch (NoSuchMethodException var2) {
            throw new NoSuchMethodError(var2.getMessage());
        } catch (ClassNotFoundException var3) {
            throw new NoClassDefFoundError(var3.getMessage());
        }
    }
}

构造方法

 public $Proxy0(InvocationHandler var1) throws  {
        super(var1);
    }

• 把执行器InvocationHandler传入进来,令属性h指向它

static静态代码块

• 通过发射获取方法对象,并赋值给代理类属性

代理类属性

代理类方法

• 实际是调用执行器中的重写后的invoke()方法
• 

所以当通过代理类的对象调用方法a时，能够动态的去调用被代理类中的同名方法a。并且还能实现功能的扩展

为何调用代理类的方法就会自动进入InvocationHandler 的 invoke（）方法呢？

• 其实是因为在动态代理类的定义中，构造函数是含参的构造，参数就是我们invocationHandler实例，而每一个被代理接口的方法都会在代理类中生成一个对应的实现方法，并在实现方法中最终调用invocationHandler的invoke方法，这就解释了为何执行代理类的方法会自动进入到我们自定义的invocationHandler的invoke方法中，然后在我们的invoke方法中再利用jdk反射的方式去调用真正的被代理类的业务方法，而且还可以在方法的前后去加一些我们自定义的逻辑。比如切面编程AOP等。

为什么JDK的动态代理必须有接口?

• 由于java的单继承，动态生成的代理类已经继承了Proxy类的，就不能再继承其他的类，所以只能靠实现被代理类的接口的形式，故JDK的动态代理必须有接口

动态代理案例 2 :CGLIB代理

区分JDK代理:

• 假如目标对象(被代理对象)实现接口，则底层可以采用JDK动态代理机制为目标对象创建代理对象（目标类和代理类会实现共同接口）。
• 假如目标对象(被代理对象)没有实现接口，则底层可以采用CGLIB代理机制为目标对象创建代理对象（默认创建的代理类会继承目标对象类型）。

依赖:

  <dependency>
            <groupId>cglib</groupId>
            <artifactId>cglib</artifactId>
            <version>3.1</version>
        </dependency>

案例演示

import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;

import java.lang.reflect.Method;
import java.util.Random;

public class cglibTest {
    public static void main(String[] args) {
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(Tank.class);
        enhancer.setCallback(new TimeMethodInterceptor());
        Tank tank = (Tank)enhancer.create();
        tank.move();
    }

}

class TimeMethodInterceptor implements MethodInterceptor {

    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {

        System.out.println(o.getClass().getSuperclass().getName());
        System.out.println("before");
        Object result = null;
        result = methodProxy.invokeSuper(o, objects);
        System.out.println("after");
        return result;
    }
}


class Tank {
    public void move() {
        System.out.println("Tank moving claclacla...");
        try {
            Thread.sleep(new Random().nextInt(10000));
        代理模式（Proxy Pattern）

 java项目实战代理模式（Proxy Pattern），静态代理 VS 动态代理
 设计模式-用代理模式（Proxy Pattern）来拯救你的代码：打造可靠的程序设计
 代理模式（Proxy Pattern）
 代理模式（Proxy Pattern）
 代理模式（Proxy Pattern）