【java设计模式】(3)---代理模式(案例解析)

设计模式之代理模式

 

一、概述

1、什么是代理模式?

解释第一遍:代理模式主要由三个元素共同构成:

  1)一个接口,接口中的方法是要真正去实现的。

  2)被代理类,实现上述接口,这是真正去执行接口中方法的类。

  3)代理类,同样实现上述接口同时封装被代理类对象,帮助被代理类去实现方法

解释第二遍:  使用代理模式必须要让代理类和目标类实现相同的接口,客户端通过代理类来调用目标方法,代理类会将所有的方法调用分派到目标对象上反射执行,还可以在分派过程中添加"前置通知"和后置处理

(如在调用目标方法前校验权限,在调用完目标方法后打印日志等)等功能。

解释第三遍(如图):

这样应该是明白了,当然代理模式又分为静态代理和动态代理,先看静态代理。

 

一、静态代理

直接举例(网上有个很不错的例子)

假如一个班的同学要向老师交班费,但是都是通过班长把自己的钱转交给老师。这里,班长就是代理类(代理学生上交班费),学生就是被代理类或者理解为目标类。

  首先,我们创建一个Teacher接口。这个接口就是学生(被代理类),和班长(代理类)的公共接口,他们都有上交班费的行为。这样,学生上交班费就可以让班长来代理执行。

/**
 * 创建Teacher接口
 */
public interface Teacher {
    //上交班费
    void giveMoney();
}

Student类实现Teacher接口。Student可以具体实施上交班费的动作。

public class Student implements Teacher {
    private String name;
    public Student(String name) {
        this.name = name;
    }
    
    @Override
    public void giveMoney() {
       System.out.println(name + "上交班费100元");
    }
}

StudentsProxy类,这个类也实现了Teacher接口,由于实现了Teacher接口,同时持有一个学生对象,那么他可以代理学生类对象执行上交班费(执行giveMoney()方法)行为。

/**
 * 学生代理类,也实现了Teacher接口,保存一个学生实体,这样既可以代理学生产生行为*/
public class StudentsProxy implements Teacher{
    //被代理的学生
    Student stu;

    public StudentsProxy(Teacher stu) {
        // 只代理学生对象
        if(stu.getClass() == Student.class) this.stu = (Student) stu;
    }

    //代理上交班费,调用被代理 学生的上交班费行为
    public void giveMoney() {
        System.out.println("张三家里是土豪,应该比其它人交更多的班费!");
        stu.giveMoney();
        System.out.println("张三班费交的最多,你就是班长了!");

    }
}

下面测试类ProxyTest,看如何使用代理模式:

public class ProxyTest {
    public static void main(String[] args) {
        //被代理的学生张三,他的班费上交有代理对象monitor(班长)完成
        Teacher zhangsan = new Student("张三");
        
        //生成代理对象,并将张三传给代理对象
        Teacher monitor = new StudentsProxy(zhangsan);
        
        //班长代理上交班费
        monitor.giveMoney();
    }
}

运行结果:

总结下

        这里并没有直接通过张三(被代理对象)来执行上交班费的行为,而是通过班长(代理对象)来代理执行了。这就是代理模式。代理模式最主要的就是有一个公共接口(Teacher),一个具体的类(Student),

一个代理类(StudentsProxy),代理类持有具体类的实例,代为执行具体类实例方法。 同时可以看到,代理类里除了实现目标类的方法,而且可以在执行前后添加其它方法来起到增强功能。这不就是AOP(面向切面

思想),对的AOP的实现就是基于代理模式,只不过它采用的是动态代理模式。

 

二、动态代理模式

 1、案例说明

public class MyProxy {
    //一个接口
    public interface IHello{
        void sayHello();
    }
    //目标类实现接口
    static class Hello implements IHello{
        public void sayHello() {
            System.out.println("sayHello......");
        }
    }
    //自定义代理类需要实现InvocationHandler接口
    static  class HWInvocationHandler implements InvocationHandler{
        //目标对象
        private Object target;
        public HWInvocationHandler(Object target){
            this.target = target;
        }
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            System.out.println("------插入前置通知代码-------------");
            //执行相应的目标方法
            Object rs = method.invoke(target,args);
            System.out.println("------插入后置处理代码-------------");
            return rs;
        }
    }
    public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
       //获取动态代理类
        Class<?> proxyClazz = Proxy.getProxyClass(IHello.class.getClassLoader(),IHello.class);
        //获得代理类的构造函数,并传入参数类型InvocationHandler.class
        Constructor<?> constructor = proxyClazz.getConstructor(InvocationHandler.class);
        //通过构造函数来创建动态代理对象,将自定义的InvocationHandler实例传入
        IHello iHello = (IHello) constructor.newInstance(new HWInvocationHandler(new Hello()));
        //通过代理对象调用目标方法
        iHello.sayHello();
    }
}

 运行结果:

Proxy类中还有个将2~4步骤封装好的简便方法来创建动态代理对象,其方法签名为:newProxyInstance(ClassLoader loader,Class<?>[] instance, InvocationHandler h),如下例:

 (方式二)

public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
       
       IHello  ihello = (IHello) Proxy.newProxyInstance(IHello.class.getClassLoader(),  //加载接口的类加载器
               new Class[]{IHello.class},      //一组接口
               new HWInvocationHandler(new Hello())); //自定义的InvocationHandler
       ihello.sayHello();
   }

 看到这里我们应该思考三个问题?

     1)动态代理类是如何创建的?

     2) 它是如何调用MyProxy中的invoke的方法的? 

     3)  MyProxy中invoke中的invoke方法又是啥含义?

带着这三问题我们具体分析下。

2、动态代理类是如何创建的?

