Java中几种常见的设计模式--代理设计模式

一、什么是代理模式

代理模式是一种设计模式，是在不修改源代码下，实现目标对象的功能扩展。

举个例子，有个歌手对象Singer，然后这个对象有个方法sing()。

public class Singer {
    public void sing(){
        System.out.println("演唱一首歌曲");
    }
}

假如你希望，通过你的某种方式生产出来的歌手对象，在唱歌前后还要想观众问好和答谢，也即对目标对象Singer的sing方法进行功能扩展。

 public void sing(){
        System.out.println("向观众们问好");
        System.out.println("演唱一首歌曲");
        System.out.println("歌手答谢");
    }
}

但是往往你又不能直接对源代码进行修改，可能是你希望原来的对象还保持原来的样子，又或许你提供的只是一个可插拔的插件，甚至你有可能都不知道你要对哪个目标对象进行扩展。这时就需要用到java的代理模式了。

代理模式有三种，静态代理模式、动态代理模式、Cglib代理模式，下面我们分别用这三种模式来实现我们想要的功能。

二、静态代理模式

在使用静态代理模式时，我们要首先定义接口或父类，让代理对象和被代理对象一起实现相同的接口或相同的父类。我们创建的接口如下：

/**
 * 代理类和被代理类共同接口
 */
public interface ISinger {
    void sing();
}

/**
 * 接口实现
 * 目标对象
 */
public class Singer implements ISinger{
    @Override
    public void sing(){
        System.out.println("演唱一首歌曲");
    }
}

/**
 * 代理对象和对象对象实现相同的接口
 *
 */
public class SingerProxy implements  ISinger {
    private ISinger singer;
    //注入目标对象，以便实现sing()方法
    public SingerProxy(ISinger singer){
        this.singer=singer;
    }
    //对sing()方法进行拓展
    @Override
    public void sing() {
        System.out.println("向观众们问好");
        singer.sing();
        System.out.println("歌手答谢");
    }
}

测试代码如下：

 @Test
    public void sing() {
        //创建目标对象
        ISinger singer=new Singer();
        //创建代理对象
        ISinger proxySinger=new SingerProxy(singer);
        //执行代理拓展的方法
        proxySinger.sing();

    }

结果如下：

向观众们问好
演唱一首歌曲
歌手答谢

这种静态代理模式的优缺点

优点：简单直观。

缺点：代理代码必须提前写出，需要对代理代码进行维护。如果接口层发生了变化，也需要修改代理代码。

如果能在运行时动态地写出代理对象，不但减少了一大批代理类的代码，也少了不断维护的烦恼，不过运行时的效率必定受到影响。这种方式就是接下来的动态代理。

三、动态代理模式

动态代理模式有以下特点

1. 代理对象，不需要实现接口
2. 代理对象的生成,是利用JDK的API,动态的在内存中构建代理对象(需要我们指定创建代理对象/目标对象实现的接口的类型)
3. 动态代理也叫做:JDK代理,接口代理

代理类所在包:java.lang.reflect.Proxy
JDK实现代理只需要使用newProxyInstance方法,但是该方法需要接收三个参数,完整的写法是：

static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces,InvocationHandler h )

• ClassLoader loader：指定目标对象的类加载器，获取类加载器的方法固定；
• Class<?>[] interfaces：指定目标对象的接口类型，使用泛型的方式获取类型；
• InvocationHandler h：事件处理接口，执行目标对象方法时会触发事件处理器的方法，会把当前执行目标对象的方法作为参数传入。

我们可以将创建一个代理工厂类

public class ProxyFactory {
    //创建一个目标对象
    Object target;
    public ProxyFactory(Object target){
        this.target=target;
    }

    //给目标对象生成代理对象
    public Object getProxyInstance(){
        return Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), new InvocationHandler() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                System.out.println("向观众们问好");
                Object returnResult=method.invoke(target,args);
                System.out.println("歌手答谢");
                return returnResult;
            }
        });
    }
}

测试方法如下：

  @Test
    public void TestProxy(){
        //创建目标对象
        ISinger singer=new Singer();
        System.out.println(singer.getClass());
        //创建代理对象
        ISinger proxySinger=(ISinger) new ProxyFactory(singer).getProxyInstance();
        System.out.println(proxySinger.getClass());
        //执行代理方法
        proxySinger.sing();
    }

结果如下：

class com.zc.core.Singer
class com.sun.proxy.$Proxy4
向观众们问好
演唱一首歌曲
歌手答谢

总结：以上代码只有标黄的部分是需要自己写出，其余部分全都是固定代码。由于java封装了newProxyInstance这个方法的实现细节，所以使用起来才能这么方便，具体的底层原理将会在下一小节说明。

缺点：可以看出静态代理和JDK代理有一个共同的缺点，就是目标对象必须实现一个或多个接口，加入没有，则可以使用Cglib代理。

四、Cglib代理模式

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

使用Cglib的前提条件：

1. 需要引入cglib的jar文件，由于Spring的核心包中已经包括了Cglib功能，所以也可以直接引入spring-core-3.2.5.jar
2. 引入功能包后,就可以在内存中动态构建子类
3. 代理的类不能为final,否则报错
4. 目标对象的方法如果为final/static,那么就不会被拦截,即不会执行目标对象额外的业务方法。

具体操作如下：

/**
 * 目标对象未实现任何接口
 */
public class Singer{
    public void sing(){
        System.out.println("演唱一首歌曲");
    }
}

/**
 *Cglib子类代理工厂
 */
public class ProxyFactory implements MethodInterceptor {
    //创建目标对象
    private Object target;
    public ProxyFactory(Object target){
        this.target=target;
    }
    //给目标对象创建一个代理对象
    public Object getProxyInstance(){
        //创建一个工具类
        Enhancer enhancer=new Enhancer();
        //设置父类
        enhancer.setSuperclass(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("向观众们问好");
        //执行目标对象方法
        Object returnResult=method.invoke(target,objects);
        System.out.println("歌手答谢");
        return returnResult;
    }
}

在代理工厂中只有标黄的地方是需要我们修改的，其他部分都是不变的。

测试方法如下：

public class Test {
    public static void main(String[] args){
        //创建目标对象
        Singer singer=new Singer();
        //创建代理对象
        Singer proxySinger=(Singer) new ProxyFactory(singer).getProxyInstance();
        //执行代理方法
        proxySinger.sing();
    }
}

测试结果：

向观众们问好
演唱一首歌曲
歌手答谢

总结：三种代理模式各有优缺点和相应的适用范围，主要看目标对象是否实现了接口。以Spring框架所选择的代理模式举例

在Spring的AOP编程中：
如果加入容器的目标对象有实现接口，用JDK代理
如果目标对象没有实现接口，用Cglib代理

--------------------------------------------------------------------------------------------------------------------------------------------------------------------------

参考博文：https://www.cnblogs.com/boboxing/p/8126046.html

参考博文：https://www.cnblogs.com/leeego-123/p/10995975.html