设计模式【二】代理模式

1. 静态代理

/**
 * @authod: pp_lan on 2020/3/20.
 */
public class StaticProxy {
    interface Car {
        void drive();
    }

    static class Benz implements Car {
        @Override
        public void drive() {
            System.out.println("benz driving");
        }
    }

    static class ProxyManager implements Car {

        private Car car;

        public ProxyManager(Car car) {
            this.car = car;
        }

        @Override
        public void drive() {
            System.out.println("【代理】准备工作");
            car.drive();
            System.out.println("【代理】结束工作");
        }
    }

    public static void main(String[] args) {
        ProxyManager proxy = new ProxyManager(new Benz());
        proxy.drive();
    }
}

2. JDK动态代理

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

/**
 * @authod: pp_lan on 2020/3/20.
 * jdk动态代理
 */
public class JdkProxy implements InvocationHandler {
    private Object target;

    public JdkProxy(Object target) {
        this.target = target;
    }

    public Object getProxy() {
        Object proxy = Proxy.newProxyInstance(this.target.getClass().getClassLoader(), this.target.getClass().getInterfaces(), this);
        return proxy;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("【JDK代理】准备开始");
        Object invoke = method.invoke(target, args);
        System.out.println("【JDK代理】执行结束");
        return invoke;
    }

    public static void main(String[] args) {
        Car proxy = (Car)new JdkProxy(new Benz()).getProxy();
        proxy.drive();
    }

    interface Car {
        void drive();
    }

    static class Benz implements Car {
        @Override
        public void drive() {
            System.out.println("Benz driving");
        }
    }
}

3. Cglib动态代理

       <!-- cglib -->
       <dependency>
            <groupId>cglib</groupId>
            <artifactId>cglib</artifactId>
            <version>3.2.4</version>
        </dependency>

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

import java.lang.reflect.Method;

/**
 * @authod: pp_lan on 2020/3/20.
 */
public class CglibProxy<T> {

    private Enhancer enhancer;

    public CglibProxy(Class<T> clazz) {
        this.enhancer = new Enhancer();
        this.enhancer.setSuperclass(clazz);
        this.enhancer.setCallback(new MethodInterceptor() {
            @Override
            public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
                System.out.println("【cglib代理】开始");
                Object t = methodProxy.invokeSuper(o, objects);
                System.out.println("【cglib代理】结束");
                return t;
            }
        });
    }

    public T getProxy () {
        return (T)this.enhancer.create();
    }

    public static void main(String[] args) {
        CglibProxy<Benz> cglib = new CglibProxy<>(Benz.class);
        Benz proxy = cglib.getProxy();
        proxy.drive();
    }


    static class Benz{
        public void drive() {
            System.out.println("Benz driving");
        }
    }
}

4. 优缺点

1. 静态代理：维护麻烦，每个代理都需要单独设置；

2. JDK代理：代理方法需要有接口，并且由于使用反射，效率相对较低；

3. CGLIB代理：使用asm生成对象，被代理对象需要有可访问的无参构造方法，效率相对较高。相关报错：

使用CGLIB动态代理错误记录

设计模式【三】原型模式