Java最全国庆前阿里二面被Spring AOP三连问给问的一脸懵逼！，大厂架构师经验分享

总结

总的来说，面试是有套路的，一面基础，二面架构，三面个人。

最后，小编这里收集整理了一些资料，其中包括面试题（含答案）、书籍、视频等。希望也能帮助想进大厂的朋友

本文已被CODING开源项目：【一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码】收录

需要这份系统化的资料的朋友，可以点击这里获取

2. CGLIB动态代理

动态代理的特点

===========

1. 目标对象不固定

2. 在应用程序执行时动态创建目标对象

3. 代理对象会增强目标对象的行为

JDK动态代理

===========

注：JDK动态代理的目标对象必须有接口实现

newProxyInstance

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

Proxy 类：

Proxy类是专门完成代理的操作类，可以通过此类为一个或多个接口动态地生成实现类，此类提供了如下操作方法：

/*

返回⼀个指定接⼝的代理类的实例⽅法调⽤分派到指定的调⽤处理程序。 (返回代理对象)

loader：⼀个ClassLoader对象，定义了由哪个ClassLoader对象来对⽣成的代理对象进⾏加载

interfaces：⼀个Interface对象的数组，表示的是我将要给我需要代理的对象提供⼀组什么接⼝，如果

我提供了⼀组接⼝给它，那么这个代理对象就宣称实现了该接⼝(多态)，这样我就能调⽤这组接⼝中的⽅法了

h：⼀个InvocationHandler接⼝，表示代理实例的调⽤处理程序实现的接⼝。每个代理实例都具有⼀个关联

的调⽤处理程序。对代理实例调⽤⽅法时，将对⽅法调⽤进⾏编码并将其指派到它的调⽤处理程序的 invoke ⽅法

（传⼊InvocationHandler接⼝的⼦类）

*/

public static Object newProxyInstance(ClassLoader loader,

Class<?>[] interfaces,

InvocationHandler h)

获取代理对象

==========

public class JdkHandler implements InvocationHandler {

// ⽬标对象

private Object target; // ⽬标对象的类型不固定，创建时动态⽣成

// 通过构造器将⽬标对象赋值

public JdkHandler(Object target) {

this.target = target;

}

/**

* 1、调⽤⽬标对象的⽅法（返回Object）

* 2、增强⽬标对象的⾏为

* @param proxy 调⽤该⽅法的代理实例

* @param method ⽬标对象的⽅法

* @param args ⽬标对象的⽅法形参

* @return

* @throws Throwable

*/

@Override

public Object invoke(Object proxy, Method method, Object[] args) throws Throwable

{

// 增强⾏为

System.out.println(“==============⽅法前执⾏”);

// 调⽤⽬标对象的⽅法（返回Object）

Object result = method.invoke(target,args);

// 增强⾏为

System.out.println(“⽅法后执⾏==============”);

return result;

}

/**

* 得到代理对象

* public static Object newProxyInstance(ClassLoader loader,

* Class<?>[] interfaces,

* InvocationHandler h)

* loader：类加载器

* interfaces：接⼝数组

* h：InvocationHandler接⼝ (传⼊InvocationHandler接⼝的实现类)

*

*

* @return

*/

public Object getProxy() {

return

Proxy.newProxyInstance(this.getClass().getClassLoader(),target.getClass().getInterface

s(),this);

}

}

通过代理对象实现目标对象的功能

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

// ⽬标对象

You you = new You();

// 获取代理对象

JdkHandler jdkHandler = new JdkHandler(you);

Marry marry = (Marry) jdkHandler.getProxy();

// 通过代理对象调⽤⽬标对象中的⽅法

marry.toMarry();

答：在生成的动态代理类 $Proxy0.class中，构造方法调用了父类Proxy.class的构造方法，给成员变量invocationHandler赋值，$Proxy0.class的 static 模块中创建了被代理类的方法，调用相应方法时方法体中调用了父类中的成员变量 InvocationHandler 的 invoke ()方法。

注：JDK 的动态代理依靠接口实现，如果有些类并没有接口实现，则不能使用 JDK 代理。

CGLIB 动态代理

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

