首页 / ASP / 使用 AspectJ 框架实现 Spring AOP

使用 AspectJ 框架实现 Spring AOP

内容导读

互联网集市收集整理的这篇技术教程文章主要介绍了使用 AspectJ 框架实现 Spring AOP，小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含7749字，纯文字阅读大概需要12分钟。

内容图文

AspectJ 是基于注释（Annotation）的，所以需要 JDK5.0 以上的支持。

AspectJ 支持的注解类型如下：

@Before
@After
@AfterReturning
@AfterThrowing
@Around

准备工作

首先定义一个简单的 bean，CustomerBo 实现了接口 ICustomerBo。ICustomerBo.java 如下：

        package com.shiyanlou.spring.aop.aspectj;

public interface ICustomerBo {
    void addCustomer();
    void deleteCustomer();
    String AddCustomerReturnValue();
    void addCustomerThrowException() throws Exception;
    void addCustomerAround(String name);
}

CustomerBo.java 如下：

        package com.shiyanlou.spring.aop.aspectj;

public class CustomerBo implements ICustomerBo {

    public void addCustomer() {
        System.out.println("addCustomer() is running ...");
    }

    public void deleteCustomer() {
        System.out.println("deleteCustomer() is running ...");
    }

    public String AddCustomerReturnValue() {
        System.out.println("AddCustomerReturnValue() is running ...");
        return "abc";
    }

    public void addCustomerThrowException() throws Exception {
        System.out.println("addCustomerThrowException() is running ...");
        throw new Exception("Generic Error");
    }

    public void addCustomerAround(String name) {
        System.out.println("addCustomerAround() is running ,args:"+name);

    }

}

简单的 AspectJ，Advice 和 Pointcut 结合在一起

首先没有引入 Aspect 之前，Advice 和 Pointcut 是混在一起的，步骤如下：

创建一个 Aspect 类
配置 Spring 配置文件

由于接下来要使用 aspectj 的 jar 包，首先添加 maven 依赖。需要在 pom.xml 添加：

                <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.9.2</version>
        </dependency>
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjtools</artifactId>
            <version>1.9.2</version>
        </dependency>
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjrt</artifactId>
            <version>1.9.2</version>
        </dependency>

注:我们在新建项目时就已经添加了这些依赖，这里写出来只是让同学们知道这些包的作用

创建 AspectJ 类，LoggingAspect.java 如下：

        package com.shiyanlou.spring.aop.aspectj;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;

@Aspect
public class LoggingAspect {

    @Before("execution(public * com.shiyanlou.spring.aop.aspectj.CustomerBo.addCustomer(..))")
    public void logBefore(JoinPoint joinPoint){
        System.out.println("logBefore() is running ...");
        System.out.println("hijacked:"+joinPoint.getSignature().getName());
        System.out.println("**********");
    }

    @After("execution(public * com.shiyanlou.spring.aop.aspectj.CustomerBo.deleteCustomer(..))")
    public void logAfter(JoinPoint joinPoint){
        System.out.println("logAfter() is running ...");
        System.out.println("hijacked:"+joinPoint.getSignature().getName());
        System.out.println("**********");
    }
}

解释：

1、必须使用 @Aspect 在 LoggingAspect 声明之前注释，以便被框架扫描到。
2、此例 Advice 和 Pointcut 结合在一起，类中的具体方法 logBefore 和 logAfter 即为 Advice，是要注入的代码，Advice 方法上的表达式为 Pointcut 表达式，即定义了切入点，上例中 @Before 注释的表达式代表执行 CustomerBo.addCustomer 方法时注入 logBefore 代码。
3、在 LoggingAspect 方法上加入 @Before 或者 @After 等注释。
4、execution(public * com.shiyanlou.spring.aop.aspectj.CustomerBo.addCustomer(..)) 是 Aspect 的切入点表达式，其中，* 代表返回类型，后边的就要定义要拦截的方法名。这里写的的是 com.shiyanlou.spring.aop.aspectj.CustomerBo.addCustomer 表示拦截 CustomerBo 中的 addCustomer 方法，(..) 代表参数匹配，此处表示匹配任意数量的参数，可以是 0 个也可以是多个，如果你确定这个方法不需要使用参数可以直接用 ()，还可以使用 () 来匹配一个任意类型的参数，还可以使用 ( , String )，这样代表匹配两个参数，第二个参数必须是 String 类型的参数。
5、AspectJ 表达式，可以对整个包定义，例如 execution ( * com.shiyanlou.spring.aop.aspectj..(..)) 表示切入点是 com.shiyanlou.spring.aop.aspectj 包中的任意一个类的任意方法，具体的表达式请自行搜索。

