设计模式：代理模式

最新推荐文章于 2024-04-02 12:55:59 发布

拉布拉多oop

最新推荐文章于 2024-04-02 12:55:59 发布

阅读量123

点赞数

分类专栏：设计模式

原文链接：https://mp.weixin.qq.com/s/4XccpeLLJr5iR3kDp2tmEg

版权

设计模式专栏收录该内容

2 篇文章 0 订阅

订阅专栏

1.代理模式简介

代理模式是一种结构型设计模式，提供了对目标对象额外的访问方式，即通过代理对象访问目标对象，这样可以在不修改原目标对象的前提下，提供额外的功能操作，扩展目标对象的功能。

简言之，代理模式就是设置一个中间代理来控制访问原目标对象，以达到增强原对象的功能和简化访问方式。

代理模式UML类图

代理模式分类：

静态代理
动态代理
CGLIB代理

2.静态代理

这种代理方式需要代理对象和目标对象实现一样的接口。

优点
可以在不修改目标对象的前提下扩展目标对象的功能。
缺点
冗余。由于代理对象要实现与目标对象一致的接口，会产生过多的代理类。
不易维护。一旦接口增加方法，目标对象与代理对象都要进行修改。

代码

/**
 * 静态代理
 */
//接口
interface Subject{
    public void doSomething();//做某些事
    public void complete();//做完某些事
}
//real类实现接口
class RealSubject implements Subject{
    @Override
    public void doSomething(){
        System.out.println("Start to  do Something");
    }

    @Override
    public void complete(){
        System.out.println("Complete doing sth");
    }
}
//代理类实现接口
class ProxyStatic implements Subject{
    Subject realSubject = new RealSubject();//将RealSubject的实例作为一个属性
    @Override
    public void doSomething(){
    	//在代理增加功能代码，不需要修改原始类
        System.out.println("write to Log  ");//增加功能，做事之前写入日志
        realSubject.doSomething();
    }
    @Override
    public void complete(){
        System.out.println("write to Log ");//同样，完成之前写入日志
        realSubject.complete();
    }
}
public class Proxy_Pattern {//主类
    public static void main(String[] args){
        Subject object = new ProxyStatic();
        object.doSomething();
    }
}

3.动态代理

动态代理利用了JDK API，动态地在内存中构建代理对象，从而实现对目标对象的代理功能。动态代理又被称为JDK代理或接口代理。

动态代理和静态代理的区别：

静态代理在编译时就已经实现，编译完成后代理类是一个实际的class文件,动态代理是在运行时动态生成的，即编译完成后没有实际的class文件，而是在运行时动态生成类字节码，并加载到JVM中

动态代理不需要跟Real类实现一样的接口，但是需要实现InvocationHandler接口。通过使用反射机制，在运行时获取类的实例，重写invoke方法实现增加新功能。

反射的一些知识：

实例.getClass().getClassLoader()，获取该实例所属类的加载器，返回类型Class。
实例.getClass().getInterfaces()，获取这个实例所属类实现了哪些接口，返回类型Class[]。

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

//接口
interface Subject{
    public void doSomething();//做某些事
    public void complete();//做完某些事
}
//real类实现接口
class RealSubject implements Subject{
    @Override
    public void doSomething(){
        System.out.println("Start to  do Something");
    }

    @Override
    public void complete(){
        System.out.println("Complete doing sth");
    }
}
/**
 * 动态代理
 */
class ProxyDynamic implements InvocationHandler{
    Object realSubject; //

    public Object bind(Object realSubject){
        this.realSubject = realSubject;
        return Proxy.newProxyInstance(realSubject.getClass().getClassLoader(),realSubject.getClass().getInterfaces(),this);

    }
    @Override
    public Object invoke(Object proxy,Method method,Object[] args) throws Throwable{
        Object result = null;
        //这里就可以进行AOP编程
        try {
            //增加相应功能
            System.out.println("write to Log ");//增加写入日志功能
            // JVM通过这条语句执行原来的方法(反射机制)
            result = method.invoke(this.realSubject,args);
        }catch (Exception e){
            e.printStackTrace();
        }
        return result;
    }
}
//主类
public class Proxy_Pattern {
    public static void main(String[] args){
        ProxyDynamic proxy = new ProxyDynamic();
        Subject sub = (Subject)proxy.bind(new RealSubject());
        sub.doSomething();
    }
}

