SpringAop

最新推荐文章于 2024-06-08 13:54:29 发布
最新推荐文章于 2024-06-08 13:54:29 发布
阅读量77 收藏
点赞数
分类专栏： JavaWeb Spring实战第四版Note SpringAop
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_41078234/article/details/98471362
版权

AopOfSpring

本章内容:

  • 面向切面编程的基本原理

  • 通过POJO创建切面

  • 使用@AspectJ注解

  • 为AspectJ切面注入依赖

 

4.1什么是切面编程呢

切面能帮助我们模块化横切关注点,对于许多需要相同同的方法去增强的bean来说,一个个来将增强代码写入其中,显然是不可取的, 假如有一百个类需要增强,那么就得写一百次增强方法,再加上修改,这不得逆天,所以AOP面向切面编程出现了

4.1.1 定义AOP术语

不多说,上图

Spring切面可以有5种类型得通知:

  • 前置通知:在目标方法调用之前调用通知

  • 后置通知:在目标方法调用之后调用通知

  • 返回通知:在目标方法成功执行后调用通知

  • 异常通知:在目标方法抛出异常后调用通知

  • 环绕通知(重点):通知包裹了被通知得方法,在被通知得方法调用之前和调用之后执行自定义得行为

4.1.2 Spring对Aop的支持

Spring提供了四种类型的AOP支持:

  • 基于代理的经典SpringAOP(太过笨重复杂,不做介绍)

  • 纯POJO切面

  • @AspectJ注解驱动的切面

  • 注入式是AspectJ切面(适用于各个版本)

前三种都是SpringAOP的变体,需要构建在JDK动态代理上,所以Spring对AOP的支持局限于方法拦截

spring在运行时通知对象

当Spring在调用bean的方法前,并不是调用目标类的方法,而是执行代理对象的方法.即当代理类拦截到方法调用时,在调用目标方法之前,会执行切面逻辑

 

4.2 通过切点来选择连接点

这边主要会介绍有关于切点的编写

如下

package concert;
//注意包名以及类名
public interface Performance {
    
    public void perform();
}

当我们使用AspectJ切点表达式选择Performance的perform()方法时

 

我们也可以使用within()指示器来限制匹配,使用方法如下

execution(* concert.Performance.perform(..)) && within(concert
*)

&&符号表示的是and操作符,即必须是concert所在包下的任意类的方法

当然我们也可以使用'||'操作符来标识(or)关系,而使用'!'操作符来标识非(not)操作

在XML中'&'有特殊含义,我们可以是用and,or,not代替符号

 

4.2.2 在切点中选择bean

//执行concert.Performance类中perform方法,但是bean的id为woodstock
execution(* concert.Performance.perform(..)) and bean('woodstock')
  
  //执行concert.Performance类中perform方法,但是bean的id不为woodstock
execution(* concert.Performance.perform(..)) and !bean('woodstock')

 

4.3 使用注解创建切面

//切面类
@Aspect
public class Audience {
        
    //来看演出需要静音手机
    @Before("execution(* concert.Performance.perform(..))")
    public void silenceCellphones() {
        System.out.println("Silenciong cell phones");
    }
    
    //静音手机
    @Before("execution(* concert.Performance.perform(..))")
    public void takeSeats() {
        System.out.println("takingSeats");
    }
    
    //表演的成功有掌声
    @AfterReturning("execution(* concert.Performance.perform(..))")
    public void applause() {
        System.out.println("CLAP CLAP");
    }
    
    //表演出现了异常 会要求退票
    @AfterThrowing("execution(* concert.Performance.perform(..))")
    public void demanRefund() {
        System.out.println("Demanding a refund");
    }
}

Spring使用AspectJ注解来声明通知方法

注解通知
@After通知方法会在目标返回或抛出异常后调用
@AfterReturning通知方法会在目标方法返回后调用
@AfrterThrowing通知方法会在目标方法抛出异常后调用
@Around通知方法会将目标方法封装起来
@Before通知方法会在目标方法调用之前执行

从上面的代码我们发现,一个切点表达式重复了四次,这可不是什么好玩的事情,我们可以做一些改造

@Aspect
public class Audience {
    
    //此方法不需要有任何执行,仅仅是一个表达式,让@PointCut去依附,仅仅是一个标识
    @Pointcut("execution(* concert.Performance.perform(..))")
    public void performance() {
    }
        
    //来看演出需要静音手机
    @Before("performance()")
    public void silenceCellphones() {
        System.out.println("Silenciong cell phones");
    }
    
    //静音手机
    @Before("performance()")
    public void takeSeats() {
        System.out.println("takingSeats");
    }
    
    //表演的成功有掌声
    @AfterReturning("performance())")
    public void applause() {
        System.out.println("CLAP CLAP");
    }
    
