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 注解方式）：
「切面（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); } } // 忽略其他代码 }
巨人的肩膀
总结
这篇聊了 IoC、DI 的概念，优点以及三种注入方式；AOP 的概念，三种配置方式，最后还通过源码揪出它的核心实现，其实就是动态代理，对动态代理有兴趣的看：工作三年，小胖问我什么是动态代理？真的菜！。
