Spring----AOP (面向切面)

1、AOP (面向切面)

• 主要功能
  • 日志记录
  • 性能统计
  • 安全控制，
  • 事务处理
  • 异常处理等

1.1、使用Spring实现AOP

  	首先，要使用AOP织入，需要导入一个jar包。
  	在这里我们使用maven依赖

注：我创建的为子项目，继承父类的pom依赖，如果你创建新项目还需导入spring-webmvc依赖，以及junit包，如下：

<dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjweaver</artifactId>
    <version>1.9.8</version>
</dependency>
<dependency>
     <groupId>org.springframework</groupId>
     <artifactId>spring-webmvc</artifactId>
     <version>5.3.18</version>
 </dependency>
<dependency>
     <groupId>junit</groupId>
     <artifactId>junit</artifactId>
     <version>4.11</version>
</dependency>

搭建接口环境及实现类：

package com.ss.service;


public interface UserService {
    
    public void add();
    public void delete();
    public void update();
    public void query();
}

package com.ss.service;


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 query() {
        System.out.println("查找了一个用户");
    }
}

方式一:使用原生Spring api接口

<?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">

	<!--使用原生Spring Api接口需要对类进行bean注册-->
    <bean id="UserService" class="com.ss.service.UserServiceImpl"/>
    <bean id="before" class="com.ss.log.Log"/>
    <bean id="after" class="com.ss.log.AfterLog"/>

<!--方式一:使用原生Spring api接口-->
<!--配置aop需要导入aop的约束-->
    <aop:config>
        <!--切入点   expression:表达式   execution(要执行的位置！ 修饰词 返回值 类名 方法名 参数 )-->

        <!--第一个* 代表的是方法类型
            参数用（..）表示
            com.ss.service.UserServiceImpl.* 表示该类下的所有方法
        -->

        <aop:pointcut id="pointcut" expression="execution(* com.ss.service.UserServiceImpl.* (..))"/>
        <!--执行环绕增加-->
        <aop:advisor advice-ref="after" pointcut-ref="pointcut"/>
        <aop:advisor advice-ref="before" pointcut-ref="pointcut"/>
    </aop:config>

</beans>

使用AOP实现接口

• 前置通知（Before advice）：在某连接点之前执行的通知，但这个通知不能阻止连接点之前的执行流程（除非它抛出一个异常）。
• 后置通知（After returning advice）：在某连接点正常完成后执行的通知：例如，一个方法没有抛出任何异常，正常返回。
• 异常通知（After throwing advice）：在方法抛出异常退出时执行的通知。
• 最终通知（After (finally) advice）：当某连接点退出的时候执行的通知（不论是正常返回还是异常退出）。
• 环绕通知（Around Advice）：包围一个连接点的通知，如方法调用。这是最强大的一种通知类型。环绕通知可以在方法调用前后完成自定义的行为。它也会选择是否继续执行连接点或直接返回它自己的返回值或抛出异常来结束执行。

写对应java类进行测试：
此类为前置切面：在运行结果前执行

package com.ss.log;

import org.springframework.aop.MethodBeforeAdvice;

import java.lang.reflect.Method;

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

此类为后置切面：在运行结果前执行

package com.ss.log;

import org.springframework.aop.AfterReturningAdvice;

import java.lang.reflect.Method;

public class AfterLog implements AfterReturningAdvice {
    
    @Override
    public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {
        System.out.println("执行了"+method.getName()+"方法，返回结果为："+returnValue+" 参数是："+args.toString()+" 目标对象："+target);
    }
}

编写测试类(此测试类可同之后方式共享)

import com.ss.service.UserService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class test {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
    
        UserService service = context.getBean("UserService", UserService.class);
        service.add();
    }
}

运行结果如下：

方式二：自定义类（切面定义）

编写自定义方法，进行切面

package com.ss.log;

public class DIY {
    
    public void before(){
        System.out.println("------------------------");
    }
    public void after(){
        System.out.println("------------------------");
    }
}

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

运行结果如下：

方式三：使用注解实现

<!--方法三：注解-->
    <bean id="UserService" class="com.ss.service.UserServiceImpl"/>
    <bean id="anno" class="com.ss.log.AnnoDiy"/>
    <aop:aspectj-autoproxy/>  <!--开启注解支持-->
    <context:component-scan base-package="com.ss"/>

package com.ss.log;

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//标注这个面是一个切面
public class AnnoDiy {
    
    @Before("execution(* com.ss.service.UserServiceImpl.* (..))")
    public void before(){
        System.out.println("方法执行前");
    }
    
    @After("execution(* com.ss.service.UserServiceImpl.* (..))")
    public void after(){
        System.out.println("方法执行后");
    }
    
    @Around("execution(* com.ss.service.UserServiceImpl.* (..))")
    public void around(ProceedingJoinPoint jp) throws Throwable {
        System.out.println("环绕前");
        jp.proceed();
        System.out.println("环绕后");
    }
}

运行结果如下：

注意：在不使用注解的情况下，一定要进行配置bean，否则
Exception in thread "main" org.springframework.beans.factory.NoSuchBeanDefinitionException: No bean named 'UserService' available
若使用注解，一定要进行
<aop:aspectj-autoproxy/> <!--开启注解支持-->
<context:component-scan base-package="com.ss"/><!--扫包-->
初次之外，可在类名前使用@component进行bean注册，
相当于<bean id="UserService" class="com.ss.service.UserServiceImpl"/>