实现完再回头看看，应该就不会支支吾吾了。

进入正文

[](()一、代理模式

=====================================================================

代理模式分为：

静态代理??

动态代理

先不管什么静还是动的，先知道这个代理模式的使用，是干嘛的。

文字描述：

为其他对象提供一个代理以控制对某个对象的访问。

代理类主要负责为委托了（真实对象）预处理消息、过滤消息、传递消息给委托类，代理类不现实具体服务，而是利用委托类来完成服务，并将执行结果封装处理。

听我说：

其实就是 在你调用 某个业务方法时, 在调用前 和调用后，加点东西。

加的这些东西 随时改动，也不会影响到业务方法代码的改动。 这样就很 解耦 ，就很喜欢。

就像， 调用某个业务方法前， 我加个 日志记录（记录一下调用的方法、参数、IP 来源等等）；

又比如说，调用某个业务方法前，我加个 权限拦截 （看看能不能给调用,判断一下 token、身份、角色、ip 等等）

从代理模式的实现效果来说，就是做到了 2 点：

1、可以对 业务代码（需要被代理的类）? 进行? 增强（附属一些逻辑代码）

2、实现代理之后 ，主业务方法不用动， 需要新增的，修改调整的一些业务，可以都丢到代理方法里面去做，这样一定程度实现了代码防入侵。

[](()二、实例讲解

=====================================================================

该篇文章使用到的实例是一个 我自己临时模拟的场景：

业务-? 点餐下单

然后 运用上代理模式，实现添加一些 点餐下单 前前后后的? 代码，记录日志、权限判断等等。

[](()1.静态代理

1.1 就像往常一样，我们先写个接口 OrderService：

import java.util.Map;

/**

• @Author : JCccc

• @CreateTime : 2020/4/16

• @Description :

**/

public interface OrderService {

//下单点餐

Map executeFoodOrder(String userName,Map<String, Integer> foodMap);

}

1.2 就像往常一样，接口 OrderService 的实现类 OrderServiceImpl：

[](()

import org.springframework.stereotype.Service;

import java.util.Ha 《一线大厂 Java 面试题解析+后端开发学习笔记+最新架构讲解视频+实战项目源码讲义》开源 shMap;

import java.util.Map;

/**

• @Author : JCccc

• @CreateTime : 2020/4/16

• @Description :

**/

@Service

public class OrderServiceImpl implements OrderService {

@Override

public Map executeFoodOrder(String userName,Map<String, Integer> foodMap) {

System.out.println("【下单主业务】");

Map resultMap=new HashMap();

for (Map.Entry<String, Integer> m : foodMap.entrySet()) {

String foodName=m.getKey();

Integer foodCount= m.getValue();

//模拟一些杂七杂八的业务

System.out.println("【下单主业务】"+foodName+"---模拟这个菜的一些杂七杂八的业务");

resultMap.put(foodName,"ok");

}

return resultMap;

}

}

1.3 现在我们有个业务需求，就是记录客户点餐信息，根据传入的用户名，去数据库查出来，然后跟点的菜啥的简单做个日志记录。

那么静态代理的方式是这样实现（这里介绍的是通过实现业务接口方式，而其实还可以简单通过继承来实现）：

静态代理类? ?OrderServiceLogProxy.java ：

import com.ilas.testboot.proxy.OrderService;

import java.util.Map;

/**

• @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 的动态代理使用感觉：

挺好，我们只需要编写一个日志代理类之后；

想这个日志代理类与哪个 Java 开源项目【ali1024.coding.net/public/P7/Java/git】 需要被代理的类绑定， 我们就动态传入；

想要在被代理的类哪个方法前后 去嵌入 一些东西， 我们就动态调用方法；

很灵活，不像静态代理那样死死的。

但是，显然我们在使用 JDK 动态代理的时候，我们发现了，Proxy 在帮我们动态即时创建 代理类的时候，要求我们传入

Class<?>[] interfaces??

那就是意味着，我们的需要被代理的类，必须实现接口：

最后

看完美团、字节、腾讯这三家的面试问题，是不是感觉问的特别多，可能咱们又得开启面试造火箭、工作拧螺丝的模式去准备下一次的面试了。

开篇有提及我可是足足背下了 1000 道题目，多少还是有点用的呢，我看了下，上面这些问题大部分都能从我背的题里找到的，所以今天给大家分享一下互联网工程师必备的面试 1000 题。

注意不论是我说的互联网面试 1000 题，还是后面提及的算法与数据结构、设计模式以及更多的 Java 学习笔记等，皆可分享给各位朋友

互联网工程师必备的面试 1000 题

而且从上面三家来看，算法与数据结构是必备不可少的呀，因此我建议大家可以去刷刷这本左程云大佬著作的《程序员代码面试指南 IT 名企算法与数据结构题目最优解》，里面近 200 道真实出现过的经典代码面试题。