08 spring中的AOP

    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.0.2.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.8.7</version>
        </dependency>
    </dependencies>

二、导入配置文件约束

bean.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"
       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">


</beans>

三、编写业务层接口与实现类

IAccountService接口

/**
 * 模拟账户的业务层接口
 *
 * @author MaRui
 * @date 2021-05-02 18:47
 */
public interface IAccountService {
    /**
     * 模拟保存账户的方法
     */
    void saveAccount();

    /**
     * 模拟更新账户的方法
     * @param id
     */
    void updateAccount(int id);

    /**
     * 模拟删除账户的方法
     * @return
     */
    int deleteAccount();
}

AccountService实现类

import com.marui.service.IAccountService;

/**
 * @author MaRui
 * @date 2021-05-02 18:50
 */
public class AccountService implements IAccountService {
    @Override
    public void saveAccount() {
        System.out.println("执行了保存方法");
    }

    @Override
    public void updateAccount(int id) {
        System.out.println("执行了更新方法");
    }

    @Override
    public int deleteAccount() {
        System.out.println("执行了删除方法");
        return 0;
    }
}

四、编写通知工具类

Logger工具类

/**
 * 用于记录日志的工具类，提供了公共代码
 *
 * @author MaRui
 * @date 2021-05-02 18:53
 */
public class Logger {

    public void beforePrintLog() {
        System.out.println("前置通知方法执行了");
    }

    public void afterReturningPrintLog() {
        System.out.println("后置通知方法执行了");
    }

    public void afterThrowingPrintLog() {
        System.out.println("异常通知方法执行了");
    }

    public void afterPrintLog() {
        System.out.println("最终通知方法执行了");
    }
}

8.3.2 四种通知的配置

ean.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"
       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的IoC，把service对象配置进来-->
    <bean id="accountService" class="com.marui.service.impl.AccountServiceImpl"></bean>

    <!--spring中基于xml的aop配置步骤
    1. 把通知Bean也交给spring管理
    2. 使用<aop:config>标签表名开始AOP的配置
    3. 使用<aop:aspect>标签表名配置切面
        id属性：给切面定义一个唯一标识
        ref属性：是指定通知类bean的id
    4. 在<aop:aspect>标签的内部使用对应标签来配置通知的类型
        （1）<aop:before>标签：表示配置前置通知
                method属性：用于指定通知类中的哪个方法是前置通知
                pointcut属性：用于指定切入点表达式，该表达式的含义是指对业务层哪些方法增强
                pointcut-ref属性：用于引用<aop:pointcut>中的切入点表达式
                    切入点表达式写法： execution(访问修饰符 返回值 包名.类名.方法名(参数列表))
                    切入点表达式全通配写法： execution(* *..*.*(..))
                    切入点表达式常用写法：execution(* com.marui.service.impl.*.*(..))
        （2）<aop:after-returning>:表示配置后置通知
        （3）<aop:after-throwing>:表示配置异常通知，与后置通知不能同时存在
        （4）<aop:after>:表示配置最终通知
        （5）<aop:after>:表示配置最终通知
        （6）<aop:pointcut>：切入点标签，当定义在<aop:aspect>内时，只有当前切面有效，若写在外面，则所有切面生效
                id属性：用于指定切表达式的唯一标识
                expression属性：用于指定表达式内容
     -->
    <!--配置通知类-->
    <bean id="logger" class="com.marui.utils.Logger"></bean>

    <!--配置AOP-->
    <aop:config>
        <!--配置切面-->
        <aop:aspect id="logAdvice" ref="logger">
            <!--配置前置通知:在切入点方法执行前执行-->
            <aop:before method="beforePrintLog" pointcut="execution(* com.marui.service.impl.*.*(..))"></aop:before>
            <!--配置后置通知：在切入点方法正常执行后执行-->
            <aop:after-returning method="afterReturningPrintLog" pointcut="execution(* com.marui.service.impl.*.*(..))"></aop:after-returning>
            <!--配置异常通知：在切入点方法产生异常后执行-->
            <aop:after-throwing method="afterThrowingPrintLog" pointcut="execution(* com.marui.service.impl.*.*(..))"></aop:after-throwing>
            <!--配置最终通知：无论如何都会执行-->
            <aop:after method="afterPrintLog" pointcut-ref="pointcut1"></aop:after>
            <!--配置切入点通用表达式-->
            <aop:pointcut id="pointcut1" expression="execution(* com.marui.service.impl.*.*(..))"/>
        </aop:aspect>
    </aop:config>
