GOF23设计模式之代理模式

核心作用：通过代理，控制对对象的访问。可以详细控制访问某个（某类）对象的方法，在调用这个方法前做前置处理，调用这个方法后做后置处理（即：AOP的微观实现）

AOP（Aspect Oriented Programming 面向切面编程）的核心实现机制

核心角色：

1）抽象角色：定义代理角色和真实角色的公共对外方法

2）真实角色：实现抽象角色，定义真实角色索要实现的业务逻辑，供代理角色调用。关注真正的业务逻辑！

3）代理角色：实现抽象角色，是真实角色的代理，通过真实角色的业务逻辑方法来实现抽象方法，并可以附加自己的操作。将统一的流程控制放到代理角色中处理。

应用场景：

1）安全代理：屏蔽对真实角色的直接访问。

2）远程代理：通过代理类处理远程方法调用（RMI）。

3）延迟加载：先加载轻量级的代理对象，真正需要再加载真实对象。

分类：

1）静态代理（静态定义代理类）

package cn.taosir.design.structure.proxy;

public class ProxyDemo {

    public static void main(String[] args) {

        Star real=new RealStar();

        Star proxy=new ProxyStar(real);

        proxy.dance();

        proxy.sing();

    }

}

interface Star{

    void sing();

    void dance();

}

class RealStar implements Star{

    @Override

    public void sing() {

        System.out.println("唱歌中...");

    }

    @Override

    public void dance() {

        System.out.println("跳舞中...");

    }

}

class ProxyStar implements Star{

    private Star star;

    public ProxyStar(Star star ) {

        super();

        this.star=star;

    }

    @Override

    public void sing() {

        star.sing();

    }

    @Override

    public void dance() {

        System.out.println("代理唱歌...");

    }

}

2）动态代理（动态生成代理类）

优点：相比于静态代理，抽象角色中（接口）声明的方法都被转移到调用处理器一个集中的方法中处理，这样，我们可以更加灵活和统一的处理众多的方法。

JDK自带的动态代理：

java.lang.reflect.Proxy　　作用：动态生成代理类和对象

java.lang.reflect.InvocationHandle（处理器接口）可以通过invoke方法实现对真实角色的代理访问，每次通过Proxy生成代理类对象时都要指定对应的处理器对象

package cn.taosir.design.structure.proxy;

import java.lang.reflect.InvocationHandler;

import java.lang.reflect.Method;

import java.lang.reflect.Proxy;

/**

 * 动态代理

 * @author taosir

 *

 */

public class DynamicProxy {

    public static void main(String[] args) {

        Star real=new RealStar();

        StarHandler handler=new StarHandler(real);

        Star proxy=(Star)Proxy.newProxyInstance(ClassLoader.getSystemClassLoader(), new Class[] {Star.class}, handler);

        proxy.sing();

    }

}

class StarHandler implements InvocationHandler{

    Star realStar;

    public StarHandler(Star realStar) {

        super();

        this.realStar=realStar;

    }

    @Override

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

        Object object=null;

        System.out.println("方法执行前");

        if (method.getName().equals("sing"))

            object=method.invoke(realStar, args);

        System.out.println("方法执行后");

        return object;

    }

}

interface Star{

    void sing();

    void dance();

}

class RealStar implements Star{

    @Override

    public void sing() {

        System.out.println("唱歌中...");

    }

    @Override

    public void dance() {

        System.out.println("跳舞中...");

    }

}

巴特西

GOF23设计模式之代理模式

GOF23设计模式之代理模式

核心角色：

应用场景：

分类：

最新文章

热门文章