# AOP

AOP（Aspect Oriented Programming）意为：面向切面编程，通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。利用 AOP 可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。

又是经典网图：

这么说可能你并不是很懂，那么我就这么说吧，在我们在实现一个单独的业务逻辑的同时，我们还想附加一些其他的操作就比如日志（在之前的动态代理例子就有类似的操作），来作为一个完整的事务。

但是我们就是不想直接去改那个原来的本身代码。那怎么办呢？就是我们的横向编程，将我们的附加的操作将其横向的织入业务逻辑之中。

:::info

Aop 相关 Info

:::

首先先了解一些名词，这些在后面配置 xml 都需要用的

横切关注点：跨越应用程序多个模块的方法或功能。即是，与我们业务逻辑无关的，但是我们需要关注的部分，就是横切关注点。如日志，安全，缓存，事务等等 ....
切面（ASPECT）：横切关注点被模块化的特殊对象。即，它是一个类。
通知（Advice）：切面必须要完成的工作。即，它是类中的一个方法。
目标（Target）：被通知对象。
代理（Proxy）：向目标对象应用通知之后创建的对象。
切入点（PointCut）：切面通知执行的 “地点” 的定义。
连接点（JointPoint）：与切入点匹配的执行点。

:::info

Aop 应用

:::

导入相应的 jar 包

	<!-- https://mvnrepository.com/artifact/org.aspectj/aspectjweaver -->
	<dependency>
	<groupId>org.aspectj</groupId>
	<artifactId>aspectjweaver</artifactId>
	<version>1.9.4</version>
	</dependency>

# Spring API 实现

1. 首先编写我们的业务接口和实现类

	public interface UserService {

	public void add();
	public void delete();
	public void update();
	public void search();

	}

	public class UserServiceImpl implements UserService{

	@Override
	public void add() {
	System.out.println("增加用户");
	}

	@Override
	public void delete() {
	System.out.println("删除用户");
	}

	@Override
	public void update() {
	System.out.println("更新用户");
	}

	@Override
	public void search() {
	System.out.println("查询用户");
	}
	}

3. 然后去写两个增强类

	public class Log implements MethodBeforeAdvice {
	//method : 要执行的目标对象的方法
	//objects : 被调用的方法的参数
	//o : 目标对象 (这里怀疑又是设计人员偷懒了，换成 target 不好吗)
	@Override
	public void before(Method method, Object[] objects, Object o) throws Throwable {
	System.out.println( o.getClass().getName() + "的" + method.getName() + "方法被执行了");
	}
	}

	public class AfterLog implements AfterReturningAdvice {
	//returnValue 返回值
	//method 被调用的方法
	//args 被调用的方法的对象的参数
	//target 被调用的目标对象
	@Override
	public void afterReturning(Object returnValue, Method method, Object[] args,Object target) throws Throwable {
	System.out.println("执行了" + target.getClass().getName()
	+"的"+method.getName()+"方法,"
	+"返回值："+returnValue);
	}
	}

4.Spring 文件注册

	<?xml version="1.0" encoding="UTF-8"?>
	<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xmlns:aop="http://www.springframework.org/schema/aop"
	xsi:schemaLocation="http://www.springframework.org/schema/beans
	http://www.springframework.org/schema/beans/spring-beans.xsd
	http://www.springframework.org/schema/aop
	http://www.springframework.org/schema/aop/spring-aop.xsd">
	<!-- 注册 bean-->
	<bean id="userService" class="com.Meteor.service.UserServiceImpl"/>
	<bean id="log" class="com.Meteor.log.Log"/>
	<bean id="afterLog" class="com.Meteor.log.AfterLog"/>
	<!--aop 的配置 -->
	<aop:config>
	<!-- 切入点 expression: 表达式匹配要执行的方法 -->
	<aop:pointcut id="pointcut" expression="execution(* com.Meteor.service.UserServiceImpl.*(..))"/>
	<!-- 执行环绕；advice-ref 执行方法 . pointcut-ref 切入点 -->
	<aop:advisor advice-ref="log" pointcut-ref="pointcut"/>
	<aop:advisor advice-ref="afterLog" pointcut-ref="pointcut"/>
	</aop:config>

	</beans>

