java 之 代理模式

1.什么是代理模式

就是给某一个对象提供一个代理对象，并由代理对象控制对原对象的引用。
就相当于我们生活中租房不是找 房东(原对象) 而是去找 中介(代理对象)

2.为什么使用代理模式

它可以在不修改别代理对象代码的基础上，通过扩展代理类，进行一些功能的附加与增强（例如Spring AOP中编写切面日志的时候）

3.代理模式应用场景

SpringAop、日志收集、权限控制、过滤器、RPC远程调用

4.代理模式创建的方式

静态代理

可以通过基于实现接口和继承的方式创建，
需要为每个被代理类创建代理类 (一般不用)

动态代理------------------------
JDK动态代理

创建JdkTestInterface 接口

public interface JdkTestInterface {
    void  add();
}

创建Test 实现类(被代理类) 实现JdkTestInterface 接口

public class JdkTest implements JdkTestInterface {
    @Override
    public void add() {
        System.out.println("目标方法");
    }
}

创建生成代理类的工厂(我这里把它叫做代理工厂) 要实现 InvocationHandler接口

public class JdkProxy implements InvocationHandler {
    /**
     * 目标代理对象
     */
    public Object target;

    public JdkProxy(Object target) {
        this.target = target;
    }
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println(">>>前置通知>>>>");
        // 执行被代理对象方法
        Object reuslt = method.invoke(target, args);
        System.out.println(">>>后置通知>>>>");
        return reuslt;
    }

    //获取代理类 代理类底层默认实现了被代理类的接口  所以用被代理类的接口接受 而 不能用被代理类接受
    public <T> T getProxy() {
        //调用Proxy的静态方法，创建代理类并生成相应的代理对象；
        return (T) Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), this);
    }
}

main方法运行

    public static void main(String[] args) {
        //new 一个代理工厂  把被代理对象传进去
        JdkProxy jdkInvocationHandler = new JdkProxy(new JdkTest());
        //获取代理对象
        JdkTestInterface proxy = jdkInvocationHandler.getProxy();
        //执行扩展后的方法
        proxy.add();
    }

执行结果如下：

>>>前置通知>>>>
目标方法
>>>后置通知>>>>

jdk动态代理的原理
它底层会用Java代码帮我们
动态的生成Java代理类文件(反射和io流)-----> 然后编译----->然后加载到我们的内存中

以下是jdk代理在运行时生成的代理类（部分源码 由于太长不易展示）

//这里它继承了Proxy 并且实现了 被代理类所实现的接口 
public final class $Proxy0 extends Proxy implements JdkTestInterface {
    private static Method m1;
    private static Method m2;
    private static Method m3;
    private static Method m0;

    //这里通过构造方法把 代理工厂对象 传进来 (该属性在父类)
    public $Proxy0(InvocationHandler var1) throws  {
        super(var1);
    }

	//
    public final void add() throws  {
        try {
        //这里 super.h表示我们的代理工厂对象 然后调用增强后的方法
            super.h.invoke(this, m3, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }
}

cjlib动态代理
创建被代理类 CglibTest

public class CglibTest {
    public void add() {
        System.out.println("目标方法");
    }
}

创建生成代理类的工厂(我这里把它叫做代理工厂) 要实现 MethodInterceptor接口

public class CglibProxy implements MethodInterceptor {
    @Override
    public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
        System.out.println("====前置增强====");
        Object reuslt = proxy.invokeSuper(obj, args);
        System.out.println("====后置增强====");
        return reuslt;
    }
}

main方法执行

public static void main(String[] args) {
        System.setProperty(DebuggingClassWriter.DEBUG_LOCATION_PROPERTY, "D:\\code");
        CglibProxy cglibMethodInterceptor = new CglibProxy();
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(CglibTest.class);
        enhancer.setCallback(cglibMethodInterceptor);
        CglibTest orderServiceImpl = (CglibTest) enhancer.create();
        orderServiceImpl.add();
    }

执行结果

====前置增强====
目标方法
====后置增强====

cglib原理：
运行时动态的生成一个被代理类的子类（通过ASM字节码处理框架实现），子类重写了被代理类中所有非final的方法。在子类中采用方法拦截的技术拦截所有父类方法的调用，顺势植入横切逻辑。

总结

JDK动态代理与CGLIB实现区别

JDK动态代理底层实现:
JDK的动态代4理通过，拼接java源代码，编译为class文件，.读取去class文件到内存中，在通过反射执行目标方法，生成的代理类实现了被代理类的接口，所有要想使用jdk动态代理必须要实现接口

CGLIB动态代理底层实现:
运行时动态的生成一个被代理类的子类（通过ASM字节码处理框架实现），子类重写了被代理类中所有非final的方法，在子类中采用方法拦截的技术拦截所有父类方法的调用，不需要被代理类对象实现接口，从而CGLIB动态代理效率比Jdk动态代理反射技术效率要高。