配置 SpringAopAspectj.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">

    <aop:aspectj-autoproxy/>

    <bean id = "customerBo" class = "com.shiyanlou.spring.aop.aspectj.CustomerBo"/>

    <bean id = "logAspect" class = "com.shiyanlou.spring.aop.aspectj.LoggingAspect" />

</beans>

<aop:aspectj-autoproxy/> 启动 AspectJ 支持，这样 Spring 会自动寻找用 @Aspect 注释过的类，其他的配置与 Spring 普通 bean 配置一样。

执行 App.java 如下：

        package com.shiyanlou.spring.aop.aspectj;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;


public class App {
    public static void main(String[] args) {

        ApplicationContext appContext = new ClassPathXmlApplicationContext(new String[] { "SpringAOPAspectj.xml" });
        ICustomerBo customer = (ICustomerBo)appContext.getBean("customerBo");

        customer.addCustomer();

        System.out.println("-------------------------------------------");

        customer.deleteCustomer();

    }
}

控制台输入命令：

        mvn clean compile
mvn exec:java -Dexec.main

实验结果如下：

技术分享图片

将 Advice 和 Pointcut 分开

需要三步：

1、创建 Pointcut
2、创建 Advice
3、配置 Spring 的配置文件

定义 Pointcut，创建 PointcutsDefinition.java，如下：

        package com.shiyanlou.spring.aop.aspectj;

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;

@Aspect
public class PointcutsDefinition {

    @Pointcut("execution(* com.shiyanlou.spring.aop.aspectj.CustomerBo.*(..))")
    public void customerLog() {
    }
}

解释：