    //表演出现了异常 会要求退票
    @AfterThrowing("performance())")
    public void demanRefund() {
        System.out.println("Demanding a refund");
    }
}

当然Audience切面也可以像其他bean一样

@Bean
public Audience audience(){
    return new Audience();
}

在前面说过,我们调用的方法其实是个代理对象,即我们应该启动AspectJ自动代理

@ComponentScan
@Configuration
//启动AspectJ代理
@EnableAspectJAutoProxy
public class JavaConfig {
    @Bean
    public Audience audience(){
        return new Audience();
    }
}

也可以在XML声明中

<aop:aspectj-autoproxy />

 

带有参数得AOP

Aspect类

@Aspect
public class Audience {
    
    //此方法不需要有任何执行,仅仅是一个表达式,让@PointCut去依附,仅仅是一个标识
    @Pointcut("execution(** concert.ServiceTest.service3(Integer)) && args(param1)")
    public void performance(Integer param1) {
    }
        
    //来看演出需要静音手机
    @Before("performance(param1)")
    public void silenceCellphones(Integer param1) {
        
        System.out.println("Silenciong cell phones" + "  "+param1);
    }
    }

JavaConfig配置类

@ComponentScan
@Configuration
@EnableAspectJAutoProxy
public class JavaConfig {
    @Bean
    public Audience audience() {
        return new Audience();
    }
    
}
​

Service类

@Service
public class ServiceTest {
​
    public void service2(Integer param1, String param2) {
        System.out.println("I am services 2 and I have param:"+param1+"     "+param2);
    }
​
}

Test类

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes=JavaConfig.class)
public class JavaAopTest {
    @Autowired
    private ServiceTest st;
    
    @Test
    public void test() {
        st.service3(6);
    }
}

XML配置可自行尝试,示例事务管理配置(不是以上得使用)

<tx:advice id="txAdvice" transaction-manager="transactionManager">
    <tx:attributes>
        <!-- 传播行为 -->
        <tx:method name="save*" propagation="REQUIRED"/>
        <tx:method name="delete*" propagation="REQUIRED"/>
        <tx:method name="insert*" propagation="REQUIRED"/>
        <tx:method name="update*" propagation="REQUIRED"/>
        <tx:method name="find*" propagation="SUPPORTS" read-only="true"/>
        <tx:method name="get*" propagation="SUPPORTS" read-only="true"/>
        <tx:method name="select*" propagation="SUPPORTS" read-only="true"/>
    </tx:attributes>
</tx:advice>
<!-- aop -->
<aop:config>
    <aop:advisor advice-ref="txAdvice" pointcut="execution(* com.pjh.atcrowdfunding..*Service.*(..))"/>
</aop:config>

 

接下来到了个重要环节即AOP底层实现,AOP得底层实现是使用了JDK动态代理,JDK动态代理需要被增强类有接口

下面来看下如何实现JDK的动态代理

Advice增加类

public class AdviceClass {
    public void advice1() {
        System.out.println("这是增强办法1111");
    }
    public void advice2() {
        System.out.println("这是增强办法22222222222");
    }
    public void advice3() {
        System.out.println("这是增强办法333333333333333333");
    }
}

目标类接口

/**
 * 目标类接口
 * @author Administrator
 *
 */
public interface ItemsService {
    
    public void addItems(int i, int b)throws Exception;
    public void updateItems()throws Exception;
    public void deleteItems()throws Exception;
}

目标类

public class ItemsServiceImpl implements ItemsService {
​
    @Override
    public void addItems(int i, int b) throws Exception {
        System.out.println("this is a:  addItems"+i+"this is b    "+b);
    }
​
    @Override
    public void updateItems() throws Exception {
        System.out.println("this is a:  updateItems");
        
    }
​
    @Override
    public void deleteItems() throws Exception {
        System.out.println("this is a:  deleteItems");
        
    }
​
}

 

当然,有了目标类和增强类以后,我们需要将两者结合起来

代理工厂类

public class BeanFactory {
    public static ItemsService createService() {
        // 目标类
        final ItemsService itemsService = new ItemsServiceImpl();
        // 切面类
        final AdviceClass advice = new AdviceClass();
        /**
         * 调用Proxy.newProxyInstance((ClassLoader loader, 类<?>[] interfaces, InvocationHandler h))生成我们的代理类
         * 参数:
         * loader  类加载器,动态代理类运行时创建,任何类的运行都需要类加载器
         * interfaces  目标类的接口,jdk代理需要接口才可以实现
         * h      处理类,接口,必须实现的,每一次执行一次方法,通过代理调用一次invoke
         *          (Object proxy, Method method, Object[] args)
         *          ivoke参数:
         *              proxy:代理对象类
         *              method:调用的方法
         *              args:调用方法的实现类   
         */
        ItemsService itemsServiceProxy = (ItemsService) Proxy.newProxyInstance(BeanFactory.class.getClassLoader(),
                itemsService.getClass().getInterfaces(), new InvocationHandler() {
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        advice.advice1();
                        Object obj = method.invoke(itemsService, args);
                        advice.advice2();
                        advice.advice3();
                        return obj;
                    }
                });
        return itemsServiceProxy;
​
    }
}

 

 

