学习笔记-proxy代理模式

proxy代理模式

proxy代理模式,让我们可以通过中间代理类去操作被代理类的一些处理,让操作者不直接操作对象类

就好比明星和经纪人的关系(参考别人博客的说法),除了明星自己的独特的演出,或者唱歌,需要调用对象本身,其余的拉赞助,接通告等其它的事情可以交给经纪人去做.
这里的经济人就相当于代理

为什么要用代理模式

当我们要对某一个方法进行增强时,比如对某个方法计算他的效率,打印开始结束日志等,我们可能会在每次调用一个方法的时候,去执行一次执行时间的统计,或者日志的打印
(比如多个明星,就需要跟着多个经纪人分开跑—>这里如果有个经济公司,统一管理这些明星)

package it.luke.proxy.v00;

public class Url_req {

    public void filter(){
        System.out.println("filter ...");
    }

   public static void main(String[] args) {
        Url_req url_req = new Url_req();


        long start = System.currentTimeMillis();
        System.out.println(start);
        url_req.filter();
        System.out.println(System.currentTimeMillis() - start);
   }

}

如果需要统计多个方法的话,就需要重复的对统计方法进行调用

package it.luke.proxy.v00;

public class Url_req {

    public void filter(){
        System.out.println("filter ...");
    }

    public void filter02(){
        System.out.println("filter02 ...");
    }
    public static void main(String[] args) {
        Url_req url_req = new Url_req();


        long start = System.currentTimeMillis();
        System.out.println(start);
        url_req.filter();
        System.out.println(System.currentTimeMillis() - start);

        long start1 = System.currentTimeMillis();
        System.out.println(start);
        url_req.filter02();
        System.out.println(System.currentTimeMillis() - start1);
    }
}

如果是多个类的话,就需要分别对多个类的执行方法进行重复调用,代码变得庞大,而且繁琐

这个时候可以通过代理模式,将被调用的类,通过代理类进行调用

静态代理

下面是一个简单的代理的实现

package it.luke.proxy.v01;

/**
 * 一个请求url的对象,实现filter方法
 */
public class Url_req implements FilterInter {
    @Override
    public void filter() {
        System.out.println("running with filter ...");
    }
}


/**
 * 通过代理类的方式,调用被代理类的方法
 * 可以附加额外的一些方法
 */
class Proxy_url implements FilterInter{

    //通过聚合的方式引入对象(代理多个明星)
    Url_req url_req ;

    public void setUrl_req(Url_req url_req) {
        this.url_req = url_req;
    }

    /**
     * 模拟经纪人拉明星1去演出
     */
    @Override
    public void filter() {
        url_req.filter();
    }
    public static void main(String[] args) {
        Proxy_url proxy_url = new Proxy_url();

        //除了调用被代理类的方法,还可以调用其它的方法进行补充(经纪人还可以做一些其它的,整理行程...)
        System.out.println("开始调用代理方法....");

        //调用代理类,让代理类去调用被代理类的方法(经纪人拉着明星去演出)
        proxy_url.filter();

        //代理类的其余方法(经纪人叫车接送明星回去)
        System.out.println("代理结束...");
    }
}

以上是静态代理,需要聚合被代理类,然后实现被代理实现的接口,然后才能通过代理类去调用被代理类的方法

如果是针对多个不同的类的不同方法,可以通过实现不同的接口,对被代理类进行聚合

package it.luke.proxy.v01;

/**
 * 一个请求url的对象,实现filter方法
 */
public class Url_req implements FilterInter {
    @Override
    public void filter() {
        System.out.println("running with filter ...");
    }
}
class Url_spo implements FilterInter {

    @Override
    public void filter() {
        System.out.println("respone filter running ...");
    }
}
/**
 * 通过代理类的方式,调用被代理类的方法
 * 可以附加额外的一些方法
 */
class Proxy_url implements FilterInter{

    //通过聚合的方式引入对象(代理多个明星)
    //明星1
    Url_req url_req ;
    //明星2
    Url_spo url_spo ;
    public void setUrl_spo(Url_spo url_spo) {
        this.url_spo = url_spo;
    }

    public void setUrl_req(Url_req url_req) {
        this.url_req = url_req;
    }
    /**
     * 模拟经纪人拉明星去演出
     */
    @Override
    public void filter() {
        url_req.filter();
        url_spo.filter();
    }

    public static void main(String[] args) {
        Proxy_url proxy_url = new Proxy_url();

        //除了调用被代理类的方法,还可以调用其它的方法进行补充(经纪人还可以做一些其它的,整理行程...)
        System.out.println("开始调用代理方法....");

        //调用代理类,让代理类去调用被代理类的方法(经纪人拉着明星去演出)
        proxy_url.filter();

        //代理类的其余方法(经纪人叫车接送明星回去)
        System.out.println("代理结束...");
    }
}

