先放个视频致敬达叔，看我微信以及公众号的头像就知道我是星爷的死忠粉，达叔对我而言就是快乐。R.I.P
回到正题，这是 Java 面试及源码剖析的第七篇
Spring 相信 Java 程序员都很熟悉，甚至于有人说 Java 开发就是面向 Spring 开发。由此可见，Spring 在 Java 领域的地位是举足轻重的。
上篇文章讲了 Bean 相关的内容，它其实也是属于 IoC 的具体实现之一，本文聊聊 Spring 中其他几个高频的面试点。比如：「谈一谈你对 IoC 和 DI、AOP 的理解」。
Spring 的 IoC 和 DI
什么是 IoC 、DI
❝IoC（ Inversion of Control）译为「控制反转」，它不是一个具体的技术，而是一种设计思想。「IoC 的作用是颠倒控制流」。没有它之前，开发者需要自行创建并销毁对象，有了它之后这些工作都交给 Spring 处理。我们直接拿来用即可。 ❞
举个栗子：找女朋友。你会有自己的要求，比如身高、体重、年龄等等，然后一个个去找符合条件的对象，贼繁琐。而 IoC 就相当于，你把要求告诉婚介中心（Spring），由 Spring 直接匹配符合条件的对象，匹配到之后你直接带回成亲即可。
IoC 是从容器角度考虑的一个概念，控制权从对象移交到了 IoC 容器。所以称为「控制反转」。还有个概念叫 DI，初学我觉得它两是一个货色。但其实 「 DI 是 IoC 设计思想的具体表现：被注入对象依赖 IoC 容器配置依赖对象」
❝DI （Dependency Injection）译为「依赖注入」表示对象之间的依赖关系交由容器在运行期间自动生成。由容器动态的将某个依赖关系注入到对象之中，我们只需要简单的配置（注解），就可指定目标对象需要的依赖对象，完成业务逻辑。并不需要关心依赖对象的来源。 ❞
IoC 的优点是啥？
- 使用方便，拿来即用。不需显示管理 Bean 的生命周期
- 解耦，低侵入设计。降低业务对象替换的复杂度
- 提供了单例模式的支持，不用自己写了
- 更符合面向对象的设计
IoC 的注入方式
有三种：构造方法注入、Setter 方法注入、接口注入。接口注入用的很少，不再讨论了。说说前两者。
构造方法注入
构造方法注入主要是依赖于构造方法去实现，构造方法可以是有参的也可以是无参的，我们平时 new 对象时就是通过类的构造方法来创建类对象的，每个类对象默认会有一个无参的构造方法，Spring 通过构造方法注入的代码示例如下：
代码语言：javascript复制public class Student {
// 无参构造
public Student() {
}
// 有参构造
public Student(String id, String name) {
this.id = id;
this.name = name;
}
private String id;
private String name;
// get、set省略
}
定义好类之后，接下来就是提要求了。你想要怎么样的学生？比如，我想要名叫 Java 的学生 applicationContext.xml 配置如下：
代码语言：javascript复制<bean id="student" class="com.nasus.ioc.construct.Student">
<constructor-arg value="24" type="java.lang.String"></constructor-arg>
<constructor-arg value="Java" type="java.lang.String"></constructor-arg>
</bean>
Setter 注入
Setter 在 Spring 主流的注入方式，主要通过 Java Bean 规范所定义的 Setter/Getter 方法来完成注入，代码简单、可读性很高。示例如下：
代码语言：javascript复制<bean id="student" class="com.nasus.ioc.setter.Student">
<property name="id" value="24"/>
<property name="name" value="Java"/>
</bean>
接口注入
跳过吧，这方式很古老。反正我学这么久都没用过，也没去了解过。
Spring 的 AOP
什么是 AOP
❝AOP（Aspect Oriented Programming）译为面向切面编程，它是 OOP（Object Oriented Programming，面向对象编程）的补充和完善。OOP 引入封装、继承和多态性等概念来建立一种公共对象处理的能力，当我们需要处理公共行为的时候，OOP 就会显得无能为力，而 AOP 的出现正好解决了这个问题。比如统一的日志处理模块、授权验证模块等都可以使用 AOP 很轻松的处理。 ❞
AOP 的一些概念
要理解 AOP 首先要认识以下相关术语，有这么个场景，我需要给用户模块的增删改查，实现日志功能，我现在通过这个场景来解释 AOP 的一些概念。
「连接点（joinpoint）」：被拦截到的点，因为 Spring 只支持方法类型的连接点，所以在 Spring 中连接点指的就是被拦截到的方法。场景中，连接点就是增删改查方法本身。
「通知（advice）」：拦截到连接点之后要执行的代码，通知分为前置、后置、异常、最终、环绕通知五类：
- 前置（Before）：在目标方法被调用之前调用通知功能；
- 后置（After）：在目标方法完成之后调用通知，此时不会关 心方法的输出是什么；
- 返回（After-returning）：在目标方法成功执行之后调用通 知；
- 异常（After-throwing）：在目标方法抛出异常后调用通知；
- 环绕（Around）：通知包裹了被通知的方法，在被通知的方 法调用之前和调用之后执行自定义的行为
「切点（pointcut）」：对连接点进行拦截的定义，它会匹配通知所要织入的一个或多个连接点。它的格式是这样的（@AspectJ 注解方式）：
切点格式（来源于：Spring4 实战）
「切面（aspect）」：切面就是对横切关注点的抽象，它定义了切点和通知。场景中，日志功能就是这个抽象，它定义了你要对拦截方法做什么？「切面是通知和切点的结合。通知和切点共同定义了切面的全部内容 —— 它是什么，在何时和何处完成其功能」
「织入（weave）」：将切面应用到目标对象并导致代理对象创建的过程
「引入（introduction）」：在不修改代码的前提下，引入可以在运行期为类动态地添加一些方法或字段
AOP 的配置方式
Spring 提供了 Java API、@AspectJ（Java）注解以及 XML标签等三种 AOP 配置方式。
Java API 方式
这种方式要实现相关接口，比如，前置通知接口：MethodBeforeAdvice 和 后置通知接口：AfterReturningAdvice，代码如下：
代码语言：javascript复制public class Student {
// 无参构造
public Student() {
}
// 有参构造
public Student(String id, String name) {
this.id = id;
this.name = name;
}
public Student getStudent(){
Student student = new Student("24", "JDK");
System.out.println("getStudent 被执行了");
return student;
}
private String id;
private String name;
// get、set省略
}
再定义一个 advice 通知 类，用于对拦截方法的调用之前和调用之后进行相关的业务处理，实现代码如下：
代码语言：javascript复制public class MyAdvice implements MethodBeforeAdvice, AfterReturningAdvice {
@Override
public void before(Method method, Object[] args, Object target) throws Throwable {
System.out.println("准备执行方法: " method.getName());
}
@Override
public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {
System.out.println(method.getName() " 方法执行结束");
}
}
在 application.xml 文件中配置相应的拦截规则，配置如下：
代码语言：javascript复制<!-- 定义 advisor -->
<bean id="myAdvice" class="com.nasus.aop.javaapi.MyAdvice"></bean>
<!-- 配置规则，拦截方法名称为 get* -->
<bean class="org.springframework.aop.support.RegexpMethodPointcutAdvisor">
<property name="advice" ref="myAdvice"></property>
<property name="pattern" value="com.nasus.javaapi.*.get.*"></property>
</bean>
<!-- 定义 DefaultAdvisorAutoProxyCreator 使所有的 advisor 配置自动生效 -->
<bean class="org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator"></bean>
以上，我们需要拦截方法的规则，然后定义一个 DefaultAdvisorAutoProxyCreator 让所有的 advisor 配置自动生效。
最后，使用测试代码来完成调用：
代码语言：javascript复制public class MyApplication {
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("classpath*:application.xml");
Student student = context.getBean("student", Student.class);
Student.getStudent();
}
}
运行结果：可见 AOP 拦截成功
代码语言：javascript复制准备执行方法: getStudent
getStudent 被执行了
getStudent 方法执行结束
@AspectJ 注解方式
pom 文件里面添加 aspectjweaver 的 jar 包，配置如下：
代码语言：javascript复制<!-- https://mvnrepository.com/artifact/org.aspectj/aspectjweaver -->
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjweaver</artifactId>
<version>1.9.5</version>
</dependency>
因为 Spring 使用了 AspectJ 提供的一些注解，因此需要添加此 jar 包。之后，我们需要开启 @AspectJ 的注解，开启方式有两种。
application.xml 中开启 @AspectJ 注解：
代码语言：javascript复制<aop:aspectj-autoproxy/>
使用 @EnableAspectJAutoProxy 注解开启：
代码语言：javascript复制@Configuration
@EnableAspectJAutoProxy
public class AppConfig {
}
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
@Aspect
public class MyAspectJ {
// 配置拦截类 Student
@Pointcut("execution(* com.nasus.aop.aspectj.beans.Student.*(..))")
public void pointCut() {}
@Before("pointCut()")
public void doBefore() {
System.out.println("执行 doBefore 方法");
}
@After("pointCut()")
public void doAfter() {
System.out.println("执行 doAfter 方法");
}
}
然后在 application.xml 配置中添加注解类，配置如下：
代码语言：javascript复制<bean class="com.nasus.aop.aspectj.advice.MyAspectJ"/>
Student 类：
代码语言：javascript复制public class Student {
// 无参构造
public Student() {
}
// 有参构造
public Student(String id, String name) {
this.id = id;
this.name = name;
}
public Student getStudent(){
Student student = new Student("24", "JDK");
System.out.println("getStudent 被执行了");
return student;
}
private String id;
private String name;
// get、set省略
}
测试类：
代码语言：javascript复制import org.springframework.beans.Person;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class MyApplication {
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("classpath*:application.xml");
Student student = context.getBean("student",Student.class);
Student.getStudent();
}
}
运行结果：
代码语言：javascript复制执行 doBefore 方法
执行 getStudent 方法
执行 doAfter 方法
XML标签方式
与注解方式类似，只是不需注解，把相关信息配置到 application.xml 中即可，配置如下：
代码语言：javascript复制<!-- 拦截处理类 -->
<bean id="myPointcut" class="com.nasus.aop.xml.advice.MyPointcut"></bean>
<aop:config>
<!-- 拦截规则配置 -->
<aop:pointcut id="pointcutConfig"
expression="execution(* com.nasus.aop.xml.beans.Student.*(..))"/>
<!-- 拦截方法配置 -->
<aop:aspect ref="myPointcut">
<aop:before method="doBefore" pointcut-ref="pointcutConfig"/>
<aop:after method="doAfter" pointcut-ref="pointcutConfig"/>
</aop:aspect>
</aop:config>
建立切点进行拦截业务的处理，实现代码如下：
代码语言：javascript复制public class MyPointcut {
public void doBefore() {
System.out.println("执行 doBefore 方法");
}
public void doAfter() {
System.out.println("执行 doAfter 方法");
}
}
测试方法跟 @AspectJ 注解方式是一致的，就不贴出来了。运行结果如下：
代码语言：javascript复制执行 doBefore 方法
执行 getStudent 方法
执行 doAfter 方法
AOP 的原理
它的原理其实不难，核心就是「动态代理」，在调用 getBean () 方法的时候返回的其实是代理类的实例，而这个代理类在 Spring 中使「用的是 JDK Proxy 或 CgLib 实现的」，它的核心代码在 DefaultAopProxyFactory.createAopProxy (...) 中，源码如下：
代码语言：javascript复制public class DefaultAopProxyFactory implements AopProxyFactory, Serializable {
@Override
public AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException {
if (config.isOptimize() || config.isProxyTargetClass() || hasNoUserSuppliedProxyInterfaces(config)) {
Class < ? > targetClass = config.getTargetClass();
if (targetClass == null) {
throw new AopConfigException("TargetSource cannot determine target class: " "Either an interface or a target is required for proxy creation.");
}
// 判断目标类是否为接口
if (targetClass.isInterface() || Proxy.isProxyClass(targetClass)) {
// 是接口,使用 jdk 的代理
return new JdkDynamicAopProxy(config);
}
// 其他情况使用 CgLib 代理
return new ObjenesisCglibAopProxy(config);
} else {
return new JdkDynamicAopProxy(config);
}
}
// 忽略其他代码
}
巨人的肩膀
- https://kaiwu.lagou.com/course/courseInfo.htm?courseId=59#/detail/pc?id=1762
总结
这篇聊了 IoC、DI 的概念，优点以及三种注入方式；AOP 的概念，三种配置方式，最后还通过源码揪出它的核心实现，其实就是动态代理，对动态代理有兴趣的看：工作三年，小胖问我什么是动态代理？真的菜！。
