/**
-
@Author : JCccc
-
@CreateTime : 2020/4/21
-
@Description :
**/
public class OrderServiceLogProxy implements OrderService {
private OrderServiceImpl orderService;
public OrderServiceLogProxy(OrderServiceImpl orderService) {
this.orderService = orderService;
}
@Override
public Map executeFoodOrder(String userName, Map<String, Integer> foodMap) {
System.out.println(“+静态代理LogProxy”);
System.out.println(“+下单前我们做点什么.”);
System.out.println(“+正在获取用户：”+userName+“用户信息…”);
System.out.println(“+正在记录用户：”+userName+“选择的菜品：”+foodMap.toString());
System.out.println(“+准备执行主业务”);
Map map = orderService.executeFoodOrder(userName, foodMap);
System.out.println(“+下单后我们做点什么.”);
System.out.println(“+记录用户”+userName+“下单后的详情信息:”+map.toString());
return map;
}
}
简单分析下，我们新创建了一个实现下单点餐接口的类，在这类里面，重写下单方法executeFoodOrder，在调用下单方法时加上一些日志记录等等的代码：
OK，有可能这样写，你还是不能看出所为的代理结构，那么如果说我 写成这样呢？
是不是这样看起来就有感觉了。（该篇文章后面的JDK动态代理、CGLIB动态代理，我就不一一抽出来写成 before和 after了）
调用方式：
public static void main(String[] args) {
//静态代理调用方式
OrderServiceImpl orderService=new OrderServiceImpl();
OrderServiceLogProxy orderServiceLogProxy=new OrderServiceLogProxy(orderService);
String userName=“JCccc”;
Map<String,Integer> orderMap=new HashMap<>();
orderMap.put(“白米饭”,2);
orderMap.put(“红烧肉”,1);
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
-
@return
*/
public T getObjByEnhancer(Class 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;
Docker步步实践
目录文档：
①Docker简介
②基本概念
③安装Docker
④使用镜像：
⑤操作容器：
⑥访问仓库：
⑦数据管理：
⑧使用网络：
⑨高级网络配置：
⑩安全：
⑪底层实现：
⑫其他项目：
micsLogProxy implements InvocationHandler {
Object obj;
//绑定委托对象，并返回代理类
public Object bind(Object obj)
{
this.obj = obj;
Docker步步实践
目录文档：
[外链图片转存中…(img-8k57qyT4-1714302427623)]
[外链图片转存中…(img-cWUrFNeM-1714302427623)]
①Docker简介
②基本概念
③安装Docker
[外链图片转存中…(img-BH6q4oj4-1714302427624)]
④使用镜像：
[外链图片转存中…(img-OgOL0uom-1714302427624)]
⑤操作容器：
[外链图片转存中…(img-NsJNpqTP-1714302427624)]
⑥访问仓库：
[外链图片转存中…(img-LBOM0Q54-1714302427625)]
⑦数据管理：
[外链图片转存中…(img-OZafeP9p-1714302427625)]
⑧使用网络：
[外链图片转存中…(img-owSmvEoE-1714302427625)]
⑨高级网络配置：
[外链图片转存中…(img-FMqWdhlT-1714302427626)]
⑩安全：
[外链图片转存中…(img-rtTUVS3H-1714302427626)]
⑪底层实现：
[外链图片转存中…(img-jN7uj1Bo-1714302427626)]
⑫其他项目：
[外链图片转存中…(img-q1udJJDX-1714302427627)]
2486
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
