`

java代理模式以及动态代理详解

Java设计模式F#框架 
阅读更多

本文讲述代理模式...

代理模式的作用是：为其他对象提供一种代理以控制对这个对象的访问。
在某些情况下，一个客户不想或者不能直接引用另一个对象，而代理对象可以在客户端和目标对象之间起到中介的作用。

 

代理模式一般涉及到的角色有：
　　抽象角色：声明真实对象和代理对象的共同接口；
　　代理角色：代理对象角色内部含有对真实对象的引用，从而可以操作真实对象，同时代理对象提供与真实对象相同的接口以便在任何时刻都能代替

真实对象。同时，代理对象可以在执行真实对象操作时，附加其他的操作，相当于对真实对象进行封装；
　　真实角色：代理角色所代表的真实对象，是我们最终要引用的对象；

 

下面四个类讲述一个简单的静态代理，参见程序Subject.java，RealSubject.java，ProxySubject.java和Client.java。把他们放在一个包下即可

，代码如下：

Subject.java代码
abstract public class Subject{     
         
    abstract public void request();     
}  

 

Realsubject.java代码
public class RealSubject extends Subject     
{     
    public void request()     
    {     
        System.out.println("From real subject.");     
    }     
} 


Proxysubject.java代码
public class ProxySubject extends Subject{     
         
    private RealSubject realSubject; // 以真实角色作为代理角色的属性     
    
    public void request() // 该方法封装了真实对象的request方法     
    {     
        preRequest();     
    
        if (realSubject == null) {     
            realSubject = new RealSubject();     
        }     
    
        realSubject.request(); // 此处执行真实对象的request方法     
    
        postRequest();     
    }     
    
    private void preRequest() {     
    
        System.out.println("先前做的事情");     
    }     
    
    private void postRequest() {     
    
        System.out.println("之后做的事情");     
    }     
} 

 

Client.java代码
public class Client{     
    public static void main(String[] args)     
    {     
        Subject sub = new ProxySubject();     
    
        sub.request();     
    }     
} 


要有四个角色：抽象角色，代理角色，真实角色和客户。在Java中要想对其他对象引用，生成一个那个对象的属性就行了。比如本例中就是在

ProxySubject类中声明了RealSubject类的对象，作为一个属性存在ProxySubject中。

 

由以上代码可以看出，客户实际需要调用的是RealSubject类的request()方法，现在用ProxySubject来代理 RealSubject类，同样达到目的，同时还

封装了其他方法(preRequest(),postRequest())，可以处理一些其他问题。
 
另外，如果要按照上述的方法使用代理模式，那么真实角色必须是事先已经存在的，并将其作为代理对象的内部属性。但是实际使用时，一个真实角色

必须对应一个 代理角色，如果大量使用会导致类的急剧膨胀；此外，如果事先并不知道真实角色，该如何使用代理呢？这个问题可以通过Java的动态代

理类来解决。

 

下面讲述动态代理。

 

Java动态代理类位于java.lang.reflect包下，一般主要涉及到以下两个类（接口算作特殊类）：


(1)Interface InvocationHandler：该接口中仅定义了一个方法

 

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


在实际使用时，第一个参数obj一般是指代理类，method是被代理的方法，如上例中的request()，args为该方法的参数数组。 这个抽象方法在代理类

中动态实现。

 

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

 

protected Proxy(InvocationHandler h)：构造函数，用于给内部的h赋值；

 

static Class getProxyClass (ClassLoader loader, Class[] interfaces)：获得一个代理类，其中loader是类装载器，interfaces是真实类所

拥有的全部接口的数组；

 

static Object newProxyInstance(ClassLoader loader, Class[] interfaces, InvocationHandler h)：返回代理类的一个实例，返回后的代理

类可以当作被代理类使用(可使用被代理类的在Subject接口中声明过的方法)。

 

所谓Dynamic Proxy是这样一种class：它是在运行时生成的class，在生成它时你必须提供一组interface给它，然后该class就宣称它实现了这些

interface。你当然可以把该class的实例当作这些interface中的任何一个来用。当然，这个Dynamic Proxy其实就是一个Proxy，它不会替你作实质

性的工作，在生成它的实例时你必须提供一个handler，由它接管实际的工作。

 

下面例子讲述了一个动态代理Subject.java，RealSubject.java，DynamicSubject.java和Client.java，把他们放在一个包下，代码如下：

Subject.java代码
//抽象角色(之前是抽象类，此处应改为接口)     
public interface Subject     
{     
    public void request();     
} 

 

Realsubject.java代码
//具体角色     
public class RealSubject implements Subject     
{     
    
    public RealSubject()     
    {     
    }     
    
    public void request()     
    {     
        System.out.println("真正做事的。");     
    }     
} 

 

Dynamicsubject.java代码
//代理处理器     
/**    
 * 该代理类的内部属性为Object类，实际使用时通过该类的构造函数DynamicSubject(Object obj)对其赋值；    
 * 此外，在该类还实现了invoke方法，该方法中的 method.invoke(sub,args);    
 * 其实就是调用被代理对象的将要被执行的方法，方法参数sub是实际的被代理对象，    
 * args为执行被代理对象相应操作所需的参数。    
 * 通过动态代理类，我们可以在调用之前或之后执行一些相关操作    
 */    
    
public class DynamicSubject implements InvocationHandler     
{     
    private Object sub;     
    
    public DynamicSubject()     
    {     
    }     
    
    public DynamicSubject(Object obj)     
    {     
        sub = obj;     
    }     
    
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable     
    {     
        System.out.println("调用前" + method);     
    
        method.invoke(sub, args);     
    
        System.out.println("调用后 " + method);     
    
        return null;     
    }     
}  

 

Client.java代码
//客户端     
public class Client     
{     
    static public void main(String[] args) throws Throwable     
    {     
    
        RealSubject rs = new RealSubject(); // 在这里指定被代理类     
        InvocationHandler ds = new DynamicSubject(rs);     
        Class<?> cls = rs.getClass();     
    
        // 以下是一次性生成代理     
    
        Subject subject = (Subject) Proxy.newProxyInstance(     
                cls.getClassLoader(), cls.getInterfaces(), ds);     
    
        subject.request();     
    }     
} 

 

这个程序中把静态代理类的抽象类改变为一个接口，而实际类实现这个接口。是因为Proxy类的newProxyInstance方法传入需要提供一个接口，这个是

Java动态代理框架给我们设计好的了。本例的ProxySubject类实现了InvocationHandler接口及实现invoke方法，并且提供一个带参数的构造方法，

通过Client类动态的调用真实类。

 

 Client类通过DynamicSubject类生成真实类的代理对象，并经由Proxy类的newProxyInstance方法实现生成“一个能做真实类做的事的代理”，并由

该代理直接调用真实类所具有的方法。

 

 OK，也许还会有些迷惑，不过不要紧，没有什么高端的知识能够一次就成功的，要勤于练习。

 

下面这个类作为参考，代码如下：

Vectorproxy.java代码
import java.lang.reflect.InvocationHandler;     
import java.lang.reflect.Method;     
import java.lang.reflect.Proxy;     
import java.util.List;     
import java.util.Vector;     
    
public class VectorProxy implements InvocationHandler     
{     
    private Object proxyobj;     
    
    public VectorProxy(Object obj)     
    {     
        proxyobj = obj;     
    }     
    
    public static Object factory(Object obj)     
    {     
        Class<?> cls = obj.getClass();     
    
        return Proxy.newProxyInstance(cls.getClassLoader(),     
                cls.getInterfaces(), new VectorProxy(obj));     
    }     
    
    public Object invoke(Object proxy, Method method, Object[] args)     
            throws Throwable     
    {     
        System.out.println("before calling " + method);     
    
        if (args != null)     
        {     
            for (int i = 0; i < args.length; i++)     
            {     
                System.out.println(args[i] + "");     
            }     
        }     
        Object object = method.invoke(proxyobj, args);     
    
        System.out.println("after calling " + method);     
        return object;     
    }     
    
    @SuppressWarnings("unchecked")     
    public static void main(String[] args)     
    {     
        List<String> v = (List<String>) factory(new Vector<String>(10));     
    
        v.add("New");     
        v.add("York");     
        System.out.println(v);     
    
        v.remove(0);     
        System.out.println(v);     
    }     
} 

import java.lang.reflect.InvocationHandler;  
import java.lang.reflect.Method;  
import java.lang.reflect.Proxy;  
import java.util.List;  
import java.util.Vector;  
 
public class VectorProxy implements InvocationHandler  
{  
    private Object proxyobj;  
 
    public VectorProxy(Object obj)  
    {  
        proxyobj = obj;  
    }  
 
    public static Object factory(Object obj)  
    {  
        Class<?> cls = obj.getClass();  
 
        return Proxy.newProxyInstance(cls.getClassLoader(),  
                cls.getInterfaces(), new VectorProxy(obj));  
    }  
 
    public Object invoke(Object proxy, Method method, Object[] args)  
            throws Throwable  
    {  
        System.out.println("before calling " + method);  
 
        if (args != null)  
        {  
            for (int i = 0; i < args.length; i++)  
            {  
                System.out.println(args[i] + "");  
            }  
        }  
        Object object = method.invoke(proxyobj, args);  
 
        System.out.println("after calling " + method);  
        return object;  
    }  
 
    @SuppressWarnings("unchecked")  
    public static void main(String[] args)  
    {  
        List<String> v = (List<String>) factory(new Vector<String>(10));  
 
        v.add("New");  
        v.add("York");  
        System.out.println(v);  
 
        v.remove(0);  
        System.out.println(v);  
    }  
}

这个类看不明白不要紧，慢慢来。

 

下面也是一个演示程序，作为扩展知识用，一共五个类，在同一包下，代码如下：

 

 五个类Foo.java， FooImpl.java， FooImpl2.java， CommonInvocationHandler.java和Demo.java。

Foo.java代码
public interface Foo     
{     
    void doAction();     
}  

public interface Foo  
{  
    void doAction();  
} 

Fooimpl.java代码
public class FooImpl implements Foo     
{     
    public FooImpl()     
    {     
    }     
    
    public void doAction()     
    {     
        System.out.println("in FooImp1.doAction()");     
    }     
}  

public class FooImpl implements Foo  
{  
    public FooImpl()  
    {  
    }  
 
    public void doAction()  
    {  
        System.out.println("in FooImp1.doAction()");  
    }  
} 

Fooimpl2.java代码
public class FooImpl2 implements Foo     
{     
    public FooImpl2()     
    {     
    }     
    
    public void doAction()     
    {     
        System.out.println("in FooImp2.doAction()");     
    }     
} 

public class FooImpl2 implements Foo  
{  
    public FooImpl2()  
    {  
    }  
 
    public void doAction()  
    {  
        System.out.println("in FooImp2.doAction()");  
    }  
}

Commoninvocationhandler.java代码
import java.lang.reflect.InvocationHandler;     
import java.lang.reflect.Method;     
    
public class CommonInvocationHandler implements InvocationHandler     
{     
    
    // 动态执行对象，需要回调的对象     
    private Object target;     
    
    // 支持构造子注射     
    public CommonInvocationHandler()     
    {     
    
    }     
    
    // 支持构造子注射     
    public CommonInvocationHandler(Object target)     
    {     
        setTarget(target);     
    }     
    
    /**    
     *     
     * 采用setter方法注射    
     *     
     * @param target    
     *     
     */    
    public void setTarget(Object target)     
    {     
        this.target = target;     
    }     
    
    /**    
     *     
     * 调用proxy中指定的方法method，并传入参数列表args    
     *     
     * @param proxy    
     *            代理类的类型，例如定义对应method的代理接口    
     *     
     * @param method    
     *            被代理的方法    
     *     
     * @param args    
     *            调用被代理方法的参数    
     *     
     * @return    
     *     
     * @throws java.lang.Throwable    
     *     
     */    
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable     
    {     
        return method.invoke(target, args);     
    }     
} 

import java.lang.reflect.InvocationHandler;  
import java.lang.reflect.Method;  
 
public class CommonInvocationHandler implements InvocationHandler  
{  
 
    // 动态执行对象，需要回调的对象  
    private Object target;  
 
    // 支持构造子注射  
    public CommonInvocationHandler()  
    {  
 
    }  
 
    // 支持构造子注射  
    public CommonInvocationHandler(Object target)  
    {  
        setTarget(target);  
    }  
 
    /** 
     *  
     * 采用setter方法注射 
     *  
     * @param target 
     *  
     */ 
    public void setTarget(Object target)  
    {  
        this.target = target;  
    }  
 
    /** 
     *  
     * 调用proxy中指定的方法method，并传入参数列表args 
     *  
     * @param proxy 
     *            代理类的类型，例如定义对应method的代理接口 
     *  
     * @param method 
     *            被代理的方法 
     *  
     * @param args 
     *            调用被代理方法的参数 
     *  
     * @return 
     *  
     * @throws java.lang.Throwable 
     *  
     */ 
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable  
    {  
        return method.invoke(target, args);  
    }  
}

Demo.java代码
import java.lang.reflect.Proxy;     
    
public class Demo     
{     
    public static void main(String[] args)     
    {     
    
        // 1.通用的动态代理实现     
    
        CommonInvocationHandler handler = new CommonInvocationHandler();     
    
        Foo f;     
    
        // 2.接口实现1     
    
        handler.setTarget(new FooImpl());     
    
        // 方法参数说明：代理类、代理类实现的接口列表、代理类的处理器     
    
        // 关联代理类、代理类中接口方法、处理器，当代理类中接口方法被调用时，会自动分发到处理器的invoke方法     
    
        // 如果代理类没有实现指定接口列表，会抛出非法参数异常     
    
        f = (Foo) Proxy.newProxyInstance(Foo.class.getClassLoader(),     
    
        new Class[] { Foo.class },     
    
        handler);     
    
        f.doAction();     
    
        // 3.接口实现2     
    
        handler.setTarget(new FooImpl2());     
    
        f = (Foo) Proxy.newProxyInstance(Foo.class.getClassLoader(),     
    
        new Class[] { Foo.class },     
    
        handler);     
    
        f.doAction();     
    }     
} 

分享到：
| java动态代理和Cglib
评论
1 楼 mj-beijing 2011-07-28  
这段代码怎么这么熟悉呢，好像在哪里见过，哦对了，教学视频里的，对吧？ 
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    Java代理模式Java动态代理

    ### Java代理模式与Java动态代理详解 #### 一、代理模式概述 代理模式是一种软件设计模式，它在客户端和目标对象之间提供了一种间接层。这种模式的主要目的是控制客户端对目标对象的访问，并且可以在不修改原有...

    Java 动态代理详解（代理模式+静态代理+JDK动态代理+CGLIB动态代理）

    Java 动态代理详解（代理模式+静态代理+JDK动态代理+CGLIB动态代理） Java 动态代理是 Java 编程语言中的一种强大工具，广泛应用于 Spring AOP、Hibernate 数据查询、测试框架的后端 mock、RPC 远程调用、Java 注解...

    java 代理模式详解

    总结一下，Java代理模式的核心在于`Proxy`类和`InvocationHandler`接口，它们共同实现了在运行时动态创建符合特定接口的代理对象。通过代理，我们可以在不修改原始对象代码的情况下，添加额外的功能或者控制对原始...

    JAVA设计模式（代理模式）

    **Java设计模式——代理模式详解** 代理模式是软件设计模式中的一个重要组成部分，它在Java编程中扮演着举足轻重的角色。代理模式的核心思想是为一个对象提供一个替身，这个替身即代理对象，代理对象可以控制对原...

    java代理模式和动态代理

    ### Java代理模式和动态代理详解 #### 一、概述 在软件工程中，代理模式是一种常用的软件设计模式，主要用于在不直接暴露目标对象的情况下提供一个替代接口。这种模式可以简化客户端与目标对象之间的交互，同时还...

    java 设计模式之代理模式（Proxy Pattern）实现代码及设计详解：动态代理模式、静态代理模式

    代理模式分为两种主要类型：静态代理和动态代理。 **静态代理** 在静态代理中，代理类和目标类都是在编译时就已经确定的。我们首先创建一个目标类接口，然后创建一个实现这个接口的代理类，同时代理类还持有目标类...

    java代理模式

    java设计模式，代理模式

    Java 代理 代理模式 静态代理与动态代理 常见的动态代理实现 .md

    ### Java 代理模式详解 #### 1. 代理模式概览 代理模式是一种设计模式，主要目的是为了控制或提供对某对象的访问。在代理模式中，代理对象充当客户端与真实对象之间的中介，使得客户端可以通过代理对象间接地访问...

    Java设计模式之代理模式(结构)

    ### Java设计模式之虚拟代理模式详解 #### 一、引言 在软件工程领域，设计模式作为一种被广泛接受的最佳实践，对于提高代码质量和可维护性起着至关重要的作用。其中，“代理模式”作为结构型设计模式之一，在解决...

    java设计模式详解合集

    Java设计模式详解合集是一份宝贵的资源，包含了丰富的面向对象设计原则和多种设计模式的深入讲解。这份资料旨在帮助开发者提升软件设计能力，遵循良好的编程实践，提高代码的可读性、可维护性和复用性。以下是其中...

    Java动态代理详解； CGLib实现动态代理1

    Java 动态代理详解与 CGLib 实现 在 Java 中，代理模式是一种设计模式，它允许我们在不修改原有对象的基础上，为对象增加额外的功能。代理模式的核心在于代理类（Proxy）作为真实对象（RealSubject）的替代品，提供...

    jdk动态代理技术详解

    Proxy 类是 JDK 中的动态代理类，是动态代理的核心类，其作用类似于代理模式中的代理。Proxy 类中包含的全是静态的方法和成员变量，这是一个纯粹的工具类，因此其源代码中含有一个私有的构造器，在某种意义上可以看...

    java23中设计模式详解

    12. **代理模式**：为其他对象提供一种代理以控制对这个对象的访问。 13. **命令模式**：将请求封装为一个对象，使得可以使用不同的请求、队列或者日志请求，也可以支持撤销操作。 14. **责任链模式**：处理请求的...

    代理模式详解

    ### 代理模式详解 #### 一、代理模式概述 代理模式是面向对象设计模式中的一种，主要用于当直接访问某个对象时会带来不便或需要增加额外的功能。代理模式通过创建一个对象来控制对另一个对象的访问，它属于结构型...

    java静态代理和动态代理详解

    Java中的代理模式是一种设计模式，它允许我们创建一个代理对象，该对象可以在调用实际对象的方法之前或之后执行额外的操作，而无需修改原始代码。在Java中，代理主要分为静态代理和动态代理。 1. 静态代理： 静态...

    java动态代理 经典文章（word 2007格式的）

    - `动态代理详解.docx`则可能深入讨论了Java动态代理的细节，包括实际应用场景和常见问题。 以上内容是对Java动态代理技术的概述，详细的学习和理解可以通过阅读给定的文档来深入探讨。在实践中，掌握动态代理能够...

    java23种设计模式详解+源码(绝对详解)

    - 代理模式（Proxy）：为其他对象提供一种代理以控制对这个对象的访问。 - 外观模式（Facade）：为子系统提供一个统一的接口，使子系统更加易用。 - 适配器模式（Adapter）：将一个类的接口转换成客户希望的另一...

    Java 代理模式详解

    代理模式是我们比较常用的设计模式之一。其中新思想是为了提供额外的处理或者不同的操作而在实际对象与调用者之间插入一个代理对象。这些额外的操作通常需要与实际对象进行通信，代理模式一般涉及到的角色有： 　...

    《Java设计模式》详解

    内容包括统一建模语言基础知识、面向对象设计原则、设计模式概述、简单...代理模式、职责链模式、命令模式、解释器模式、迭代器模式、中介者模式、备忘录模式、观察者模式、状态模式、策略模式、模板方法模式、访问者...

Magicbox
Global site tag (gtag.js) - Google Analytics