Spring--基于AspectJ的AOP开发

最新推荐文章于 2022-05-23 12:18:28 发布
最新推荐文章于 2022-05-23 12:18:28 发布
阅读量148 收藏 1
点赞数
分类专栏： SSM主流框架入门与综合项目实战
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_38517206/article/details/90199323
版权

主要内容：

AspectJ简介：

环境准备：

step1:引入依赖

 <dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.11</version>
      <scope>test</scope>
    </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>

<!--    AOP-->
    <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>

<!--    引入aspectj-->
    <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>

step2:配置文件

<?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"> <!-- bean definitions here -->

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

通知的类型介绍：

切入点表达式的定义：

案例：

类：

package com.imooc.aspectJ.demo1;

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

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

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

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

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

}

增强实现类：

package com.imooc.aspectJ.demo1;

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

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

    //对指定类中所有方法增强
    //@Before(value = "execution(* com.imooc.aspectJ.demo1.ProductDao.*(..))")

    //对指定类中指定方法增强
    @Before(value = "execution(* com.imooc.aspectJ.demo1.ProductDao.findOne(..))")
    public void before(){
        System.out.println("前置通知========");
    }

}

配置文件：

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

<!--    目标类-->
    <bean id="productDao" class="com.imooc.aspectJ.demo1.ProductDao"></bean>
<!--    切面类-->
    <bean class="com.imooc.aspectJ.demo1.MyAspectAnno"></bean>

测试代码：

package com.imooc.aspectJ.demo1;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.context.annotation.Configuration;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import javax.annotation.Resource;

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

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

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

    }
}

输出结果：只对特定类的特定方法进行增强

保存商品...
前置通知========
查找单一商品...
查找所有商品...
修改商品...
删除商品...

@Before前置通知：

    //对指定类中指定方法增强
    @Before(value = "execution(* com.imooc.aspectJ.demo1.ProductDao.findOne(..))")
    public void before(JoinPoint joinPoint){
        System.out.println("前置通知========"+joinPoint);
    }

测试代码：

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

    }

输出结果：会输出切入点的信息

保存商品...
前置通知========execution(void com.imooc.aspectJ.demo1.ProductDao.findOne())
查找单一商品...
查找所有商品...
修改商品...
删除商品...

@AfterReturing 后置通知:

对于有返回值的方法：

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

使用后置注解： 

    @AfterReturning(value = "execution(* com.imooc.aspectJ.demo1.ProductDao.update(..))",returning = "result")
    public void afterReturing(Object result){
        System.out.println("后置通知========"+result);
    }

测试代码：

    @Test
    public void demo1(){
        productDao.update();
        productDao.delete();

    }

输出结果：加上了返回值

修改商品...
后置通知========hello
删除商品...

@Around 环绕通知：

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

测试代码：

    @Test
    public void demo1(){
        productDao.delete();
    }

输出结果：

环绕前通知========
删除商品...
环绕后通知========

@AfterThrowing 异常抛出通知：

在方法里设置异常： 

    public void findAll() {
        System.out.println("查找所有商品...");
        int i=1/0;
    }

异常抛出通知：

    //异常抛出通知
    @AfterThrowing(value = "execution(* com.imooc.aspectJ.demo1.ProductDao.findAll(..))",throwing = "e")
    public void afterThrowing (Throwable e) {
        System.out.println("异常抛出通知========"+e.getMessage());
    }

测试代码：

    @Test
    public void demo1(){
        productDao.findAll();
    }

输出结果：

查找所有商品...
异常抛出通知========/ by zero

@After 最终通知：

    //最终通知
    @After(value = "execution(* com.imooc.aspectJ.demo1.ProductDao.findOne(..))")
    public void after () {
        System.out.println("最终通知========");
    }

测试代码：

    @Test
    public void demo1(){
        productDao.findOne();
    }

输出结果：

查找单一商品...
最终通知========

@Pointcut 切点命名:

package com.imooc.aspectJ.demo1;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;

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

    //对指定类中所有方法增强
    //@Before(value = "execution(* com.imooc.aspectJ.demo1.ProductDao.*(..))")

    //前置通知
    //对指定类中指定方法增强
    @Before(value = "myPointcut1()")
    public void before(JoinPoint joinPoint){
        System.out.println("前置通知========"+joinPoint);
    }

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

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

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

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


    //切点命名
    @Pointcut(value = "execution(* com.imooc.aspectJ.demo1.ProductDao.save(..))")
    private void myPointcut1(){}

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

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

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

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

