Spring1.5——AspectJ基于xml和注解的演示

最新推荐文章于 2022-09-15 10:19:42 发布
最新推荐文章于 2022-09-15 10:19:42 发布
阅读量253 收藏
点赞数
分类专栏： java框架 文章标签： AspectJ spring aop AspectJ注解
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/smallhc/article/details/81304514
版权

JAVA框架学习文章点这里
AspectJ：
AspectJ是一个基于Java语言的AOP框架
Spring2.0以后新增了对AspectJ切点表达式支持
@AspectJ 是AspectJ1.5新增功能，通过JDK5注解技术，允许直接在Bean类中定义切面
新版本Spring框架，建议使用AspectJ方式来开发AOP
主要用途：自定义开发
切入点表达式：
1.execution：用于描述方法
2.within：匹配包或子包中的方法
3.this：匹配实现接口的代理对象中的方法
4.target:匹配实现接口的目标对象中的方法
5.args:匹配参数格式符合标准的方法
6.bean(id) 对指定的bean所有的方法
主要使用的还是execution，以下举一个例子
execution(* com.h_Aspectj_xml.BookServiceImpl.*(..))
表示指定 返回值任意类型，在指定类中的任意方法（方法参数为任意类型）
AspectJ通知类型：
before:前置通知(应用：各种校验)，在方法执行前执行，如果通知抛出异常，阻止方法运行
afterReturning:后置通知(应用：常规数据处理)，方法正常返回后执行，如果方法中抛出异常，通知无法执行，必须在方法执行后才执行，所以可以获得方法的返回值。
around:环绕通知(应用：可以做任何事情)，方法执行前后分别执行，可以阻止方法的执行，必须手动执行目标方法
afterThrowing:抛出异常通知(应用：包装异常信息)，方法抛出异常后执行，如果方法没有抛出异常，无法执行，after:最终通知(应用：清理现场)，方法执行完毕后执行，无论方法中是否出现异常
基于xml的使用：
before（前置方法）的使用：
目标类：

public interface BookService {
    public void addBook();
    public void deleteBook();
    public void selectBook();
}
package com.h_Aspectj_xml;

public class BookServiceImpl implements BookService{
    public void addBook() {
        System.out.println("add books");
    }
    public void deleteBook() {
        System.out.println("delete books");
    }
    public void selectBook() {
        System.out.println("select books");
    }
}

切面类：

package com.h_Aspectj_xml;

import org.aspectj.lang.JoinPoint;

public class MyAspect{
    public void myBefore(JoinPoint joinPoint) {
        System.out.println("before:"+joinPoint.getSignature().getName());
    }
}

配置文件：

<?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 name="BookService" class="com.h_Aspectj_xml.BookServiceImpl"></bean>
    <bean name="MyAspect" class="com.h_Aspectj_xml.MyAspect"></bean>
    <aop:config>
        <!--配置切入点类-->
        <aop:pointcut expression="execution(* com.h_Aspectj_xml.BookServiceImpl.*(..))" id="myCutPoint"/>
        <!--配置切面，以及before使用的方法和切入点-->
        <aop:aspect ref="MyAspect">
            <aop:before method="myBefore" pointcut-ref="myCutPoint" />
        </aop:aspect>
    </aop:config>
</beans>

测试类:

package com.h_Aspectj_xml;

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

public class TestDemo {
    @Test
    public void test1() {
        String xmlPath = "com/h_Aspectj_xml/beans.xml";
        ApplicationContext appcont = new ClassPathXmlApplicationContext(xmlPath);
        BookService bookService = (BookService) appcont.getBean("BookService");
        bookService.addBook();
        bookService.selectBook();
        bookService.deleteBook();
    }
}

结果：

before:addBook
add books
before:selectBook
select books
before:deleteBook
delete books

after（后置方法）的使用：
目标类：同上
切面类：在上面的基础上加上一个方法

    public void myAfterReturning(JoinPoint joinPoint, Object ret) {
        System.out.println(joinPoint.getSignature().getName()+",after,返回值："+ret);
    }

