JAVA 代理模式(Proxy)死磕,一文全懂

疯狂创客圈:如果说Java是一个武林,这里的聚集一群武痴, 交流着编程的各种招式
QQ群链接:
疯狂创客圈QQ群

 

在Java编程中,代理模式是一种极为重要的设计模式。

什么是代理模式呢?简单的说,当不想直接访问,或者无法直接访问某个方法时,可以通过一个代理对象来间接访问,这便是代理的模式。


为什么在这里讲解代理模式呢? 
Java中的代理模式,与Java的反射技术关系非常的密切,故与反射技术一起分析和研究。


代理场景一:访问日志

打个比方,我们前面设计了一个简单的宠物类Pet类。

有两个方法: sayHello和sayAge,赘述如下:

 

 

JAVA 代理模式(Proxy)死磕,一文全懂_第1张图片

 

现在问题来了: 如果在调用sayHello 和sayHi时,需要在文件中加上访问日志,该如何实现呢?

假如,要求实现的访问日志的实例如下:


2018-09-23 03:03:11 嗨,大家好!我是小狗-1
2018-09-23 03:03:11 嗨,我是小狗-1,我的年龄是:91
2018-09-23 03:03:11 嗨,大家好!我是小猫-1
2018-09-23 03:03:11 嗨,我是小猫-1,我的年龄是:4


访问日志,是一种非常普遍、非常常见的日常开发需求。

在我们的日常开发中,往往需要进行访问的统计,统计网站页面或者API接口的详细访问日志,以便进行后续的性能分析和产品优化。这种访问统计,小部分是保存在文件中,更多的是保存在数据库中,而大型的网站的访问日志,则是保存在分布式的文件系统中。


为了简单起见,本实例将日志保存在文件中。 按照日期为单位,每天在log目录下生成一个以当天为文件名称的log文件。

如何实现这个日志的功能呢?
有一种愚笨蠢的方式,就是直接修改原来的代码,加上日志的功能。为什么说这个方法愚笨蠢呢? 这明细不符合面向对象设计的原则:对修改封闭,对扩展开放。去修改原来的老的代码,一是可能会引入新的问题。更何况,老的代码可能来自其他的项目和工程,手上未必有老的代码。
 稍微高级一点的办法,是使用静态代理的模式,对原来的代码进行继承和扩展。


静态代理以及实例

首先说下静态代理的简单做法:
(1)首先,继承老的代码,增加中间层。
(2)在中间层中,加入扩展的功能。
(3)在中间层中,组合老的对象实例,调用老的代码。
(4)中间层代码,必须继承原来的接口。

保持接口的一致,利用面向对象的多态机制和向上转型功能,这样,能保障客户端代码不需要改变。

在思路上非常的简单,按照上面的思路,实现前面讲的案例:设计一个静态代理类,给Pet类增加日志的能力,设计UML图如下:

 

JAVA 代理模式(Proxy)死磕,一文全懂_第2张图片

 

新设计一个PetLoger类,作为Pet类的代理,包含一个原Pet对象的组合,并且扩展了日志的能力。

PetLoger类代理对象控制对Pet原对象的引用,对客户端的调用,隐藏Pet原对象的具体信息。

PetLoger类的代码如下:

package com.crazymakercircle.Proxy;
import com.crazymakercircle.common.pet.IPet;
import com.crazymakercircle.common.pet.Pet;
import com.crazymakercircle.util.FileLogger;
 class PetLogger  extends Pet implements IPet  {
    IPet pet;
    public PetLogger(IPet pet) {
        this.pet = pet;
    }

    @Override
    public IPet sayHello() {
        pet.sayHello();
        String logInfo = "嗨,大家好!我是" + pet.getName();
        FileLogger.info(logInfo);
        return this;
    }

    @Override
    public IPet sayAge() {
        pet.sayAge();
        String logInfo = "嗨,我是" + pet.getName() + ",我的年龄是:" + pet.getAge();
        FileLogger.info(logInfo);
        return this;
    }
}

在PetLogger 代理类的sayHello和sayAge方法中,进行了日志能力的增强,调用fileLogger,向文件中进行日志的记录。

客户端的调用代码如下:


