设计模式代理模式

最新推荐文章于 2023-01-02 20:26:38 发布

这个bug不是我写的

最新推荐文章于 2023-01-02 20:26:38 发布

阅读量584

点赞数 2

本文链接：https://blog.csdn.net/ss_s1gn/article/details/78367406

版权

参考自：

定义：代理模式给目标对象提供一个代理对象，并由代理对象控制对目标对象的引用。

好处：在不修改目标对象的前提下，增加目标对象的功能，是对目标对象的拓展。符合开闭原则（对扩展开放，对修改关闭）

举个栗子：公司发展越来越好，老板越来越忙，没有时间去处理琐碎的事情，这时候他招了一个秘书（代理），来帮助他处理这些琐碎的事情。但其实重要的事情，都是老板去处理去谈，像一些准备、善后工作要交由秘书去做。

这里注意：真正的业务功能还是交由目标对象处理，代理只是为目标对象增加了某种公共服务。

分类：

静态代理：运行之前就写好代理类，由程序员创建或生成源代码
动态代理： JDK动态代理和cglib动态代理。JDK动态代理在程序运行时由Java反射机制动态生成，Java 反射机制可以生成任意类型的动态代理类。java.lang.reflect 包中的Proxy类和InvocationHandler 接口提供了生成动态代理类的能力；cglib动态代理在内存中构建子类，对父类方法拦截实现代理

上代码：

//具体的行为（业务）接口
public interface IBehavior {
    //开会
    void meeting();

    //吃饭
    void eat();
}

接口实现类：即目标对象

//老板
public class Boss implements IBehavior {

    @Override
    public void meeting() {
        System.out.println("我是老板，我只管开会");
    }

    @Override
    public void eat() {
        System.out.println("我是老板，我只管吃饭");
    }
}

代理类：实现业务接口，增强目标对象功能（此处为静态代理）

//秘书
public class Secretary implements IBehavior {
    private Boss boss;

    public Secretary(Boss boss) {
        this.boss = boss;
    }

    @Override
    public void meeting() {
        //开会前
        System.out.println("召集相关人员，整理会议室");
        //人齐了，收拾好了，叫老板开会
        boss.meeting();
        //开会后
        System.out.println("保存会议记录，打扫会议室");
    }

    @Override
    public void eat() {
        //吃饭前
        System.out.println("定饭馆，订菜，通知、招待客户");
        //定好了，人齐了
        boss.eat();
        //吃饭后
        System.out.println("安排客户住宿，送客户");
    }
}

模拟场景操作


//场景操作
public class Operator {

    public static void main(String args[]) {
        //静态代理
        Boss boss = new Boss();
        Secretary secretary = new Secretary(boss);
        secretary.meeting();
        secretary.eat();
    }
}

运行结果：

召集相关人员，整理会议室
我是老板，我只管开会
保存会议记录，打扫会议室
定饭馆，订菜，通知、招待客户
我是老板，我只管吃饭
安排客户住宿，送客户

可以看到，开会这个行为还是由老板去完成的，但是在老板开会之前和之后秘书进行了一些准备和善后工作。
例如在项目开发中我们没有加入缓冲，日志这些功能，后期想加入，我们就可以使用代理来实现，而没有必要对原来的类进行修改。

JDK动态代理实现方法

//JDK动态代理
public class DynamicProXY implements InvocationHandler {
    //目标对象
    private Object obj;

    public DynamicProXY(Object obj) {
        this.obj = obj;
    }

    /**
     * @param proxy  生成的动态代理对象
     * @param method 要调用的方法
     * @param args   方法调用时所需要的参数
     * @return
     * @throws Throwable
     */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("proxy.getClass()" + proxy.getClass());
        System.out.println("obj.getClass()" + obj.getClass());
        Object result = null;
        if (method.getName().equals("meeting")) {
            //开会前
            System.out.println("召集相关人员，整理会议室");
            //开会
            result = method.invoke(this.obj, args);
            //开会后
            System.out.println("保存会议记录，打扫会议室");
        } else if ("eat".equals(method.getName())) {
            //吃饭前
            System.out.println("定饭馆，订菜，通知、招待客户");
            //定好了，人齐了
            result = method.invoke(this.obj, args);
            //吃饭后
            System.out.println("安排客户住宿，送客户");
        }
        return result;
    }
}

模拟场景操作：

//场景操作
public class Operator {

    public static void main(String args[]) {
        //动态代理
        Boss dynamicBoss = new Boss();
        InvocationHandler handler = new DynamicProXY(dynamicBoss);
        IBehavior behavior = (IBehavior) Proxy.newProxyInstance(dynamicBoss.getClass().getClassLoader(), dynamicBoss.getClass().getInterfaces(), handler);
        System.out.println("behavior.getClass()" + behavior.getClass());
        behavior.meeting();
        behavior.eat();
    }
}

JDK动态代理中包含一个类和一个接口：

InvocationHandler接口
我们定义的一个实现类“Proxy“，这是一个万能的代理类，我们就是通过这个代理类来实现动态代理的。

InvocationHandler接口

public Object invoke(Object proxy, Method method, Object[] args) throws Throwable

