Spring框架:IOC、AOP知识总结

1.Spring IOC

Spring 的 IOC 容器是一个核心组件，负责实例化、配置和组装应用程序中的对象（Bean）。它将控制权从应用程序代码中反转出来，将对象的创建和依赖注入委托给容器。

1.1 Bean 定义

在 Spring IOC 容器中，每个被管理的对象都称为一个 Bean。Bean 由 Bean 定义描述，包括它的类名、依赖、配置信息等。Bean 定义可以通过 XML 文件、Java 注解或者 Java 代码来定义。

1.2 IOC 容器类型

Spring 提供了两种主要的 IOC 容器实现：

BeanFactory：最基本的 IOC 容器接口，提供了基本的依赖注入功能。
ApplicationContext：是 BeanFactory 的子接口，提供了更多的企业级功能，如事件处理、国际化、资源加载等。

1.3 IOC 容器的初始化

IOC 容器初始化的过程包括：

加载 Bean 定义：从 XML 文件、Java 注解或者 Java 代码中加载 Bean 的配置信息。
实例化 Bean：根据 Bean 定义创建 Bean 的实例。
注入依赖：将声明的依赖关系注入到 Bean 中。
初始化 Bean：调用 Bean 的初始化方法
将 Bean 放入容器管理：将初始化完成的 Bean 放入容器中供应用程序使用。

1.4. 依赖注入（DI）

依赖注入是 IOC 的具体实现，用于将对象之间的依赖关系从代码中解耦，由 IOC 容器负责管理和注入。

1.5 注入方式

Spring 主要使用以下几种依赖注入方式：

构造器注入：通过构造函数注入依赖。
属性注入：通过属性的 setter 方法注入依赖。
接口注入：通过接口上的注入注解（如 @Autowired、@Inject）注入依赖。

2.Spring AOP

2.1概念介绍

在传统的面向对象编程中，系统的功能被分散到多个模块中，如日志、事务管理、安全性等，它们跨越应用程序的不同部分。AOP 提供了一种通过在关键点上的代码注入来实现这些横切关注点的机制，而不是通过传统的代码编写方式。

2.2 核心概念

2.2.1 切面

切面是一个模块化的单元，它封装了与横切关注点相关的行为和逻辑。在 Spring 中，切面可以包括通知（advice）、切点（pointcut）和引入（introduction）等内容。

2.2 连接点

连接点是在应用程序执行过程中能够插入切面的点（所有可能织入通知的方法）。

2.3 通知

通知是切面的具体行为。Spring AOP 提供了以下几种类型的通知：

前置通知（Before advice）：在方法调用之前执行。
后置通知（After returning advice）：在方法正常返回后执行。
异常通知（After throwing advice）：在方法抛出异常后执行。
最终通知（After (finally) advice）：无论方法是否正常返回，都会执行。
环绕通知（Around advice）：包围目标方法的通知，可以在方法调用前后自定义处理。

2.4 切点

切点定义了哪些连接点会触发通知的执行。它使用表达式匹配连接点的集合，允许开发者精确地控制在哪些方法上应用通知。

2.5织⼊

织⼊：程序运⾏期将切⾯应⽤到⽬标对象 并⽣成代理对象的过程

2.6 引入

在不修改原始代码情况下，在程序运⾏期为程序动态引⼊⽅法或字段的过程
 

2.3XML实现

2.3.1定义切面

**
* 切⾯
* 切⼊点和通知的抽象 （与⾯向对象中的 类 相似）
* 定义 切⼊点和通知 （切⼊点定义了要拦截哪些类的哪些⽅法，通知则定义了拦截过⽅法后要做什么）
*/
@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("最终通知.....");
 }
 /**
 * 声明异常通知 并将通知应⽤到定义的切⼊点上
 * ⽬标类⽅法出现异常时 执⾏该通知
 */
 public void afterThrow(Exception e) {
 System.out.println("异常通知....." + " 异常原因：" + e.getCause());
 }
 /**
 * 声明环绕通知 并将通知应⽤到切⼊点上
 * ⽅法执⾏前后 通过环绕通知定义相应处理
 * 需要通过显式调⽤对应的⽅法，否则⽆法访问指定⽅法 (pjp.proceed();)
 * @param pjp
 * @return
 */
 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;
 }
}

 2.3.2配置文件（spring.xml）

<!--aop相关配置-->
<aop:config>
 <!--aop切⾯-->
 <aop:aspect ref="logCut02">
 <!-- 定义aop 切⼊点 -->
 <aop:pointcut id="cut" expression="execution(* com.xxxx.service..*.*(..))"/>
 <!-- 配置前置通知 指定前置通知⽅法名 并引⽤切⼊点定义 -->
 <aop:before method="before" pointcut-ref="cut"/>
 <!-- 配置返回通知 指定返回通知⽅法名 并引⽤切⼊点定义 -->
 <aop:after-returning method="afterReturn" pointcut-ref="cut"/>
 <!-- 配置异常通知 指定异常通知⽅法名 并引⽤切⼊点定义 -->
 <aop:after-throwing method="afterThrow" throwing="e" pointcut-ref="cut"/>
 <!-- 配置最终通知 指定最终通知⽅法名 并引⽤切⼊点定义 -->
 <aop:after method="after" pointcut-ref="cut"/>
 <!-- 配置环绕通知 指定环绕通知⽅法名 并引⽤切⼊点定义 -->
 <aop:around method="around" pointcut-ref="cut"/>
 </aop:aspect>
</aop:config>

2.4注解实现

/**
* 切⾯
* 切⼊点和通知的抽象 （与⾯向对象中的 类 相似）
* 定义 切⼊点和通知 （切⼊点定义了要拦截哪些类的哪些⽅法，通知则定义了拦截过⽅法后要做什么）
*/
@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;
 }
}