设计模式（十）——代理模式

最新推荐文章于 2025-09-13 14:01:10 发布

weixin_33915554

最新推荐文章于 2025-09-13 14:01:10 发布

阅读量49

点赞数

CC 4.0 BY-SA版权

文章标签：设计模式 java

原文链接：https://my.oschina.net/kun123/blog/726812

本文详细介绍了代理模式的概念及其三种实现方式：普通代理、强制代理和动态代理。通过具体的Java代码示例，展示了如何使用代理模式来控制对对象的访问。

为什么80%的码农都做不了架构师？>>>

一、定义

为其他对象提供一种代理以控制对该对象的访问

二、要素

1.抽象角色：通过接口或抽象类声明真实角色实现的业务方法

2.代理角色：实现抽象角色，是真实角色的代理，通过真实角色的业务逻辑方法来实现抽象方法，并可以附加自己的操作

3.实现抽象角色，定义真实角色所要实现的业务逻辑，供代理角色调用

四、普通代理

//抽象角色

public abstract class Abstraction {
public abstract void doSomething();
}

//实现抽象角色

public class ConcreteImplementor extends Abstraction{

   @Override
   public void doSomething() {
       System.out.print("doSomething");
   }

}

//代理角色

public class Proxy extends Abstraction{
   private Abstraction impl = null;
   public Proxy(){
       this.impl = new ConcreteImplementor();
   }
   @Override
   public void doSomething() {
       impl.doSomething();
   }
}

//客户端

public class Client {
   public static void main(String[] args) {
       Proxy proxy = new Proxy();
       proxy.doSomething();
   }
}

五、强制代理

含义：必须通过真实角色查找到代理角色，否则不能访问；改动代码如下

//代理角色

public class Proxy extends Abstraction{
   private Abstraction impl = null;
   public Proxy(Abstraction value){
       this.impl = value;
   }

   public void doSomething() {
       impl.doSomething();
   }
}

//实现抽象角色

public class ConcreteImplementor extends Abstraction{
   private Abstraction mProxy = null;

   public Abstraction getProxy(){
       return this.mProxy = new Proxy(this);
   }
   public boolean isProxy(){
       if(this.mProxy == null){
           return false;
       }
       return true;
   }

   @Override
   public void doSomething() {
       if(isProxy()){
           System.out.print("doSomething");
       }
   }
}

//客户端

public class Client {
   public static void main(String[] args) {
       Abstraction proxy = new ConcreteImplementor().getProxy();
       proxy.doSomething();
   }
}

六、动态代理

相对自己写代理类的静态代理，动态代理不需要自己写代理，而是用jdk提供的动态代理接口

//动态代理接口实现类

public class invokeHandler implements InvocationHandler{
   private Object obj = null;

   public invokeHandler(Object value){
       this.obj = value;
   }

   public Object invoke(Object arg0, Method arg1, Object[] arg2)
           throws Throwable {
       Object result = arg1.invoke(this.obj, arg2);
       return result;
   }

}

//抽象角色

public interface Abstraction {
void doSomething();
}

//具体实现角色

public class ConcreteImplementor implements Abstraction{

   public void doSomething() {
       System.out.print("doSomething");
   }

}

//客户端

public class Client {
   public static void main(String[] args) {
       Abstraction impl = new ConcreteImplementor();
       InvocationHandler handler = new invokeHandler(impl);
       ClassLoader cl = impl.getClass().getClassLoader();
       Abstraction proxy = (Abstraction) Proxy.newProxyInstance(cl,
               new Class[]{Abstraction.class}, handler);
       proxy.doSomething();
   }
}

七、说明

1.代理模式体现了最小知识原则

2.AOP编程的核心就是动态代理

转载于:https://my.oschina.net/kun123/blog/726812