JDK 的动态代理机制只能代理实现了接口的类，而不能实现接口的类就不能使用 JDK 的动态代理，cglib 是针对类来实现代理的，它的原理是对指定的目标类生成一个子类，并覆盖其中方法实现增强，但因为采用的是继承，所以不能对 final 修饰的类进行代理。

添加依赖

========

在 pom.xml 文件中引入 cglib 的相关依赖

cglib

cglib

2.2.2

定义类

=======

实现 MethodInterceptor 接口

public class CglibInterceptor implements MethodInterceptor {

// ⽬标对象

private Object target;

// 通过构造器传⼊⽬标对象

public CglibInterceptor(Object target) {

this.target = target;

}

/**

* 获取代理对象

* @return

*/

public Object getProxy() {

// 通过Enhancer对象的create()⽅法可以⽣成⼀个类，⽤于⽣成代理对象

Enhancer enhancer = new Enhancer();

// 设置⽗类 (将⽬标类作为其⽗类)

enhancer.setSuperclass(target.getClass());

// 设置拦截器 回调对象为本身对象

enhancer.setCallback(this);

// ⽣成⼀个代理类对象，并返回

return enhancer.create();

}

/**

* 拦截器

* 1、⽬标对象的⽅法调⽤

* 2、增强⾏为

* @param object 由CGLib动态⽣成的代理类实例

* @param method 实体类所调⽤的被代理的⽅法引⽤

* @param objects 参数值列表

* @param methodProxy ⽣成的代理类对⽅法的代理引⽤

* @return

* @throws Throwable

*/

@Override

public Object intercept(Object object, Method method, Object[] objects,

MethodProxy methodProxy) throws Throwable {

// 增强⾏为

System.out.println(“==============⽅法前执⾏”);

// 调⽤⽬标对象的⽅法（返回Object）

Object result = methodProxy.invoke(target,objects);

// 增强⾏为

System.out.println(“⽅法后执⾏==============”);

return result;

}

}

调用方法

========

// ⽬标对象

You you = new You();

CglibInterceptor cglibInterceptor = new CglibInterceptor(you);

Marry marry = (Marry) cglibInterceptor.getProxy();

marry.toMarry();

User user = new User();

CglibInterceptor cglibInterceptor = new CglibInterceptor(user);

User u = (User) cglibInterceptor.getProxy();

u.test();

JDK代理与CGLIB代理的区别

• JDK 动态代理实现接口，Cglib 动态代理继承思想

• JDK 动态代理（目标对象存在接口时）执行效率高于 Ciglib

• 如果目标对象有接口实现，选择 JDK 代理，如果没有接口实现选择 Cglib 代理

Spring AOP

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

日志处理带来的问题

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

我们有一个 Pay (接口) 然后两个实现类 DollarPay 和 RmbPay，都需要重写 pay ()方法, 这时我们需要对 pay 方法进行性能监控，日志的添加等等怎么做？

最容易想到的方法

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

对每个字符方法均做日志代码的编写处理，如下面方式

缺点: 代码重复太多, 添加的日志代码耦合度太高（如果需要更改日志记录代码功能需求，类中方法需要全部改动，工程量浩大）

使用装饰器模式 /代理模式改进解决方案

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

装饰器模式：动态地给一个对象添加一些额外的职责。

代理模式：以上刚讲过。于是得出以下结构：

仔细考虑过后发现虽然对原有内部代码没有进行改动， 对于每个类做日志处理，并引用目标类，但是如果待添加日志的业务类的数量很多，此时手动为每个业务类实现一个装饰器或创建对应的代理类，同时代码的耦合度也加大，需求一旦改变，改动的工程量也是可想而知的。

有没有更好的解决方案，只要写一次代码，对想要添加日志记录的地方能够实现代码的复用，达到松耦合的同时，又能够完美完成功能？

答案是肯定的，存在这样的技术，aop 已经对其提供了完美的实现！

什么是AOP？

===========