CGlib代理

和JDK动态代理不同,CGlib代理不需要实现接口,但是需要一个父接口,但我们都知道,Java默认继承Object类

这里只对BeanFactory做了更改

BeanFactory

public class BeanFactory {
    public static ItemsService createService() {
        // 目标类
        final ItemsServiceImpl itemsService = new ItemsServiceImpl();
        // 切面类
        final AdviceClass advice = new AdviceClass();
        // .代理类 ，采用cglib，底层创建目标类的子类
        Enhancer enhancer = new Enhancer();
        //确定父类
        enhancer.setSuperclass(itemsService.getClass());
        /* 设置回调函数 , MethodInterceptor接口 等效 jdk InvocationHandler接口
         *  intercept() 等效 jdk  invoke()
         *      参数1、参数2、参数3：以invoke一样
         *      参数4：methodProxy 方法的代理
         */
        enhancer.setCallback(new MethodInterceptor() {
            
            @Override
            public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
            
                advice.advice1();
                advice.advice2();
                
                //执行目标类的方法
                Object obj = method.invoke(itemsService, args);
                // * 执行代理类的父类 ，执行目标类 （目标类和代理类 父子关系）
                methodProxy.invokeSuper(proxy, args);
                
                //后
                advice.advice3();
                
                return obj;
                
            }
        });     
        //3.4 创建代理
        ItemsServiceImpl proxService = (ItemsServiceImpl) enhancer.create();
                
                return proxService;
        
        
​
    }
}
​

 

