Java动态代理

      这一篇主要记录一下Java动态代理，包括代理模式的简述、静态代理模式以及动态代理模式。

 

 

一、代理模式

 

代理模式可以理解为：例如有用户A，A想访问B，但是由于有某种限制，或者说访问B有某种条件，我们需要对A直接访问B加以限制。因此我们可以建立一个代理C，C可以在A访问B之前去完成某些限制条件的工作，也就是A如果要访问B的话，需要通过C来间接的访问B。但是对于A来说，就像是直接访问B一样，也同样完成了对B的访问。

 

代理模式的作用是：为其他对象提供一种代理以控制对这个对象的访问。

代理模式一般涉及到的角色有:

– 抽象角色：声明真实对象和代理对象的共同接口

– 代理角色：代理对象角色内部含有对真实对象的引用，从而可以操作真实对象，同时代理对象提供与真实对象相同的接口以便在任何时刻都能代替真实对象。同时，代理对象可以在执行真实对象操作时，附加其他的操作，相当于对真实对象进行封装

– 真实角色：代理角色所代表的真实对象，是我们最终要引用的对象

 

二、静态代理

 

举例：

 

抽象角色：Subject

 

package com.hdjava.proxy;

 

public abstract class Subject {

   

    public  abstract void request();

}

 

 

真实角色： RealSubject

 

package com.hdjava.proxy;

 

public class RealSubject extends Subject {

 

    public void request() {

       System.out.println("From run realSubject.");

    }

 

}

 

代理角色：ProxySubject

 

package com.hdjava.proxy;

 

public class ProxySubject extends Subject {

   

    private RealSubject realSubject;

   

    public void request() {

      

       System.out.println("calling request : beforeRequest()");

      

       realSubject.request();

      

       System.out.println("calling request : afterRequest()");

    }

   

    public ProxySubject(){

       realSubject = new RealSubject();

    }

   

   

   

    public ProxySubject( RealSubject realSubject){

       this.realSubject = realSubject;

    }

       

}

 

测试类：Client

package com.hdjava.proxy;

 

public class Client {

   

    public static void main(String[] args) {

      

       RealSubject realSub1 = new RealSubject();

      

       ProxySubject proxy = new ProxySubject(realSub1);

       proxy.request();

      

      

    }

}

 

 

运行结果：

calling request : beforeRequest()

From run realSubject.

calling request : afterRequest()

 

通过上述运行结果，我们可以看到，对于客户Client (A)想要访问RealSubject(B)的request()方法，但是实际上再调用方法之前和之后我们需要做一些处理，所以我们让Client去访问代理类ProxySubject(C)的request()方法。在ProxySubject中实际上是调用的被代理类RealSubject的request()方法，同时还经行了其他处理。

 

另外，如果要按照上述的方法使用代理模式，那么真实角色(realSub1)必须是事先已经存在的，并将其作为代理对象的内部属性(new ProxySubject(realSub1))。但是实际使用时，一个真实角色(realSub1)必须对应一个代理角色(proxy)，如果大量使用会导致类的急剧膨胀；此外，如果事先并不知道真实角色，该如何使用代理呢？这个问题可以通过Java的动态代理类来解决

 

三、Java中jdk动态代理类

 

动态代理：即在程序运行期间动态的生成代理类，并实例化代理类对象，通过调用代理类实现对被代理类的访问。

以$Proxy0 代理 new ArrayList()为例。

动态代理类($Proxy0)是这样一种class：它是在运行时生成的($Proxy0.class)class，在生成它时你必须提供一组interface(ArrayList实现的接口 List，Collection，Iterable等等)给它，然后该（$Proxy0）class就实现了这些 interface（List，Collection，Iterable等等）。你当然可以把该（$Proxy0）class的实例当作这些interface中的任何一个来用（List）。当然，这个动态代理类其实就是一个代理，它不会替你作实质性的工作，在生成它的实例时你必须提供一个handler，由它接管实际的工作即方法的反射。

 

Java动态代理类位于java.lang.reflect包下，一般主要涉及到以下两个类：

 

(1) 接口 InvocationHandler

InvocationHandler 是代理实例的调用处理程序实现的接口,每个代理实例都具有一个关联的调用处理程序。

 

public object invoke(Object proxy,Method method, Object[] args)

proxy - 在其上调用方法的代理实例

method - 对应于在代理实例上调用的接口方法的 Method 实例。

args - 包含传入代理实例上方法调用的参数值的对象数组。

 

(2 )Proxy：该类即为动态代理类，作用类似于上例中的ProxySubject，其中主要包含以下内容:

 

static Class getProxyClass (ClassLoader loader, Class[] interfaces)：获得一个代理类，其中loader是类装载器，interfaces是真实类所拥有的全部接口的数组。

 

static Object newProxyInstance(ClassLoader loader, Class[] interfaces, InvocationHandler h)：

返回代理类的一个实例，返回后的代理类可以当作被代理类使用(可使用被代理类的在Subject接口中声明过的方法)。

 

通过以上jdk中两个与动态代理相关类分析，

1:Proxy类的作用可以理解为通过调用Proxy的静态方法获取代理类的实例，或者获取代理类。

2:Proxy类获取代理类实例的静态方法中需要一个InvocationHandler handler参数，而该参数为接口，该接口中的invoke方法是通过反射机制，实现通过代理类完成对被代理类方法的调用。

 

 

举例：

 

抽象角色 Subject：

 

package com.hdjava.proxy.dynamic;

 

public interface Subject {

   

    public void request();

}

 

真实角色 RealSubject：

 

package com.hdjava.proxy.dynamic;

 

public class RealSubject implements Subject {

 

    public void request() {

      

       System.out.println("calling realSubject request()...");

    }

 

}

 

代理实例的调用处理程序 DynamicHandler：

 

package com.hdjava.proxy.dynamic;

 

import java.lang.reflect.InvocationHandler;

import java.lang.reflect.Method;

 

public class DynamicHandler implements InvocationHandler {

   

    private Object realSubject;

   

    public DynamicHandler(Object realSubject){

       this.realSubject = realSubject;

    }

   

    public Object invoke(Object proxy, Method method, Object[] args)

           throws Throwable {

       System.out.println("before proxy"+method);

       Object result = method.invoke(realSubject, args);

       System.out.println("after proxy"+method);

       return result;

    }

 

}

 

 

测试类：Client

 

package com.hdjava.proxy.dynamic;

 

import java.lang.reflect.InvocationHandler;

import java.lang.reflect.Proxy;

 

public class Client {

   

    public static void main(String[] args) throws Throwable{

       RealSubject realSubject = new RealSubject();

      

       InvocationHandler handler = new DynamicHandler(realSubject);

      

       Class proxyClass = Proxy.getProxyClass(RealSubject.class.getClassLoader(),

              new Class[]{Subject.class});

      

       Subject subject = (Subject)proxyClass.getConstructor(new Class[]{InvocationHandler.class}).newInstance(new Object[]{handler});

       subject.request();

      

    }

}

 

 

获取代理类实例的两个方法：

1、              Subject subject=(Subject)Proxy.newProxyInstance(

Subject.class.getClassLoader(),

       realSub.getClass().getInterfaces(), handler);

2、

Class proxyClass = Proxy.getProxyClass(RealSubject.class.getClassLoader(),

              new Class[]{Subject.class});

Subject subject = (Subject)proxyClass.getConstructor(

new Class[]{InvocationHandler.class}).newInstance(

new Object[]{handler});