GOF23设计模式之代理模式

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("跳舞中...");
    }
}