Spring AOP

最新推荐文章于 2021-05-26 17:26:43 发布
最新推荐文章于 2021-05-26 17:26:43 发布
阅读量460 收藏
点赞数
分类专栏： Spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/MRW456/article/details/50358304
版权

准备Spring AOP需要的jar包

@Before

Mymother.java:

package com.mrw.springtest9;
public class Mymother {
    public void back(){
        System.out.println("好好准备!");
    }
}

Relation.java

package com.mrw.springtest9;

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;
@Aspect
public class Relation {
    @Before("execution(* com.mrw.springtest9.Mymother.back())")//当调用Mymother的back()时，在它之前执行want()方法
    public void want(){
        System.out.println("我想做事!");
    }
}

将Mymother.java与及Relation.java装入beans.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:context="http://www.springframework.org/schema/context"
    xmlns:p="http://www.springframework.org/schema/p"
    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-4.1.xsd
        http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.1.xsd">
     <aop:aspectj-autoproxy/>//必须这样写Spring才能扫描到AOP的注解
     <bean id="Mymother" class="com.mrw.springtest9.Mymother"></bean>
    <bean id="Relation" class="com.mrw.springtest9.Relation"></bean>
</beans>

建立测试类Test1.java进行测试
import org.junit.Test;
import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Test1 {
    @Test
    public void test() {
        ConfigurableApplicationContext context=new ClassPathXmlApplicationContext("beans.xml");
        Mymother mymother=(Mymother)context.getBean("Mymother");
        System.out.println("---------------------");
        mymother.back();
        System.out.println("---------------------");
    }
}

输出测试结果:

@After

将第一个示例中的其它不变，Relation.java中的@Before替换为:

@After("execution(* com.mrw.springtest9.Mymother.back())")
 public void dosomething(){
        System.out.println("我要开始做事啦!");
 }

输出结果为:

@AfterReturning

将第一个示例中的进行改变，Relation.java中的@Before替换为:

@AfterReturning(value="execution(** com.mrw.springtest9.Mymother.caclculate(..))",returning="var") //caclculate()方法有返回值时，下面的returnvalue就打印出了返回值
    public void returnvalue(Object var){
        System.out.println("返回的值为:"+var);
  }

Mymother中添加如下方法:

  public double caclculate(int x,int y){
        return x/y;
    }

改变Test1.java改变为:

package com.mrw.springtest9;

import static org.junit.Assert.*;

import org.junit.Test;
import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class Test1 {

    @Test
    public void test() {
        ConfigurableApplicationContext context=new ClassPathXmlApplicationContext("beans.xml");
        Mymother mymother=(Mymother)context.getBean("Mymother");
        System.out.println("---------------------");
        mymother.caclculate(10, 5);
        System.out.println("---------------------");
    }

}

输出的结果为:

@Around

往第一个示例中Mymother.java添加

   public void life(){
        System.out.println("人生必须活得精彩!");
    }

，Relation.java中的@Before替换为:

@Around("execution(** com.mrw.springtest9.Mymother.must())")
    public void eat(){
        System.out.println("吃饭!");
    }

改变Test1.java为:

       ConfigurableApplicationContext context=new ClassPathXmlApplicationContext("beans.xml");
        Mymother mymother=(Mymother)context.getBean("Mymother");
        System.out.println("---------------------");
        mymother.must();
        System.out.println("---------------------");

输出结果为:

@After注解的方法就是在一个方法执行完之后执行

@After注解的方法就是在一个方法抛出异常时执行

@Pointcut

当要注解的方法进行重复时，可采用该方法

MyPoint.java

package com.mrw.springtest9;

import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
@Aspect
public class MyPointcut {
    @Pointcut("execution (** com.mrw.springtest9.Mymother.*(..))")
    public void selectMymother(){};//这里的方法必须为空，最好别带参数啦
    
    @Before("selectMymother()")  //相当于@Before((** com.mrw.springtest9.Mymother.*(..))"))
    public void beforeMymother(){
        System.out.println("在所有方法之前执行。。。");
    }
    @AfterReturning(pointcut="selectMymother()",returning="val") //相当于@AfterReturning(value="execution (** com.mrw.springtest9.Mymother.*(..))",returning="var")
    public void afterReturnMymother(Object val)
    {
        System.out.println("返回值为:"+val);
    }
    @Around("selectMymother()")   //相当于 @Around("execution (** com.mrw.springtest9.Mymother.*(..))")
    public void alll(){
        System.out.println("哪里都有我!");
    }

}