</beans>

8.3.3 环绕通知的配置

Logger工具类

import org.aspectj.lang.ProceedingJoinPoint;

/**
 * 用于记录日志的工具类，提供了公共代码
 *
 * @author MaRui
 * @date 2021-05-02 18:53
 */
public class Logger {

    public void beforePrintLog() {
        System.out.println("前置通知方法执行了");
    }

    public void afterReturningPrintLog() {
        System.out.println("后置通知方法执行了");
    }

    public void afterThrowingPrintLog() {
        System.out.println("异常通知方法执行了");
    }

    public void afterPrintLog() {
        System.out.println("最终通知方法执行了");
    }

    public Object aroundPrintLog(ProceedingJoinPoint pjp) {
        beforePrintLog();
        Object returnValue = null;
        try {
            returnValue = pjp.proceed(pjp.getArgs());
            afterReturningPrintLog();
        } catch (Throwable throwable) {
            afterThrowingPrintLog();
            throwable.printStackTrace();
        } finally {
            afterPrintLog();
        }
        return returnValue;
    }
}

bean.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"
       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的IoC，把service对象配置进来-->
    <bean id="accountService" class="com.marui.service.impl.AccountServiceImpl"></bean>
    <!--配置通知类-->
    <bean id="logger" class="com.marui.utils.Logger"></bean>

    <!--配置AOP-->
    <aop:config>
        <!--配置切面-->
        <aop:aspect id="logAdvice" ref="logger">
            <!--配置环绕通知-->
            <aop:around method="aroundPrintLog" pointcut-ref="pointcut1"></aop:around>
            <!--配置切入点表达式-->
            <aop:pointcut id="pointcut1" expression="execution(* com.marui.service.impl.*.*(..))"/>
        </aop:aspect>
    </aop:config>
</beans>

8.4 spring基于注解的AOP配置

spring基于注解的aop配置，在使用四种通知进行配置时有调用顺序问题，谨慎使用推荐使用环绕通知。

8.4.1 编写配置文件

bean.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">

        <!-- 配置spring创建容器时要扫描的包-->
        <context:component-scan base-package="com.marui"></context:component-scan>
       <!-- 开启spring注解aop的支持-->
        <aop:aspectj-autoproxy></aop:aspectj-autoproxy>
</beans>

8.4.2 添加注解

AccountServiceImpl实现类

import com.marui.service.IAccountService;
import org.springframework.stereotype.Service;

/**
 * @author MaRui
 * @date 2021-05-02 18:50
 */
@Service("accountService")
public class AccountServiceImpl implements IAccountService {
    @Override
    public void saveAccount() {
        System.out.println("执行了保存方法");
    }

    @Override
    public void updateAccount(int id) {
        System.out.println("执行了更新方法");
    }

    @Override
    public int deleteAccount() {
        System.out.println("执行了删除方法");
        return 0;
    }
}

使用四种基本通知的Logger工具类

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

/**
 * 用于记录日志的工具类，提供了公共代码
 *
 * @author MaRui
 * @date 2021-05-02 18:53
 */