package com.crazymakercircle.Proxy;
import com.crazymakercircle.common.pet.Cat;
import com.crazymakercircle.common.pet.Dog;
public class PetLoggerDemo
{
    public static void main(String[] args) {
        PetLogger petLogger=new PetLogger(new Dog());
        petLogger.sayHello();
        petLogger.sayAge();
        petLogger=new PetLogger(new Cat());
        petLogger.sayHello();
        petLogger.sayAge();
      }
}

客户端程序,除了对象的新建需要稍微的调整之外,其他的代码,都不需要改变。


运行客户端的程序,在日志文件中,进行了日志的保存。日志保存的结果,如下所示:

2018-09-23 03:03:11 嗨,大家好!我是小狗-1
2018-09-23 03:03:11 嗨,我是小狗-1,我的年龄是:91
2018-09-23 03:03:11 嗨,大家好!我是小猫-1
2018-09-23 03:03:11 嗨,我是小猫-1,我的年龄是:4

新设计的PetLogger,调用了一个通用的日志类FileLogger,向日志文件,追加日志。 

日志类FileLogger的代码,逻辑上比较简单。

由于与本例核心逻辑不相干,这里不赘述,欢迎来疯狂创客圈QQ群共享下载。 


静态代理的原理

通过上面的实例,对静态代理有一个比较清晰的了解。
静态代理模式,原理上由3大组成部分:
(1)抽象接口类(abstract subject)
该类的主要职责是声明目标类与代理类的共同接口方法,该类既可以是一个抽象类也可以是一个接口。
(2) 真实目标类(real subject)
该类也称为被委托类或被代理类,该类定义了代理所表示的真实对象,由其执行具体业务逻辑方法,而客户端则通过代理类间接地调用真实目标类中定义的方法。 
(3)代理类(proxy subject)
该类也称为委托类或代理类,该类持有一个对真实目标类(realSubject)的引用,在其所实现的接口方法中调用真实目标类中相应的接口方法执行,以此起到代理的作用。同时,代理类执行扩展的业务逻辑,实现能力的扩展。

    
前面讲到,静态代理模式,完美的符合了面向对象的一项基本原则:对修改封闭,对扩展开放。

然而,这种模式有一个显而易见的缺点。

下面做一个假设, 假设一种新的场景:需要对属性的合理性进行校验。静态代理模式的缺点就一览无余了。

代理的场景二:属性校验


在实际的开发中,客户会一个接着一个,不断提出新的要求。这也符合互联网开发的迭代思维,是在一次又一次的迭代开发中,产品的功能一步一步丰富和完善的。

这里假设一种新的场景:
在解决完了日志的能力扩展之后,领导或者客户又提出了一项新的能力扩展,需要对宠物的年龄进行属性校验。

校验的逻辑是:对于在合理范围之外的宠物年龄,要求进行年龄的保密,不暴露给外界。

为了进行属性校验,先进行两项准备工作:
(1)定义一个注解,用来进行年龄的配置注解的代码如下:

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
public @interface AgeRange {

int min();
int max();
}

(2)第二项准备工作是: 给Pet 类的age成员,加上年龄的注解标记


public class Pet  implements IPet{
 .........
    @AgeRange(max = 15,min = 2)
    protected int age;
..........

}


接下来,万事具备,只欠东风了。

为了实现对年龄进行校验,可以使用静态代理模式。


参考前面的案例,再一次对Pet类进行扩展,新增一个AgaChecker 代理类,在 AgaChecker 代理类的sayAge方法中,对age的属性值进行校验。

AgaChecker 代理类的代码如下:

class AgaChecker extends PetLogger implements IPet {
    IPet pet;
    public AgaChecker(IPet pet) {
        super(pet);
        this.pet = pet;
    }

