基于注解实现SpringAOP

一、AOP的核心概念

1、连接点(JoinPoint): 程序执行的某一个特定位置,即类某一个方法调用前/调用后,方法抛出异 常后,一个类或一段程序代码拥有一些具有边界性质的特定点。Spring仅支持方法连接点。
2、切点(Pointcut): 连接点的集合。
3、增强(Advice(通知)): 切点处要执行的代码。
4、目标对象(target): 增强逻辑的织入目标类。
5、引介(Introduction):一种特殊的增强,它为类添加一些属性和方法.这样,即使一个业务类原本 没有实现某一个接口,通过AOP的引介功能,也可以动态地为该业务类添加接口的实现逻辑. 让业务类成为这个接口的实现类。
6、织入(Weaving):织入是将增强添加到目标类具体链接点上的过程,即通知执行到切点的过程。
7、代理(proxy): 增强后的代理类。
8、切面(Aspect): 由增强(或通知)和切点共同组成。

二、AOP的五种通知

1、前置通知：目标方法运行之前调用。
2、后置通知(如果出现异常不会调用)：在目标方法运行之后调用。
3、环绕通知：在目标方法之前和之后都调用。
4、异常拦截通知：如果出现异常，就会调用。
5、返回通知(无论是否出现 异常都会调用)：在目标方法运行之后调用。

三、基于注解实现SpringAOP的具体配置

1、在pom.xml中加入如下代码：

<dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>com.springsource.org.aspectj.weaver</artifactId>
            <version>1.6.8.RELEASE</version>
        </dependency>

2、在resource下创建beans.xml：

<?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"
       xmlns:context="http://www.springframework.org/schema/context"
       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
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd">

    
    <context:component-scan base-package="com.qianfeng.aop06" />

    
    <aop:aspectj-autoproxy />
</beans>

其中context:component-scan标签指组件扫描
base-package是指定要扫描的包的路径
<aop:aspectj-autoproxy />标签实现自动代理

3、创建一个接口类和实现类：

package com.qianfeng.aop06;

import org.springframework.stereotype.Component;

import java.util.ArrayList;
import java.util.List;

@Component("us")
public class UserServiceImpl implements IUserService {

    @Override
    public List<Object> getAllUser() {
        System.out.println("--------getAllUser----------");
        return new ArrayList<>();
    }

    @Override
    public boolean saveUser(Object user) {
        System.out.println("--------saveUser----------");
        return true;
    }

    @Override
    public boolean deleteUser(int uid) {
        System.out.println("--------deleteUser----------");
        return false;
    }

    @Override
    public boolean updateUser(Object obj) {
        System.out.println("--------updateUser----------");
        return true;
    }

    @Override
    public void getUserByUid() {
        System.out.println("--------getUserByUid----------");
        System.out.println(1 / 0);
        String str = null;
        System.out.println(str.length());
    }
}

package com.qianfeng.aop06;

import java.util.List;

public interface IUserService {

    /**
     * 获取所有的用户对象列表
     * @return
     */
    List<Object> getAllUser();

    /**
     * 保存用户
     * @param user
     * @return
     */
    boolean saveUser(Object user);

    /**
     * 根据用户uid删除该uid对应的用户信息
     * @param uid
     * @return
     */
    boolean deleteUser(int uid);

    /**
     * 更新指定用户信息
     * @param obj
     * @return
     */
    boolean updateUser(Object obj);


    void getUserByUid();
}

4、以注解的方式实现切面类MyAspect

(1)代码主体前加的注解：
@Component注解标注当前类是一个组件，在扫描时会被扫描进来
@Aspect标注当前类是一个切面类

(2)

@Pointcut(value = "execution(* com.qianfeng.aop06.*.*(..))")
    public void setAll(){}

@Pointcut 注解为了避免相同的匹配规则被定义多处，专门定义该方法设置执行的匹配规则，各个自行调用即可

(3)

@Before("setAll()")
    public void myBefore(JoinPoint jp){
        System.out.println("this is before.");
    }

@Before 表示该方法为一个前置通知

(4)

@After("setAll()")
    public void myAfter(JoinPoint jp){
        System.out.println("this is after.");
    }

@After 表示该方法为一个后置通知

(5)

