对于Spring AOP的了解

AOP为Aspect Oriented Programming的缩写 ：面向切面编程， AOP是OOP的连续 AOP并不是一种技术，只是一种思维，即面向切面编程的思维

在开发中日志的应用时很频繁的，上面就来用AOP来解决一下开发中的日志输入的问题

@Servicepublic class TestService {    public int sum(int a ,int b ){        System.out.println("参数为："+a+"+"+b);        int sum = a+b;        System.out.println("后果为:"+sum);        return sum;    }}
@Autowiredprivate TestService testService;@Testvoid contextLoads() {    testService.sum(1,2);}
参数为：1+2后果为:3

在不应用aop的状况下，咱们打印日志要这样写，这样写的话就是业务代码跟日志输入都写在了一起，使得代码冗余，而且在前面如果说，不须要将参数输入到日志中了，这样须要一个类一个类的批改代码，工作量时很大的

AOP就很不便简略的解决了这个问题

AOP的了解

这是之前的日志输入办法

这个时应用AOP的日志输入办法

其实AOP，面向切面很好了解，就是在一个类上横切一刀，将咱们须要的代码切入，并且不影响之前代码的执行，实现理解耦

AOP的长处

1、面向切面编程使得每个关注点都集中于一个中央而不是扩散在多处代码中，便于前期的对立保护治理。

2、服务模块更简洁，它们只蕴含次要关注点，而主要关注点的代码被转移到切面中了。

3、对原办法进行办法加强，且不影响原办法的失常应用。

4、应用简略可插拔的配置，在理论逻辑执行之前、之后或四周动静增加横切关注点。

AOP的术语
名称形容
切面（Aspect）切面是告诉和切点的联合
告诉（Advice）告诉定义了切面是什么以及何时应用。除了形容切面要实现的工作，告诉还解决了何时执行这个工作的问题
切点（Pointcut）切点定义了在何处工作，也就是真正被切入的中央，也就是在哪个办法利用告诉
连接点（Join point）连接点是在利用执行过程中可能插入切面的一个点
引入（Introduction）引入让一个切面能够申明被告诉的对象实现了任何他们没有真正实现的额定接口，而且为这些对象提供接口的实现
织入（Weaving）织入是把切面利用到指标对象并创立新的代理对象的过程

其中在Spring中有5中告诉类型

名称形容
前置告诉（Before）在指标办法被调用之前调用
后置告诉（After）在指标办法实现之后调用
返回告诉（After-returning）在指标办法胜利执行之后调用
异样告诉（After-throwing）在指标办法抛出异样后调用
盘绕告诉（Around）告诉包裹了被告诉的办法，可同时定义前置告诉和后置告诉
SpringBoot 实现AOP
  1. 新建一个SpringBoot我的项目

  2. 导入依赖

    <dependency>    <groupId>org.springframework.boot</groupId>    <artifactId>spring-boot-starter-aop</artifactId></dependency><dependency>    <groupId>org.aspectj</groupId>    <artifactId>aspectjweaver</artifactId></dependency>

  3. AOP的实现须要进行配置，在Spring 中应用的时xm的形式进行配置，然而在SpringBoot中勾销了xml，改为应用了配置类进行配置

    package com.mango.Aspect;import org.aspectj.lang.JoinPoint;import org.aspectj.lang.annotation.AfterReturning;import org.aspectj.lang.annotation.Aspect;import org.aspectj.lang.annotation.Before;import org.aspectj.lang.annotation.Pointcut;import org.springframework.stereotype.Component;/** * @Author:   * @Date:      * @Component 被Spring治理
*/

@Component
@Aspect
public class TestAspect {

   /**    *  @Pointcut("execution(* com.mango.service.*.*(..))")    *  execution 括号中的是一个表达式，外表在com.mango.service 这个包下的所有类所有办法所有返回值，所有参数    *  申明切入点    *  execution 关键字    *  *           com.mango.service. *.    *          (..)  )    *  所有的返回值  包名                         所有类 所有办法   所有的参数    */   @Pointcut("execution(* com.mango.service.*.*(..))")   public void pointcut(){}   /**    * @Before("pointcut()")  前置告诉，在切入点之前    * @param joinPoint  能够通过他来获取办法以及参数    */   @Before("pointcut()")   public void before(JoinPoint joinPoint){       Object [] args = joinPoint.getArgs();       for (Object arg : args) {           System.out.println("参数为："+arg);       }   }   /**    * @param joinPoint    * @param returnValue    * @AfterReturning(value = "pointcut()",returning = "returnValue")    * returning 获取返回值    */   @AfterReturning(value = "pointcut()",returning = "returnValue")   public void returning(JoinPoint joinPoint,Object returnValue){       System.out.println("后果为："+returnValue);   }

}

@Service
public class TestService {

public int sum(int a ,int b ){    int sum = a+b;    return sum;}

}

@SpringBootTest
class SpringbootAopApplicationTests {

@Autowiredprivate TestService testService;@Testvoid contextLoads() {    testService.sum(1,2);}

}

参数为：1
参数为：2
后果为：3

其余的After之类的就不再举例了，用法都是一样的这样就是实现了AOP，是不是很简略，其实AOP的应用时很简略的，重要的是了解AOP的这种思维### AOP的使用的技术 SpringAOP应用了两种代理机制，一种是基于JDK的动静代理，另一种是基于CGLib的动静代理，之所以须要两种代理机制，很大水平上是因为JDK自身只提供基于接口的代理，不反对类的代理。 **切面植入的办法：**编译期织类装载期织入 动静代理织入 在运行期为指标类增加加强生成子类的形式，Spring AOP采纳动静代理织入切面AOP 有两种次要的框架，SpringAOP和AspectJ