设计模式(九)——代理模式

一、代理模式

1、核心作用

核心作用
通过代理，控制对象的访问！可以详细控制访问某个（某类）对象的方法，在调用这个方法前做前置处理，调用这个方法后做后置处理。（即AOP的微观实现！）
实现将统一流程代码放到代理类中处理。
AOP（面向切面编程）的核心机制

2、核心角色

抽象角色
定义代理角色和真实角色的公共对外方法
真实角色
实现抽象角色，定义真实角色所要实现的业务逻辑，供代理角色调用。
关注真正的业务逻辑！
代理角色
实现抽象角色，是真实角色的代理，通过真实角色的业务逻辑方法来实现抽象方法，并可以附加自己的操作。
将统一的流程控制放到代理角色中处理！

3、应用场景

安全代理：屏蔽对真实角色的直接访问。
远程代理：通过代理类处理远程方法调用（RMI）
延迟加载：先加载轻量级的代理对象，真正需要再加载真实对象。
比如开发一个大文件查看软件，大文件中有图片，图片可能有100M，在打开文件时不可能将所有图片都显示出来，这样可以使用代理模式查看一个质量稍微差点的图片。

4、分类

— 静态代理（静态定义代理类）：我们自己定义这个代理类

— 动态代理（动态生成代理类）：程序自动生成这个代理类

JDK自带的动态代理
Javaassist字节码操作库实现
CGLIB
ASM（底层使用指令，可维护性差）

5、静态代理实例

抽象角色

public interface Star {
    void confer();//面谈
    void signContract();//签合同
    void bookTicket();//订票
    void sing();//唱歌
    void collectionMoney();//收钱
}

代理角色

public class ProxyStar implements Star {

    private Star star;

    public ProxyStar(Star star) {
        this.star = star;
    }

    @Override
    public void confer() {
        System.out.println("ProxyStar.confer");
    }

    @Override
    public void signContract() {
        System.out.println("ProxyStar.signContract");
    }

    @Override
    public void bookTicket() {
        System.out.println("ProxyStar.bookTicket");
    }

    @Override
    public void sing() {
        star.sing();
    }

    @Override
    public void collectionMoney() {
        System.out.println("ProxyStar.collectionMoney");
    }
}

真实角色

public class RealStar implements Star {
    @Override
    public void confer() {
        System.out.println("RealStar.confer");
    }

    @Override
    public void signContract() {
        System.out.println("RealStar.signContract");
    }

    @Override
    public void bookTicket() {
        System.out.println("RealStar.bookTicket");
    }

    @Override
    public void sing() {
        System.out.println("RealStar.sing——周杰伦");
    }

    @Override
    public void collectionMoney() {
        System.out.println("RealStar.collectionMoney");
    }
}

测试

public class Client {
    public static void main(String[] args) {
        Star real = new RealStar();
        Star proxy = new ProxyStar(real);

        proxy.confer();
        proxy.signContract();
        proxy.bookTicket();
        proxy.sing();
        proxy.collectionMoney();

    }
}

6、动态代理实例

动态代理相比于静态代理优点
抽象角色中（接口）声明的所有方法都被转移到调用处理器一个集中的方法中处理，这样我们可以更加灵活的和统一的处理众多的方法。
JDK自带的动态代理
— java.lang.reflect.Proxy
作用：动态生成代理类和对象
— java.lang.reflect.InvocationHandler（处理接口）
可以通过invoke方法实现对真实角色的代理访问
每次通过Proxy生成代理类对象时都要指定对应的处理器对象

抽象角色

public interface Star {
    void confer();//面谈
    void signContract();//签合同
    void bookTicket();//订票
    void sing();//唱歌
    void collectionMoney();//收钱
}

真实角色

public class RealStar implements Star {
    @Override
    public void confer() {
        System.out.println("RealStar.confer");
    }

    @Override
    public void signContract() {
        System.out.println("RealStar.signContract");
    }

    @Override
    public void bookTicket() {
        System.out.println("RealStar.bookTicket");
    }

    @Override
    public void sing() {
        System.out.println("RealStar.sing——周杰伦");
    }

    @Override
    public void collectionMoney() {
        System.out.println("RealStar.collectionMoney");
    }
}

处理器

public class StarHandler implements InvocationHandler {
    private Star realStar;

    public StarHandler(Star realStar) {
        this.realStar = realStar;
    }

    /**
     * @param proxy 代理类
     * @param method 方法
     * @param args 参数
     * @return
     * @throws Throwable
     */
    @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;
    }
}

测试

public class Client {
    public static void main(String[] args) {
        Star realStar = new RealStar();
        StarHandler handler = new StarHandler(realStar);

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

7、开发框架中应用场景

数据库连接池关闭处理
Hibernate延迟加载的实现
Mybatis中实现拦截器插件
AspectJ的实现
Spring中AOP的实现
1、日志拦截
2、声明式事务处理
RMI远程方法调用

设计模式(九)——代理模式

一、代理模式

猜你喜欢