测试代码：

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

输出结果：

前置通知========execution(void com.imooc.aspectJ.demo1.ProductDao.save())
保存商品...
查找所有商品...
修改商品...
后置通知========hello
环绕前通知========
删除商品...
环绕后通知========
查找单一商品...
最终通知========

AspectJ的XML方式开发AOP：

配置前置通知：

package com.imooc.aspectJ.demo2;

public class MyAspectXml {
    //前置通知
    public void before(){
        System.out.println("XML配置方式的前置通知......");
    }
}

配置XML： 

    <!--XML的配置方式完成AOP的开发-->

    <!--    配置目标类-->
    <bean id="customerDao" class="com.imooc.aspectJ.demo2.CustomerDaoImpl"/>
    <!--配置切面类-->
    <bean id="myAspectXml" class="com.imooc.aspectJ.demo2.MyAspectXml"></bean>

<!--    aop的相关配置-->
    <aop:config>
<!--        配置切入点-->
        <aop:pointcut id="pointcut1" expression="execution(* com.imooc.aspectJ.demo2.CustomerDao.save(..))"/>
<!--        配置aop的切面-->
        <aop:aspect ref="myAspectXml">
<!--            配置前置增强-->
            <aop:before method="before" pointcut-ref="pointcut1"></aop:before>

        </aop:aspect>
    </aop:config>

测试代码：

package com.imooc.aspectJ.demo2;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import javax.annotation.Resource;

@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();
    }
}

输出结果：

XML配置方式的前置通知......
保存客户...
修改客户...
删除客户...
查询单个客户...

各种通知类型的配置：

package com.imooc.aspectJ.demo2;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;

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：

<?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"> <!-- bean definitions here -->

    <!--XML的配置方式完成AOP的开发-->

    <!--    配置目标类-->
    <bean id="customerDao" class="com.imooc.aspectJ.demo2.CustomerDaoImpl"/>
    <!--配置切面类-->
    <bean id="myAspectXml" class="com.imooc.aspectJ.demo2.MyAspectXml"></bean>

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

输出结果：

XML配置方式的前置通知......execution(void com.imooc.aspectJ.demo2.CustomerDao.save())
保存客户...
修改客户...
XML配置方式的后置通知......hello
XML配置方式的环绕前通知......
删除客户...
XML配置方式的环绕后通知......
XML配置方式的异常抛出通知....../ by zero

 