豪哥super叼
关注
专栏目录
SpringAOP(图文详解)
lhj520cb的博客
07-16 4万+
Spring实现的AOP是代理模式，给调用者使用的实际是已经过加工的对象，你编程时方法体里只写了A，但调用者拿到的对象的方法体却是xAy。x和y总还是需要你来写的，这就是增强。x和y具体在什么时候被调用总还是需要你来规定的，虽然是基于约定的声明这种简单的规定，这就是切点。
Spring AOP全面详解(超级详细)
热门推荐
Cr1556648487的博客
09-09 8万+
AOP （Aspect Orient Programming）,直译过来就是 面向切面编程,AOP 是一种编程思想，是面向对象编程（OOP）的一种补充。面向切面编程，实现在不修改源代码的情况下给程序动态统一添加额外功能的一种技术，如下图所示：AOP可以拦截指定的方法并且对方法增强，而且无需侵入到业务代码中，使业务与非业务处理逻辑分离，比如Spring的事务，通过事务的注解配置，Spring会自动在业务方法中开启、提交业务，并且在业务处理失败时，执行相应的回滚策略。
SpringAOP学习--SpringAOP简介及原理
u012098021的博客
05-15 6万+
前文对AOP做了介绍，实际项目中，一般不会直接上手手动实现aop，而是使用一些高级封装的aop实现，如SpringAOP。 Spring是一个广泛应用的框架，SpringAOP则是Spring提供的一个标准易用的aop框架，依托Spring的IOC容器，提供了极强的AOP扩展增强能力，对项目开发提供了极大地便利。 前文提到AOP的实现有AspectJ、JDK动态代理、CGLIB动态代理，SpringAOP不是一种新的AOP实现，其底层采用的是JDK/CGLIB动态代理。 JDK动态代理回顾 上一篇简单介绍了
spring aop详解
hanbin1998的博客
04-13 6274
1.前言 spring aop是一个面向切面的编程，在自己第一遍学习的时候，感觉aop没有什么作用，但是真实接触下来，感觉spring aop还是很有用途的，感觉自己之前的想法太年轻了。 2.概念 Spring 提供了两种AOP 的实现：基于注解式配置和基于XML配置，我这里主要就是介绍一下，基于注解式配置。 2.1 AOP 即 Aspect Oriented Program 面向切面编程 首先，在面向切面编程的思想里面，把功能分为核心业务功能，和周边功能。 所谓的核心业务，工作中做的最多的
Spring AOP详解
chongbaozhong的博客
05-26 3786
前言 什么是AOP AOP （Aspect Orient Programming）,直译过来就是 面向切面编程。AOP 是一种编程思想，是面向对象编程（OOP）的一种补充。面向对象编程将程序抽象成各个层次的对象，而面向切面编程是将程序抽象成各个切面，是Spring的核心思想之一。 AOP 实现分类 AOP 要达到的效果是，保证开发者不修改源代码的前提下，去为系统中的业务组件添加某种通用功能。AOP 的本质是由 AOP 框架修改业务组件的多个方法的源代码，按照 AOP 框架修改源代码的时机，可以将其分为两类：
spring aop参数传递
weixin_43931625的博客
04-23 2745
spring aop参数传递
SpringAOP 常见应用场景
Zyw907155124的博客
06-08 2805
常见应用场景:日志记录、权限检查、事务管理、异常处理、性能监控、缓存、参数校验和转换、API调用统计、SLF4J、Logback、Log4j等日志框架集成、自定义注解的处理。 1、AOP实现 性能监控；2、AOP实现 API调用统计；3、AOP实现 缓存；4、AOP实现自定义滑动窗口限流
spring aop 注解
面朝大海，春暖花开
02-27 3416
spring Aop 注解 Aop 术语 AOP 的特性术语，不同的翻译还会不一样，得在过程中理解 横切关注点：跨越程序多个模块的方法或功能。即与业务逻辑无关，但我们也要关注的部分，就是横切关注点。如日志、安全、缓存等。 切面（ Aspect ）：横切关注点被模块化的特殊对象；即切面应是一个类。 通知（ Advice）：切面要完成的增强处理，通知描述了切面何时执行以及如何执行增强处理；即通知应是切面中的方法。 目标（ Target ）：被通知对象。 代理（ Proxy ）：向目标对象应用通知之后创建的对象
Spring AOP 动态代理
qq15035899256的博客
08-30 1783
本文是Spring AOP的学习，学习AOP的思想，AOP的使用(定义切面、切点和通知)，以及两种常用的AOP使用方法。之后的学习内容将持续更新！！！
Spring——Spring AOP原理
庄小焱
03-30 2873
AOP即面向切面编程，是OOP编程的有效补充。使用AOP技术，可以将一些系统性相关的编程工作，独立提取出来，独立实现，然后通过切面切入进系统。从而避免了在业务逻辑的代码中混入很多的系统相关的逻辑.AOP是Spring提供的关键特性之一，本文深入剖析Spring AOP的原理。
Spring AOP 16道面试题及答案.docx
06-29
Spring AOP，全称为Aspect Oriented Programming，是面向切面编程的一种编程范式，它是对传统的面向对象编程（OOP）的一种补充。在OOP中，核心是对象，而在AOP中，核心则是切面。切面是关注点的模块化，即程序中的...
SpringAOP:Spring AOP示例
05-06
SpringAOP Spring AOP（面向方面​​的编程）用于模块化“横截面”服务。 用一种简单的方式，我们可以说它是一个旨在拦截某些进程的组件，例如，在执行某个方法时，Spring AOP可以审核该执行方法，并在该方法执行...
Spring源码最难问题：当Spring AOP遇上循环依赖.docx
06-15
Spring源码最难问题：当Spring AOP遇上循环依赖 Spring源码中最难的问题之一是循环依赖问题，当Spring AOP遇上循环依赖时，该如何解决？ Spring通过三级缓存机制解决循环依赖的问题。 在Spring中，bean的实例化...
open3d-0.11.2-cp36-cp36m-win_amd64.whl
10-19
open3d-0.11.2-cp36-cp36m-win_amd64.whl
SpringBoot是一个经典实用的员工管理系统。集成了Mybatis在MySQL数据库上的
10-19
SpringBoot是一个经典实用的员工管理系统。集成了Mybatis在MySQL数据库上的操作。页面模板使用themleaf。经典SpringBoot案例研究_ SpringBoot_案例研究_
nipy-0.4.1-cp35-cp35m-win_amd64.whl
10-19
nipy-0.4.1-cp35-cp35m-win_amd64.whl
算法部署-使用OpenVINO在FPGA上部署人脸检测算法-附详细流程教程+项目源码-优质项目实战.zip
最新发布
10-19
算法部署_使用OpenVINO在FPGA上部署人脸检测算法_附详细流程教程+项目源码_优质项目实战
Pillow_SIMD-6.0.0.post0+avx2-cp35-cp35m-win_amd64.whl
10-19
Pillow_SIMD-6.0.0.post0+avx2-cp35-cp35m-win_amd64.whl
spring aop
09-11
Spring AOP（Aspect-Oriented Programming）是Spring框架中的一个重要特性，它提供了一种在应用程序中实现横切关注点（cross-cutting concerns）的方法。所谓横切关注点，指的是那些在应用程序中散布于各个模块之中...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值