6、代理模式(设计模式笔记)

一、简介

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

  • 核心角色

    • 抽象角色:定义代理角色和真实角色的公共对外方法
    • 真实角色:实现抽象角色,定义真实角色所要实现的业务逻辑,供代理角色调用(关注真正的业务逻辑)
    • 代理角色:实现抽象角色,是真实角色的代理,通过真实角色的业务逻辑方法来实现抽象方法,并可以附加自己的操作
  • 应用场景

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

    • 静态代理(静态定义代理类)
    • 动态代理(动态生成代理类)(使用更多)
      jdk自带的动态代理
      javaassist字节码操作库实现
      cglib
      asm(底层使用指令,可维护性较差)

二、静态代理

Star.java

package cn.itcast.day236.static_proxy;
//一个“明星”接口,请明星我们需要面谈、签合同、订票、演唱、收款等任务
//当然这只是一个角色接口
public interface Star {
    public void confer();//面谈
    public void signContract();//签合同
    public void bookTicket();//订票
    public void sing();//演唱
    public void collectMoney();//收款
}

说明:这是一个“明星”接口,这里我们使用“明星”作为例子进行说明。模拟邀请一位明星参加演出所需要的一些步骤。

RealStart.java

package cn.itcast.day236.static_proxy;
//一个真实角色
public class RealStart implements Star{

    public void confer() {
        System.out.println("RealStart面谈");
    }

    public void signContract() {
        System.out.println("RealStart签合同");
    }

    public void bookTicket() {
        System.out.println("RealStart订票");
    }

    public void sing() {
        System.out.println("RealStart演唱");
    }

    public void collectMoney() {
        System.out.println("RealStart收款");
    }
}

说明:这是一个真实角色,加入这是一位真实的明星,我们要邀请他参加演出,需要一些步骤,但是真实情况下明星除了演唱很多事情都是交给其“经纪人”(代理)来处理。

ProxyStart.java

package cn.itcast.day236.static_proxy;
//代理(经纪人)
public class ProxyStart implements Star{
    
    private Star star;//需要知道自己到底代理的是哪个对象
    
    public ProxyStart(Star star) {
        this.star = star;
    }

    public void confer() {
        System.out.println("ProxyStart面谈");
    }

    public void signContract() {
        System.out.println("ProxyStart签合同");
    }

    public void bookTicket() {
        System.out.println("ProxyStart订票");
    }
    //代理人可以干其他所有事情,但是唯独演唱是需要明星(真实对象)来做的
    public void sing() {
        star.sing();//调用真实对象演唱
    }

    public void collectMoney() {
        System.out.println("ProxyStart收款");
    }   
}

说明:在使用代理对象的时候我们需要将其和真正的对象关联起来,这里通过构造方法传递进去。同时可以看到代理帮其代理的对象做了除演唱的其他所有事情。

Client.java

package cn.itcast.day236.static_proxy;
public class Client {
    public static void main(String[] args) {
        Star real = new RealStart();
        Star proxy = new ProxyStart(real);
        proxy.confer();
        proxy.signContract();
        proxy.bookTicket();
        proxy.sing();
        proxy.collectMoney();
    }
}

说明:可以看到除了演唱以外都是代理做的,但是静态代理往往要将代理类写死了。下面看动态代理。

三、动态代理

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

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

首先明星接口和真实对象都和之前的静态模式一样,但是和静态代理不同的是代理类是动态生成的。这里我们需要实现一个处理器类:

StarHandler.java

package cn.itcast.day237.dynamic_proxy;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
//处理器接口需要处理真实角色
public class StarHandler implements InvocationHandler{
    
    private Star realStart;
    
    public StarHandler(Star realStart) {
        this.realStart = realStart;
    }

    /**
     * proxy:代理类
     * method:正在调用的方法
     * args:方法的参数
     */
    public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable {
        Object obj = null;
        System.out.println("演唱之前");
        //只有演唱才调用真实对象来处理
        if(method.getName().equals("sing")){
            obj = method.invoke(realStart, args);//这里如果有返回值我们可以获取到
        }
        System.out.println("演唱之后");
        return obj;//如果没有返回值我们直接返回一个null
    }
}

说明:在后面使用的过程中调用代理对象的所有方法都将有invoke方法进入,所以我们可以在此方法中作相关的处理。下面我们看使用方式:

Client.java

package cn.itcast.day237.dynamic_proxy;
import java.lang.reflect.Proxy;
public class Client {
    public static void main(String[] args) {
        Star realStar = new RealStart();
        StarHandler handler = new StarHandler(realStar);
        Star proxy = (Star) Proxy.newProxyInstance(ClassLoader.getSystemClassLoader(),
                new Class[] { Star.class }, handler);
        proxy.confer();
        proxy.signContract();
        proxy.bookTicket();
        proxy.sing();
        proxy.collectMoney();
    }
}

说明:这里我们通过Proxy.newProxyInstance方法来动态生成代理类。其中第一个参数是类加载器,第二个参数是需要代理的类(当然可能需要代理的类有几个),第三个参数是处理器类。

你可能感兴趣的:(6、代理模式(设计模式笔记))