国庆前阿里二面被Spring AOP三连问给问的一脸懵逼！，2024年最新java面试百度网盘

2401_84446787

于 2024-04-19 01:02:08 发布

阅读量318

点赞数 3

分类专栏： 2024年程序员学习文章标签： java spring 面试

本文链接：https://blog.csdn.net/2401_84446787/article/details/137943398

版权

2024年程序员学习专栏收录该内容

19 篇文章 0 订阅

订阅专栏

先自我介绍一下，小编浙江大学毕业，去过华为、字节跳动等大厂，目前阿里P7

深知大多数程序员，想要提升技能，往往是自己摸索成长，但自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年最新Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上Java开发知识点，真正体系化！

由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新

如果你需要这些资料，可以添加V获取：vip1024b （备注Java）

正文

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();

答：在生成的动态代理类 $P ro x y 0. c l a ss 中，构造方法调用了父类 P ro x y . c l a ss 的构造方法，给成员变量 in v oc a t i o n H an d l er 赋值，$ Proxy0.class的 static 模块中创建了被代理类的方法，调用相应方法时方法体中调用了父类中的成员变量 InvocationHandler 的 invoke ()方法。

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

CGLIB 动态代理

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

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

添加依赖

========

在 pom.xml 文件中引入 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的特点

==========

降低模块与模块之间的耦合度，提高业务代码的聚合度。（高内聚低耦合）
提高了代码的复用性
提高了代码的复用性
可以在不影响原有的功能基础上添加新的功能

AOP的底层实现

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

动态代理（JDK + CGLIB）

AOP基本概念

===========

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

Pointcut（切入点）

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

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

Advice（通知）

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

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

前置通知（前置增强）— before() 执行方法前通知
返回通知（返回增强）— afterReturn 方法正常结束返回后的通知
异常抛出通知（异常抛出增强）— afetrThrow()
最终通知 — after 无论方法是否发生异常，均会执行该通知。
环绕通知 — 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）

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

aop:aspectj-autoproxy/

XML实现

=========

定义切面

========

* 切⾯

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

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

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

public class LogCut02 {

public void cut(){}

/**

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

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

public void before() {

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

}

/**

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

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

public void afterReturn() {

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

}

/**

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

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

public void after() {

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

}

/**

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

总结

面试前的“练手”还是很重要的，所以开始面试之前一定要准备好啊，不然也是耽搁面试官和自己的时间。

我自己是刷了不少面试题的，所以在面试过程中才能够做到心中有数，基本上会清楚面试过程中会问到哪些知识点，高频题又有哪些，所以刷题是面试前期准备过程中非常重要的一点。

面试题及解析总结

三年Java开发，刚从美团、京东、阿里面试归来，分享个人面经

大厂面试场景

三年Java开发，刚从美团、京东、阿里面试归来，分享个人面经

知识点总结

三年Java开发，刚从美团、京东、阿里面试归来，分享个人面经

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化的资料的朋友，可以添加V获取：vip1024b （备注Java）

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

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

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

public void afterReturn() {

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

}

/**

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

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

public void after() {

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

}

/**

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

总结

面试前的“练手”还是很重要的，所以开始面试之前一定要准备好啊，不然也是耽搁面试官和自己的时间。

面试题及解析总结

[外链图片转存中…(img-FKvRPh6D-1713459717711)]

大厂面试场景

[外链图片转存中…(img-REjn6xe8-1713459717711)]

知识点总结

[外链图片转存中…(img-YWQuMM53-1713459717711)]

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化的资料的朋友，可以添加V获取：vip1024b （备注Java）
[外链图片转存中…(img-iRz9cnG3-1713459717711)]

2401_84446787

关注

3
点赞
踩
4

收藏

觉得还不错? 一键收藏
0
评论
国庆前阿里二面被Spring AOP三连问给问的一脸懵逼！，2024年最新java面试百度网盘

面试前的“练手”还是很重要的，所以开始面试之前一定要准备好啊，不然也是耽搁面试官和自己的时间。我自己是刷了不少面试题的，所以在面试过程中才能够做到心中有数，基本上会清楚面试过程中会问到哪些知识点，高频题又有哪些，所以刷题是面试前期准备过程中非常重要的一点。网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。需要这份系统化的资料的朋友，可以添加V获取：vip1024b （备注Java）一个人可以走的很快，但一群人才能走的更远！
复制链接

扫一扫