@Component("logger")
//表示为切面
@Aspect
public class Logger {
    //定义通用的切入点表达式
    @Pointcut("execution(* com.marui.service.impl.*.*(..))")
    private void pointcut1() {

    }
    @Before("execution(* com.marui.service.impl.*.*(..))")
    public void beforePrintLog() {
        System.out.println("前置通知方法执行了");
    }
    @AfterReturning(pointcut = "execution(* com.marui.service.impl.*.*(..))")
    public void afterReturningPrintLog() {
        System.out.println("后置通知方法执行了");
    }
    @AfterThrowing("execution(* com.marui.service.impl.*.*(..))")
    public void afterThrowingPrintLog() {
        System.out.println("异常通知方法执行了");
    }
    @After("pointcut1()")
    public void afterPrintLog() {
        System.out.println("最终通知方法执行了");
    }

    public Object aroundPrintLog(ProceedingJoinPoint pjp) {
        beforePrintLog();
        Object returnValue = null;
        try {
            returnValue = pjp.proceed(pjp.getArgs());
            afterReturningPrintLog();
        } catch (Throwable throwable) {
            afterThrowingPrintLog();
            throwable.printStackTrace();
        } finally {
            afterPrintLog();
        }
        return returnValue;
    }
}

使用环绕通知配置的Logger工具类

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

/**
 * 用于记录日志的工具类，提供了公共代码
 *
 * @author MaRui
 * @date 2021-05-02 18:53
 */
@Component("logger")
//表示为切面
@Aspect
public class Logger {
    //定义通用的切入点表达式
    @Pointcut("execution(* com.marui.service.impl.*.*(..))")
    private void pointcut1() {

    }

    public void beforePrintLog() {
        System.out.println("前置通知方法执行了");
    }

    public void afterReturningPrintLog() { System.out.println("后置通知方法执行了"); }

    public void afterThrowingPrintLog() {
        System.out.println("异常通知方法执行了");
    }

    public void afterPrintLog() {
        System.out.println("最终通知方法执行了");
    }

    @Around("pointcut1()")
    public Object aroundPrintLog(ProceedingJoinPoint pjp) {
        beforePrintLog();
        Object returnValue = null;
        try {
            returnValue = pjp.proceed(pjp.getArgs());
            afterReturningPrintLog();
        } catch (Throwable throwable) {
            afterThrowingPrintLog();
            throwable.printStackTrace();
        } finally {
            afterPrintLog();
        }
        return returnValue;
    }
}

8.4.3 使用纯注解配置AOP

在主配置文件上加上@EnableAspectJAutoProxy注解。

内容总结

以上是互联网集市为您收集整理的08 spring中的AOP全部内容，希望文章能够帮你解决08 spring中的AOP所遇到的程序开发问题。如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。

内容备注

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容，请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。

内容手机端

扫描二维码推送至手机访问。

本文链接：https://qyyshop.com/info/992533.html

来源：【匿名】

【上一篇】Double-ended Strings 【下一篇】关于IE的RegExp.exec的问题

更多 ►

【08 spring中的AOP】教程文章相关的互联网学习教程文章

AOP就是面向切面编程，我们可以从几个层面来实现AOP。在编译器修改源代码，在运行期字节码加载前修改字节码或字节码加载后动态创建代理类的字节码，以下是各种实现机制的比较。 spring AOP是Spring框架面向切面的编程思想，AOP采用一种称为“横切”的技术，将涉及多业务流程的通用功能抽取并单独封装，形成独立的切面，在合适的时机将这些切面横向切入到业务流程指定的位置中。AOP到底能做什么呢？ AOP能做的事情非常多。性能...

Spring AOP aspectjweaver.jar与aopalliance-1.0.jar 下载地址【图】

aspectjweaver.jar 官方下载地址： https://mvnrepository.com/artifact/org.aspectj/aspectjweaver aopalliance-1.0.jar 官方下载地址： https://mvnrepository.com/artifact/aopalliance/aopalliance/1.0

基于aop注解形式和 mybatis-plus3.4.2实现数据权限控制【代码】

