Spring 基于Aspect的AOP

最新推荐文章于 2024-11-13 20:43:20 发布
最新推荐文章于 2024-11-13 20:43:20 发布
阅读量82 收藏
点赞数
文章标签： java
原文链接：https://my.oschina.net/popfei/blog/1830787
版权

a450cc98bd9d9bc8d898908efe3c45de835.jpg

3f16584b9a69dd1334e438ced4407e026d5.jpg

dae94d18352f4cdf97a73a931798cf5c9e7.jpg

26ffa022d623f13c69854729f4d19b03725.jpg

0038e8cbcd6adc8570cabb4961369a78982.jpg

简单版:

ffa60fdad939744cc6e5305254ad31d503f.jpg

完整版例子：

package com.imooc.aspectJ.demo1;

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("查询一个商品...");
//        int i=1/0;
    }

    public void findAll(){
        System.out.println("查询所有商品...");
//        int i=1/0;
    }
}
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 = "MyPointCut1()||MyPointCut2()")
    public void before(JoinPoint joinPoint){
        System.out.println("前置通知=================="+joinPoint);
    }

    @AfterReturning(value = "MyPointCut2()",returning="result")
    public void afterReturning(JoinPoint joinPoint,Object result){
        System.out.println("后置通知============="+joinPoint+",result:"+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.findOne(..))))")
    private void MyPointCut4(){}

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

}
<?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/>

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

    <!--定义切面-->
    <bean class="com.imooc.aspectJ.demo1.MyAspectAnno"/>
</beans>
package com.imooc.aspectJ.demo1;

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

 

d103f3cfd77153256326bccc706ef2106ca.jpg

5861cbf776253e5250381e256a5689ad89e.jpg

97dc4a9991d809a135aa442d6b35aed5b7e.jpg

e5124bd6650ca6804644c3e8fbe37845688.jpg

4ea8354d651900d7c1ef9d038d263dea841.jpg

3d3352e27ff8a156fa2d04f9046dd38c34a.jpg

172728cd887d3904a587e8e09f241cb79c3.jpg

 

===============XML方式===============

package com.imooc.aspectJ.demo2;

public interface CustomerDao {
    public void save();
    public String update();
    public void delete();
    public void findOne();
    public void findAll();
}
package com.imooc.aspectJ.demo2;

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

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

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

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

    @Override
    public void findAll() {
        System.out.println("查询多个客户...");
        //int i=1/0;
    }
}
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 afterRetruning(String 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方式的最终通知通知=============");
    }
}
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 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"/>

    <!--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:after-returning method="afterRetruning" 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>

一般在实际开发过程中AOP，基本不会使用传统AOP开发。一般使用AspectJ的方式。企业中有些用注解，有些使用XML方式。

转载于:https://my.oschina.net/popfei/blog/1830787