这里解释一下

<aop:pointcut id="pointcut" expression="execution(* com.Meteor.service.UserServiceImpl.*(..))"/>

本质上是 execution (修饰符返回类型切入点类切入点方法 (参数) 异常抛出)

修饰符： 可选，支持通配符，（public/private/protected）

返回类型： 必填，支持通配符，可以使用 * 来匹配所有的返回值类型

切入点类： 可选，支持通配符，指定切入点类

切入点方法： 必填，支持通配符，指定要匹配的方法名，可以使用 "*" 通配符来匹配所有方法

参数： 若无可不填，指定方法声明中的形参列表，支持两个通配符，即 *(匹配一个参数) 和..(匹配所有参数)

这里就是省略了修饰符和切入点类。

# 自定义实现 AOP

第一步：写我们自己的一个切入类

	public class DiyPointcut {
	public void before(){
	System.out.println("---------方法执行前---------");
	}
	public void after(){
	System.out.println("---------方法执行后---------");
	}
	}

去 spring 中配置

	<!-- 第二种方式自定义实现 -->
	<!-- 注册 bean-->
	<bean id="diy" class="com.Meteor.config.DiyPointcut"/>
	<!--aop 的配置 -->
	<aop:config>
	<!-- 第二种方式：使用 AOP 的标签实现 -->
	<aop:aspect ref="diy">
	<aop:pointcut id="diyPonitcut" expression="execution(* com.Meteor.service.UserServiceImpl.*(..))"/>
	<aop:before pointcut-ref="diyPonitcut" method="before"/>
	<aop:after pointcut-ref="diyPonitcut" method="after"/>
	</aop:aspect>
	</aop:config>

# 注解实现

第一步：编写一个注解实现的增强类

	package com.Meteor.config;

	import org.aspectj.lang.ProceedingJoinPoint;
	import org.aspectj.lang.annotation.After;
	import org.aspectj.lang.annotation.Around;
	import org.aspectj.lang.annotation.Aspect;
	import org.aspectj.lang.annotation.Before;

	@Aspect
	// 注解标记为 aspect
	public class AnnotationPointcut {
	@Before("execution(* com.Meteor.service.UserServiceImpl.*(..))")
	public void before(){
	System.out.println("---------方法执行前---------");
	}

	@After("execution(* com.Meteor.service.UserServiceImpl.*(..))")
	public void after(){
	System.out.println("---------方法执行后---------");
	}

	@Around("execution(* com.Meteor.service.UserServiceImpl.*(..))")
	public void around(ProceedingJoinPoint jp) throws Throwable {
	System.out.println("环绕前");
	System.out.println("签名:"+jp.getSignature());
	// 执行目标方法 proceed
	Object proceed = jp.proceed();
	System.out.println("环绕后");
	System.out.println(proceed);
	}
	}

第二步：在 Spring 配置文件中，注册 bean，并增加支持注解的配置

	<!-- 第三种方式：注解实现 -->
	<bean id="annotationPointcut" class="com.Meteor.config.AnnotationPointcut"/>
	<aop:aspectj-autoproxy/>
	<!--
	通过 aop 命名空间的 & lt;aop:aspectj-autoproxy /> 声明自动为 spring 容器中那些配置 @aspectJ 切面的 bean 创建代理，织入切面。当然，spring 在内部依旧采用 AnnotationAwareAspectJAutoProxyCreator 进行自动代理的创建工作，但具体实现的细节已经被 & lt;aop:aspectj-autoproxy /> 隐藏起来了
	可以理解为实现了
	<aop:config>
	<aop:aspect ref="annotationPointCut"/>
	</aop:config>
	-->

spring5

spring5-6 Aop

# AOP

# Spring API 实现

# 自定义实现 AOP

# 注解实现

spring5-5 代理模式

spring5-7 整合mybatis