大型Java进阶专题(六)设计模式之代理模式

代理模式

前言

又开始我的专题了,又停滞了一段时间了,加油继续吧。都知道 SpringAOP 是用代理模式实现,到底是怎么实现的?我们来一探究竟,并且自己仿真手写还原部分细节。

代理模式的应用

在生活中,我们经常见到这样的场景,如:租房中介、售票黄牛、婚介、经纪人、快递、 事务代理、非侵入式日志监听等,这些都是代理模式的实际体现。代理模式(Proxy Pattern)的定义也非常简单,是指为其他对象提供一种代理,以控制对这个对象的访问。 代理对象在客服端和目标对象之间起到中介作用,代理模式属于结构型设计模式。使用 代理模式主要有两个目的:一保护目标对象,二增强目标象。下面我们来看一下代理 模式的类结构图:

Subject 是顶层接口,RealSubject 是真实对象(被代理对象),Proxy 是代理对象,代 理对象持有被代理对象的引用,客户端调用代理对象方法,同时也调用被代理对象的方 法,但是在代理对象前后增加一些处理。在代码中,我们想到代理,就会理解为是代码 增强,其实就是在原本逻辑前后增加一些逻辑,而调用者无感知。代理模式属于结构型 模式,有静态代理和动态代理。

静态代理

举个例子:人到了适婚年龄,父母总是迫不及待希望早点抱孙子。而现在社会的人在各 种压力之下,都选择晚婚晚育。于是着急的父母就开始到处为自己的子女相亲,比子女 自己还着急。这个相亲的过程,就是一种我们人人都有份的代理。来看代码实现: 

/**
 * 人很多行为,要谈恋爱
 */
public interface Person {
    void findLove();
}


/**
 * 儿子需要找对象
 */
public class Son implements Person {

    @Override
    public void findLove() {
        System.out.println("工作没时间!");
    }
}

/**
 * 父亲代理儿子 先帮物色对象
 */
public class Father{

    private Son son;

    //代理对象持有 被代理对象的应用 但没办法扩展
    private Father(Son son) {
        this.son = son;
    }

    private void findLove() {
        //before
        System.out.println("父母帮物色对象");
        son.findLove();
        //after
        System.out.println("双方同意交往!");
    }

    //测试代码
    public static void main(String[] args) {
        Son son = new Son();
        Father father = new Father(son);
        father.findLove();
    }
}

动态代理

动态代理和静态对比基本思路是一致的,只不过动态代理功能更加强大,随着业务的扩 展适应性更强。如果还以找对象为例,使用动态代理相当于是能够适应复杂的业务场景。 不仅仅只是父亲给儿子找对象,如果找对象这项业务发展成了一个产业,进而出现了媒 婆、婚介所等这样的形式。那么,此时用静态代理成本就更大了,需要一个更加通用的 解决方案,要满足任何单身人士找对象的需求。我们升级一下代码,先来看 JDK 实现方式:

JDK 实现方式

创建媒婆(婚介)JDKMeipo 类:

package com.study;

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


public class JdkMeipo implements InvocationHandler {
  	//持有被代理对象的引用
    Object target;

    public Object getInstance(Object target){
        this.target =target;
        Class<?> aClass = target.getClass();
        return Proxy.newProxyInstance(aClass.getClassLoader(),aClass.getInterfaces(),this);
    }
  
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        before();
        Object object = method.invoke(this.target,args);
        after();
        return object;
    }

    private void before() {
        System.out.println("我是婚介,帮你物色对象");
    }

    private void after() {
        System.out.println("已找到,如果合适就开始");
    }
}

创建单身客户

package com.study;

public class Customer implements Person{

    @Override
    public void findLove() {
        System.out.println("我要找白富美");
    }
}

测试代码

package com.study;

public class DemoTest {
    public static void main(String[] args) {
        Person person = (Person) new JdkMeipo().getInstance(new Customer());
        person.findLove();
    }
}

执行效果

Jdk代理的原理

不仅知其然,还得知其所以然。既然 JDK Proxy 功能如此强大,那么它是如何实现的呢? 我们现在来探究一下原理。 我们都知道 JDK Proxy 采用字节重组,重新生的对象来替代原始的对象以达到动态代理 的目的。JDK Proxy 生成对象的步骤如下:

1.拿到代理对象的应用,并获取它的所有接口,反射获取。

2.通过JDK proxy 类重新生成一个新的类,同时新的类要实现被代理类所有实现的接口。

3.动态生成Java代码,把新加的业务逻辑方法由一定的逻辑代码去调用(在代码中体现)。

4.编译重新生成Java代码.class

5.再重新加载的JVM中
以上这个过程就叫字节重组。

CGLib实现方式

简单看一下 CGLib 代理的使用,还是以媒婆为例,创建 CglibMeipo 类:

package com.study;

import org.springframework.cglib.proxy.Enhancer;
import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;

import java.lang.reflect.Method;

public class CGlibMeipo implements MethodInterceptor {
    Object target;
    public Object getInstance(Class<?> aClass){
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(aClass);
        enhancer.setCallback(this);
        return enhancer.create();
    }
    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        before();
        Object invokeSuper = methodProxy.invokeSuper(o, objects);
        after();
        return invokeSuper;
    }

    private void after() {
        System.out.println("已找到,如果合适就开始");
    }

    private void before() {
        System.out.println("我是婚介,帮你物色对象");
    }
}

测试调用

package com.study;

public class DemoTest {
    public static void main(String[] args) {
        //Person person = (Person) new JdkMeipo().getInstance(new Customer());
        Person person = (Person) new CGlibMeipo().getInstance(Customer.class);
        person.findLove();
    }
}

执行结果:(CGLib代理的对象是不需要实现任何接口的,他是通过动态继承目标对象实现的动态代理。)

CGLib 动态代理执行代理方法效率之所以比 JDK 的高是因为 Cglib 采用了 FastClass 机 制,它的原理简单来说就是:为代理类和被代理类各生成一个 Class,这个 Class 会为代 理类或被代理类的方法分配一个 index(int 类型)。这个 index 当做一个入参,FastClass 就可以直接定位要调用的方法直接进行调用,这样省去了反射调用,所以调用效率比 JDK 动态代理通过反射调用高。

CGLib 和 JDK 动态代理对比

1.JDK 动态代理是实现了被代理对象的接口,CGLib 是继承了被代理对象。

2.JDK 和 CGLib 都是在运行期生成字节码,JDK 是直接写 Class 字节码,CGLib 使用 ASM 框架写 Class 字节码,Cglib 代理实现更复杂,生成代理类比 JDK 效率低。

3.JDK 调用代理方法,是通过反射机制调用,CGLib 是通过 FastClass 机制直接调用方法, CGLib 执行效率更高。