02-代理模式

>代理模式(proxy pattern)
核心作用：
通过代理，控制对对象的访问！ 可以详细控制访问某个（某类）对象的方法，在调用这个方法前做前置处理，调用这个方法后做后置处理。（即：AOP的微观实现！）
AOP(Aspect  Oriented  Programming面向切面编程)的核心实现机制！

代理模式(Proxy pattern)：
核心角色：
抽象角色
定义代理角色和真实角色的公共对外方法
真实角色
实现抽象角色，定义真实角色所要实现的业务逻辑，供代理角色调用。
关注真正的业务逻辑！
代理角色
实现抽象角色，是真实角色的代理，通过真实角色的业务逻辑方法来实现抽象方法，并可以附加自己的操作。

将统一的流程控制放到代理角色中处理！

应用场景：
安全代理：屏蔽对真实对象的直接访问。
远程代理：通过代理类出力远程方法调用(RMI)。
延迟加载：先加载轻量级的代理对象，真正需要再加载真实对象。
(比如你要开发一个大文档查看软件，大文档中有大的图片，有可能一个图片有100MB，在打开文件时不可能将所有的图片都显示出来，这样就可以使用代理模式，当需要查看图片时，用proxy来进行大图片的打开。)

分类：
静态代理(静态定义代理类)
动态代理(动态生成代理类)
　　JDK自带的动态代理
　　javaassist字节码操作库实现
　　CGLIB
　　ASM(底层使用指令，可维护性较差)

静态代理(static proxy)：
静态代理(静态定义代理类)

抽象角色：

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

真实角色：

public class RealStar implements Star{

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

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

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

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

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

代理角色：

public class ProxyStar implements Star{
    private Star star;

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

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

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

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

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

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

客户类：

public class Client {
    public static void main(String[] args) {
        RealStar realObj = new RealStar();
        ProxyStar proxyObj = new ProxyStar(realObj);
        
        proxyObj.confer();
        proxyObj.signContract();
        proxyObj.bookTicket();
        
        proxyObj.sing();
        
        proxyObj.collectMoney();
    }
}

动态代理(dynamic proxy)
动态代理(动态生成代理类)
　　JDK自带的动态代理
　　javaassist字节码操作库实现
　　CGLIB
　　ASM(底层使用指令，可维护性较差)

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

1、动态代理(JDK自带的实现)
JDK自带的动态代理
java.lang.reflect.Proxy
　　作用：动态生成代理类和对象
java.lang.reflect.InvocationHandler(处理器接口)
　　可以通过invoke方法实现对真实角色的代理访问。
　　每次通过Proxy生成代理类对象对象时都要指定对应的处理器对象

>>方式一

import java.lang.reflect.Proxy;

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

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

>>方式二
抽象对象：

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

真实对象：

public class RealStar implements Star{

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

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

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

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

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

处理器接口的实现类，模拟动态生成的代理的结构：

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;

/**
 * 模拟动态生成的代理的结构
 */
public class StarHandler implements InvocationHandler{
    Star realStar;

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

    //通过反射调用真实对象的方法，方法和真实对象作为参数，故而能实现“动态”代理
    @Override
    public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable {
        Object obj = null;

        System.out.println("真正的方法执行前！");
        System.out.println("面谈，签合同，预付款，订机票");

        if(method.getName().equals("sing")){
            obj = method.invoke(realStar, args);
        }

        System.out.println("真正的方法执行后！");
        System.out.println("收尾款");
        return obj;
    }
}

代理对象。使用处理器接口(只有一个invoke(...)方法)。处理器接口的实现类的实例相当于一个代理对象。

public class ProxyStar implements Star{
    StarHandler handler ;

    public ProxyStar(StarHandler handler) {
        this.handler = handler;
    }

    @Override
    public void confer() {
        
    }

    @Override
    public void signContract() {

    }

    @Override
    public void bookTicket() {

    }
    
    @Override
    public void sing() throws Throwable {
        handler.invoke(this, Star.class.getDeclaredMethod("sing"),null);
    }

    @Override
    public void collectMoney() {

    }
}

代理类：

public class Client02 {
    public static void main(String[] args) throws Throwable {
        RealStar realStar = new RealStar();
        StarHandler handler = new StarHandler(realStar);
        
        ProxyStar proxyStar = new ProxyStar(handler);
        proxyStar.sing();
    }
}

代理模式在框架中的应用场景：
struts2中拦截器的实现
数据库连接池关闭处理
Hibernate中延时加载的实现
mybatis中实现拦截器插件
AspectJ的实现
spring中AOP的实现
　　日志拦截
　　声明式事务处理
web service
RMI远程方法调用
...
实际上，随便选择一个技术框架都会用到代理模式！！


面向切面编程
AOP（Aspect-Oriented Programming，面向切面的编程）
它是可以通过预编译方式和运行期动态代理实现在不修改源代码的情况下给程序动态统一添加功能的一种技术。它是一种新的方法论，它是对传统OOP编程的一种补充。

常用术语：
切面（Aspect）：其实就是共有功能的实现。
通知（Advice）：是切面的具体实现。
连接点（Joinpoint）：就是程序在运行过程中能够插入切面的地点。
切入点（Pointcut）：用于定义通知应该切入到哪些连接点上。
目标对象（Target）：就是那些即将切入切面的对象，也就是那些被通知的对象
代理对象（Proxy）：将通知应用到目标对象之后被动态创建的对象。
织入（Weaving）：将切面应用到目标对象从而创建一个新的代理对象的过程。

开源的AOP框架
AspectJ