应用场景

• 安全代理:屏蔽对真实角色的直接访问

• 远程代理:通过代理类处理远程方法调用

• 延迟加载:先加载轻量级的代理对象,真正需要再加载真实对象

  • 比如你要开发一个大文档查看软件,大文档中有大的图片,可能一个图片有100M,在打开文件时不可能将所有的图片都显示出来,这样就可以使用代理模式,当需要查看图片时,用proxy来进行大图片的打开

核心角色

• 抽象角色

  • 定义代理角色和真实角色的公共对外方法

• 真实角色

  • 实现抽象角色,定义真实角色所需要的业务逻辑,供代理角色调用

  • 关注真正的业务逻辑

• 代理角色

  • 实现抽象角色,是真实角色的代理,通过真实角色的业务逻辑方法来实现抽象方法,并可以附加自己的操作

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

分类

• 静态代理(静态定义代理类)

• 动态代理(动态生成代理类)

  • JDK自带的动态代理

  • Javaassist字节码操作库实现

  • CGLIB

  • ASM(底层使用指令,可维护性较差)

核心作用

• 通过代理,控制对对象的访问,可以详细控制访问某个(类)对象的方法,在调用这个方法前做前置处理,调用这个方法后做后置处理(即AOP的微观实现)

• AOP(Aspect Oriented Programming面向切面编程)的核心实现机制

经纪人可以代理多个明星

静态代理

抽象角色

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

}

真实角色

public class RealStar implements Star{

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

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

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

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

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

}

代理角色

public class ProxyStar implements Star{

    private RealStar star;

    ProxyStar(RealStar star){
        this.star = star;
    }

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

    }

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

    }

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

    }

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

    }

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

    }

}

Client

public class Client {

    public static void main(String[] args) {
        RealStar star = new RealStar();
        ProxyStar proxy = new ProxyStar(star);
        proxy.confer();
        proxy.singContract();
        proxy.bookTicket();
        proxy.sing();
        proxy.collectMoney();
    }
}

动态代理

• 动态代理相比于静态代理的优点

  • 抽象角色中(接口)声明的所有方式都被转移到调用处理器一个集中的方法中处理,这样,我们可以更加灵活和统一的处理众多的方法

• JDK自带的动态代理

  • java.lang.reflect.Proxy

    • 作用:动态生成代理类和对象

  • java.lang.reflect.InvoctionHandler(处理器接口)

    • 可以通过invoke方法实现对真实角色的代理访问

    • 每次通过Proxy生成代理类对象时都要指定对应的处理器对象

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

import design.proxy.staticproxy.Star;

public class StartHandler implements InvocationHandler{

    Star RealStar;

    public StartHandler(Star realStar) {
        super();
        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")){
            object = method.invoke(RealStar, args);
        }
        System.out.println("真正的方法执行后");

        return object;
    }

}

import java.lang.reflect.Proxy;

import design.proxy.staticproxy.RealStar;
import design.proxy.staticproxy.Star;

public class Client {

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

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

        proxy.sing();
    }
}