Java23种设计模式（GOF）——代理模式

核心作用

• 通过代理，控制对对象的访问。
  可以详细控制访问 某个（某类） 对象的方法，在调用这个方法前做前置处理，调用这个方法后做后置处理,从而实现将统一流程代码放到代理类中进行处理。（即AOP的微观实现）

核心角色

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

应用场景

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

分类

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

静态代理

案例

/**
 *
 * @author huangyzh
 * @create 2020-05-16 0:53
 */
public interface Star {
    /**
     * 面谈
     */
    void confer();

    /**
     * 签合同
     */
    void singContract();

    /**
     * 订票
     */
    void boolTicket();

    /**
     * 唱歌
     */
    void sing();

    /**
     * 收钱
     */
    void collectMoney();
}

/**
 * @author huangyzh
 * @create 2020-05-16 0:55
 */
public class RealStar implements Star {
    @Override
    public void confer() {
        System.out.println("真实角色……面谈");
    }

    @Override
    public void singContract() {
        System.out.println("真实角色……签合同");
    }

    @Override
    public void boolTicket() {
        System.out.println("真实角色……订票");
    }

    @Override
    public void sing() {
        System.out.println("真实角色……唱歌");
    }

    @Override
    public void collectMoney() {
        System.out.println("真实角色……收钱");
    }
}

/**
 * @author huangyzh
 * @create 2020-05-16 0:57
 */
public class ProxyStar implements Star {

    private Star star;

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

    @Override
    public void confer() {
        System.out.println("代理角色……mt");
    }

    @Override
    public void singContract() {
        System.out.println("代理角色……qht");
    }

    @Override
    public void boolTicket() {
        System.out.println("代理角色……dp");
    }

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

    @Override
    public void collectMoney() {
        System.out.println("代理角色……sq");
    }
}

/**
 * @author huangyzh
 * @create 2020-05-16 0:58
 */
public class Test01 {
    public static void main(String[] args) {
        Star real = new RealStar();
        Star proxy = new ProxyStar(real);

        proxy.sing();
        proxy.boolTicket();
        proxy.collectMoney();
        proxy.singContract();
        proxy.confer();

    }
}

动态代理

优点

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

JDK自带的动态代理

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

案例

package edu.yunyu.proxy.dynaticproxy;
/**
 *
 * @author huangyzh
 * @create 2020-05-16 0:53
 */
public interface Star {
    /**
     * 面谈
     */
    void confer();

    /**
     * 签合同
     */
    void singContract();

    /**
     * 订票
     */
    void boolTicket();

    /**
     * 唱歌
     */
    void sing();

    /**
     * 收钱
     */
    void collectMoney();
}

package edu.yunyu.proxy.dynaticproxy;

/**
 * @author huangyzh
 * @create 2020-05-16 0:55
 */
public class RealStar implements Star {
    @Override
    public void confer() {
        System.out.println("真实角色……面谈");
    }

    @Override
    public void singContract() {
        System.out.println("真实角色……签合同");
    }

    @Override
    public void boolTicket() {
        System.out.println("真实角色……订票");
    }

    @Override
    public void sing() {
        System.out.println("真实角色……唱歌");
    }

    @Override
    public void collectMoney() {
        System.out.println("真实角色……收钱");
    }
}

/**
 * @author huangyzh
 * @create 2020-05-17 13:34
 */
public class StarHandler implements InvocationHandler {

    private 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("方法执行前");
        if("sing".equals(method.getName())){
            obj = method.invoke(realStar,args);
        }else{
            System.out.println("################");
        }

        return obj;
    }
}

/**
 * @author huangyzh
 * @create 2020-05-17 13:37
 */
public class Test01 {
    public static void main(String[] args) {
        Star realStar = new RealStar();
        StarHandler handler = new StarHandler(realStar);
        Star star = (Star) Proxy.newProxyInstance(ClassLoader.getSystemClassLoader(), new Class[]{Star.class}, handler);
        star.sing();
        star.boolTicket();
    }
}

开发框架中应用场景

• struts2中拦截器的实现
• 数据库连接池关闭处理
• Hibernate中延时加载的实现
• mybatis中实现拦截器插件
• AspectJ的实现
• SpringAOP中的实现
  • 日志拦截
  • 声明式事务处理
• web service
• RMI远程方法调用

实际上，随便选择一个技术框架都会用到代理模式