1、实现思路，通过ThreadLocal获取是否开启数据权限，开启则通过mybatis-plus的DataPermissionHandler实现数据权限 controller上添加的注解DataScope.java package com.pojo.common.datascope.annotation;import com.pojo.common.core.config.HkhjDataPermissionHandler; import com.pojo.common.core.utils.DataScopeContext;import java.lang.annotation.Documented; import java.lang.annotation.ElementType; import java.lang...

基于AOP注解实现业务功能的动态配置【代码】

一、导入jar包<dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-aop</artifactId></dependency> 二、自定义注解package com.test.domi.annotation; import java.lang.annotation.ElementType; import java.lang.annotation.Retention; import java.lang.annotation.RetentionPolicy; import java.lang.annotation.Target;/*** 标注业务功能注解*/ @Target({ElementType....

spring第三天轻松理解AOP思想(面向切面编程)【图】

转载自:https://www.cnblogs.com/Wolfmanlq/p/6036019.html 本文旨在帮助还没有理解AOP的童鞋看透弄懂AOP，也欢迎高手批评指正。先说一个Spring是什么吧，大家都是它是一个框架，但框架这个词对新手有点抽象，以致于越解释越模糊，不过它确实是个框架的，但那是从功能的角度来定义的，从本质意义上来讲，Spring是一个库，一个Java库，所以我个人觉得应该这样回答Spring是什么：Spring是一个库，它的功能是提供了一个软件框架，这...

Spring——IOC、AOP、事务【代码】【图】

1.IOC1.什么是控制反转？就是把创建和管理bean的过程交给第三方，而这个第三方就是IoC容器。容器负责创建、配置和管理bean，也就是管理着bean的生命，控制着bean的依赖注入。 1. 为什么要用 IoC 这种思想呢？答：解藕。本来ABCD是互相关联在一起的，当加入第三方容器的管理后，每个对象都和第三方Ioc容器相互关联，ABCD彼此不再联系，解除了耦合关系，全由容器来实现。 2. 什么是bean？——包装好了的Object Bean其实就是包装...

AOP框架Dora.Interception 3.0 [5]: 基于策略的拦截器注册方式【代码】

注册拦截器旨在解决如何将拦截器应用到目标方法的问题。在我看来，针对拦截器的注册应该是明确而精准的，也就是我们提供的注册方式应该让拦截器准确地应用到期望的目标方法上，不能多也不能少。如果注册的方式过于模糊，很容易将拦截器应用到非目标方法上。按照这个原则，一些AOP框架提供的针对类型命名空间、类型或者成员名称前（后）缀的拦截器映射策略其实都是不严谨的。Dora.Interception只提供两种严谨的拦截器注册方式，一种...

Spring AOP之AspectJ实现方式【代码】【图】

案例源码下载：https://gitee.com/yangzhenyu322/Spring-aop.git ①：添加配置xmlns:aop="http://www.springframework.org/schema/aop"http://www.springframework.org/schema/aophttps://www.springframework.org/schema/aop/spring-aop.xsd将上面配置添加到beans配置中： <beans xmlns="http://www.springframework.org/schema/beans"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xmlns:context="http://www.springfra...

Spring实现AOP的4种方式

来自：http://blog.csdn.net/udbnny/article/details/5870076 先了解AOP的相关术语:1.通知(Advice):通知定义了切面是什么以及何时使用。描述了切面要完成的工作和何时需要执行这个工作。2.连接点(Joinpoint):程序能够应用通知的一个“时机”，这些“时机”就是连接点，例如方法被调用时、异常被抛出时等等。3.切入点(Pointcut)通知定义了切面要发生的“故事”和时间，那么切入点就定义了“故事”发生的地点，例如某个类或方法的名...

黑马----面向方面编程AOP【图】

黑马程序员：Java培训、Android培训、iOS培训、.Net培训 JAVA反射－面向方面编程AOP一、面向方面的需求有如下模型：需要统计客户登录时间、使用系统情况，或系统运行日记等信息时，我们就需要到AOP。二、上述模型可转换为面向对象编程模型：即面向方面编程AOP 客户对任何方法的调用都会重定向到处理器上，这样我们就实现对客户行为的统计。三、实例代码 1、技术要点：将系统功能...

AOP 面向切面编程

AOP 面向切面编程AOP 即面向切面编程，是一种编程思想。可以将一个通用代码或业务组件，通过配置的方式，动态的添加到一个或多个对象上。已实现代码的复用，和业务组件模块之间的解耦合。通常可用动态的程序扩展及一些系统层面的问题处理（日志记录，事务，权限等）AOP中相关概念：1) Aspect 切面：即通用的业务代码。需要动态添加到其他对象上去的代码。2) JoinPoint 连接点：指的是切面组件在目标对象上作用的具体位置。（具体的...

