1. Spring的AOP简介

1.1 什么是AOP?

AOP 为 Aspect Oriented Programming 的缩写, 意思为面向切面编程,

是通过预编译形式和运行期动静代理实现程序性能的对立保护的一种技术。

AOP是OOP(Ojebct Oriented Programming)的连续, 是软件开发中的一个热点, 是Spring框架的一个重要内容局部,是函数式编程的一种衍生范型。利用AOP能够对业务逻辑的各个局部进行隔离，从而使得业务逻辑各局部之间的耦合度升高，进步程序的可重用性，同时进步了开发的效率。

OOP的局限性

在业务代码中通常有日志管制,性能统计,安全控制,事务管制,异样解决等等操作, 只管应用OOP能够通过封装或继承的形式达到代码的重用,但任然有同样的代码扩散各个办法中,采纳OOP解决日志等加强了开发者工作量，而且进步了降级保护艰难

这一条条横线好像切开了 OOP 的树状构造，犹如一个大蛋糕被切开多层，每一层都会执行雷同的辅助逻辑，所以大家将这些辅助逻辑称为层面或者切面。

1.2 AOP的劣势

作用：在程序运行期间, 在不批改源代码的状况下对办法进行性能增强

劣势：缩小反复代码, 进步开发效率,便于保护。

1.3 AOP的底层实现

实际上，AOP 的底层是通过 Spring 提供的的动静代理技术实现的。在运行期间，Spring通过动静代理技术动静的生成代理对象，代理对象办法执行时进行加强性能的染指，在去调用指标对象的办法，从而实现性能的加强

1.4 AOP的代理技术

罕用的动静代理技术

JDK 代理：基于接口的动静代理技术
cglib 代理：基于父类的动静代理技术

罕用的动静代理技术

JDK 代理 : 基于接口的动静代理技术
cglib 代理：基于父类的动静代理技术

1.5 JDK的动静代理

指标类接口

public interface TargetInterface{    void save();}

2. 指标类

public class Target implements TargetInterface{        public void save(){       System.out.println("save running....");    }    }

减少类

public class Advice{    public void before(){        System.out.println("前置加强");    }        public void afterReturning(){        System.out.println("后置加强...");    }    }

动静代理代码

public class ProxyTest{    public static void main(String [] args){        // 指标对象    final Target target = new Target();        // 加强对象    final Advice advice = new Advice();                //返回值 就是动静生成的代理对象    TargetInterface proxy = (TargetInterface)Proxy.newProxyInstance(        // 指标对象类加载器        target.getClass().getClassLoader(),        // 指标对象雷同的接口字节码对象数组        target.getClass().getInterfaces(),        new InvocationHandler() {            // 调用代理对象的任何办法 本质执行的都是invoke办法            public Object invoke(Object proxy,Method method, Object[] args) throws InvocationTargetException, IllegalAccessException{            advkce.before(); // 前置减少           Object invoke = method.invoke(target,args) //执行指标办法            advice.afterReturning(); //后置减少            return invoke; // 返回值就是指标对象 -> null也行(尽量别)            }        }    );            // 调用代理对象办法        proxy.save();    // (调用接口的任意办法时,代理对象的代码都无需批改)    }}

输入后果：