看上去好像很复杂，比静态代理要复杂。
！！但是如上，RealSubject类有两个方法，doSomething和complete，如果要求不同方法执行之前写不同的日志，那么对于静态代理，就需要重写两个方法，分别实现写入日志功能，如果不止两个呢？？这时候就体现动态代理的作用了！！
如下：
通过判断正在调用哪个方法，实现不同的日志策略！

class ProxyDynamic implements InvocationHandler{
    Object realSubject; //

    public Object bind(Object realSubject){
        this.realSubject = realSubject;
        return Proxy.newProxyInstance(realSubject.getClass().getClassLoader(),realSubject.getClass().getInterfaces(),this);

    }
    @Override
    public Object invoke(Object proxy,Method method,Object[] args) throws Throwable{
        Object result = null;
        //这里就可以进行AOP编程
        try {
            //获取该实例正在调用的方法名
            String name = method.getName();
            if(name.equals("doSomething")){
                System.out.println("使用策略A去写日志 ");
            }
            else if(name.equals("complete")){
                System.out.println("使用策略B去写日志 ");
            }
            else{
                System.out.println("使用策略C去写日志 ");
            }
            result = method.invoke(this.realSubject,args);
        }catch (Exception e){
            e.printStackTrace();
        }
        return result;
    }
}

4.CGLIB代理

cglib is a powerful, high performance and quality Code Generation Library. It can extend JAVA classes and implement interfaces at runtime.

cglib (Code Generation Library )是一个第三方代码生成类库，运行时在内存中动态生成一个子类对象从而实现对目标对象功能的扩展。

cglib特点：

JDK的动态代理有一个限制，就是使用动态代理的对象必须实现一个或多个接口。
如果想代理没有实现接口的类，就可以使用CGLIB实现。
CGLIB是一个强大的高性能的代码生成包，它可以在运行期扩展Java类与实现Java接口。
它广泛的被许多AOP的框架使用，例如Spring AOP和dynaop，为他们提供方法的interception（拦截）。
CGLIB包的底层是通过使用一个小而快的字节码处理框架ASM，来转换字节码并生成新的类。
不鼓励直接使用ASM，因为它需要你对JVM内部结构包括class文件的格式和指令集都很熟悉。

cglib与动态代理最大的区别就是：

使用动态代理的对象必须实现一个或多个接口
使用cglib代理的对象则无需实现接口，达到代理类无侵入。

保存用户功能的动态代理实现

目标类：

package com.cglib;

public class RealSubject{

    public void save() {
        System.out.println("保存数据");
    }
}

代理类：

package com.cglib;

import java.lang.reflect.Method;

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

public class ProxyFactory implements MethodInterceptor{

    private Object target;//维护一个目标对象
    public ProxyFactory(Object target) {
        this.target = target;
    }

    //为目标对象生成代理对象
    public Object getProxyInstance() {
        //工具类
        Enhancer en = new Enhancer();
        //设置父类
        en.setSuperclass(target.getClass());
        //设置回调函数
        en.setCallback(this);
        //创建子类对象代理
        return en.create();
    }

    @Override
    public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
        //这里就可以进行所谓的AOP编程了
        //在调用具体函数方法前，执行功能处理
        System.out.println("start time:"+System.currentTimeMillis());
        // 执行目标对象的方法
        Object returnValue = method.invoke(target, args);
        System.out.println("start time:"+System.currentTimeMillis());        
        return returnValue;
    }
}

测试类

package com.cglib;

import org.junit.Test;

public class TestProxy {

    @Test
    public void testCglibProxy(){
        //目标对象
        RealSubject target = new RealSubject();
        System.out.println(target.getClass());
        //代理对象
        RealSubject proxy = (UserDao) new ProxyFactory(target).getProxyInstance();
        System.out.println(proxy.getClass());
        //执行代理对象方法
        proxy.save();
    }
}

5.总结

静态代理实现较简单，只要代理对象对目标对象进行包装，即可实现增强功能，但静态代理只能为一个目标对象服务，如果目标对象过多，则会产生很多代理类。
JDK动态代理需要目标对象实现业务接口，代理类只需实现InvocationHandler接口。
动态代理生成的类为 class com.sun.proxy.$Proxy4，cglib代理生成的类为class com.cglib.UserDao$$EnhancerByCGLIB$$552188b6。
静态代理在编译时产生class字节码文件，可以直接使用，效率高。
动态代理必须实现InvocationHandler接口，通过反射代理方法，比较消耗系统性能，但可以减少代理类的数量，使用更灵活。
cglib代理无需实现接口，通过生成类字节码实现代理，比反射稍快，不存在性能问题，但cglib会继承目标对象，需要重写方法，所以目标对象不能为final类。