相比一下Pointcut是不是更加简洁啦


在beans.xml配置Spring AOP

Life.java

package com.mrw.springtest10;

public class Life {
    public void strive()
    {
        System.out.println("After:奋斗!奋斗!奋斗的人生最美妙!");
    }
    public void hard()
    {
        System.out.println("Before:生活必须奋力拼搏!");
    }
    public void havemoney(Object var)
    {
        System.out.println("我有"+var+"块钱!");
    }
    public void need()
    {
        System.out.println("Around:生活需要空气和水");
    }

}

ExolLife.java
public class ExolLife {
    public void exol()
    {
        System.out.println("生活如此美妙!");
    }
    public double moremoney(){
        return 10000;
    }
}
在beans.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:context="http://www.springframework.org/schema/context"
    xmlns:p="http://www.springframework.org/schema/p"
    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-4.1.xsd
        http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.1.xsd">
    <bean id="life" class="com.mrw.springtest10.Life"></bean>
    <aop:config>
        <aop:aspect ref="life"> //指定相对应的类的id
            <aop:pointcut expression="execution(** com.mrw.springtest10.ExolLife.moremoney(..))" id="money"/>  //指定表达式
            <aop:pointcut expression="execution(** com.mrw.springtest10.ExolLife.exol())"  id="exol"/>  //指定表达式
            <aop:after method="strive" pointcut-ref="exol"/>  //Life中的strive方法在调用ExolLife.exol方法之后执行
            <aop:before method="hard" pointcut-ref="exol"/>//Life中的hard方法在调用ExolLife.exol方法之前执行
            <aop:after-returning method="havemoney" returning="var" pointcut-ref="money"/>//Life中的havemoney方法在调用ExolLife.moremoney()有返回值时执行，并捕获返回值
            <aop:around method="need" pointcut-ref="exol"/> //Life中的need方法在调用ExolLife.exol方法时执行
        </aop:aspect>
    </aop:config>
    <bean id="ExolLife" class="com.mrw.springtest10.ExolLife"></bean>
</beans>
编写测试类Test1.java进行测试

package com.mrw.springtest10;
import org.junit.Test;
import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class Test1 {
    @Test
    public void test() {
        ConfigurableApplicationContext context=new ClassPathXmlApplicationContext("beans.xml");
        ExolLife life=(ExolLife)context.getBean("ExolLife");
        life.exol();
    }
}

输出结果为：

要想输出其它结果可改变测试类进行测试