Aspect Oriented Programing 面向切面编程，相比较 oop 面向对象编程来说，Aop 关注的不再是程序代码中某个类，某些方法，而 aop 考虑的更多的是一种面到面的切入，即层与层之间的一种切入，所以称之为切面。联想大家吃的汉堡（中间夹肉）。那么 aop 是怎么做到拦截整个面的功能呢？考虑前面学到的 servlet filter /* 的配置 ，实际上也是 aop 的实现。

AOP能做什么？

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

AOP 主要应用于日志记录，性能统计，安全控制，事务处理等方面，实现公共功能性的重复使用。

AOP的特点

==========

1. 降低模块与模块之间的耦合度，提高业务代码的聚合度。（高内聚低耦合）

2. 提高了代码的复用性

3. 提高了代码的复用性

4. 可以在不影响原有的功能基础上添加新的功能

AOP的底层实现

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

动态代理（JDK + CGLIB）

AOP基本概念

===========

被拦截到的每个点，spring 中指被拦截到的每一个方法，spring aop 一个连接点即代表一个方法的执行。

Pointcut（切入点）

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

对连接点进行拦截的定义（匹配规则定义 规定拦截哪些方法，对哪些方法进行处理），spring 有专门的表达式语言定义。

Advice（通知）

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

拦截到每一个连接点即（每一个方法）后所要做的操作

1. 前置通知 （前置增强）— before() 执行方法前通知

2. 返回通知（返回增强）— afterReturn 方法正常结束返回后的通知

3. 异常抛出通知（异常抛出增强）— afetrThrow()

4. 最终通知 — after 无论方法是否发生异常，均会执行该通知。

5. 环绕通知 — around 包围一个连接点（join point）的通知，如方法调用。这是最强大的一种通知类型。 环绕通知可以在方法调用前后完成自定义的行为。它也会选择是否继续执行连接点或直接返回它们自己的返回值或抛出异常来结束执行。

Aspect（切面）

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

切入点与通知的结合，决定了切面的定义，切入点定义了要拦截哪些类的哪些方法，通知则定义了拦截过方法后要做什么，切面则是横切关注点的抽象，与类相似，类是对物体特征的抽象，切面则是横切关注点抽象。

Target（目标对象）

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

被代理的目标对象

Weave（织入）

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

将切面应用到目标对象并生成代理对象的这个过程即为织入

Introduction（引入）

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

在不修改原有应用程序代码的情况下，在程序运行期为类动态添加方法或者字段的过程称为引入

Spring AOP的实现

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

Spring AOP环境搭建

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

坐标依赖引入

==========

org.aspectj

aspectjweaver

1.8.9

添加 spring.xml 的配置

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

添加命名空间

xmlns:aop=“http://www.springframework.org/schema/aop”

http://www.springframework.org/schema/aop

http://www.springframework.org/schema/aop/spring-aop.xsd

注解实现

========

定义切面

========

/**

* 切⾯

* 切⼊点和通知的抽象 （与⾯向对象中的 类 相似）

* 定义 切⼊点和通知 （切⼊点定义了要拦截哪些类的哪些⽅法，通知则定义了拦截过⽅法后要做什么）

*/

@Component // 将对象交给IOC容器去实例化

@Aspect // 声明当前类是⼀个切⾯