    @Override
    public IPet sayAge() {
        Field field = null;
        try {
            field = Pet.class.getDeclaredField("age");
        } catch (NoSuchFieldException e) {
           e.printStackTrace();
        }
        AgeRange anno = field.getAnnotation(AgeRange.class);
        if (this.getAge() > anno.max() || this.getAge() 


在上面的 AgaChecker 代理类的sayAge方法中, 首先取得了注解的min和max值,然后对age 进行校验:如果不在合理范围之类, 不在输出宠物的年龄,实现了保密的目的。

在这个代码中, 应用了注解的技术、 反射的技术、静态代理的技术。

几项Java的比较牛逼的技术,都全面的得到了引用。 然后,通过新技术的应用,优美的解决了客户的问题。

正在心里洋洋得意之时,客户或者领导不断的暗示你:这个不是终点,后面几轮迭代,还需要对持续Pet类进行扩展和改进,还需要扩展性能统计能力、安全控制能力、异常处理能力 ........

在这种场景下,估计作为开发者的你,也是头都大了。

难道每一种场景,都去增加一个代理类吗? 显然,静态代理模式的缺点,已经昭然若揭的出来了。


静态代理的一个显著的缺点是:

一个静态代理类,只服务于一种场景的能力增强。反过来说,每一次能力的增强,需要设计一个新的代理类。

如果能力增强的场景很多,就需要设计较多的代理类型。在这种情况下,若采用静态代理,则会出现新增静态代理类多,造成代码量大,从而导致代码冗余、重复的问题。

如何解决这个问题呢?
上帝告诉我们:办法总比问题多。 其办法之一就是:动态代理。

动态代理

动态代理则与静态代理相反,不需要手工实现代理类。
动态代理通过反射机制,动态地生成代理类型。在编码阶段,不需要编写代理类。这个代理类,由JDK通过反射技术,在执行阶段动态生成,所以也叫动态代理。

通过JDK 的方式,实现动态代理的代码很简单,大致如下3步:
(1)构造一个能力扩展对象,能力扩展对象需要实现InvocationHandler接口,实现该接口的invoke抽象方法。能力扩展的代码逻辑,写在此invoke方法中。 InvocationHandler接口是JDK的预定义接口,位于 java.lang.reflect 包中。
(2)在JDK生成运行时代理对象前,需要取得真实目标对象(real subject)的接口,作为运行时代理类需要实现的接口。
(3)将第一步构造的InvocationHandler接口的能力扩展对象、第二步获取的真实目标对象的接口、还加上一个类加载器,三者凑齐一起,作为入口参数,传入java.lang.reflect.Proxy类的newProxyInstance方法中,获取JDK 在运行阶段生成动态代理对象,然后,大功告成。

本例中,将以上的第二步、第三个步骤进行了封装,写成了一个通用的获取代理对象的方法,具体如下:

public static Object newProxyInstance(IPet targetObject, InvocationHandler handler ) {
    Class targetClass = targetObject.getClass();
    ClassLoader loader = targetClass.getClassLoader();
    //被代理类实现的接口
    Class[] targetInterfaces = ReflectionUtil.getInterfaces(targetClass);
    Object proxy = Proxy.newProxyInstance(loader, targetInterfaces, handler);
    return proxy;
}

为了代码的复用,将以上的定义的newProxyInstance方法,放置在一个与反射相关的Util类——ReflectionUtil类中,供后续调用。

顺便说一下,上面这个方法,后面会反复用到,用来取得动态代理类型对象。

如果这个三步暂时不好理解,看两个例子就清楚了。


动态代理实例

按照上面的三步,来实现动态代理实例,实现前面日志记录的能力。
其第一步,构造一个能力扩展对象LogHandler,实现InvocationHandler接口,实现该接口的invoke抽象方法,代码如下:

package com.crazymakercircle.Proxy;

import com.crazymakercircle.common.pet.IPet;
import com.crazymakercircle.util.FileLogger;
import com.crazymakercircle.util.Logger;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
class LogHandler implements InvocationHandler {
    IPet pet;
    public LogHandler(IPet pet) {
        this.pet = pet;
    }
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        if (!(proxy instanceof IPet)) {
            Logger.info("proxy is not IPet, need not file log");
        }
        IPet pet = this.pet;
        if (method.getName().equals("sayHello")) {
//            method.invoke(pet, args);
            pet.sayHello();
            String logInfo = "嗨,大家好!我是" + pet.getName();
            FileLogger.info(logInfo);
        } else if (method.getName().equals("sayAge")) {
            pet.sayAge();
//            method.invoke(pet, args);
            String logInfo = "嗨,我是" + pet.getName() + ",我的年龄是:" + pet.getAge();
            FileLogger.info(logInfo);
        } else {
            return method.invoke(pet, args);
        }
        return null;
    }
}

动态代理方案,简化了编程。不需要继承抽象接口,编写一个一个的新的代理类型。 只需要将扩展的代码逻辑,写在InvocationHandler 实现类的invoke方法中即可。


完成了能力扩展实例的设计,只需要通过java.lang.reflect.Proxy类,传入前面说的3个参数,获取所需要的动态代理对象即可。
下面的代码,使用前面封装好的ReflectionUtil类中的newProxyInstance方法,取得动态代理对象,然后直接调用。
调用动态代理对象的代码如下:

package com.crazymakercircle.Proxy;
import com.crazymakercircle.common.pet.Cat;
import com.crazymakercircle.common.pet.Dog;
import com.crazymakercircle.common.pet.IPet;
import com.crazymakercircle.util.ReflectionUtil;

import java.lang.reflect.InvocationHandler;

public class PetLoggerProxyDemo {
    public static void main(String[] args) {
//生成代理类的class文件
System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles", "true");

        // 创建被代理类的委托类,之后想要调用被代理类的方法时,
        // 都会委托给这个类的invoke方法
        IPet dog=new Dog();
        InvocationHandler handler = new LogHandler(dog);
        IPet petProxy =(IPet) ReflectionUtil.newProxyInstance(dog,handler);
        petProxy.sayHello();
        petProxy.sayAge();
        IPet cat=new Cat();
        // 创建被代理类的委托类,之后想要调用被代理类的方法时,
        // 都会委托给这个类的invoke方法
        handler = new LogHandler(cat);
        petProxy =(IPet)  ReflectionUtil.newProxyInstance(cat,handler);
        petProxy.sayHello();
        petProxy.sayAge();
    }
}

 

动态代理的原理


动态代理,是本质上是通过java.lang.reflect.Proxy的newProxyInstance方法,生成一个动态代理类的实例。
这里对 java.lang.reflect.Proxy的newProxyInstance方法,做一个详细的介绍。该方法的定义如下:

public static Object newProxyInstance(ClassLoader loader,
                                      Class[] interfaces,
                                      InvocationHandler h)
    throws IllegalArgumentException
{
....
}


我们已经知道,此方法会产生一个动态代理类,并且创建一个动态代理类的对象,并且返回。
此方法的参数中,最重要的是第二个和第三个参数。
第二个参数是动态代理类需要实现的抽象接口,此接口也是真实目标类的所实现的接口。
第三个参数是一个对真实目标类进行能力增强的InvocationHandler 对象。在此类中, 实现扩展的业务逻辑,比方日志的记录、属性的检查,或者其他的能力增强的逻辑。

JVM执行时,所产生的动态代理类,到底长成啥样呢?是否能看到动态扩展类的class字节码呢?
答案是肯定的。

需要一个额外的操作。在生成动态扩展类之前,加上一句系统属性设置的代码,就可以将JVM在运行时生成的动态扩展类的class文件,保存在当前的工程目录下。
设置系统属性的代码,具体如下:

System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles", "true");


这句代码告诉JVM 在将生成的字节码保存下来,默认的保存为项目根路径的com/sun/proxy/下。
以前面的日志动态代理实例为例,运行程序,可以发现 在com/sun/proxy/路径下生成了$Proxy0.class字节码文件。如果IDE有反编译的能力,可以在IDE中直接打开,后可以看到它的源码如下:

package com.sun.proxy;

import com.crazymakercircle.common.pet.IPet;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.lang.reflect.UndeclaredThrowableException;

public final class $Proxy3 extends Proxy implements IPet {
    private static Method m1;
    private static Method m6;
    private static Method m3;
    private static Method m2;
    private static Method m4;
    private static Method m5;
    private static Method m0;

    public $Proxy3(InvocationHandler var1) throws  {
        super(var1);
    }

    public final boolean equals(Object var1) throws  {
        try {
            return ((Boolean)super.h.invoke(this, m1, new Object[]{var1})).booleanValue();
        } catch (RuntimeException | Error var3) {
            throw var3;
        } catch (Throwable var4) {
            throw new UndeclaredThrowableException(var4);
        }
    }

    public final IPet sayHello() throws  {
        try {
            return (IPet)super.h.invoke(this, m6, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    public final String getName() throws  {
        try {
            return (String)super.h.invoke(this, m3, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    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 IPet sayAge() throws  {
        try {
            return (IPet)super.h.invoke(this, m4, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    public final int getAge() throws  {
        try {
            return ((Integer)super.h.invoke(this, m5, (Object[])null)).intValue();
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    public final int hashCode() throws  {
        try {
            return ((Integer)super.h.invoke(this, m0, (Object[])null)).intValue();
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    static {
        try {
            m1 = Class.forName("java.lang.Object").getMethod("equals", new Class[]{Class.forName("java.lang.Object")});
            m6 = Class.forName("com.crazymakercircle.common.pet.IPet").getMethod("sayHello", new Class[0]);
            m3 = Class.forName("com.crazymakercircle.common.pet.IPet").getMethod("getName", new Class[0]);
            m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]);
            m4 = Class.forName("com.crazymakercircle.common.pet.IPet").getMethod("sayAge", new Class[0]);
            m5 = Class.forName("com.crazymakercircle.common.pet.IPet").getMethod("getAge", new Class[0]);
            m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]);
        } catch (NoSuchMethodException var2) {
            throw new NoSuchMethodError(var2.getMessage());
        } catch (ClassNotFoundException var3) {
            throw new NoClassDefFoundError(var3.getMessage());
        }
    }
}

通过代码可以看出,这个动态代理类,其实只做了两件简单的事情:
(1)实现了抽象接口类的每一个抽象方法
上面的例子,是实现了IPet接口的动态代理类。除了实现了Ipet接口的sayHello、sayAge等四个方法,还有额外的三个方法。
这个额外的三个方法,是从java.lang.Object中继承来的equals()、hashCode()、toString()方法。这个3方法,都在代理类中,生成了对应的代理实现。
(2)在每一个代理实现的方法中,其实代码很简单。仅仅是统一调用了InvocationHandler对象的invoke()方法。并且将调用的参数,进行了二次传递。
而实际上,InvocationHandler对象的invoke()方法,正是我们进行能力增强的方法。


动态代理实现属性检查


使用动态代理,实现多种能力的增强,就不需要再继承抽象接口,实现很多的能力增强类了。
比如,使用动态代理的方法,进行年龄属性的合理性检查,为以下两步:
(1)实现InvocationHandler 的invoke方法,加入能力增强的代码,进行age的合理性检查
(2)通过Proxy.newProxyInstance方法,取得动态代理对象,可以使用。

实现属性检查的能力增强,第一步的代码如下:

package com.crazymakercircle.Proxy;

import com.crazymakercircle.anno.AgeRange;
import com.crazymakercircle.common.pet.IPet;
import com.crazymakercircle.common.pet.Pet;
import com.crazymakercircle.util.Logger;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;

class AgeCheckerHandler implements InvocationHandler {
    IPet pet;

    public AgeCheckerHandler(IPet pet) {
        this.pet = pet;
    }

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

        if (method.getName().equals("sayAge")) {
            Field field = null;

            try {
                field = Pet.class.getDeclaredField("age");
            } catch (NoSuchFieldException e) {
                e.printStackTrace();
                return null;
            }
            AgeRange anno = field.getAnnotation(AgeRange.class);
            if (pet.getAge() > anno.max() || pet.getAge() < anno.min()) {
                Logger.debug("sorry,my age is secret ");
                return null;
            }
           return pet.sayAge();
//            return   method.invoke(pet, args);
        } else {
            return method.invoke(pet, args);
        }
    }
}

在invoke方法中,首先对调用的方法进行判断,只对sayAge进行增强。对年龄进行边界的校验,边界之外的直接保密。
除了sayAge之前的其他的方法,还是直接执行目标对象的原方法。

这里执行原目标对象的方法,使用的是反射的方式:

return  method.invoke(pet, args);


总结起来,使用动态代理,主要通过InvocationHandler 的invoke方法来调用具体的被代理方法。动态代理可以使我们的代码逻辑更加简洁,不需要写一大堆的代理类,不再需要关心到底代理谁。

最后,说明一下,动态代理的,可以直接通过JDK 实现,也可以使用第三方的字节码生成工具cglib等来实现。
使用第三方库进行动态代理,原理与JDK的方法,基本相同,这里不做展开。

你可能感兴趣的:(java,动态代理)