学习笔记——JAVA设计模式<6>代理模式

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

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

应用场景
安全代理：屏蔽对真实角色的直接访问
远程代理：通过代理类处理远程方法调用（RMI）
延迟加载：先加载轻量级的代理对象，正真需要再加载真实对象

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

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

package studyGFO;
/**
 * 接口（明星）
 * @author http://blog.csdn.net/thewaiting
 *
 */
public interface Star {

    void confer();//面谈
    void signContract();//签合同
    void bookTicket();//订票
    void sing();//唱歌
    void collectMoney();//收钱

}

package studyGFO;
/**
 * 真实角色（明星）
 * @author http://blog.csdn.net/thewaiting
 *
 */
public class RealStar implements Star{

    @Override
    public void confer() {
        System.out.println("明星面谈");
    }

    @Override
    public void signContract() {
        System.out.println("明星签合同");
    }

    @Override
    public void bookTicket() {
        System.out.println("明星订票");
    }

    @Override
    public void sing() {
        System.out.println("明星唱歌");
    }

    @Override
    public void collectMoney() {
        System.out.println("明星收钱");
    }


}

package studyGFO;
/**
 * 代理角色（代理人）
 * @author http://blog.csdn.net/thewaiting
 *
 */
public class ProxyStar implements Star{

    private Star star;


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

    @Override
    public void confer() {
        System.out.println("代理人面谈");
    }

    @Override
    public void signContract() {
        System.out.println("代理人签合同");
    }

    @Override
    public void bookTicket() {
        System.out.println("代理人订票");
    }

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

    @Override
    public void collectMoney() {
        System.out.println("代理人收钱");
    }

}

package studyGFO;

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.collectMoney();
    }

}

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

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

修改代码

package studyGFO;

import java.lang.reflect.Proxy;

public class Client {

    public static void main(String[] args) {

        Star realStar = new RealStar();
        StartHandler handler = new StartHandler(realStar);

        Star pStar = (Star) Proxy.newProxyInstance(
                ClassLoader.getSystemClassLoader(),//loader - 定义代理类的类加载器
                new Class[]{Star.class},//interfaces - 代理类要实现的接口列表
                handler);//h - 指派方法调用的调用处理程序 

        //pStar.bookTicket();
        pStar.sing();

    }

}

package studyGFO;

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

public class StartHandler implements InvocationHandler{

    Star realStar;

    public StartHandler(Star realStar) {
        super();
        this.realStar = realStar;
    }

    //通过反射来调用方法
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

        Object object = null;//接收方法的返回值
        System.out.println("方法执行前");
        System.out.println("#########");

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

        System.out.println("方法执行后");
        System.out.println("*********");
        return object;
    }

}