配置文件

    <aop:config>
        <aop:pointcut expression="execution(* com.h_Aspectj_xml.BookServiceImpl.*(..))" id="myCutPoint"/>
        <aop:aspect ref="MyAspect">
            <!--配置后置方法的方法名，切入点和返回值名-->
            <aop:after-returning method="myAfterReturning" pointcut-ref="myCutPoint" returning="ret"/>
        </aop:aspect>
    </aop:config>

结果：

add books
addBook,after,返回值：null
select books
selectBook,after,返回值：null
delete books
deleteBook,after,返回值：null

afterThrowing（异常处理）的使用
在前面的实现类中修改方法制造异常

    public void deleteBook() {
        int a = 10/0;
        System.out.println("delete books");
    }

在前面切面类的基础上添加方法：

    public void myAfterThrowing(JoinPoint joinPoint, Throwable e) {
        System.out.println(joinPoint.getSignature().getName()+"方法抛出异常:"+e.getMessage());
    }

修改配置文件：

    <aop:config>
        <aop:pointcut expression="execution(* com.h_Aspectj_xml.BookServiceImpl.*(..))" id="myCutPoint"/>
        <aop:aspect ref="MyAspect">
            <!--指定异常处理方法名，切入点和抛出的异常对象名称-->
            <aop:after-throwing method="myAfterThrowing" pointcut-ref="myCutPoint" throwing="e"/>
        </aop:aspect>
    </aop:config>

结果：

add books
select books
deleteBook方法抛出异常:/ by zero

around（环绕通知）的使用：
屏蔽掉之前在实现类中写的异常
在切面类中添加方法：

    public void myAround(ProceedingJoinPoint joinPoint) throws Throwable {
        System.out.println("前");
        //环绕需要手动调用目标方法
        Object object = joinPoint.proceed();
        System.out.println("后");
    }

修改配置文件

    <aop:config>
        <aop:pointcut expression="execution(* com.h_Aspectj_xml.BookServiceImpl.*(..))" id="myCutPoint"/>
        <aop:aspect ref="MyAspect">
            <aop:around method="myAround" pointcut-ref="myCutPoint"/>
        </aop:aspect>
    </aop:config>

运行结果：

前
add books
后
前
select books
后
前
delete books
后

after（最终）的使用：
在切面类中添加方法：

    public void myAfter(JoinPoint joinPoint) {
        System.out.println("finall");
    }

修改配置文件：

    <aop:config>
        <aop:pointcut expression="execution(* com.h_Aspectj_xml.BookServiceImpl.*(..))" id="myCutPoint"/>
        <aop:aspect ref="MyAspect">
            <aop:after method="myAfter" pointcut-ref="myCutPoint"/>
        </aop:aspect>
    </aop:config>

运行结果：

add books
finall
select books
finall
delete books
finall

注解的使用：
目标类：

package com.h_Aspectj_anno;

import org.springframework.stereotype.Service;

@Service("BookService")
public class BookServiceImpl implements BookService{
    public void addBook() {
        System.out.println("add books");
    }
    public void deleteBook() {
        //int a = 10/0;
        System.out.println("delete books");
    }
    public void selectBook() {
        System.out.println("select books");
    }
}

切面类：

package com.h_Aspectj_anno;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;
//配置切面类
@Component//相当于xml中配置bean
@Aspect
public class MyAspect{
    //配置公共切入点，配置后可以方便后续方法引用
    @Pointcut("execution(* com.h_Aspectj_anno.BookServiceImpl.*(..))")
    public void myPointCut() {
    }
    //@Before("myPointCut()")
    public void myBefore(JoinPoint joinPoint) {
        System.out.println("before:"+joinPoint.getSignature().getName());
    }
    //@AfterReturning(value="myPointCut()" , returning="ret")
    public void myAfterReturning(JoinPoint joinPoint, Object ret) {
        System.out.println(joinPoint.getSignature().getName()+",after,返回值："+ret);
    }
    //@AfterThrowing(value="myPointCut()", throwing="e")
    public void myAfterThrowing(JoinPoint joinPoint, Throwable e) {
        System.out.println(joinPoint.getSignature().getName()+"方法抛出异常:"+e.getMessage());
    }
    //@Around("myPointCut()")
    public void myAround(ProceedingJoinPoint joinPoint) throws Throwable {
        System.out.println("前");
        //环绕需要手动调用目标方法
        Object object = joinPoint.proceed();
        System.out.println("后");
    }
    //@After("myPointCut()")
    public void myAfter(JoinPoint joinPoint) {
        System.out.println("finall");
    }
}