@Around("setAll()")
    public Object myAround(ProceedingJoinPoint pjp){
        Object obj = null;
        try {
            System.out.println("this is around before");

            obj = pjp.proceed();


            System.out.println("this is around after");
        } catch (Throwable throwable) {
            throwable.printStackTrace();
        }

        return obj;
    }

@Around 表示该方法为一个环绕通知
@ pjp 处理连接点
@return 返回每个业务方法的返回值

(6)

@AfterReturning(value = "setAll()", returning = "obj")
    public void myReturn(JoinPoint jp, Object obj){
        System.out.println("this is after returnning " + obj);
    }

@AfterReturning 表示该方法为一个带有返回值的通知

(7)

@AfterThrowing(value = "setAll()", throwing = "e")
    public void myThrowing(JoinPoint jp, Throwable e){
        System.out.println("this is after throwing " + e.getMessage());
    }

@AfterThrowing 表示该方法为一个带有异常的通知

(8)总体代码如下：

@Component          //  标注当前类为一个组件
@Aspect             //  标注当前类为一个切面类
public class MyAspect {

    /**
     * @Pointcut 注解为了避免相同的匹配规则被定义多处，专门定义该方法设置执行的匹配规则，各个自行调用即可
     *    write once， only once
     */
    @Pointcut(value = "execution(* com.qianfeng.aop06.*.*(..))")
    public void setAll(){}


    /**
     * @Before 表示该方法为一个前置通知
     * @param jp 连接点
     */
    @Before("setAll()")
    public void myBefore(JoinPoint jp){
        System.out.println("this is before.");
    }

    /**
     * @After 表示该方法为一个后置通知
     * @param jp 连接点
     */
    @After("setAll()")
    public void myAfter(JoinPoint jp){
        System.out.println("this is after.");
    }

    /**
     * @Around 表示该方法为一个环绕通知
     * @param pjp 处理连接点
     * @return 返回每个业务方法的返回值
     */
    @Around("setAll()")
    public Object myAround(ProceedingJoinPoint pjp){
        Object obj = null;
        try {
            System.out.println("this is around before");

            obj = pjp.proceed();


            System.out.println("this is around after");
        } catch (Throwable throwable) {
            throwable.printStackTrace();
        }

        return obj;
    }

    /**
     * @AfterReturning 表示该方法为一个带有返回值的通知
     * @param jp 连接点
     * @param obj 业务方法的返回值
     */
    @AfterReturning(value = "setAll()", returning = "obj")
    public void myReturn(JoinPoint jp, Object obj){
        System.out.println("this is after returnning " + obj);
    }

    /**
     * @AfterThrowing 表示该方法为一个带有异常的通知
     * @param jp 连接点
     * @param e Throwable对象
     */
    @AfterThrowing(value = "setAll()", throwing = "e")
    public void myThrowing(JoinPoint jp, Throwable e){
        System.out.println("this is after throwing " + e.getMessage());
    }

注解方式的执行顺序为：(after throwing) around before>before > 业务方法 > around-after > after >after returning

最后编辑于 ：
©著作权归作者所有,转载或内容合作请联系作者
平台声明：文章内容（如有图片或视频亦包括在内）由作者上传并发布，文章内容仅代表作者本人观点，简书系信息发布平台，仅提供信息存储服务。
禁止转载，如需转载请通过简信或评论联系作者。

推荐阅读更多精彩内容

  • 【Spring实战】面向切面编程
    本章内容： 面向切面编程的基本原理 通过POJO创建切面 使用@AspectJ注解 为AspectJ切面注入依赖 ...
    谢随安阅读 3,203评论 0赞 9
  • Spring day5
    面向切面编程（AOP） 什么是面向切面编程 AOP是面向切面的编程，其编程思想是把散布于不同业务但功能相同的代码从...
    cifang12阅读 98评论 0赞 0
  • Spring Framework 5 Core 学习笔记
    IoC 容器 Bean 的作用域 自定义作用域实现 org.springframework.beans.facto...
    Hsinwong阅读 2,517评论 0赞 7
  • Spring-AOP基础
    1.概述 Aop（Aspect Oriented Programming），即面向切面编程，这是面向对象思想的一种...
    Tian_Peng阅读 3,561评论 0赞 2
  • Spring学习笔记
    概述 Spring是什么？ Spring是一个开源框架，为了解决企业应用开发的复杂性而创建的，但是现在已经不止于企...
    琅筑阅读 1,207评论 2赞 8