AOP

一、什么是AOP？

Aspect oriented programming 面向切面编程，AOP 是 OOP（面向对象编程）的一种延续。

链接：面试被问了几百遍的 IoC 和 AOP ，还在傻傻搞不清楚？ - 知乎 (zhihu.com)

通过OOP思想中的继承，可以多个类继承一个父类，其中父类中含有他们基本的方法 ，但是在继承的方法中可能含有多个重复的代码，这部分代码就被称为横切逻辑代码

例如：现有三个类，Horse、Pig、Dog，这三个类中都有 eat 和 run 两个方法，这三个类可以按照OOP思想来继承动物Animal类

/**
 * 动物父类
 */
public class Animal {

    /** 身高 */
    private String height;

    /** 体重 */
    private double weight;

    public void eat() {
        // 性能监控代码
        long start = System.currentTimeMillis();

        // 业务逻辑代码
        System.out.println("I can eat...");

        // 性能监控代码
        System.out.println("执行时长：" + (System.currentTimeMillis() - start)/1000f + "s");
    }

    public void run() {
        // 性能监控代码
        long start = System.currentTimeMillis();

        // 业务逻辑代码
        System.out.println("I can run...");

        // 性能监控代码
        System.out.println("执行时长：" + (System.currentTimeMillis() - start)/1000f + "s");
    }
}

横切逻辑代码存在的问题：

• 代码重复问题
• 横切逻辑代码和业务代码混杂在一起，代码臃肿，不变维护

AOP就是来解决这些问题的

AOP就是将横切逻辑代码和业务逻辑代码分离

二、使用Spring实现AOP

【重点】使用AOP值入，需要导入一个依赖包！

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

方式一：使用Spring的API接口【主要是SpringAPI接口实现】

<!--方式一：使用原生Spring API接口-->
<!--配置aop：需要导入aop的约束-->
<aop:config>
    <!--切入点： expression:表达式，exeution(要执行的位置！*****)-->
    <aop:pointcut id="pointcut" expression="execution(* com.z.service.UserServiceI  mpl.*(..))"/>

    <!--执行环绕增加！-->
    <aop:advisor advice-ref="log" pointcut-ref="pointcut"/>
    <aop:advisor advice-ref="afterlog" pointcut-ref="pointcut"/>

</aop:config>

public class Log implements MethodBeforeAdvice {


    //method：要执行的目标对象的方法
    //args：参数
    //target：目标对象
    @Override
    public void before(Method method, Object[] args, Object target) throws Throwable {
        System.out.println(target.getClass().getName()+"的"+method.getName()+"被执行了");
    }
}

public class AfterLog implements AfterReturningAdvice {

    //returnValue:返回值

    @Override
    public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {
        System.out.println("执行了"+method.getName()+"方法，返回结果为："+returnValue);
    }
}

方式二：自定义类来实现AOP 【主要是切面定义，也就是含有要切入方法的那个类】

<!--方式二：自定义类-->
<bean id="diy" class="com.z.diy.DiyPointCut"></bean>
<aop:config>
    <!--自定义切面，ref要引用的类-->
    <aop:aspect ref="diy">
    <!--切入点-->
        <aop:pointcut id="point" expression="execution(* com.z.service.UserServiceImpl.*(..))"/>
        <!--通知-->
        <aop:before method="before" pointcut-ref="point"/>
        <aop:after method="after" pointcut-ref="point"/>
    </aop:aspect>
</aop:config>

public class DiyPointCut {
    public void before(){
        System.out.println("====方法前====1");
    }
    public void after(){
        System.out.println("====方法后====11");
    }
}

方式三：使用注解实现！

<!--方式三：-->
<bean id="annotationpointcut" class="com.z.diy.AnnotationPointCut"/>
<!--开启注解支持-->
<aop:aspectj-autoproxy/>

@Aspect  //标注这个类是一个切面
public class AnnotationPointCut {
    @Before("execution(* com.z.service.UserServiceImpl.*(..))")
    public void before(){
        System.out.println("====方法前====");
    }

    @After("execution(* com.z.service.UserServiceImpl.*(..))")
    public void after(){
        System.out.println("====方法后====");
    }

    //在环绕增强中，我们可以给定一个参数，代表我们要获取处理切入的点
    @Around("execution(* com.z.service.UserServiceImpl.*(..))")
    public void around(ProceedingJoinPoint jp) throws Throwable {
        System.out.println("环绕前");
        Signature signature=jp.getSignature();
        System.out.println("signayure："+signature);
        //执行方法
        Object proceed = jp.proceed();

        System.out.println("环绕后");
    }
}