配置文件：

<?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: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/context
                           http://www.springframework.org/schema/context/spring-context.xsd
                           http://www.springframework.org/schema/aop
                           http://www.springframework.org/schema/aop/spring-aop.xsd
                           ">
    <!-- 配置自动扫描 -->
    <context:component-scan base-package="com.h_Aspectj_anno"></context:component-scan>
    <!-- 配置注解自动代理 -->
    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>
</beans>

需要类：

package com.h_Aspectj_anno;

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

public class TestDemo {
    @Test
    public void test1() {
        String xmlPath = "com/h_Aspectj_anno/beans.xml";
        ApplicationContext appcont = new ClassPathXmlApplicationContext(xmlPath);
        BookService bookService = (BookService) appcont.getBean("BookService");
        bookService.addBook();
        bookService.selectBook();
        bookService.deleteBook();
    }
}

需要测试那个方法就打开注解，最终效果和使用xml的时候一样

Spring框架之AspectJ（xml、注解形式配置）
hestyle的博客
12-02 845
1、AspectJ是什么？ AspectJ是一个基于Java语言的AOP框架。 AOP是什么？ AOP为Aspect Oriented Programming的缩写，意为：面向切面编程，通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。 参考我的另外一篇博客 Java之AOP面向切面编程（手动动态代理实现） 那么面向切面编程又是什么？ 停！ 面向切面编程是一种横向代码抽取维护机制，在...
Spring5框架—— AspectJ
qq_50233116的博客
11-08 542
AOP基本的操作术语，AspectJ的准备（基于AspectJ实现AOP操作、切入点表达式）、AOP操作（AspectJ注解方式、AspectJ配置文件方式）包括完全注解方式
AspectJ 基于xml开发和基于注解的开发
Lilyの博客 ٩(❛ัᴗ❛ั)
06-23 465
AspectJ是一个基于Java语言的AOP框架。Spring2.0以后新增了对AspectJ切点表达式支持。@AspectJ 是AspectJ1.5新增功能，通过JDK5注解技术，允许直接在Bean类中定义切面。新版本Spring框架，建议使用AspectJ方式来开发AOP。主要用途：自定义开发。
spring框架之AspectJ基于xml和基于注解
qq_43161124的博客
10-06 577
AOP为Aspect Oriented Programming的缩写，意为：面向切面编程，通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。 今天写...
AspectJ 案例讲解【基于xml】
cyh0503的博客
07-02 2957
第一步：导jar包 相关jar包链接：链接: https://pan.baidu.com/s/1lo8eehhJNds-8HULbJ3LuQ 提取码: fdhn 第二步：实现类与切面类 2.1、首先写一个IUserService接口： public interface IUserService { void addUser(); void updateUser()...
Spring-1.5
Desperate_gh的博客
01-05 127
AspectJ切面编程： 需要的jar包： aop配置： 总结配置aop的格式： <aop:config> <aop:pointcut ... /> <aop:aspect ... > <aop:before ... "/> <aop:after-returning ... /> ... </aop:aspect> </aop:config> 前置通知：<aop:befor
JAVA Spring AspectJ的两种声明式（基于xml、基于注解）
qq_17490417的博客
09-18 660
AspectJ：基于JAVA语言 的AOP框架，提供了强大的AOP功能。 需要用到的jar包 1.基于xml的声明式AspectJ（配置较多） 所有的切面、切入点、通知都必须定义在<aop:config>元素内。下图灰色部分为常用的配置元素： 图片来源于www.itheima...
Spring使用AspectJ注解和XML配置实现AOP
09-01
本主题将深入探讨如何使用AspectJ注解和XML配置在Spring中实现AOP。 首先，我们要了解AOP的基本概念。AOP的核心是切面（Aspect），它将分散在多个对象中的横切关注点（如日志、性能监控）提取出来，形成独立的模块...
Spring 使用AspectJ 实现 AOP（基于xml文件、基于注解）
04-18
本教程将探讨如何在Spring中结合AspectJ实现AOP，包括基于XML配置和基于注解的方式。 **一、AOP基本概念** AOP的核心概念有切面（Aspect）、连接点（Join Point）、通知（Advice）、切点（Pointcut）和引入...
[JAVAEE]实验04：Spring AOP基于XML和注解的AspectJ开发
Topus的博客
03-22 1117
#一、实验目的： （1）熟练掌握AOP术语（切面、切入点、通知等）； （2）熟练掌握基于XML和注解的AspectJ开发。 #二、实验内容： 使用前置通知进行访问控制：通过方法参数决定是否可以访问该方法，当参数值为"agree"时允许访问，否则不允许访问。 #三、实现方法与代码 ##方法1.基于XML的声明式AspectJ实现： 第一步： 1.建立dao接口（规范化模拟数据库访问） package...
AspectJ——基于注解的开发方式
Gavin
05-11 8488
基于注解的开发方式 AspectJ5版本支持了基于注解的开发方式，当然其仍然需要AspectJ自己的编译器。 要使用基于注解的开发方式，需要为项目引入aspectjweaver.jar包，该Jar包也在AspectJ安装目录下的lib目录中。aspectjweaver.jar中包含了aspectjrt.jar包中的内容，所以只需要引入aspectjweaver.jar包即可。 0.一个示...
记spring1.5转用mysql的坑
weixin_35442221的博客
09-15 368
记spring1.5转用mysql的坑
AOP之基于AspectJ注解总结与案例
Evankaka的专栏
05-04 9591
Spring除了支持Schema方式配置AOP，还支持注解方式
SpringBoot 1.5.9到2.0.0的踩坑记录
热门推荐
cslucifer的博客
03-19 1万+
一.2018/3/19 09:13 findOne()刚刚升级到2.0,发现service的实现类报错,发现findOne方法无法再根据id查询了findOne(ID)--&gt;findById(ID)需要先判断findById的返回值/** * If a value is present in this {@code Optional}, returns the value, * othe...
Spring Boot1.5 学习笔记
03-21 2570
Spring Boot 1.5.9 入门
Spring AOP之AspectJ框架（XML的声明式和注解的声明式）
weixin_44117272的博客
07-04 497
1.概述 2.基于XML的声明式 2.1简介 2.2XML文件中常用元素的配置方式
Common application properties
新丶的博客
03-09 708
Various properties can be specified inside your application.properties/application.yml file or as command line switches. This section provides a list of common Spring Boot properties and references to
Spring Boot 1.5.x新特性：动态修改日志级别
weixin_34150830的博客
02-01 205
2019独角兽企业重金招聘Python工程师标准>>> ...
spring boot 1.5.9.RELEASE @Aspect aop 切面不生效问题
starzxf的专栏
03-24 4813
1、我的语法是这样的：@AfterReturning(value = "execution(public int cn.hy.tailer.service.IMessagesSmsoutService.save(MessagesSmsout)) &amp;&amp; args(model)")2、IMessagesSmsoutService 的实现类public class MessagesSms...
Spring结合AspectJ注解与XML配置实践AOP
"本文将详细介绍如何在Spring框架中利用AspectJ注解和XML配置来实现面向切面编程(AOP)。首先，我们将概述什么是AOP，它如何补充OOP(对象导向编程)，以及在Spring中引入AOP的重要性。然后，我们会深入探讨如何在...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值