工作三年，小胖问我什么是 Spring 的 IoC 和 AOP？真的菜！

JavaFish

发布于 2021-03-04 14:49:09

2490

发布于 2021-03-04 14:49:09

文章被收录于专栏：狗哥的 Java 世界狗哥的 Java 世界

先放个视频致敬达叔，看我微信以及公众号的头像就知道我是星爷的死忠粉，达叔对我而言就是快乐。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 通过构造方法注入的代码示例如下：

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 配置如下：

<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 方法来完成注入，代码简单、可读性很高。示例如下：

<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，代码如下：

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 通知类，用于对拦截方法的调用之前和调用之后进行相关的业务处理，实现代码如下：

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 文件中配置相应的拦截规则，配置如下：

<!-- 定义 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 配置自动生效。

最后，使用测试代码来完成调用：

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 拦截成功

准备执行方法: getStudent
getStudent 被执行了
getStudent 方法执行结束

@AspectJ 注解方式

pom 文件里面添加 aspectjweaver 的 jar 包，配置如下：

<!-- 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 注解：

<aop:aspectj-autoproxy/>

使用 @EnableAspectJAutoProxy 注解开启：

@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 配置中添加注解类，配置如下：

<bean class="com.nasus.aop.aspectj.advice.MyAspectJ"/>

Student 类：

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省略
}

测试类：

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

}

运行结果：

执行 doBefore 方法
执行 getStudent 方法
执行 doAfter 方法

XML标签方式

与注解方式类似，只是不需注解，把相关信息配置到 application.xml 中即可，配置如下：

<!-- 拦截处理类 -->
<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>

建立切点进行拦截业务的处理，实现代码如下：

public class MyPointcut {
   public void doBefore() {
      System.out.println("执行 doBefore 方法");
   }
   public void doAfter() {
      System.out.println("执行 doAfter 方法");
   }
}

测试方法跟 @AspectJ 注解方式是一致的，就不贴出来了。运行结果如下：

执行 doBefore 方法
执行 getStudent 方法
执行 doAfter 方法

AOP 的原理

它的原理其实不难，核心就是「动态代理」，在调用 getBean () 方法的时候返回的其实是代理类的实例，而这个代理类在 Spring 中使「用的是 JDK Proxy 或 CgLib 实现的」，它的核心代码在 DefaultAopProxyFactory.createAopProxy (...) 中，源码如下：

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);
        }
    }
    // 忽略其他代码
    
}