木木的Java知识整理——基于AspectJ的AOP开发

最新推荐文章于 2022-03-30 00:02:24 发布
最新推荐文章于 2022-03-30 00:02:24 发布
阅读量440 收藏 1
点赞数 1
分类专栏： Java知识整理 文章标签： java aop
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42287169/article/details/106406668
版权

基于AspectJ的AOP开发

一、AspectJ概述

1.1 AspectJ的简介

1、AspectJ是一个基于Java语言的AOP框架
2、Spring2.0以后新增了对AspectJ切点表达式支持
3、@AspectJ是AspectJ1.5新增的功能，通过JDK5注解技术，允许直接在Bean类中定义切面
4、新版本Spring框架，建议使用AspectJ方式来开发AOP
5、使用AspectJ需要导入Spring AOP和AspectJ相关jar包
在这里插入图片描述

二、AspectJ的注解开发AOP

2.1 环境准备

pom.xml

<dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.11</version>
    </dependency>

    <!--引入Spring的基本开发包-->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-core</artifactId>
      <version>4.2.4.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context</artifactId>
      <version>4.2.4.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-beans</artifactId>
      <version>4.2.4.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-expression</artifactId>
      <version>4.2.4.RELEASE</version>
    </dependency>

    <dependency>
      <groupId>aopalliance</groupId>
      <artifactId>aopalliance</artifactId>
      <version>1.0</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-aop</artifactId>
      <version>4.2.4.RELEASE</version>
    </dependency>

    <dependency>
      <groupId>org.aspectj</groupId>
      <artifactId>aspectjweaver</artifactId>
      <version>1.8.9</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-aspects</artifactId>
      <version>4.2.4.RELEASE</version>
    </dependency>

    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-test</artifactId>
      <version>4.2.4.RELEASE</version>
    </dependency>
</dependencies>

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

    <!--开启AspectJ的注解开发，自动代理=====================-->
    <aop:aspectj-autoproxy/>
    
</beans>

2.2 通知的类型介绍

传统AOP：
在这里插入图片描述
基于AspectJ的AOP：

通知类型介绍
@Before前置通知，相当于BeforeAdvice
@AfterReturning后置通知，相当于AfterReturningAdvice
@Around环绕通知，相当于MethodInterceptor
@AfterThrowing异常抛出通知，相当于ThrowAdvice
@After最终final通知，不管是否异常，该通知都会执行
@DeclareParents引介通知，相当于IntroductionInterceptor(不要求掌握)

2.3 切入点表达式的定义

在通知中通过value属性定义切点

通过execution函数，可以定义切点的方法切入
语法：
-execution（<访问修饰符>？<返回类型><方法名>（<参数>）<异常>）
访问修饰符可以省略

例如：

  • 匹配所有类public方法 execution（public * * （…））
    （第一个* 代表任意方法返回值，第二个* 代表任意名称，…代表任意参数）

  • 匹配指定包下所有类方法 execution（* com.linmin.dao.* （…））不包含子包
    （第一个* 代表返回值类型，是任意的；第二个* 代表方法名称，任意的；…任意参数）

  • execution（* com.linmin.dao…*（…）） …*表示包含包、子孙包下所有类（第一…代表包含子包）

  • 匹配指定类所有方法 execution（* com.linmin.service.UserService.*（…））

  • 匹配实现特定接口所有类方法 execution（* com.linmin.dao.GenericDAO+.*（…））
    +号代表子类

  • 匹配所有save开头的方法 execution（* save*(…）)

2.4 前置通知

在applicationContext.xml中添加目标类和切面类，进行注解开发。

<!--目标类===================-->
<bean id="productDao" class="com.linmin.aspectJ.demo1.ProductDao"/>

<!--定义切面-->
<bean class="com.linmin.aspectJ.demo1.MyAspectAnno"/>

public class ProductDao {

    public void save(){
        System.out.println("保存商品...");
    }

    public String update(){
        System.out.println("修改商品...");
        return "hello";
    }

    public void delete(){
        System.out.println("删除商品...");
    }

    public void findOne(){
        System.out.println("查询一个商品...");
    }

    public void findAll(){
        System.out.println("查询所有商品...");
    }

}

/**
 * 切面类
 */
@Aspect
public class MyAspectAnno {