MRW456
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
SpringAOP(图文详解)
lhj520cb的博客
07-16 4万+
Spring实现的AOP是代理模式，给调用者使用的实际是已经过加工的对象，你编程时方法体里只写了A，但调用者拿到的对象的方法体却是xAy。x和y总还是需要你来写的，这就是增强。x和y具体在什么时候被调用总还是需要你来规定的，虽然是基于约定的声明这种简单的规定，这就是切点。
Spring AOP
policevos的博客
07-01 299
AOP概念AOP的动态代理技术spring的AOP相关概念（词汇）AOP开发的三步曲XML的AOP开发切点表达式通知的类型切点表达式的抽取植入的配置注解的AOP配置开发的步骤 概念 Aspect Oriented Programming 面向切面编程 预编译，运行期间，动态代理技术，解耦 AOP的动态代理技术 JDK代理：接口 cglib:父类 spring的AOP 是对JDK代理和cg...
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详解
chongbaozhong的博客
05-26 3664
前言 什么是AOP AOP （Aspect Orient Programming）,直译过来就是 面向切面编程。AOP 是一种编程思想，是面向对象编程（OOP）的一种补充。面向对象编程将程序抽象成各个层次的对象，而面向切面编程是将程序抽象成各个切面，是Spring的核心思想之一。 AOP 实现分类 AOP 要达到的效果是，保证开发者不修改源代码的前提下，去为系统中的业务组件添加某种通用功能。AOP 的本质是由 AOP 框架修改业务组件的多个方法的源代码，按照 AOP 框架修改源代码的时机，可以将其分为两类：
Spring AOP教程
12-07
Spring框架的关键组件之一是面向方面编程(AOP)框架。 面向方面的编程需要将程序逻辑分解成不同的部分。 此教程将通过简单实用的方法来学习Spring框架提供的AOP/面向方面编程。
Spring aop失效的几种解决方案
08-19
Spring AOP失效解决方案详解 作为一名IT行业大师，我将从给定的文件中生成相关知识点，主要介绍Spring AOP失效的几种解决方案。 标题解释 Spring AOP失效的几种解决方案是指在使用Spring框架时，Aspect Oriented ...
spring aop
03-28
Spring AOP，全称为Aspect-Oriented Programming（面向切面编程），是Spring框架的重要组成部分，它为Java应用程序提供了声明式的企业级服务，如事务管理、日志记录等。AOP的核心概念是切面（Aspect）和通知（Advice...
spring aop jar 包
07-26
Spring AOP(Aspect Oriented Programming，面向切面编程)是Spring框架的重要组成部分，它提供了一种在不修改源代码的情况下，对程序进行功能增强的技术。这个"spring aop jar 包"包含了实现这一功能所需的类和接口，...
Spring AOP 16道面试题及答案.docx
06-29
Spring AOP，全称为Aspect Oriented Programming，是面向切面编程的一种编程范式，它是对传统的面向对象编程（OOP）的一种补充。在OOP中，核心是对象，而在AOP中，核心则是切面。切面是关注点的模块化，即程序中的...
Eclipse中安装Spring IDE
MRWisme的博客
10-10 9209
====》在线安装 1、寻找Spring IDE插件更新地址:http://marketplace.eclipse.org/content/spring-ide 2、复制对应Eclipse版本的Spring IDE插件更新地址 3、打开Eclipse,点击Help->Install New Software... 4、单击Add按钮 4、在打开的窗口中，Name可以随
Spring4配置需要的jar包(Spring4.1.2)
MRWisme的博客
11-14 1411
Spring @Autowired与@Inject
MRWisme的博客
11-21 1067
@Autowired 1、新建Calculateshort.java和Calculate.java Calculateshort.java： package com.mrw.springtest3; public class Calculateshort {     public void differ(double x,double y){         System.out.
Spring SpEL
MRWisme的博客
12-06 561
解析SpEL表达式之前：                                       ExpressionParser parser=new SpelExpressionParser();                                       Expression exp=parser.parseExpression("需要解析的SpEL表达式");
Spring constructor-arg、c、p
MRWisme的博客
11-21 552
constructor-arg 1、新建Fruit.java package com.mrw.springtest5; public class Fruit {     private String name;     private double money;     public Fruit(String name, double money) {         super()
Spring4之Hello World
MRWisme的博客
11-14 455
1、在项目中添加所需的jar:http://blog.csdn.net/mrw456/article/details/49835463 2、编写一个bean类SpringHello package com.mrw.springtest1; public class SpringHello {     public void SayHello(){         System.out
Spring @Configuration
MRWisme的博客
11-21 384
1、新建Mobile.java与Product.java Mobile.java: package com.mrw.springtest4; public class Mobile {     public void create(){         System.out.println("一部手机正在被创造。。。");     } } Product.java: packag
pillow_heif-0.17.0-pp39-pypy39_pp73-macosx_14_0_arm64.whl
最新发布
07-27
基本介绍 名称与起源：Pillow，原名为PIL（Python Imaging Library），但PIL只支持Python 2版本。随着Python 3的普及，Pillow作为PIL的一个分支出现，兼容Python 3并提供更多的功能和改进。 主要功能：Pillow支持多种图像格式的打开、保存、显示以及基本的图像操作和处理，如裁剪、缩放、旋转、翻转、滤镜应用等。 跨平台性：Pillow库可以在不同的操作系统上运行，包括Windows、Linux和MacOS等。 主要功能模块 Pillow库包含多个功能模块，每个模块都提供了特定的图像处理功能。以下是一些常用的模块： Image：用于处理图像文件，提供打开、保存、调整大小、旋转、裁剪、滤镜等功能。 ImageDraw：提供在图像上绘制各种形状（如线条、矩形、圆形）和文本的功能。 ImageFont：用于加载和使用TrueType字体文件，以便在图像上绘制文本时设置字体样式、大小和颜色。 ImageFilter：提供各种滤镜效果，如模糊、锐化、边缘增强等，用于图像增强、特效处理和图像识别等应用。 ImageEnhance：用于调整图像的亮度、对比度、颜色饱和度等参数，使图像更加清晰、明亮或具有特定的调色效果。 高级功能 除了基本的图像处理功能外，Pillow还支持一些高级功能，如色彩空间转换、直方图均衡化等。这些功能可以帮助用户进行更复杂的图像处理和分析。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值