proxy：生成的动态代理对象（待会log中可看到）
method：要调用的方法
args：方法调用时所需要的参数

Proxy类中的newProxyInstance方法：

public static Object newProxyInstance(ClassLoader loader, Class<？>[] interfaces , InvocationHandler h) throws IllegalArgumentException

ClassLoader loader：类加载器
Class<？>[] interfaces：得到全部的接口
InvocationHandler h：得到InvocationHandler接口的子类实例｛执行目标对象的方法时，会触发事件处理器的方法，会把当前执行目标对象的方法（即本例中的meeting方法和eat方法）作为参数（invoke方法的第二个参数）传入｝

运行结果：

behavior.getClass()class com.sun.proxy.$Proxy0
proxy.getClass()class com.sun.proxy.$Proxy0
obj.getClass()class com.sign.proxydemo.Boss
召集相关人员，整理会议室
我是老板，我只管开会
保存会议记录，打扫会议室
proxy.getClass()class com.sun.proxy.$Proxy0
obj.getClass()class com.sign.proxydemo.Boss
定饭馆，订菜，通知、招待客户
我是老板，我只管吃饭
安排客户住宿，送客户

由运行结果看到：

InvocationHandler接口invoke方法的第一个参数和Proxy的newProxyInstance返回值都是代理对象
和静态代理结果一样实现了对目标对象的扩展

静态代理的缺点：

一旦业务接口增加方法，目标对象与代理对象都要维护
代理对象需要与目标对象实现一样的接口,所以会有很多代理类,类太多

JDK动态代理当然也有缺陷，JDK的动态代理依靠接口实现，要是我一个没有接口的类想被代理怎么办？
如果有些类并没有实现接口，则不能使用JDK代理，这就要使用cglib动态代理了

cglib动态代理

也叫作子类代理,它是在内存中构建一个子类对象从而实现对目标对象功能的扩展
CGLib 给我们提供的是方法级别的代理，也可以理解为对方法的拦截
Cglib是一个强大的高性能的代码生成包,它可以在运行期扩展java类与实现java接口.它广泛的被许多AOP的框架使用,例如SpringAOP和synaop,为他们提供方法的interception(拦截)
Cglib包的底层是通过使用一个小而块的字节码处理框架ASM来转换字节码并生成新的类.不鼓励直接使用ASM,因为它要求你必须对JVM内部结构包括class文件的格式和指令集都很熟悉.

注意：

代理的类不能是final的，因为cglib代理需要构建一个子类对象
目标对象的方法如果为final/static,那么就不会被拦截

public class CGLibProXY implements MethodInterceptor {

    private Object target;

    public Object getInstance(Object target) {
        this.target = target;
        Enhancer enhancer = new Enhancer();
        //设置父类
        enhancer.setSuperclass(this.target.getClass());
        //设置回调
        enhancer.setCallback(this);
        //创建代理对象
        return enhancer.create();
    }

    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        System.out.println("o.getClass()" + o.getClass());

        Object result = null;
        if (method.getName().equals("meeting")) {
            //开会前
            System.out.println("召集相关人员，整理会议室");
            //开会
            result = methodProxy.invokeSuper(o, objects);
            //开会后
            System.out.println("保存会议记录，打扫会议室");
        } else if ("eat".equals(method.getName())) {
            //吃饭前
            System.out.println("定饭馆，订菜，通知、招待客户");
            //定好了，人齐了
            result = methodProxy.invokeSuper(o, objects);
            //吃饭后
            System.out.println("安排客户住宿，送客户");
        }
        return result;
    }
}

模拟场景操作

//场景操作
public class Operator {

    public static void main(String args[]) {
        //cglib动态代理
        CGLibProXY cgLibProXY = new CGLibProXY();
        Boss boss = (Boss) cgLibProXY.getInstance(new Boss());
        System.out.println("boss.getClass()" + boss.getClass());
        boss.meeting();
        boss.eat();
    }
}

运行结果

boss.getClass()class com.sign.proxydemo.Boss$$EnhancerByCGLIB$$f9d4550
o.getClass()class com.sign.proxydemo.Boss$$EnhancerByCGLIB$$f9d4550
召集相关人员，整理会议室
我是老板，我只管开会
保存会议记录，打扫会议室
o.getClass()class com.sign.proxydemo.Boss$$EnhancerByCGLIB$$f9d4550
定饭馆，订菜，通知、招待客户
我是老板，我只管吃饭
安排客户住宿，送客户

可以看到：intercept方法的第一个参数和操作时生成的代理对象为同一个对象
这里由于CGLibProXY持有目标对象的引用，我们同样可以将

result = methodProxy.invokeSuper(o, objects);

修改为：

result = method.invoke(target, objects);

输出是一样的。

源码点我

这个bug不是我写的

关注

2
点赞
踩
3

收藏

觉得还不错? 一键收藏
1
评论
设计模式代理模式

参考自：http://blog.csdn.net/wangyongxia921/article/details/46124197http://www.cnblogs.com/cenyu/p/6289209.htmlhttp://www.cnblogs.com/xiaoluo501395377/p/3383130.htmlhttp://yangguangfu.iteye.com/blog...
复制链接

扫一扫