public class LogCut {

/**

* 切⼊点：

* 匹配规则。规定什么⽅法被拦截、需要处理什么⽅法

* 定义切⼊点

* @Pointcut(“匹配规则”)

*

* Aop 切⼊点表达式简介

* 1. 执⾏任意公共⽅法：

* execution(public *(…))

* 2. 执⾏任意的set⽅法

* execution(* set*(…))

* 3. 执⾏com.xxxx.service包下任意类的任意⽅法

* execution(* com.xxxx.service.*.*(…))

* 4. 执⾏com.xxxx.service 包 以及⼦包下任意类的任意⽅法

* execution(* com.xxxx.service…*.*(…))

*

* 注：表达式中的第⼀个* 代表的是⽅法的修饰范围

* 可选值：private、protected、public （* 表示所有范围）

*/

@Pointcut(“execution (* com.xxxx.service…*.*(…) )”)

public void cut(){}

/**

* 声明前置通知 并将通知应⽤到定义的切⼊点上

* ⽬标类⽅法执⾏前 执⾏该通知

*

*/

@Before(value = “cut()”)

public void before() {

System.out.println(“前置通知…”);

}

/**

* 声明返回通知 并将通知应⽤到定义的切⼊点上

* ⽬标类⽅法（⽆异常）执⾏后 执⾏该通知

*

*/

@AfterReturning(value = “cut()”)

public void afterReturn() {

System.out.println(“返回通知…”);

}

/**

* 声明最终通知 并将通知应⽤到定义的切⼊点上

* ⽬标类⽅法（⽆异常或有异常）执⾏后 执⾏该通知

*

*/

@After(value = “cut()”)

public void after() {

System.out.println(“最终通知…”);

}

/**

* 声明异常通知 并将通知应⽤到定义的切⼊点上

* ⽬标类⽅法出现异常时 执⾏该通知

*/

@AfterThrowing(value=“cut()”,throwing = “e”)

public void afterThrow(Exception e) {

System.out.println(“异常通知…” + " 异常原因：" + e.getCause());

}

/**

* 声明环绕通知 并将通知应⽤到切⼊点上

* ⽅法执⾏前后 通过环绕通知定义相应处理

* 需要通过显式调⽤对应的⽅法，否则⽆法访问指定⽅法 (pjp.proceed()😉

* @param pjp

* @return

*/

@Around(value = “cut()”)

public Object around(ProceedingJoinPoint pjp) {

System.out.println(“前置通知…”);

Object object = null;

try {

object = pjp.proceed();

System.out.println(pjp.getTarget() + “======” + pjp.getSignature());

// System.out.println(“返回通知…”);

} catch (Throwable throwable) {

throwable.printStackTrace();

System.out.println(“异常通知…”);

}

System.out.println(“最终通知…”);

return object;

}

}

配置文件（spring.xml）

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

总结：绘上一张Kakfa架构思维大纲脑图（xmind）

其实关于Kafka，能问的问题实在是太多了，扒了几天，最终筛选出44问：基础篇17问、进阶篇15问、高级篇12问，个个直戳痛点，不知道如果你不着急看答案，又能答出几个呢？

若是对Kafka的知识还回忆不起来，不妨先看我手绘的知识总结脑图（xmind不能上传，文章里用的是图片版）进行整体架构的梳理

梳理了知识，刷完了面试，如若你还想进一步的深入学习解读kafka以及源码，那么接下来的这份《手写“kafka”》将会是个不错的选择。

• Kafka入门

• 为什么选择Kafka

• Kafka的安装、管理和配置

• Kafka的集群

• 第一个Kafka程序

• Kafka的生产者

• Kafka的消费者

• 深入理解Kafka

• 可靠的数据传递

• Spring和Kafka的整合

• SpringBoot和Kafka的整合

• Kafka实战之削峰填谷

• 数据管道和流式处理(了解即可)

本文已被CODING开源项目：【一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码】收录

需要这份系统化的资料的朋友，可以点击这里获取

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

总结：绘上一张Kakfa架构思维大纲脑图（xmind）

[外链图片转存中…(img-jQsNmZCX-1715341608193)]

其实关于Kafka，能问的问题实在是太多了，扒了几天，最终筛选出44问：基础篇17问、进阶篇15问、高级篇12问，个个直戳痛点，不知道如果你不着急看答案，又能答出几个呢？

若是对Kafka的知识还回忆不起来，不妨先看我手绘的知识总结脑图（xmind不能上传，文章里用的是图片版）进行整体架构的梳理

梳理了知识，刷完了面试，如若你还想进一步的深入学习解读kafka以及源码，那么接下来的这份《手写“kafka”》将会是个不错的选择。

• Kafka入门

• 为什么选择Kafka

• Kafka的安装、管理和配置

• Kafka的集群

• 第一个Kafka程序

• Kafka的生产者

• Kafka的消费者

• 深入理解Kafka

• 可靠的数据传递

• Spring和Kafka的整合

• SpringBoot和Kafka的整合

• Kafka实战之削峰填谷

• 数据管道和流式处理(了解即可)

[外链图片转存中…(img-HZnt8tXS-1715341608193)]

[外链图片转存中…(img-fNINq3zI-1715341608193)]

本文已被CODING开源项目：【一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码】收录

需要这份系统化的资料的朋友，可以点击这里获取