java设计模式之代理模式

         一句话概括：在不改变原有对象的条件下，增强原有对象的功能。

      静态代理

                显方式声明代理类的方式称之为静态代理。直接上Demo。

package com.lvyuanji.staticproxy;

/**
 * 接口
 */
public interface Irun {
    void drive();
}

                

package com.lvyuanji.staticproxy;

public class Driver implements Irun {
    @Override
    public void drive() {
        System.out.println("我开始开车了，嘟嘟嘟！");
    }
}

                

package com.lvyuanji.staticproxy;

public class DrivaerProxy implements Irun {

    private Irun runner;

    public DrivaerProxy(Irun runner) {
        this.runner = runner;
    }

    @Override
    public void drive() {
        System.out.println("我先去考个驾照");
        runner.drive();
    }

    public static void main(String[] args) {
        Irun driverProxy = new DrivaerProxy(new Driver());
        driverProxy.drive();
    }
}

 静态代理必须显示的声明代理类，即此处的DriverProxy。这样我们每次需要代理一个东西都需要创建一个代理类。很不方便，而且会导致类爆炸，那么我们再来看看动态代理是怎么玩的吧。

JDK动态代理

          JDK反射包提供了代理类Proxy方便我们动态的在代码中创建代理类。使用如下

package com.lvyuanji.staticproxy;

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

public class Test {

    public static void main(String[] args) {
        //目标对象
        Driver driver = new Driver();
        Class<? extends Driver> driverClass = driver.getClass();
        //通过jdk动态代理生成的对象
        Irun runProxy = (Irun) Proxy.newProxyInstance(driverClass.getClassLoader(), driverClass.getInterfaces(), new InvocationHandler() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                //增强的代码
                System.out.println("我先去考个驾照");
                return method.invoke(driver,args);
            }
        });
        runProxy.drive();
    }
}

 可能有同学会说，搞那么大一圈，跟我直接在调用代码前面调用增强逻辑有什么区别？

  其实这可是有根本的不通啦，此处是实实在在的在内存中创建了一个类，请看调试代码

 此处driver对象的类为Driver runProxy对应的类为$Proxy0

CGLIB动态代理

        如果一个类没有继承任何接口是否我们就不能动态代理了呢？答案是否定的，JDK动态代理无确实无能为力，但是CGLIB动态代理却是可以实现的，直接看demo

首先项目中引入CGLIB的依赖包

 <dependency>
            <groupId>cglib</groupId>
            <artifactId>cglib</artifactId>
            <version>3.3.0</version>
</dependency>

我们再创建一个没有继承接口的类

package com.lvyuanji.cglibproxy;

public class ZhangSan {

    public void drive(){
        System.out.println("我开始开车啦！");
    }
}

package com.lvyuanji.cglibproxy;

import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;

import java.lang.reflect.Method;

public class Test {
    public static void main(String[] args) {
        //CGLIB提供的增强
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(ZhangSan.class);
        enhancer.setCallback(new MethodInterceptor() {
            @Override
            public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
                System.out.println("我先去考个驾照");
                return methodProxy.invokeSuper(o,objects);
            }
        });
        ZhangSan zhangSan = (ZhangSan) enhancer.create();
        zhangSan.drive();

    }
}

 这样我们就实现了给一个没有实现接口的类创建代理类，我们debug一下，看一下生成的代理对象的类是什么。

        

 好吧，此处可能看不出来，我们可以用工具将对象的class信息反写进一个class文件，然后再反编译这个class文件，最终就可以看到这个生成的代理类是目标类的子类。