 前置减少 save running..... 后置减少

1.6 cglib的动静代理

1）指标类

public class Target {    public void save() {        System.out.println("save running.....");    }}

2）加强类对象

public class Advice {    public void before(){        System.out.println("前置加强....");    }    public void afterReturning(){        System.out.println("后置加强....");    }}

3）动静代理代码

public class ProxyTest {    public static void main(String[] args) {        // 指标对象        final Target target = new Target();        // 减少对象        final Advice advice = new Advice();        // 返回值 就是动静生成的代理对象 基于从cglib        // 1. 创立增强器        Enhancer enhancer = new Enhancer();        // 2. 设置父类(指标)        enhancer.setSuperclass(Target.class);        // 3. 设置回调        enhancer.setCallback(new MethodInterceptor() {            public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {                //执行前置                advice.before();                Object invoke = method.invoke(target, args);                // 执行后置                advice.afterReturning();                return invoke;            }        });        // 4. 创立代理对象        Target proxy = (Target) enhancer.create();        proxy.save();    }}

1.7 AOP的相干概念

Spring 的 AOP 实现底层就是对下面的动静代理的代码进行了封装，封装后咱们只须要对须要关注的局部进行代码编写，并通过配置的形式实现指定指标的办法加强。
AOP 罕用的相干术语如下：

Target（指标对象） : 代理的指标对象
Proxy (代理) ：一个类被AOP织入加强后,就会产生一个后果代理类
Joinpoint(连接点): 所谓连接点是指那些被拦挡到的点。在spring中,这些点指的是办法，因为spring只反对办法类型的连接点
Pointcut(切入点)：所谓的切入点是指咱们要对那些 JoinPoint 进行拦挡的定义
Advice(告诉/减少)：所谓告诉是拦挡到 Joinpoint之后所要做的是事件就是告诉
Aspect(切面)：是切入点和告诉(引介)的联合
Weaving（织入）：是指把加强利用到指标对象来创立新的代理对象的过程。spring采纳动静代理织入，而AspectJ采纳编译期织入和类装载期织入

Spring AOP术语：

连接点和切点的区别

连接点(Join point) : 连接点是利用执行过程中可能插入切面(Aspect) 的一个点, 这些点能够是调用办法时、甚至批改一个字段时。
切点（Pointcut): 切点时指告诉(Adivce) 所要织入的中央的具体位置

连接点：连接点时一个虚构的概念,他能够了解为所有满足切点条件的所有机会。

具体举个例子：比方开车通过一条高速公路,这条高速公路有很多个路口（连接点）,然而咱们不会每个进口都会进来，指挥抉择咱们须要的那个进口（切点) 开进来。

简略能够了解为，每个进口都是连接点然而咱们应用的那个进口才是切点，每个利用有多个地位适宜织入告诉,这些都是连接点,然而只有咱们抉择的那个具体的地位才是切点

小总结： 所有办法都须要连接点，切点是咱们对连接点的实现，通过切点确定那些连接点须要被解决。

参考：https://blog.csdn.net/weixin_...

AOP 开发明确开发及总结

须要编写的内容

编写指标类的指标方)
编写切面类(内含有加强办法)
在配置文件中,配置织入关系,以及那些告诉和连接点汇合

总结

aop的重点概念

Pointcut（切入点）：被加强的办法

Advice（告诉/ 加强）：封装加强业务逻辑的办法

Aspect（切面）：切点+告诉

Weaving（织入）：将切点与告诉联合的过程

开发者步骤

谁是切点(切点表达式)

谁是告诉(切面类的加强办法)

将切点和告诉进行织入配置

基于XML的AOP开发

2.1疾速入门

maven AOP 的坐标
指标接口指标类(外部有切点)
切面类
在applicationContext.xml配置织入等
测试

1.导包

<dependencies>        <!-- 导入spirng的context坐标,context依赖aop -->        <dependency>            <groupId>org.springframework</groupId>            <artifactId>spring-context</artifactId>            <version>5.0.2.RELEASE</version>        </dependency>        <!-- aop小框架 aspectj的织入 -->        <dependency>            <groupId>org.aspectj</groupId>            <artifactId>aspectjweaver</artifactId>            <version>1.8.6</version>        </dependency>        <dependency>            <groupId>junit</groupId>            <artifactId>junit</artifactId>            <version>4.12</version>            <scope>test</scope>        </dependency>        <!-- 这是一个spring自带的测试等等我会演示 -->        <dependency>            <groupId>org.springframework</groupId>            <artifactId>spring-test</artifactId>            <version>5.0.2.RELEASE</version>        </dependency>    </dependencies>

2.指标接口指标类（外部有切点）

package com.xxx.aop; // 指标接口public interface TargetInterface {    public void save();}package com.xxx.aop; // 指标类public class Target implements TargetInterface {    public void save() {//        int i = 1/0;        System.out.println("save running.....");    }}

3.切面类（外部有加强办法）

package com.xxx.aop;import org.aspectj.lang.ProceedingJoinPoint;public class MyAspect {    public void before(){        System.out.println("前置加强......");    }}

4.xml进行配置

aop命名空间及束缚空间

xml代码

<?xml version="1.0" encoding="UTF-8"?><beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"       xmlns="http://www.springframework.org/schema/beans"       xmlns:context="http://www.springframework.org/schema/context"        xmlns:aop="http://www.springframework.org/schema/aop"       xsi:schemaLocation="http://www.springframework.org/schema/beans        http://www.springframework.org/schema/beans/spring-beans-4.2.xsd         http://www.springframework.org/schema/context         http://www.springframework.org/schema/context/spring-context-4.2.xsd        http://www.springframework.org/schema/aop        http://www.springframework.org/schema/aop/spring-aop-4.2.xsd ">    <!-- 指标对象 -->    <bean id="target" class="com.xxx.aop.Target"></bean>    <!-- 切面对象 -->    <bean id="myAspect" class="com.xxx.aop.MyAspect"></bean>    <!-- 配置织入: 通知spring框架 那些办法(切点)须要进行那些加强(前置,后置..)-->    <aop:config>        <!-- 申明切面 -->        <aop:aspect ref="myAspect">            <!-- 配置Target的save办法执行时要进行myAspect的before办法前置加强 -->                        <!--切面： 切点+告诉(减少)   pointcut切点 -->            <aop:before method="before" pointcut="execution(public void com.xxx.aop.Target.())"/>        </aop:aspect>    </aop:config>    </beans>

5.测试

@RunWith(SpringJUnit4ClassRunner.class) // spring测试类@ContextConfiguration("classpath:applicationContext.xml") // 指定测试的文件 public class AopTest {    @Autowired // 把要测试的对象 注入进来    private TargetInterface target;    @Test    public void test1() {        target.save();    }       }

输入后果：

前置加强......
save running.....

xml配置AOP详解

1）切点表达式的写法

表达式语法

execution([修饰符] 返回值类型 包名.类名.办法名(参数))

修饰符能够省略
返回值类型、包名、类名、办法名能够应用星号* 代表任意
包名与类名之间一个点 . 代表以后包下的类，两个点 .. 示意以后包及其子包下的类
参数列表能够应用两个点 .. 示意任意个数，任意类型的参数列表

# 全execution(public void com.xxx.aop.Target.method()) # 任意办法任意参数execution(void com.xxx.aop.Target.*(..)) # 任意返回值com.xxx.aop包下任意类任意办法任意参数execution(* com.xxx.aop.*.*(..)) # 任意返回值com.xxx.aop下以其子包下任意类任意参数execution(* com.xxx.aop..*.*(..))# 你成心找茬是吧execution(* *..*.*(..))小总结： 修饰符能够不写 第一个 * = 返回值 第二个 * = 包 第三个 * = 类第四个 * = 办法括号外.. = 本人包含子包下所有类的xxx括号内的 .. = 任意参数

2）告诉的类型

告诉的配置语法：

<aop:告诉类型 method="切面类中办法名" pointcut="切点表达式"></aop:告诉类型>

名称	标签	阐明
前置告诉	`<aop:before>`	用于配置前置告诉。指定加强的办法在切入点办法之前执行
后置告诉	`<aop:after-returning>`	用于配置后置告诉。指定加强的办法在切入点办法之后执行
盘绕告诉	`<aop:around>`	于配置盘绕告诉。指定加强的办法在切入点办法之前和之后都执行
异样抛出告诉	`<aop:throwing>`	用用于配置异样抛出告诉。指定加强的办法在出现异常时执行
最终告诉	`<aop:after>`	用于配置最终告诉。无论加强形式执行是否有异样都会执行

3）切点表达式的抽取

当多个加强的切点表达式雷同时，能够将切点表达式进行抽取，在加强中应用 pointcut-ref 属性代替 pointcut 属性来援用抽取后的切点表达式。

<aop:config>    <!--援用myAspect的Bean为切面对象-->    <aop:aspect ref="myAspect">        <!--抽取切点表达式-->        <aop:pointcut id="myPointcut" expression="execution(* com.itheima.aop.*.*(..))"></aop:pointcut>        <aop:around method="around" pointcut-ref="myPointcut"/>        <aop:after method="after" pointcut-ref="myPointcut"/>    </aop:aspect></aop:config>

告诉办法存在于切面类中，依据切点表达式，对切点加强。

3. 基于注解的AOP开发

3.1 疾速入门

步骤：
1、创立指标接口和指标类（开启注解扫描）
2、创立切面类（开启注解扫描配置织入关系）
3、xml开启启组件扫描和 AOP 的主动代理
4、测试

1、创立指标接口和指标类（外部有切点）

public interface TargetInterface {    public void save();}

@Componentpublic class Target implements TargetInterface {    public void save() {        System.out.println("save running.....");    }}

2、创立切面类（外部有加强办法）

@Component("myAspect")@Aspect //标签以后MyAspect是一个切面类public class MyAspect {    // 配置前置加强    // @Before(value = "execution( * com.xxx.anno.*.*(..))")    public void before(){        System.out.println("前置加强......");    }  }

5、在配置文件中开启组件扫描和 AOP 的主动代理

<!--组件扫描--><context:component-scan base-package="com.itheima.anno"/><!--aop主动代理--><aop:aspectj-autoproxy/>

6、测试

@RunWith(SpringJUnit4ClassRunner.class)@ContextConfiguration("classpath:applicationContext-anno.xml")public class AnnoTest {    @Autowired    private TargetInterface target;    @Test    public void test1() {        target.save();    }}

输入：

前置加强......

save running.....

3.2 注解配置 AOP 详解

1）注解告诉的类型

告诉的配置语法：@告诉注解("切点表达式")

名称	注解	阐明
前置告诉	`@Before`	用于配置前置告诉。指定加强的办法在切入点办法之前执行
后置告诉	`@AfterReturning`	用于配置后置告诉。指定加强的办法在切入点办法之后执行
盘绕告诉	`@Around`	用于配置盘绕告诉。指定加强的办法在切入点办法之前和之后都执行
异样抛出告诉	`@AfterThrowing`	用于配置异样抛出告诉。指定加强的办法在出现异常时执行
最终告诉	`@After`	用于配置最终告诉。无论加强形式执行是否有异样都会执行

2）切点表达式的抽取

通xml 配置 aop 一样，咱们能够将切点表达式抽取。抽取形式是在切面内定义方法，在该办法上应用@Pointcut 注解定义切点表达式，而后在在加强注解中进行援用。具体如下：

@Component("myAspect")@Aspect //标注以后MyAspect是一个切面类public class MyAspect {    //Proceeding JoinPoint:  正在执行的连接点===切点    //@Around("execution(* com.xxx.anno.*.*(..))")    @Around("pointcut()")    public Object around(ProceedingJoinPoint pjp) throws Throwable {        System.out.println("盘绕前加强....");        Object proceed = pjp.proceed();//切点办法        System.out.println("盘绕后加强....");        return proceed;    }    public void afterThrowing() {        System.out.println("异样抛出加强..........");    }    //@After("execution(* com.xxx.anno.*.*(..))")    @After("MyAspect.pointcut()")    public void after() {        System.out.println("最终加强..........");    }    //定义切点表达式    @Pointcut("execution(* com.xxx.anno.*.*(..))")    public void pointcut() {    }}