    @Before(value="myPointcut1()")
    public void before(JoinPoint joinPoint){
        System.out.println("前置通知=================="+joinPoint);
    }

	@Pointcut(value="execution(* com.linmin.aspectJ.demo1.ProductDao.save(..))")
    private void myPointcut1(){}
}

测试类：

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class SpringDemo1 {

    @Resource(name="productDao")
    private ProductDao productDao;

    @Test
    public void demo1(){
        productDao.save();
        productDao.update();
        productDao.delete();
        productDao.findAll();
        productDao.findOne();
    }

}

2.5 后置通知

@Aspect
public class MyAspectAnno {

    @AfterReturning(value="myPointcut2()",returning = "result")
    public void afterReturing(Object result){
        System.out.println("后置通知=================="+result);
    }

	@Pointcut(value="execution(* com.linmin.aspectJ.demo1.ProductDao.update(..))")
    private void myPointcut2(){}
}

若增强的方法有返回值，则通过returning获取返回值。

2.6 环绕通知

around方法的返回值就是目标代理方法执行的返回值
参数为ProceedingJoinPoint可以调用拦截目标方法执行

@Aspect
public class MyAspectAnno {

    @Around(value="myPointcut3()")
    public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
        System.out.println("环绕前通知================");
        Object obj = joinPoint.proceed(); // 执行目标方法
        System.out.println("环绕后通知================");
        return obj;
    }

	@Pointcut(value="execution(* com.linmin.aspectJ.demo1.ProductDao.delete(..))")
    private void myPointcut3(){}
}

重点：如果不调用ProceedingJoinPoint的proceed方法，那么目标方法就被拦截了

2.7 异常抛出通知

通过设置throwing属性，可以设置发生异常对象参数。

@Aspect
public class MyAspectAnno {

     @AfterThrowing(value="myPointcut4()",throwing = "e")
    public void afterThrowing(Throwable e){
        System.out.println("异常抛出通知=============="+e.getMessage());
    }

	@Pointcut(value="execution(* com.linmin.aspectJ.demo1.ProductDao.findOne(..))")
    private void myPointcut4(){}
}

2.8 最终通知

无论是否出现异常，最终通知总是会被执行的。

@Aspect
public class MyAspectAnno {

     @After(value="myPointcut5()")
    public void after(){
        System.out.println("最终通知==================");
    }

	@Pointcut(value="execution(* com.linmin.aspectJ.demo1.ProductDao.findAll(..))")
    private void myPointcut5(){}
}

2.9 切点命名

通过@Pointcut为切点命名

  • 在每个通知内定义切点，会造成工作量大，不易维护，对于重复的切点，可以使用@Pointcut进行定义；
  • 切点方法：private void 无参数方法，方法名为切点命；
  • 当通知多个切点时，可以使用 || 进行连接。

在上面的各个通知中已经使用。

三、AspectJ的XML方式的AOP开发

3.1 各类通知类型的配置

public interface CustomerDao {
    public void save();
    public String update();
    public void delete();
    public void findOne();
    public void findAll();
}

public class CustomerDaoImpl implements CustomerDao {
    public void save() {
        System.out.println("保存客户...");
    }

    public String update() {
        System.out.println("修改客户...");
        return "spring";
    }

    public void delete() {
        System.out.println("删除客户...");
    }

    public void findOne() {
        System.out.println("查询一个客户...");
//       int a = 1/ 0;
    }

    public void findAll() {
        System.out.println("查询多个客户...");
//        int b = 1/0;
    }
}

public class MyAspectXml {

    // 前置通知
    public void before(JoinPoint joinPoint){
        System.out.println("XML方式的前置通知=============="+joinPoint);
    }

    // 后置通知
    public void afterReturing(Object result){
        System.out.println("XML方式的后置通知=============="+result);
    }