_kooo
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spring Boot - spring-boot-starter-aop
学无止境
06-12 1018
然后，我们创建了一个切面类LoggingAspect，它使用@Before和@After注解来定义前置通知和后置通知，这些通知将在UserService类的getUser()在工作中，spring-boot-starter-aop常用于在应用程序中实现切面编程，例如日志记录、性能监控、事务管理等。最后，在Application类的main()方法中，我们获取UserService的实例并调用getUser()方法。在这个示例中，我们创建了一个UserService类，它有一个getUser()
jar包---Spring Aop AspectJ新增包.rar
07-16
包含学习Spring AOP以及学习Spring Aspect J需要新增的jar包，需要的朋友可以下载哦！
Spring的基于AspectJ的AOP开发
qq_54876312的博客
05-23 114
使用AspectJ实现AOP 注解方式 XML方式 AspectJ简介 AspectJ是一个基于Java语言的AOP框架 Spring2.0以后新增了对AspectJ切点表达式支持 @AspectJ是AspectJ1.5新增的功能，通过JDK5注解技术，允许直接在Bean类中定义切面 新版本Spring框架，建议使用AspectJ方式来开发AOP 使用AspectJ需要导入Spring AOP和AspectJ相关jar包 Spring-aop springsource.org.aopallianc.
基于@Aspect实现AOP的两种方式
coderchem的博客
11-26 2056
第一种： package com.anno; import java.lang.annotation.ElementType; import java.lang.annotation.Retention; import java.lang.annotation.RetentionPolicy; import java.lang.annotation.Target; @Retention(R...
Spring - AOP之AspectJ（XML）
牧码的博客
11-22 294
package com.imooc.aspectJ.demo2; public interface CustomerDao { public void save(); public String update(); public void delete(); public void findOne(); public void findAll();...
spring-boot-starter-aop及其使用场景说明
热门推荐
吴声子夜歌的博客
11-21 1万+
如今，AOP（Aspect Oriented Programming）已经不是什么崭新的概念了，在经历了代码生成、动态代理、字节码增强甚至静态编译等不同时代的洗礼之后，Java 平台上的 AOP 方案基本上已经以 SpringAOP 结合 AspectJ 的方式稳固下来（虽然大家依然可以自己通过各种字节码工具偶尔“打造一些轮子”）。 现在 Spring 框架提供的 AOP 方案倡导了一种各取所长的...
spring-aop-aspectj-ctw:用AspectJ编译Spring AOP
05-17
Spring AOP的一个常见问题是获取Pointcut到达类的内部方法调用。 在这个示例中，您可以在一个简单的Spring Boot示例中看到如何使用AspectJ处理节拍时间编织。 示例场景 在此示例中，将发生以下情况： 我们在上调用...
spring-loadtime-weaving-example:使用AspectJ的Spring Boot加载时编织示例
05-18
使用AspectJ的Spring Boot加载时编织示例 这是一个用AspectJ编织Spring Boot加载时间的示例。 这是前面的的延续。 加载时间编织 加载时编织是一种二进制编织，其中已编译的Java类在运行时（而不是编译时）作为输入。...
Spring用AspectJ开发AOP(基于Annotation)
08-25
主要介绍了Spring用AspectJ开发AOP(基于Annotation),文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
基于框架的Web开发-基于AspectJ的AOP.doc
07-04
2.2 基于@AspectJ的AOP @AspectJ使用注解来描述切点。 1 添加依赖Jar包 使用@AspectJ，需要以下的额外Jar包 (1) aspectjweaver.jar和aspectjtools.jar(提供两个版本，低版本JDK6的使用aspectj1.6，高版本如JDK8的...
SpringMVC--入门
Java小白的自学之路
06-03 4044
MVC设计模式： MVC流程： SpringMVC： SpringMVC详解： SpringMVC实现流程： SpringMVC深入使用： SpringMVC--基于XML配置： 1、创建一个maven web工程：并在pom.xml里导入依赖 <dependencies> &l...
MyBatis--批量新增数据
Java小白的自学之路
05-07 995
主要内容： JDBC插入数据方法： 传统JDBC进行批量数据插入： 1、使用For循环 package jdbc; import java.sql.Connection; import java.sql.PreparedStatement; /** * Created by imooc */ public class BatchTestOne { pub...
MyBatis--拦截器实现分页
Java小白的自学之路
05-08 690
主要内容： MyBatis四大对象及插件原理： MyBatis插件开发： 测试：定义一个插件类： MyFirstInterceptor ：一定继承自Interceptor类，重写里面的方法 package com.mooc.mybatis.interceptor; import org.apache.ibatis.executor.resultset....
SpringMVC--RESTful入门
Java小白的自学之路
06-04 547
主要内容： RESTful概述： RESTful核心内容： RESTful架构特点： RESTful风格概述： 案例：课程添加删除 web.xml配置过滤器： <filter> <filter-name>hiddenHttpMethodFilter</filter-name> <...
MyBatis--入门
Java小白的自学之路
05-04 395
主要内容： ORM模型： JDBC的缺陷： MyBatis概述： MyBatis背景： MyBatis优势： MyBatis使用场景： 学习使用MyBatis： 1、获取MyBatis 两种引入方式： 1、下载安装包 2、maven方式引入 案例：MyBatis入门程序 github:https://github.com/...
SpringMVC--拦截器
Java小白的自学之路
06-04 190
主要内容： 拦截器和过滤器： ...
MyBatis--参数传递
Java小白的自学之路
05-07 182
主要内容： github地址：https://github.com/ChuanshuaiLi/MyBatisParamDemo.git 应用场合： 以数组为传递参数进行查询： 单参数进行传递： 多参数进行传递： 1、JavaBean传递参数：是我最常用的方式。 2、Map传递参数 3、@param注解传递参数 MyBat...
SpringMVC--数据绑定
Java小白的自学之路
06-04 150
主要内容： SpringMVC数据绑定原理： 数据绑定代码实现： DataBindController: package com.imooc.controller; import com.imooc.dao.CourseDAO; import com.imooc.entity.Course; import com.imooc.entity.Course...
Spring--Bean管理
Java小白的自学之路
05-12 149
主要内容： Spring的工厂类： 测试代码： package com.imooc.ioc.demo1; import org.junit.Test; import org.springframework.beans.factory.BeanFactory; import org.springframework.beans.factory.xml.XmlBeanFactory; ...
spring-boot-starter-aop
最新发布
04-02
It uses the Spring AOP module, which is based on the AspectJ framework, to apply aspects to the application's components. Some of the features provided by the spring-boot-starter-aop module include:...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值