Java 结合实例学会使用 静态代理、JDK 动态代理、CGLIB 动态代理
orderMap.put("水煮鱼",1);
orderMap.put("番茄炒蛋",1);
Map resultMap = orderServiceLogProxy.executeFoodOrder(userName, orderMap);
System.out.println("静态代理方法执行完毕,结果："+resultMap);
}
可以看下控制台的输出情况：
蓝色：静态代理类做的事情 （可以看到在主业务执行的前后）
红色：原本主业务做的事情
静态代理使用感觉：
实现代理的代码都是提前设计好，而且还是一一对应起来，OrderService 的代理是?OrderServiceLogProxy；
而且实现代理的方法也是一一对应。
那么如果 需要记录日志 的不止是 OrderService ，再来一个 UserService 呢？ 再来一个 GameService 呢？
这样一来，需要我们写死的代码就非常非常多。
这就是所谓的 静态 的不好之处，于是乎有了 动态代理（能够根据我们传入的 需要被代理类，实现代理）。
2.动态代理
动态代理有两种：
JDK 动态代理
CGLIB 动态代理
2.1 JDK 动态代理
基于前面创建好的?OrderService 和?OrderServiceImpl ，我们接下来采取 JDK 动态代理的方式去实现我们的日志添加。
（已经有种解耦的意味了吧，我们根本不需要动原本的业务接口和业务实现类，代理模式的作用无形中已经慢慢崭露出来了）
创建咱们的日志动态代理类，DynamicsLogProxy.java ：
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.Arrays;
/**
@Author : JCccc
@CreateTime : 2020/4/21
@Description :
**/
public class DynamicsLogProxy implements InvocationHandler {
Object obj;
//绑定委托对象，并返回代理类
public Object bind(Object obj)
{
this.obj = obj;
//绑定该类实现的所有接口，取得代理类
return Proxy.newProxyInstance(obj.getClass().getClassLoader(),
obj.getClass().getInterfaces(),
this);
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("+静态代理 LogProxy");
System.out.println("+下单前我们做点什么.");
System.out.println("+正在获取目前传入的参数："+Arrays.toString(args));
System.out.println("+正在记录.....");
System.out.println("+准备执行主业务");
Object res = method.invoke(obj, args);
System.out.println("+下单后我们做点什么.");
System.out.println("+可得到业务方法执行后结果"+res.toString());
System.out.println("+记录.......");
return res;
}
}
JDK 动态代理的一些代码剖析：
1. JDK 动态代理类 必须 实现?InvocationHandler 接口：
2.被代理的类 必须 存在 类 和实现的接口 （OrderService? 和? OrderServiceImpl）?
3.需要把 被代理对象传过去，因为动态生成代理类时要使用到：
3.使用 jdk 的 api 中的 java.lang.reflect.Proxy 帮我们即时创建 代理实例对象：
前面两个参数，可以理解为把需要被代理的类相关信息传过去，最后一个参数??InvocationHandler h，
这玩意讲究。
咱们的 DynamicsLogProxy 实现了这玩意，那么 Proxy 帮我们创建出来的一个代理实例对象，自然是不清楚咱们要代理的具体方法。
而 invoke 就是帮我们根据传入的参数：
proxy 表示动态代理类实例，method 表示调用的方法，args 表示调用方法的参数
实现 调用 目标对象（被代理的类）的 目标方法。
简单点理解：
Proxy 会帮我们 动态创建一个代理类，? 这个代理类 代理的谁， 是我们传入的。
而 InvocationHandler 的 invoke 方法，随时待命从代理类中去调用 被代理类的对应方法。
调用方式：
public static void main(String[] args) {
//动态代理调用方式
OrderService dynamicsOrderProxy = (OrderService)new DynamicsLogProxy().bind(new OrderServiceImpl());
String userName="JCccc";
Map<String,Integer> orderMap=new HashMap<>();
orderMap.put("白米饭",2);
orderMap.put("红烧肉",1);
orderMap.put("水煮鱼",1);
orderMap.put("番茄炒蛋",1);
//通过动态代理类去调用不同方法
Map resultMap = dynamicsOrderProxy.executeFoodOrder(userName, orderMap);
System.out.println("动态代理方法执行完毕,结果："+resultMap);
}
可以看下控制台的输出情况：
JDK 的动态代理使用感觉：
挺好，我们只需要编写一个日志代理类之后；
想这个日志代理类与哪个 需要被代理的类绑定， 我们就动态传入；
想要在被代理的类哪个方法前后 去嵌入 一些东西， 我们就动态调用方法；
很灵活，不像静态代理那样死死的。
但是，显然我们在使用 JDK 动态代理的时候，我们发现了，Proxy 在帮我们动态即时创建 代理类的时候，要求我们传入
Class<?>[] interfaces??
那就是意味着，我们的需要被代理的类，必须实现接口：
因为 JDK 动态代理其实也是悄咪咪帮我们创建一份代理类代码，也帮我们实现同样的接口。
也就是说， 如果你的 被代理类， 没有实现接口，那么就没办法使用 JDK 动态代理。
那怎么办？? CGLIB 动态代理出来了，它说 我不关心你是否实现接口，只需要告诉我 哪个类需要被代理。
2.2 CGLIB 动态代理
上面咱们已经说了，CGLIB 动态代理只关心 哪个类需要被代理。
因为这个家伙其实是悄咪咪地帮我们 针对需要被代理的类 创建一个 代理子类。根据调用的方法，拦截调用到父类的方法。
看 CGLIB 动态代理实现，CglibLogProxy.java：
import org.springframework.cglib.proxy.Enhancer;
import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;
import java.lang.reflect.Method;
/**
@Author : JCccc
@CreateTime : 2020/4/21
@Description :
**/
public class CglibLogProxy implements MethodInterceptor {
/**
自定义方法：利用 Enhancer 类生成代理类
@param clazz
@param <T>
@return
*/
public <T> T getObjByEnhancer(Class<T> clazz) {
Enhancer enhancer = new Enhancer();
enhancer.setSuperclass(clazz);
enhancer.setCallback(this);
T res = (T) enhancer.create();
return res;
}
@Override
public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
System.out.println(" +CGLIB 日志代理 CglibLogProxy");
System.out.println("+CGLIB 日志代理获取到执行的方法名" + method.getName());
System.out.println("+做一些日志记录......");
System.out.println("+做一些日志记录...");
Object res = methodProxy.invokeSuper(o, objects);
System.out.println("+主业务方法执行后我们做点什么.");
System.out.println("+可得到业务方法执行后结果"+res.toString());
System.out.println("+记录.......");
return res;
}
}
实现代码简单剖析：
1.?implements MethodInterceptor? ? cglib 动态代理类实现了这个方法拦截
2.?intercept 方法，这个也就是 提供地方给咱们 添加 日志记录、权限判断等等的地方
3.?Enhancer
Enhancer? 这个玩意是 CGLIB 动态代理类的核心。
它的职责是，创建出一个子类（代理类）， 然后将我们传入的 被代理类? 设置成?SuperClass 父类?。
这个子类（代理类） ’继承‘ 了父类（ 被代理类）的 所有 可以公开的方法 ，然后设置拦截回调的类（父类），子类中拦截父类方法并织入方法增强逻辑。
ps：cglib 动态代理不能代理声明为 final 类型的类和方法? ?
事不宜迟，我们贴出 CGLIB 动态代理调用方式：
public static void main(String[] args) {
CglibLogProxy cglibLogProxy=new CglibLogProxy();
OrderServiceImpl orderProxy= cglibLogProxy.getObjByEnhancer(OrderServiceImpl.class);
String userName="JCccc";
Map<String,Integer> orderMap=new HashMap();
orderMap.put("白米饭",2);
orderMap.put("红烧肉",1);
orderMap.put("水煮鱼",1);
orderMap.put("番茄炒蛋",1);
Map map = orderProxy.executeFoodOrder(userName, orderMap);
System.out.println(map.toString());
}
注意看， 调用方法的时候，用的是什么？
orderProxy.executeFoodOrder(userName, orderMap);
没错，跟 JDK 动态代理看似一样直接调用 我们执行的业务方法，
但是接下来就不一样了，再看看 cglib 动态代理类的实现代码：
没错，orderProxy 是我们通过 Enhancer 去生成的，特意设置了回调拦截方法。从拦截的这个意思去看，就更有 AOP 的意味，更有代理的感觉了。
调用父类方法（被代理类）前，拦住， 先调用咱们自己写的 拦截方法， 啥时候完事了，再通过?methodProxy.invokeSuper 切回到主业务方法去。
可以看到控制台输出：
简单的介绍就到这里吧。
=================================================================
静态代理 和 动态代理? 对比 ：
静态代理是 一开始咱们编码的时候，已经写死了，哪个代理类对应哪个被代理类。
而动态代理都是 运行时动态即时创建的。
疑问：
那么是不是静态代理就肯定不如动态代理？
那肯定不能这么说，人家静态代理一开始就码好了，运行调用的时候，肯定就快啊。
而动态代理时运行时才去开始，所以自然也会慢。
JDK 动态代理 和 CGLIB 动态代理：
JDK 动态代理，代理的类 必须实现接口，没有实现接口的类 无法使用 JDK 动态代理。
CGLIB 动态代理，代理的类必须能被子类继承使用（方法也得能被重写），所以不能代理声明为 final 类型的类和方法。
多级代理实现方式：
=============
补充：
如果我们想实现， 在调用下单点餐这个方法时，? 不单是 进行日志记录 ，我们还想进行 一个营业判断或者说权限判断。
（JDK 动态代理-多层级代理）
这时就会引出一个， 多级代理的概念。
也就是说，
对应的动态代理切点不止一个：
我们需要的流程是， 当通过代理方式去调用主业务方法?executeFoodOrder ，先给我进行 日志记录， 再给我进行 营业时间判断（可以类比成一些权限判断、角色判断、身份判断等等），时间判断符合在营业时间时，最后再给我去调用主业务方法?executeFoodOrder 。
实现代码，两个动态代理类?
DynamicsLogProxy.java:
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.Arrays;
/**
@Author : JCccc
@CreateTime : 2020/4/21
@Description :
**/
public class DynamicsLogProxy implements InvocationHandler {
Object obj;
//绑定委托对象，并返回代理类
public Object bind(Object obj)
{
this.obj = obj;
//绑定该类实现的所有接口，取得代理类
return Proxy.newProxyInstance(obj.getClass().getClassLoader(), obj.getClass().getInterfaces(), this);
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("+JDK 动态代理 LogProxy");
System.out.println("+下单前我们做点什么.");
System.out.println("+正在获取目前传入的参数："+Arrays.toString(args));
System.out.println("+正在记录.....");
System.out.println("+准备执行主业务");
Object res = method.invoke(obj, args);
System.out.println("+JDK 动态代理 LogProxy 下单后我们做点什么.");
System.out.println("+可得到业务方法执行后结果"+res.toString());
System.out.println("+记录.......");
return res;
}
}
DynamicsOperateProxy.java:
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
/**
@Author : JCccc
@CreateTime : 2020/4/21
@Description :
**/
public class DynamicsOperateProxy implements InvocationHandler {
Object obj;
//绑定委托对象，并返回代理类
public Object bind(Object obj)
{
this.obj = obj;
//绑定该类实现的所有接口，取得代理类
return Proxy.newProxyInstance(obj.getClass().getClassLoader(),
obj.getClass().getInterfaces(),
this);
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("-----JDK 动态代理 OperateProxy 执行主方法前-----");
Object res =null;
if (method.getName().equals("executeFoodOrder")){
System.out.println("-----检测当前时需要下单点餐......");
System.out.println("-----执行相关判断......");
System.out.println("-----查看该店是否营业......");
System.out.println("-----检测 XXXXX......");
System.out.println("-----可以调用主业务");
// 如果不符合要求, 不执行 method.invoke(obj, args);
//做拦截处理即可,抛出异常或者重定向等等
res= method.invoke(obj, args);
System.out.println("-----JDK 动态代理 OperateProxy 执行主方法后----");
}
return res;
}
}
注意此时 ，多级代理的 调用方式：
public static void main(String[] args) {
OrderService operateProxy= (OrderService) new DynamicsOperateProxy().bind(new OrderServiceImpl());
OrderService operateAndLogProxy = (OrderService)new DynamicsLogProxy().bind(operateProxy);
Map<String,Integer> orderMap=new HashMap();
orderMap.put("白米饭",2);
orderMap.put("红烧肉",1);
orderMap.put("水煮鱼",1);
orderMap.put("番茄炒蛋",1);
Map result = operateAndLogProxy.executeFoodOrder("JCccc",orderMap);
System.out.println(result.toString());
}
细看：
我们先是让 需要被代理的类 绑定到??DynamicsOperateProxy 上，
然后绑定完创建出来的类，我们继续 绑定到?DynamicsLogProxy 上，然后创建我们最后的多级动态代理类。
看控制台输出：
注意到此时的调用执行顺序，
第一步，进入到了 log 动态代理，执行 调用主业务方法 前 的 代码；
第二步，即将切回到主业务方法时，发现还有一级代理，operate 动态代理，那么进入?operate 动态代理 ，执行相关的?执行 调用主业务方法 前 的 代码；
第三步，切入主业务方法，拿到主业务方法的返回结果，回到?operate 动态代理，执行 主业务方法调用后的 代码；
评论