1、类声明前加入 @Aspect 注释，以便被框架扫描到。
2、@Pointcut 是切入点声明，指定需要注入的代码的位置，如上例中指定切入点为 CustomerBo 类中的所有方法，在实际业务中往往是指定切入点到一个逻辑层，例如 execution (* com.shiyanlou.spring.aop.aspectj..(..)），表示 aop 切入点为 aspectj 包中所有类的所有方法，具体的表达式后边会有介绍。
3、方法 customerLog 是一个签名，在 Advice 中可以用此签名代替切入点表达式，所以不需要在方法体内编写实际代码，只起到助记功能，例如此处代表操作 CustomerBo 类时需要的切入点。
创建 LoggingAspect.java：

        package com.shiyanlou.spring.aop.aspectj;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;

@Aspect
public class LoggingAspect {

    @Before("com.shiyanlou.spring.aop.aspectj.PointcutsDefinition.customerLog()")
    public void logBefore(JoinPoint joinPoint){
        System.out.println("logBefore() is running ...");
        System.out.println("hijacked:"+joinPoint.getSignature().getName());
        System.out.println("**********");
    }

    @After("com.shiyanlou.spring.aop.aspectj.PointcutsDefinition.customerLog()")
    public void logAfter(JoinPoint joinPoint){
        System.out.println("logAfter() is running ...");
        System.out.println("hijacked:"+joinPoint.getSignature().getName());
        System.out.println("**********");
    }
}

解释：

1、@Before 和 @After 使用 PointcutsDefinition 中的方法签名代替 Pointcut 表达式找到相应的切入点，即通过签名找到 PointcutsDefinition 中 customerLog 签名上的 Pointcut 表达式，表达式指定切入点为 CustomerBo 类中的所有方法。所以此例中 Advice 类 LoggingAspect，为 CustomerBo 中的所有方法都加入了 @Before 和 @After 两种类型的两种操作。
2、对于 PointcutsDefinition 来说，主要职责是定义 Pointcut，可以在其中定义多个切入点，并且可以用便于记忆的方法签名进行定义。
3、单独定义 Pointcut 的好处是，一是通过使用有意义的方法名，而不是难读的 Pointcut 表达式，使代码更加直观；二是 Pointcut 可以实现共享，被多个 Advice 直接调用。若有多个 Advice 调用某个 Pointcut，而这个 Pointcut 的表达式在将来有改变时，只需修改一个地方，维护更加方便。

配置 Spring 配置文件。

配置 SpringAOPAspectJ.xml 文件，如下：

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

    <aop:aspectj-autoproxy/>

    <bean id = "customerBo" class = "com.shiyanlou.spring.aop.aspectj.CustomerBo"/>

    <bean id = "logAspect" class = "com.shiyanlou.spring.aop.aspectj.LoggingAspect" />

</beans>

App.java 不变，运行测试代码 App.java：

        mvn clean compile
mvn exec:java -Dexec.main

结果如下：
技术分享图片

原文：https://www.cnblogs.com/sakura579/p/13973974.html

内容总结

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

内容备注

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

内容手机端

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

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

来源：【匿名】

【下一篇】ASP知识讲座四

更多 ►

【使用 AspectJ 框架实现 Spring AOP】教程文章相关的互联网学习教程文章

使用 AspectJ 框架实现 Spring AOP【代码】【图】

AspectJ 是基于注释（Annotation）的，所以需要 JDK5.0 以上的支持。AspectJ 支持的注解类型如下：@Before@After@AfterReturning@AfterThrowing@Around准备工作首先定义一个简单的 bean，CustomerBo 实现了接口 ICustomerBo。ICustomerBo.java 如下：package com.shiyanlou.spring.aop.aspectj;public interface ICustomerBo {void addCustomer();void deleteCustomer();String AddCustomerReturnValue();void addCustomerThrowExc...

Spring Aspectj切入点语法定义【代码】

在使用spring框架配置AOP的时候，pointcut"切入点"例如定义切入点表达式 execution(* com.sample.service.impl..*.*(..))execution()是最常用的切点函数，其语法如下所示：整个表达式可以分为五个部分：1、execution(): 表达式主体。2、第一个*号：表示返回类型，*号表示所有的类型。3、包名：表示需要拦截的包名，后面的两个句点表示当前包和当前包的所有子包，com.sample.service.impl包、子孙包下所有类的方法。4、第二个*号：表...

Spring--基于AspectJ的AOP开发【代码】【图】

AspectJ简介 ·AspectJ是一个基于Java语言的AOP框架·Spring2.0以后新增了对AspectJ切点表达式支持·@AspectJ是AspectJ1.5新增功能，通过JDK5注解技术，允许直接在Bean类中定义切面·新版本Spring框架，建议使用AspectJ方式来开发AOP·使用AspectJ需要导入Spring AOP和 Aspect/相关jar包-spring-aop-4.2.4.RELEASE.jar-com.springsource.org.aopalliance-1.0.0.jar-spring-aspects-4.2.4.RELEASE.jar-com.springsource.org.aspectj.weav...

深入理解SVG坐标体系和transformations- viewport, viewBox,preserveAspectRatio【代码】

本文翻译自blog:https://www.sarasoueidan.com/blog/svg-coordinate-systems/SVG元素不像其他HTML元素一样受css盒子模型所制约。这个特点导致transform和postioning svg元素显得有些神秘，并且初看起来不是那么浅显易懂。然而，一旦你理解了SVG坐标体系以及transformation是如何工作的，那么操作SVG会变得非常简单。本文中，我们将涵盖控制SVG坐标体系的三个方面内容：viewport, viewBox和preserveAspectRatio这是包含三篇文章系列...

ASP.NET Core 3.0 使用AspectCore-Framework实现AOP【代码】

AspectCore是适用于Asp.Net Core 平台的轻量级Aop(Aspect-oriented programming)解决方案，它更好的遵循Asp.Net Core的模块化开发理念，使用AspectCore可以更容易构建低耦合、易扩展的Web应用程序。在使用过程中，由于相关文档、博客还未更新到.Net Core 3.0,本文操作参考了使用.Net Core 3.0的EasyCaching，并对其中公用的方法进行封装简化。安装Aspectcore此处配合微软自家的DI实现，安装Nuget包AspectCore.Extensions.Dependenc...

Spring AspectJ 例子【代码】

1. Waiter目标类 1package com.smart.aop.advice.pointcut;2 3publicclass Waiter {4 5publicvoid greetTo(String name) {6 System.out.println("Waiter greet to " + name + " ...");7 }8 9publicvoid serverTo(String name) { 10 System.out.println("waiter server to " + name + " ..."); 11 } 12 } 2. 使用AspectJ注解定义切面 1package com.smart.aop.advice.aspectj;2 3import org.aspectj.lang.anno...

认识一下ysoserial的AspectJWeaver【代码】【图】

前言AntCTFxD^3CTF 中学到了很多，参照大佬的文章也跟着分析一下ysoserial中的AspectJWeaver基础部分ysoserial中的AspectJWeaver : 此gadget用于写文件Java的File类相关知识File.separator表示目录分隔符/或者\,根据系统判断HashSetHashSet 实现原理简述 : HashMap是HashSet的核心，而Map添加元素需要调用put(key,value)则必须有键和值。但HashSet相当于只有键，故实现HashSet时官方使用了固定值来做value，即PRESENT。而PRESENT则...

基于aspectj的aop注解操作【图】

原文：http://www.cnblogs.com/hwgok/p/6765089.html

Spring AOP配置中的问题aop:aspectj-autoproxy

(1)对于菜鸟来说，在Spring学习中可能会遇到各种各样的问题。下面就简单的写一下，我在学习Spring AOP配置中遇到的问题吧。一般情况下，很多人都认为我们把spring framework中的所有jar包都加入到classpath中就OK了，在学习Ioc和Aop的时候就只剩下编程了，啥都不用管了。其实不是这样的，对于以前的版本来说，可能所有用到的包都集成在一起了，但spring 技术的不断发展和扩大、完善。最终，好多模块都分家了，比如，在学习Ioc的时候...

配置SpringAop时需要用到的AspectJ表达式

Aspectj切入点语法定义在使用spring框架配置AOP的时候，不管是通过XML配置文件还是注解的方式都需要定义pointcut"切入点"例如定义切入点表达式 execution (* com.sample.service.impl..*.*(..))execution()是最常用的切点函数，其语法如下所示：整个表达式可以分为五个部分： 1、execution(): 表达式主体。 2、第一个*号：表示返回类型，*号表示所有的类型。 3、包名：表示需要拦截的包名，后面的两个句点表示当前包和当前包的所...

Aspect表达式

任意公共方法的执行：execution(public * *(..))任何一个以“set”开始的方法的执行：execution(* set*(..))AccountService 接口的任意方法的执行：execution(* com.xyz.service.AccountService.*(..))定义在service包里的任意方法的执行：execution(* com.xyz.service.*.*(..))定义在service包和所有子包里的任意类的任意方法的执行：execution(* com.xyz.service..*.*(..))定义在pointcutexp包和所有子包里的JoinPointObjP2类的任...

Android Aspectj 接入 - 非组件【代码】

前言　　Android 中接入 Aspectj 目前常用的方式有两种，一种是项目非组件的方式接入，即我们在使用切片的 module 下加入编织脚本。另一种方式是组件的方式接入，就是以 Gradle Plugin 的方式接入。对于使用的 module ，直接 apply 我们定义的 Plugin 就行。我个人比较推荐第二种，因为只需要维护一个脚本即可。非组件的方式接入，在涉及编织的 module 下都需加入编织脚本。由于脚本依赖于 Gradle ，所以接入前说明一下本文的环境，...

javaEE之------Spring-----》 AspectJ注解

前面介绍了下Spring中的切面技术，现在说下采用注解的方式进行切面首先肯定和之前的一样，需要一个自动代理的注解类 AnnotationAwareAspectJAutoProxyCreator配置文件中的代码：<?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:context="http://www.springframework.org/schema/context"xmlns:tx="http://www.spr...

spring之AspectJ AOP编程

一、引言：　　AspectJ框架不仅实现了面向切面编程，而且还支持注解，spring将它引入自己的规范之中。二、需要了解： AspectJ是基于java语言的AOP框架spring2.0之后支持AspectJ切入点表达式描述切点使用切入点表达式三、通知的类型（重点）原文：https://www.cnblogs.com/pecool/p/8275888.html

AOP为Aspect Oriented Programming的缩写，意为：面向切面编程

在软件业，AOP为Aspect Oriented Programming的缩写，意为：面向切面编程，通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。原文：http://www.cnblogs.com/DTWolf/p/50000...

首页 / ASP / 使用 AspectJ 框架实现 Spring AOP

使用 AspectJ 框架实现 Spring AOP

内容导读

内容图文

准备工作

简单的 AspectJ，Advice 和 Pointcut 结合在一起

将 Advice 和 Pointcut 分开

内容总结

内容备注

内容手机端

【使用 AspectJ 框架实现 Spring AOP】教程文章相关的互联网学习教程文章

ASPECT - 相关标签

AOP - 相关标签

框架 - 相关标签

ASP - 技术教程分类

ASP - 最新教程

ASP - 最热教程