chihanjue1993
关注
基于spring@aspect注解的aop实现过程代码实例
08-24
Spring AOP实现过程代码实例基于@Aspect注解 基于Spring @Aspect注解的AOP实现过程代码实例是指通过使用Spring框架中的AOP（Aspect-Oriented Programming）机制来实现面向切面编程的代码实例。在这个实例中，我们将...
详解Spring 基于 Aspect 注解的增强实现
08-30
Spring 框架提供了基于 Aspect 注解的增强实现，这种实现方式可以帮助开发者更方便地实现面向切面编程（AOP）。在本篇文章中，我们将详细介绍 Spring 基于 Aspect 注解的增强实现，并提供了实际的代码示例和测试结果...
Spring AOP用法及原理
跟心爱的人一起浪迹天涯
07-10 160
AOP作为Spring的第二大核心内容，日常开发中，也是经常会用到的。所谓面向切面编程，就是对某些特定的方法执行的前后切入一些特定的代码。核心原来采用动态代理实现。 使用场景 日志 在方法执行前后打印日志 事务 在方法执行前开启事务，执行完提交事务，异常回滚事务 权限校验 在方法执行前对用户的登录状态及权限做校验 使用方法 步骤如下 1.添加Aspect依赖 <dependency> <groupId>org.springframework</groupId> ..
SpringAop与AspectJ的联系与区别
yzgyjyw的博客
05-19 1万+
SpringAop与AspectJ的联系与区别区别AspectJAspectJ是一个面向切面的框架，它扩展了Java语言。AspectJ定义了AOP语法，所以它有一个专门的编译器用来生成遵守Java字节编码规范的Class文件。spring aopSpring提供了四种类型的Aop支持 * 基于经典的SpringAOP * 纯POJO切面 * @ASpectJ注解驱动的切面 * 注入式Asp
细说Spring——AOP详解（AOP概览）
热门推荐
啦啦啦的博客
05-30 53万+
一、对AOP的初印象 首先先给出一段比较专业的术语（来自百度）： 在软件业，AOP为Aspect Oriented Programming的缩写，意为：面向切面编程，通过预编译方 式和运行期动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个 热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑 的各个部分进行隔离，从而...
Spring基于AspectJ实现AOP操作
『愚』的博客
01-18 6149
基于AspectJ实现AOP操作准备工作在项目工程里面引入 AOP 相关依赖。学会使用切入点表达式AOP 操作（AspectJ 注解）1、创建类，在类里面定义方法2、创建增强类（编写增强逻辑），在增强类里面，创建方法，让不同方法代表不同通知类型3、进行通知的配置4、配置不同类型的通知相同的切入点抽取有多个增强类多同一个方法进行增强，设置增强类优先级完全使用注解开发代码结构测试代码 Spring 框架一般都是基于 AspectJ 实现 AOP 操作。 需要注意的是：AspectJ 不是 Spring 组成部
Spring AOP和Aspect AOP有什么区别？
qq_38197844的博客
10-26 2218
1. Spring AOP属于运行时的增强，而Aspect AOP属于编译时的增强。SpringAOP是基于代理（Proxying），而AspectAOP是基于字节码操作。 2. 如果切面比较少，两者差不多，如果切面太多，最好使用AspectAOP，它比SpringAOP快很多。 ...
基于AspectJ的Spring的Aop
weixin_42179326的博客
12-08 149
引入依赖 <dependency> <groupId>org.springframework</groupId> <artifactId>spring-aop</artifactId> <version>4.1.3.RELEASE</version> </dependency> <dependency> <groupId>aopalliance</gro
spring-boot aop
01-23
默认情况下，Spring使用基于Java的代理，但对于需要在静态方法或非Spring管理对象上应用AOP的情况，可能需要使用CGLIB或AspectJ字节码代理。 5. **理解代理行为**：理解Spring AOP代理的工作方式很重要，因为这可能...
Spring aop aspect
秀才的专栏
04-20 2397
package com.my.aop; import org.aspectj.lang.ProceedingJoinPoint; import org.aspectj.lang.annotation.After; import org.aspectj.lang.annotation.Around; import org.aspectj.lang.annotation.Aspect;
Spring框架基于AOP实现简单日志管理步骤解析
08-19
在本篇文章中，我们将详细介绍如何使用Spring框架基于AOP（Aspect-Oriented Programming，面向方面编程）来实现简单日志管理步骤解析。AOP是一种编程范式，旨在将横切关注点与业务逻辑分离，提高代码的可维护性和...
spring aop aspect
zoudingrong的专栏
07-13 93
package test; /** * * @author neu_20063500 * */ public class HelloWorld { public void sayHello(String helloworld) { System.out.println(helloworld);...
日常bug记录，easyexcel导入报错convert data ... to class java.math.BigDecimal error
mm
11-11 257
排查发现实体类中有BigDecimal属性，然而数据中这个属性为null，进行转换时报错。在实体类上加上自定义转换器。解决方法：自定义转换器类。
Servlet的生命周期
最新发布
wyk的博客
11-13 859
Servlet 的生命周期包含四个主要阶段：加载与实例化、初始化、请求处理、销毁。开发者可以在这些生命周期方法中编写初始化、请求处理和资源清理的代码，确保 Web 应用程序的正常运行。
Java基础07
m0_74977981的博客
11-11 671
如图下图：每个case中都有一个break，如果没有这个break，就不会跳出case，直到遇见break为止。
1112--接口
kequanrrr的博客
11-12 371
interface + 接口名{ }。。。。implements 接口名{ }接口：接口中的抽象方法可以省略 abstract 关键字使用：要实现接口中的所有 抽象方法隐含三个修饰符：public+static+final2.单继承 多接口。
SpringBoot(五)
₍˄·͈༝·͈˄*₎◞ ̑̑的博客
11-13 682
Rest请求处理
JAVA学习接口案例实例
shangan_3的博客
11-08 238
【代码】JAVA学习接口案例实例。
深入理解Java的类加载与卸载机制
Luffy的博客
11-12 1056
类加载是指JVM将.class文件中的二进制数据读入内存中，经过一系列验证、解析和初始化，最终在JVM中生成可以被使用的Class对象。JVM会为每个类加载并生成一个唯一的Class对象，这个对象封装了类的所有信息，包括方法、属性等。类加载的三大步骤：1.加载（Loading）：从不同的源（如文件、网络）获取类的二进制字节码，并生成Class对象。2.链接（Linking）：对类的二进制进行校验和解析，确保类文件格式正确。验证（Verification）：检查字节码是否符合JVM的规范。
ArkTS--应用状态
qq_63946637的博客
11-10 636
本文旨在帮助大家学习鸿蒙中的LocalStorage和AppStorage
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值