    // 环绕通知
    public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
        System.out.println("XML方式的环绕前通知==============");
        Object obj = joinPoint.proceed();
        System.out.println("XML方式的环绕后通知==============");
        return obj;
    }

    // 异常抛出通知
    public void afterThrowing(Throwable e){
        System.out.println("XML方式的异常抛出通知============="+e.getMessage());
    }

    // 最终通知
    public void after(){
        System.out.println("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">

    <!--XML的配置方式完成AOP的开发===============-->
    <!--配置目标类=================-->
    <bean id="customerDao" class="com.linmin.aspectJ.demo2.CustomerDaoImpl"/>

    <!--配置切面类-->
    <bean id="myAspectXml" class="com.linmin.aspectJ.demo2.MyAspectXml"/>

    <!--aop的相关配置=================-->
    <aop:config>
        <!--配置切入点-->
        <aop:pointcut id="pointcut1" expression="execution(* com.linmin.aspectJ.demo2.CustomerDao.save(..))"/>
        <aop:pointcut id="pointcut2" expression="execution(* com.linmin.aspectJ.demo2.CustomerDao.update(..))"/>
        <aop:pointcut id="pointcut3" expression="execution(* com.linmin.aspectJ.demo2.CustomerDao.delete(..))"/>
        <aop:pointcut id="pointcut4" expression="execution(* com.linmin.aspectJ.demo2.CustomerDao.findOne(..))"/>
        <aop:pointcut id="pointcut5" expression="execution(* com.linmin.aspectJ.demo2.CustomerDao.findAll(..))"/>
        <!--配置AOP的切面-->
        <aop:aspect ref="myAspectXml">
            <!--配置前置通知-->
            <aop:before method="before" pointcut-ref="pointcut1"/>
            <!--配置后置通知-->
            <aop:after-returning method="afterReturing" pointcut-ref="pointcut2" returning="result"/>
            <!--配置环绕通知-->
            <aop:around method="around" pointcut-ref="pointcut3"/>
            <!--配置异常抛出通知-->
            <aop:after-throwing method="afterThrowing" pointcut-ref="pointcut4" throwing="e"/>
            <!--配置最终通知-->
            <aop:after method="after" pointcut-ref="pointcut5"/>
        </aop:aspect>

    </aop:config>
</beans>

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(value="classpath:applicationContext2.xml")
public class SpringDemo2 {

    @Resource(name="customerDao")
    private CustomerDao customerDao;

    @Test
    public void demo1(){
        customerDao.save();
        customerDao.update();
        customerDao.delete();
        customerDao.findOne();
        customerDao.findAll();
    }
}
木木非咸鱼也
关注
专栏目录
Spring Aop（二）——基于Aspectj注解的Aop简单实现
Elim的博客
09-28 3322
2 基于Aspectj注解的Spring Aop简单实现Spring Aop是基于Aop框架Aspectj实现的，它不是完完全全的对Aspectj框架进行扩展和改造，而是利用Aspectj里面的一些功能来实现自己的Aop框架，其中就包括对Aspectj提供的注解的解析。之前已经提过Spring Aop和Aspectj实现的Aop之间的差别，这里就不再赘述。本文主要描述的是如何利用Aspectj提供
Java课题笔记~ AspectJ 对 AOP 的实现(掌握)
qq_53142796的博客
08-07 293
AspectJ 是一个优秀面向切面的框架，它扩展了 Java 语言，提供了强大的切面实现。
Spring——AOP操作 AspectJ动态代理方式
chenxingxingxing的博客
03-30 2746
Spring——AOP操作 AspectJ动态代理方式
开发AOP的途径--AspectJ开发 (2) (超详细)
qq_44692189的博客
03-08 673
AspectJ是一个基于Java语言的AOP框架，它提供了强大的AOP功能。Spring 2.0以后，Spring AOP引入了对AspectJ的支持，并允许直接使用AspectJ进行编程，而Spring自身的AOP API也尽量与AspectJ保持一致。 新版本的Spring框架，也建议使用AspectJ来开发AOP。使用AspectJ实现AOP有两种方式:一种是基于XML的声明式AspectJ...
Spring的基于AspectJ的AOP开发
jiuweideqixu的博客
04-09 317
AspetcJ简介 环境准备 Spring基本jar包 spring集成单元测试所用jar包 spring进行传统aop开发所用jar包 spring进行Aspect开发所用jar包（会用到spring进行传统aop开发所用到的jar包） 开启AspectJ的注解开发，自动代理 基于AspectJ的注解方式的AOP开发 在通知中定义...
AOP框架之：Spring AOP和AspectJ
xuxiao1987的专栏
12-17 563
AOP是Spring框架的重要组成部分。目前我所接触的AOP实现框架有Spring AOP还有就是AspectJ(还有另外几种我没有接触过)。我们先来说说他们的区别： AspectJ是一个比较牛逼的AOP框架，他可以对类的成员变量，方法进行拦截。由于 AspectJ 是 Java 语言语法和语义的扩展，所以它提供了自己的一套处理方面的关键字。除了包含字段和方法之外，AspectJ 的方面声明还包...
基于AspectJ的Java AOP项目设计源码
最新发布
09-29
该项目为君匡出品，采用AspectJ技术实现的Java AOP项目示例源码。项目包含143个文件，其中84个为Java源代码文件，34个为XML配置文件，18个为Markdown文档，5个为AspectJ注解文件，1个为Git忽略配置文件，1个为YAML...
Spring用AspectJ开发AOP(基于Annotation)
08-25
Spring用AspectJ开发AOP(基于Annotation) 作为一名IT行业大师，我将详细介绍Spring用AspectJ开发AOP(基于Annotation)，并对标题、描述、标签和部分内容进行详细解释。 标题: Spring用AspectJ开发AOP(基于...
基于AspectJ的AOP开发案例源码.rar
06-27
aspectj的Aop开发的入门学习案例 demo1是aspectj的Aop开发，用于用户是否登录的验证，使用注解来实现，在切面类中配置好切入点。优点：方便快捷 demo2是aspectj的Aop开发，用于用户是否登录的验证，在xml中配置好切...
征服Spring AOP—— @AspectJ
04-03
在IT行业中，Spring框架是Java企业级应用开发的首选，而Spring AOP（面向切面编程）则是其核心特性之一，用于实现横切关注点的模块化，如日志、事务管理等。@AspectJ是Spring AOP的一种注解驱动方式，它极大地简化了...
aspectj1.8.10
09-20
aspectj最新版本Jar包 解压就可以使用 100 个字节 好多 aspectj-1.8.10 和 aspectjweaver-1.8.10 这两个Jar包要配合使用
（七）AOP之AspectJ （Spring中通知类型5种）
FixedStar 的博客
03-27 475
例子参考： 注解方式：https://blog.csdn.net/u010502101/article/details/78823056 xml方式：https://www.yiibai.com/spring/spring-aop-examples-advice.html
基于AspectJ的注解方式进行AOP开发
siwuxie095's blog
08-22 299
-------------------siwuxie095                            基于 AspectJ 的注解方式进行 AOP 开发       1、在 Spring 的核心配置文件中配置对象                 2、在 Spring 的核心配置文件中通过命名空间 aop 开启 Aspe
springboot进阶学习（九）springboot常见注解详解
牛魔王的专栏
07-07 346
springboot常见注解详解 springboot中的注解很多很多，我们不一一说明，就把常见的讲解下就行，遇到不常见的到时候再查资料就可以了。 启动类中的注解 @SpringBootApplication：该注解用在启动类上面，是springboot最核心注解，也是组合注解，他包含下面几个注解 @SpringBootConfiguration：继承自@Configuration，@SpringBootConfiguration是来声明当前类是SpringBoot应用的配置类，项目中只能有一个 @En
Spring入门第八讲——Spring的JDBC模板
李阿昀的博客
04-09 6213
Spring使用AspectJ进行AOP的开发：注解方式之前我已讲过Spring使用AspectJ通过配置文件的方式来进行AOP的开发，现在就来讲怎样使用注解方式进行AOP的开发。 创建一个Web项目， 引入相关的jar包。所要导入的jar包如下： 引入Spring的配置文件。主要引入AOP的约束：<?xml version="1.0" encoding="UTF-8"?> <beans xmlns
java框架篇---spring aop两种配置方式
weixin_41884118的博客
03-01 116
第一种：注解配置AOP 注解配置AOP（使用 AspectJ 类库实现的），大致分为三步： 使用注解@Aspect来定义一个切面，在切面中定义切入点(@Pointcut),通知类型(@Before, @AfterReturning,@After,@AfterThrowing,@Around). 开发需要被拦截的类。 将切面配置到xml中，当然，我们也可以使用自动扫描Bean的方式。这样的话，那就...
AspectJ 1.7.4版本：Java AOP开发核心库
资源摘要信息:"AspectJ 1.7.4 是一个功能强大的面向切面编程（AOP）框架，它允许开发者为 Java 语言添加额外的行为，以便更好地模块化横切关注点。AspectJ 通过扩展Java语言来提供对面向切面编程的支持，它在运行时...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值