三种动态代理使用梳理

待增强类：

/**
 *
 */
public interface OrderService {

    public int save(Object object);

    public void update(Object objetc);
}

实现类：

import com.lai.interview.proxy.OrderService;

public class OrderServiceImpl implements OrderService {
    @Override
    public int save(Object object) {
        System.out.println("工单保存");
        return 0;
    }

    @Override
    public void update(Object objetc) {
        System.out.println("工单更新");

    }
}

使用静态代理实现增强：

import com.lai.interview.proxy.OrderService;
import com.lai.interview.proxy.OrderServiceImpl;

/**
 * 静态代理：代理模式是一种设计模式，简单说即是在不改变源码的情况下，实现对目标对象的功能扩展。
 * 缺点是代理对象必须提前写出，如果接口层发生了变化，代理对象的代码也要进行维护。
 *
 * 在不改动orderServiceImpl的源码情况下实现对原有功能的增强
 */
public class StaticProxy implements OrderService {
    private OrderService target;

    public StaticProxy(OrderService target) {
        this.target = target;
    }

    @Override
    public int save(Object object) {
        //TODO 前置增强
        System.out.println("静态代理前置增强");
        target.save(new Object());
        //TODO 后置增强
        System.out.println("静态代理后置增强");
        return 0;
    }

    @Override
    public void update(Object objetc) {
        target.update(new Object());
    }

    //测试
    public static void main(String[] args) {
        //实例化要增强的对象
        OrderServiceImpl target = new OrderServiceImpl();

        //不使用代理前
        target.save(new Object());
        System.out.println("==============================");
        //使用代理
        //实例化代理对象，传入待增强对象
        StaticProxy staticProxy = new StaticProxy(target);
        //调用代理增强方法
        staticProxy.save(new Object());
    }
}

使用JDK动态代理：

import com.lai.interview.proxy.OrderService;
import com.lai.interview.proxy.OrderServiceImpl;

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

/**
 * 动态代理: JDK动态代理
 * 主要方法：Proxy.newProxyInstance(ClassLoader loader, Class<?>[] interfaces,InvocationHandler h )
 * 适用于有接口实现的类，如果无接口的类适用cglib 动态代理
 */
public class JdkDynamicProxy {

    public static void main(String[] args) {
        //实例化待增强对象
        OrderServiceImpl target = new OrderServiceImpl();
        //使用jdk动态代理增强
        OrderService proxy = (OrderService)Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(),
                new InvocationHandler() {
                   //调用任何对象的方法都会被增强，如果想要分别对某个方法增强，加上方法判断
                    @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动态代理后置增强");
                        if("save".equals(method.getName())){
                            System.out.println("jdk动态代理  对save方法前置增强");
                            Object invoke = method.invoke(target, args);
                            System.out.println("jdk动态代理 对save方法后置增强");
                            return invoke;
                        }if("update".equals(method.getName())){
                            System.out.println("jdk动态代理  对update方法前置增强");
                            Object invoke = method.invoke(target, args);
                            System.out.println("jdk动态代理  对update方法后置增强");
                            return invoke;
                        }
                        return null;
                    }
                });
        //执行代理对象方法实现增强
        //proxy.save(new Object());
        proxy.update(new Object());
    }
}

Cblib动态代理适用于无实现接口的类进行增强：
待增强类：

public class OrderBusiness {
    public int save(Object object){
        System.out.println("工单保存");
        return 0;
    }

    public void update(){
        System.out.println("工单更新");
    }
}

cglib动态代理增强：

import com.lai.interview.proxy.OrderBusiness;
import org.springframework.cglib.proxy.Enhancer;
import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;

import java.lang.reflect.Method;

/**
 * cglib 动态代理
 */
public class CglibDynamicProxy {
    //待增强类
    private OrderBusiness orderBusiness;

    public CglibDynamicProxy(OrderBusiness orderBusiness) {
        this.orderBusiness = orderBusiness;
    }

    public OrderBusiness createProxy(){
        //创建cglib核心类
        Enhancer enhancer = new Enhancer();
        //设置父类
        enhancer.setSuperclass(orderBusiness.getClass());
        //设置回调函数
        enhancer.setCallback(new MethodInterceptor() {
            @Override
            public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {

                if("save".equals(method.getName())){
                    //前置增强
                    System.out.println("前置增强 save 方法");
                    Object invoke = methodProxy.invokeSuper(o, objects);
                    //后置增强
                    System.out.println("后置增强 save方法");
                    return invoke;
                }if("update".equals(method.getName())){
                    //前置增强
                    System.out.println("前置增强 update方法");
                    Object invoke = methodProxy.invokeSuper(o, objects);
                    //后置增强
                    System.out.println("后置增强 update方法");
                    return invoke;
                }

                return methodProxy.invoke(o,objects);
            }
        });
        return  (OrderBusiness)enhancer.create();
    }

    //测试
    public static void main(String[] args) {
        //实例化待增强类
        OrderBusiness target = new OrderBusiness();
        //实例化代理类
        CglibDynamicProxy cglibDynamicProxy = new CglibDynamicProxy(target);
        OrderBusiness proxy = cglibDynamicProxy.createProxy();
        proxy.update();
        proxy.save(new Object());
    }
}