`

Proxy 代理模式学习笔记

    博客分类:
  • java
阅读更多
1. 意图:
为其他对象提供一种代理以控制对这个对象的访问

2. 别名:
surrogate替身

3. 动机
按需创建, 替代对象

4. 适用性
* 远程代理
* 虚代理
* 保护代理
* 智能指引

5. 结构




6. 实例

Java代码
package net.yeah.fanyamin.pattern.proxy;  
 
/** 
* @author walter 
*/ 
interface Greet {  
    void sayHello(String name);  
    void goodBye();  
}  
 
class GreetImpl implements Greet {  
    public void sayHello(String name) {  
        System.out.println("Hello " + name);  
    }  
    public void goodBye() {  
        System.out.println("Good bye.");  
    }  
}  
 
public class SimpleProxy implements Greet {  
    private Greet greet = null;  
      
    SimpleProxy(Greet greet) {  
        this.greet = greet;  
    }  
      
    public void sayHello(String name) {  
        System.out.println("--before method sayHello");  
        greet.sayHello(name);  
        System.out.println("--after method sayHello");  
    }  
      
    public void goodBye() {  
        System.out.println("--before method goodBye");  
        greet.goodBye();  
        System.out.println("--after method goodBye");  
    }  
    /** 
     * @param args 
     */ 
    public static void main(String[] args) {  
        Greet greet = new SimpleProxy(new GreetImpl());  
        greet.sayHello("walter");  
        greet.goodBye();  
 
    }  
 


package net.yeah.fanyamin.pattern.proxy;

/**
* @author walter
*/
interface Greet {
    void sayHello(String name);
    void goodBye();
}

class GreetImpl implements Greet {
    public void sayHello(String name) {
        System.out.println("Hello " + name);
    }
    public void goodBye() {
        System.out.println("Good bye.");
    }
}

public class SimpleProxy implements Greet {
    private Greet greet = null;
   
    SimpleProxy(Greet greet) {
        this.greet = greet;
    }
   
    public void sayHello(String name) {
        System.out.println("--before method sayHello");
        greet.sayHello(name);
        System.out.println("--after method sayHello");
    }
   
    public void goodBye() {
        System.out.println("--before method goodBye");
        greet.goodBye();
        System.out.println("--after method goodBye");
    }
    /**
     * @param args
     */
    public static void main(String[] args) {
        Greet greet = new SimpleProxy(new GreetImpl());
        greet.sayHello("walter");
        greet.goodBye();

    }

}
利用JDK中的动态代理

Java代码
/** 
*  
*/ 
package net.yeah.fanyamin.pattern.proxy;  
 
import java.lang.reflect.InvocationTargetException;  
import java.lang.reflect.Method;  
 
/** 
* @author walter 
*/ 
public class DebugProxy implements java.lang.reflect.InvocationHandler {  
 
    private Object obj;  
 
    public static Object newInstance(Object obj) {  
        return java.lang.reflect.Proxy.newProxyInstance(obj.getClass().getClassLoader(),  
                                                        obj.getClass().getInterfaces(), new DebugProxy(obj));  
    }  
 
    private DebugProxy(Object obj) {  
        this.obj = obj;  
    }  
 
    public Object invoke(Object proxy, Method m, Object[] args) throws Throwable {  
        Object result;  
        try {  
            System.out.println("--before method " + m.getName());  
            result = m.invoke(obj, args);  
        } catch (InvocationTargetException e) {  
            throw e.getTargetException();  
        } catch (Exception e) {  
            throw new RuntimeException("unexpected invocation exception: " + e.getMessage());  
        } finally {  
            System.out.println("--after method " + m.getName());  
        }  
        return result;  
    }  
 
    /** 
     * @param args 
     */ 
    public static void main(String[] args) {  
        Greet greet = (Greet) DebugProxy.newInstance(new GreetImpl());  
        greet.sayHello("walter");  
        greet.goodBye();  
    }  
 


/**
*
*/
package net.yeah.fanyamin.pattern.proxy;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

/**
* @author walter
*/
public class DebugProxy implements java.lang.reflect.InvocationHandler {

    private Object obj;

    public static Object newInstance(Object obj) {
        return java.lang.reflect.Proxy.newProxyInstance(obj.getClass().getClassLoader(),
                                                        obj.getClass().getInterfaces(), new DebugProxy(obj));
    }

    private DebugProxy(Object obj) {
        this.obj = obj;
    }

    public Object invoke(Object proxy, Method m, Object[] args) throws Throwable {
        Object result;
        try {
            System.out.println("--before method " + m.getName());
            result = m.invoke(obj, args);
        } catch (InvocationTargetException e) {
            throw e.getTargetException();
        } catch (Exception e) {
            throw new RuntimeException("unexpected invocation exception: " + e.getMessage());
        } finally {
            System.out.println("--after method " + m.getName());
        }
        return result;
    }

    /**
     * @param args
     */
    public static void main(String[] args) {
        Greet greet = (Greet) DebugProxy.newInstance(new GreetImpl());
        greet.sayHello("walter");
        greet.goodBye();
    }

}
 
  • 大小: 5.6 KB
分享到:
评论

相关推荐

    设计模式学习笔记总结

    这里我们聚焦于C#语言中的设计模式学习笔记,涵盖了多种经典的设计模式,如合成模式、桥梁模式、装饰模式、享元模式、门面模式、命令模式、工厂方法、策略模式、代理模式以及状态模式。下面将对这些模式逐一进行详细...

    16-Java代理模式的学习笔记1

    Java代理模式是一种设计模式,它允许我们为一个对象创建一个代理,这个代理对象可以在调用原始对象的方法之前或之后执行额外的操作。代理模式在软件工程中有多种应用,例如:增加安全控制、性能监控、事务管理等。...

    C#设计模式学习笔记

    C#设计模式学习笔记是一份详尽的资源,适合任何希望深入了解如何在C#编程中应用设计模式的开发者。这份笔记涵盖了多种设计模式,旨在提升代码的可读性、可维护性和可扩展性,这些都是软件开发中至关重要的要素。 ...

    设计模式学习笔记及其模式特点总结

    代理模式分为静态代理和动态代理,其中动态代理在Java中可以通过InvocationHandler接口和Proxy类实现。 2. **单例模式**: 单例模式确保一个类只有一个实例,并提供全局访问点。这种模式常用于控制资源的共享,如...

    Head First 设计模式学习笔记(十四)模式的组合使用

    在《Head First 设计模式学习笔记(十四)模式的组合使用》中,作者探讨了如何在实际编程中灵活地组合多种设计模式以解决复杂问题。这篇文章可能是基于《Head First 设计模式》这本书的一个章节,该书是设计模式领域...

    Java 版设计模式学习笔记-java-design-patterns.zip

    这个“Java版设计模式学习笔记”涵盖了多种设计模式,旨在帮助开发者更好地理解和应用这些模式。让我们深入探讨一下其中可能包含的关键知识点。 一、单例模式 单例模式确保一个类只有一个实例,并提供一个全局访问...

    设计模式学习笔记

    7. 代理模式(Proxy):为其他对象提供一种代理以控制对这个对象的访问。 行为型模式涉及对象之间的责任分配,包括: 1. 责任链模式(Chain of Responsibility):将请求沿着处理者链传递,直到有对象处理为止。 2....

    设计模式之美—学习笔记

    装饰模式(Decorator)可以在运行时动态地给对象添加新的行为或责任,而代理模式(Proxy)为其他对象提供一种代理以控制对这个对象的访问。 行为型模式关注对象之间的交互和职责分配。策略模式(Strategy)定义了一...

    Spring学习笔记(13)----动态代理模式分析演示

    在本篇Spring学习笔记中,我们将深入探讨动态代理模式,并结合Spring框架的实现进行分析演示。动态代理模式是Java编程中一种重要的设计模式,它允许我们在不修改原对象代码的情况下,为对象添加额外的功能或行为。...

    《设计模式》学习笔记

    ### 设计模式学习笔记 #### 引言 设计模式(Design Patterns)是在软件设计领域内广泛应用的一种实践指南,它提供了一系列解决常见问题的方案。设计模式可以被理解为面向对象软件设计的经验总结,是对特定面向对象...

    GoF 23种设计模式学习笔记

    "GoF 23种设计模式学习笔记" 是一个深入探讨这23个经典设计模式的资源,这些模式最初由Erich Gamma、Richard Helm、Ralph Johnson和John Vlissides四位作者在1994年的著作《设计模式:可复用面向对象软件的基础》中...

    23中设计模式学习笔记.docx

    ### 23种设计模式学习笔记 #### 一、软件设计模式的概念与意义 **概念:** 软件设计模式(Software Design Pattern),又称设计模式,是一套被广泛采用、经过整理和分类的代码设计经验总结。它针对软件设计过程中...

    300Java设计模式部分学习笔记

    2. 代理模式(Proxy Pattern):为其他对象提供一种代理以控制对这个对象的访问。 3. 桥接模式(Bridge Pattern):将抽象部分与实现部分分离,使它们都可以独立地变化。 4. 组合模式(Composite Pattern):将对象...

    Spring学习笔记(12)----静态代理模式分析演示

    在本篇Spring学习笔记中,我们将探讨静态代理模式在Spring框架中的应用与分析。静态代理是一种常见的设计模式,它在不修改目标类代码的情况下,通过代理类来扩展或增强目标类的功能。在Spring中,静态代理主要应用于...

    图解java设计模式_学习笔记_java开发

    这份"图解java设计模式_学习笔记"是针对Java开发者深入理解和应用设计模式的重要资源。在这里,我们将深入探讨Java设计模式的核心概念、分类以及它们在实际开发中的应用。 设计模式分为三大类:创建型、结构型和...

    spring学习笔记(七)

    【标题】"Spring学习笔记(七)"主要涵盖了Spring框架中的一个重要概念——代理模式。在Spring中,代理模式被广泛应用于AOP(面向切面编程)中,为对象提供额外的功能,如事务管理、日志记录等。这篇笔记可能详细解析...

    spring aop 学习笔记

    本学习笔记将深入探讨Spring AOP的核心概念、工作原理以及实际应用。 1. **核心概念** - **切面(Aspect)**:切面是关注点的模块化,包含业务逻辑之外的横切关注点,如日志、事务管理。 - **连接点(Join Point...

    Qt - ModelView模式学习笔记.docx

    在Qt中,这一模式被扩展和细化,形成了Model-View-ProxyModel-Delegate-SelectionModel等组件的体系。 **Model**: 模型是数据的源头,它负责存储和管理实际的数据。数据可以来源于各种数据源,如文件、数据库查询...

    23个设计模式图解--学习笔记

    在《23个设计模式图解--学习笔记》中,我们探讨了这些模式,以便于理解和应用到实际开发中。以下是这23个设计模式的详细说明: 1. **工厂方法**(Factory Method):定义一个用于创建对象的接口,让子类决定实例化...

Global site tag (gtag.js) - Google Analytics