Spring源码学习(十八)---基于注解配置Aop的aspectj-autoproxy解析【代码】【图】

这里主要是使用org.springframework:spring-beans:5.2.0.RELEASE进行分析文章目录 ①. aspectj-autoproxy标签1. proxy-target-class属性2. expose-proxy属性 ②. aspectj-autoproxy标签解析③. DefaultBeanDefinitionDocumentReader类的parseBeanDefinitions方法④. 通过parseCustomElement解析自定义标⑤. Namespacehandler接口⑥. 获取NamespaceHandler⑦. AopNamespaceHandler的init方法⑧. 通过NamespaceHandler的parse方法解...

spring学习之aspectj的注解aop【图】

基于aspectj的注解aop 1 使用注解方式实现aop操作第一步创建对象第二步在spring核心配置文件中，开启aop配置第三步在增强类上面使用注解完成aop操作

Spring笔记：AOP介绍与源码剖析【代码】【图】

文章目录前言一、AOP介绍二、AOP源码剖析1.代理对象创建1.1 AOP基础用例准备1.2 时机点分析1.3 代理对象创建流程暂停(有事，这文章后两天再往下写，先把作业提交了)前言好记性不如烂笔头，做记录亦是复习。加油一、AOP介绍 AOP本质：在不改变原有业务逻辑的情况下增强横切逻辑，横切逻辑代码往往是权限校验代码、日志代码、事务控制代码、性能监控代码。上图描述的就是未采用AOP思想设计的程序，当红色框中圈定的方法时，会带来...

Spring AOP 源码解析【代码】【图】

原文链接：https://www.javadoop.com/post/spring-aop-source文章目录前言本文使用的调试代码IOC 容器管理 AOP 实例ProxyFactory 详解基于注解的 Spring AOP 源码分析闲聊 InstantiationAwareBeanPostProcessor小结之前写过 IOC 的源码分析，那篇文章真的有点长，看完需要点耐心。很多读者希望能写一写 Spring AOP 的源码分析文章，这样读者看完 IOC + AOP 也就对 Spring 会有比较深的理解了。今天终于成文了，可能很多读者早就不...

首页 / 更多教程 / 08 spring中的AOP

08 spring中的AOP

内容导读

内容图文

8 spring中的AOP

8.1 AOP的概述

8.1.1 什么是AOP

8.1.2 AOP的优势与作用

8.1.3 AOP的实现方式

8.2 spring中的AOP

8.2.1 AOP相关术语

8.2.2 使用spring中AOP需要做的事

8.3 spring基于xml的AOP配置

8.3.1 环境准备

8.3.2 四种通知的配置

8.3.3 环绕通知的配置

8.4 spring基于注解的AOP配置

8.4.1 编写配置文件

8.4.2 添加注解

8.4.3 使用纯注解配置AOP

内容总结

内容备注

内容手机端

【08 spring中的AOP】教程文章相关的互联网学习教程文章

更多教程 - 最新教程

更多教程 - 最热教程