小记:主要用的的都是多态的思想,让代理类实现和被代理类一样的接口,拿到相同的方法名,然后引入被代理类到代理对象中

动态代理

什么是动态代理,和静态代理不同的是,静态代理的代理类是需要自己去实现被代理类的实现接口,通过实现接口去拿到和被代理类一样的方法名

而动态代理,是程序帮你生成代理类,和静态代理一样,需要被代理类的接口,拿到相同的方法名,然后将一些有经纪人进行操作的"杂物"封装到invoke 中,通过代理类去调用

通过调用java 提供的Proxy这个类,通过newProxyInstance,获取一个代理实例,要获取这个实例需要传三个参数,通过着三个参数可以定位到被代理的类,然后通过反射的方法,对被代理类进行处理.

//ClassLoader loader, 用来加载被代理类
//Class<?>[] interfaces, 被代理类的实现接口
//InvocationHandler h  行为处理器

InvocationHandler 行为处理器这个参数主要是要重写invoke方法,因为在动态代理生成后,底层再构建代理类的时候,会自动调用invoke这个方法.

可以通过"jdk.proxy.ProxyGenerator.saveGeneratedFiles" true 来查看保存在本地的生成代理文件

package it.luke.proxy.v02;

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

/**
 * 动态代理
 */
public class Dynamic_proxy {
    /*
    动态代理,顾名思义,自己进行调用代理,不在需要自己去指定被代理类的实现
     */
    public static void main(String[] args) {

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

        //通过设置这个参数,可以将程序动态生成的代理保存下来 不同的java 版本可能设置的参数不一样,有坑-->java8
        System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles", "true");

        Url_req url_req = new Url_req();
        //ClassLoader loader, 用来加载被代理类
        //Class<?>[] interfaces, 被代理类的实现接口
        //InvocationHandler h  行为处理器
        FilterInter o = (FilterInter)Proxy.newProxyInstance(Url_req.class.getClassLoader(), new Class[]{FilterInter.class},
                new InvocationHandler() {
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

                        System.out.println("methon " + method.getName() + "start");
                        Object invoke2 = method.invoke(url_req,args);

                        System.out.println("methon " + method.getName() + "end");
                        return invoke2;
                    }
                });
        o.filter();
    }

}

代码小记:

先准备好被代理类的类加载器(确保被代理的时候能够正确的调用到被代理类的方法)
获取被代理类的方法实现接口(确保生成的代理类拥有和被代理类一样的方法名…底层通过匹配MethonName 来调用类加载器加载的类对象对应的方法—>用到反射)
准备好执行逻辑 invoke() 需要传入一个实现了InvocationHandler接口的对象,并重写invoke()方法(invoke在代理类生成的时候,同时生成在代理类中)

最后通过调用生成的代理对象,来实现对被代理对象的处理

为了更直观的查看到动态生成的代理对象,我们将动态生成的临时代理对象保存下来
System.getProperties().put(“sun.misc.ProxyGenerator.saveGeneratedFiles”, “true”);

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//

package com.sun.proxy;

import it.luke.proxy.v02.FilterInter;
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 FilterInter {
    private static Method m1;
    private static Method m2;
    private static Method m3;
    private static Method m4;
    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 filter() throws  {
        try {
            super.h.invoke(this, m3, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    public final void filter_parm(Integer 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 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");
            m3 = Class.forName("it.luke.proxy.v02.FilterInter").getMethod("filter");
            m4 = Class.forName("it.luke.proxy.v02.FilterInter").getMethod("filter_parm", Class.forName("java.lang.Integer"));
            m0 = Class.forName("java.lang.Object").getMethod("hashCode");
        } catch (NoSuchMethodException var2) {
            throw new NoSuchMethodError(var2.getMessage());
        } catch (ClassNotFoundException var3) {
            throw new NoClassDefFoundError(var3.getMessage());
        }
    }
}

动态生成的代理类对象可以看到,在调用代理类中的filter的时候,调用了父类的h.invoke方法,其实就是前面实现InvocationHandler接口的时候定义的invoke()方法

底层是通过asm框架进行代理对象的构建,可以直接修改二进制码(待了解)

缺陷:通过jdk api进行动态代理,要求被代理类要实现接口,并且在接口中定义方法

CGlib

除了jdk proxy 方法可以进行动态代理,java还提供了CGlib
jdk 是通过接收被代理类的接口的方式匹配到被代理类的方法
而CGlib是通过继承被代理类,通过重写的方式进行代理…

• 待补充