首页 > 编程语言 > 详细

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

时间:2020-07-19 23:07:55      阅读:91      评论:0      收藏:0      [点我收藏+]

一、什么是代理模式

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

举个例子,有个歌手对象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

 

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

原文:https://www.cnblogs.com/Jerryoned/p/13341129.html

(0)
(0)
   
举报
评论 一句话评论(0
关于我们 - 联系我们 - 留言反馈 - 联系我们:wmxa8@hotmail.com
© 2014 bubuko.com 版权所有
打开技术之扣,分享程序人生!