具体源码我就不分析了,我们用上面的第一种方式,进行断点查看(括号中的就是通过IDEA断点显示的信息)。

        //1、获取动态代理类(proxyClazz:class com.sun.proxy.$Proxy0 )
        Class<?> proxyClazz = Proxy.getProxyClass(IHello.class.getClassLoader(),IHello.class);
        //2、获得代理类的构造函数(constructor: public com.sun.proxy.$Proxy0(java.lang.reflect.InvocationHandler)
        Constructor<?> constructor = proxyClazz.getConstructor(InvocationHandler.class);
        //3、通过构造函数来创建动态代理对象(iHello:cn.edu.zju.grs.alufer.albert.jz.dao.MyProxy$Hello@16b4a017)
        IHello iHello = (IHello) constructor.newInstance(new HWInvocationHandler(new Hello()));

通过断点发现:

     (1)第一步已经获得了代理对象,代理对象的名称是:$Proxy0

    (2)第二步我们发现代理类的构造函数需要传入一个java.lang.reflect.InvocationHandler类

     (3)第三步通过构造函数创建对象,构造函数里放到就是HWInvocationHandler类,而它是实现InvocationHandler接口的,所以没毛病。

总的来讲这三步都是通过类的反射机制来实现创建类的。

3、如何调用MyProxy中的invoke的方法

这里就需要看下$Proxy0.class进行反编译后的代码

//代理类名为$Proxy0,继承Proxy,实现IHello接口
public final class $Proxy0 extends Proxy implements IHello {   
    //变量,都是private static Method  XXX
    private static Method m3;  
    private static Method m1;
    private static Method m0;
    private static Method m2;
    //代理类的构造函数,其参数正是是InvocationHandler实例,Proxy.newInstance方法就是通过通过这个构造函数来创建代理实例的
    public $Proxy0(InvocationHandler var1)  {
        super(var1);
    }
    //接口代理方法
    public final void sayHello()  {
        try {
            
            //这里才是关键,通过这里终于知道是如何调用MyProxy中的invoke方法的
            super.h.invoke(this, m3, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }
    //以下Object中的三个方法
    public final boolean equals(Object var1)  {
        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 int hashCode()  {
        try {
            return ((Integer)super.h.invoke(this, m0, (Object[])null)).intValue();
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }
    public final String toString()   {
        try {
            return (String)super.h.invoke(this, m2, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }
    //对变量进行一些初始化工作
    static {
        try {
            //我们发现m3就代表着sayHello()方法
            m3 = Class.forName("com.mobin.proxy.IHello").getMethod("sayHello", new Class[0]);
            m1 = Class.forName("java.lang.Object").getMethod("equals", new Class[]{Class.forName("java.lang.Object")});
            m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]);
            m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]);
        } catch (NoSuchMethodException var2) {
            throw new NoSuchMethodError(var2.getMessage());
        } catch (ClassNotFoundException var3) {
            throw new NoClassDefFoundError(var3.getMessage());
        }
    }
}

看到这里是不是和前面断点的代码对象的获得的信息是一样的。(比如代理类名就加$Proxy0,构造方法也和上面分析的一样)。总算明白了。

4、MyProxy中invoke中的invoke方法又是啥含义?

其实到这一步就已经变得简单了 Object rs = method.invoke(target,args);执行的方法就是目标类中的sayHello()方法,这个也就一个反射知识。

我针对这个举例:

有一个A类 
package com.jincou.study;

public class A {
    
    public void foo(String name) {
    System.out.println("Hello, " + name);
    }
}

TestClassLoad来反射调用A上的方法

public class TestClassLoad {
    
    public static void main(String[] args) throws Exception {
      
        //获得代理类
        Class<?> clz = Class.forName("com.jincou.study.A");
        //获得代理类对象
        Object o = clz.newInstance();
        //获得foo方法
         Method m = clz.getMethod("foo", String.class);
        //执行foot方法
         m.invoke(o,"张三");
   }
}

运行结果

那么到这里你就应该明白了,在MyProxy中invoke中的

    //这个method就是sayHello()方法,target是指new Hello()对象(也就是目标类对象),参数为null
    Object rs = method.invoke(target,args);

 是不是和上面最后一步一个意思,总算明白了。

这里顺便看下invoke源码:

 //这个源码只要知道一点就是Object... args,它表示的是可变参数所以他可以是空或者多个
     @CallerSensitive
        public Object invoke(Object obj, Object... args)
            throws IllegalAccessException, IllegalArgumentException,
               InvocationTargetException
        {
            if (!override) {
                if (!Reflection.quickCheckMemberAccess(clazz, modifiers)) {
                    Class<?> caller = Reflection.getCallerClass();
                    checkAccess(caller, clazz, obj, modifiers);
                }
            }
            MethodAccessor ma = methodAccessor;             // read volatile
            if (ma == null) {
                ma = acquireMethodAccessor();
            }
            return ma.invoke(obj, args);
        }

总算理解完了,这篇文章并没有很深入的讲底层源码,看源码自己都会被绕进去,到头来可能还是一头雾水。这样的分析还是蛮清晰的。

最后总结下使用动态代理的五大步骤

     1)通过实现InvocationHandler接口来自定义自己的InvocationHandler;
 
     2)通过Proxy.getProxyClass获得动态代理类
 
     3)通过反射机制获得代理类的构造方法,方法签名为getConstructor(InvocationHandler.class)
 
     4)通过构造函数获得代理对象并将自定义的InvocationHandler实例对象传为参数传入
 
     5)通过代理对象调用目标方法

 

想太多,做太少,中间的落差就是烦恼。想没有烦恼,要么别想,要么多做。中校【5】  

 

posted on 2018-06-28 23:59  雨点的名字  阅读(6463)  评论(1编辑  收藏  举报