AOP术语，AOP 操作（AspectJ 配置文件）一篇掌握AOP

AOP相关的术语，掌握

1、连接点
类里面的哪些方法可以被增强，这些方法就可以被称为连接点
2、切入点
实际被真正增强的方法
3、通知（增强）
（1）实例增强的逻辑部分称为通知
（2）通知有多种类型
前置通知
后置通知
环绕通知
异常通知
最终通知
4、切面
动作
把通知应用到切面点过程

AOP操作

1、Spring 框架一般都是基于 AspectJ 实现 AOP 操作
（1）AspectJ 不是 Spring 组成部分，独立 AOP 框架，一般把 AspectJ 和 Spirng 框架一起使
用，进行 AOP 操作
2、基于 AspectJ 实现 AOP 操作
（1）基于 xml 配置文件实现
（2）基于注解方式实现（使用）
3、在项目工程里面引入 AOP 相关依赖
相关的包如下：

4、切入点表达式
（1）切入点表达式作用：知道对哪个类里面的哪个方法进行增强
（2）语法结构： execution([权限修饰符] [返回类型] [类全路径] 方法名称 )
举例 1：对 com.dao.BookDao 类里面的 add 进行增强
…表示方法的参数
execution(* com.dao.BookDao.add(…))
举例 2：对 com.dao.BookDao 类里面的所有的方法进行增强
表示类中所有的方法
execution( com.dao.BookDao.* (…))
举例 3：对 com.dao 包里面所有类，类里面所有方法进行增强
execution(* com.dao.. (…))

AOP代码的展示

第一部分（基于注解的方式来实现）

1、创建类，在类里面定义方法

package AOP;

import org.springframework.stereotype.Component;

//被增强的类
@Component
public class User {
    public void add(){
        System.out.println("add.......");
    }
}

2、创建增强类（编写增强逻辑）
（1）在增强类里面，创建方法，让不同方法代表不同通知类型

package AOP;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;

//增强的类
@Component
@Aspect
public class UserProxy {
    //前置通知
    //@Before注释表示作为前置通知
    @Before(value = "execution(* AOP.User.add(..))")
    public void before(){
        System.out.println("before......");
    }


    @After(value = "execution(* AOP.User.add(..))")
    public void after(){
        System.out.println("after.......");
    }

    //返回通知
    @AfterReturning(value = "execution(* AOP.User.add(..))")
    public void afterReturning(){
        System.out.println("afterreturning.....");
    }

    @AfterThrowing(value = "execution(* AOP.User.add(..))")
    public void AfterThrowing(){
        System.out.println("AfterThrowing.....");
    }

    @Around(value = "execution(* AOP.User.add(..))")
    public void Around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable{
        System.out.println("环绕之前.....");
        //被增强的方法
        proceedingJoinPoint.proceed();
        System.out.println("环绕之后.....");
    }

}

3、进行通知的配置
（1）在 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:p="http://www.springframework.org/schema/p"
       xmlns:util="http://www.springframework.org/schema/util"
       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.xsd


    http://www.springframework.org/schema/context
    http://www.springframework.org/schema/context/spring-context.xsd
       http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd">
    <!--    开启组件的扫描1.如果扫描多个包，使用逗号来隔开2扫描这个包的上层路径
    -->
    <context:component-scan base-package="AOP"></context:component-scan>
<!--    开启Aspect生成代理对象-->
    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>
</beans>

（2）使用注解创建 User 和 UserProxy 对象，在注解上添加@Component
（3）在增强类上面添加注解 @Aspect
（4）在 spring 配置文件中开启生成代理对象
4、配置不同类型的通知
（1）在增强类的里面，在作为通知方法上面添加通知类型注解，使用切入点表达式配置
代码在上面都有所呈现

5、相同的切入点抽取

//相同切入点抽取
    @Pointcut(value = "execution(* AOP.User.add(..))")
    public void pointcut(){

    }

    //前置通知
    //@Before注释表示作为前置通知
    @Before(value = "pointcut()")
    public void before(){
        System.out.println("before......");
    }

6、有多个增强类多同一个方法进行增强，设置增强类优先级
（1）在增强类上面添加注解 @Order(数字类型值)，数字类型值越小优先级越高

@Component
@Aspect
@Order(1)
public class UserProxy {
}

7、完全使用注解开发 （1）创建配置类，不需要创建 xml 配置文件（重点，这种配置更加的方便）

package three;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.EnableAspectJAutoProxy;
import org.springframework.stereotype.Component;

@Component
@ComponentScan(basePackages = {"three"})
@EnableAspectJAutoProxy(proxyTargetClass = true)
public class ConfigAop {
}

第二部分（配置文件的方式来实现）

1、创建两个类，增强类和被增强类，创建方法

package three;

public class Book {
    public void buy(){
        System.out.println("buy.....");
    }
}

package three;

public class BookProxy {
    public void before(){
        System.out.println("before.......");
    }
}

2、在 spring 配置文件中创建两个类对象
3、在 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:p="http://www.springframework.org/schema/p"
       xmlns:util="http://www.springframework.org/schema/util"
       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.xsd


    http://www.springframework.org/schema/context
    http://www.springframework.org/schema/context/spring-context.xsd
       http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd">
 

<!--    创建对象-->
    <bean id="book" class="three.Book"></bean>
    <bean id="bookProxy" class="three.BookProxy"></bean>
<!--    配置AOP超强-->
    <aop:config>
<!--        切入点-->
        <aop:pointcut id="p" expression="execution(* three.Book.buy(..))"/>
<!--        配置切面-->
        <aop:aspect ref="bookProxy">
<!--            增强作用在具体的方法上-->
            <aop:before method="before" pointcut-ref="p"></aop:before>
        </aop:aspect>
    </aop:config>
</beans>

执行效果：