================================

©Copyright 蕃薯耀 2020-01-21

https://www.cnblogs.com/fanshuyao/

一、第一步,引用依赖类,在Pom.xml加入依赖

<dependencies>

        <dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>5.1.12.RELEASE</version>
</dependency> <dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>5.1.12.RELEASE</version>
</dependency> <dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-tx</artifactId>
<version>5.1.12.RELEASE</version>
</dependency> <dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-aspects</artifactId>
<version>5.1.12.RELEASE</version>
</dependency> <dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-test</artifactId>
<version>5.1.12.RELEASE</version>
<scope>test</scope>
</dependency> <dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
<scope>test</scope>
</dependency> </dependencies>

二、第二步:增加配置类

1、@Configuration:声明该类为配置类

2、@ComponentScan("com.lqy.spring.aop"):扫描相应的类,纳入spring容器中管理

3、@EnableAspectJAutoProxy:启用注解方式的Aop模式

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.EnableAspectJAutoProxy; @Configuration
@ComponentScan("com.lqy.spring.aop")
@EnableAspectJAutoProxy
public class AopConfig { }

三、第三步:自定义逻辑运算

import org.springframework.stereotype.Component;

/**
* Calculator类需要在spring容器才能使用aop
* 使用:@Component,同时使用@ComponentScan注解扫描时,要扫描到该类
*
*/
@Component
public class Calculator { public int divInteger(int a, int b) {
System.out.println("除法运算");
return a/b;
} public double div(double a, double b) {
System.out.println("除法运算");
return a/b;
} public double add(double a, double b) {
System.out.println("加法运算");
return a + b;
}
}

四、第四步:运算逻辑类切面注入类

1、@Before:方法执行之前

2、@After:方法执行之后(不管会不会出现异常都会执行)

3、@AfterReturning:方法正常执行返回之后

4、@AfterThrowing:方法发生异常执行

import java.util.Arrays;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component; /**
* 类需要在spring容器才能使用aop,并且添加切面类的注解:@Aspect
*
*/
@Aspect
@Component
public class CalculatorAop { /**
* 公共切点
*/
@Pointcut("execution( * com.lqy.spring.aop.Calculator.*(..))")
public void pointCut() {} /**
* 方法执行之前
*/
@Before(value = "execution( * com.lqy.spring.aop.Calculator.*(..))")
public void before(JoinPoint joinPoint) {
System.out.println("");
System.out.println("===============================================================");
System.out.println("before方法:{" + joinPoint.getSignature().getDeclaringTypeName() + "." +joinPoint.getSignature().getName() + "}开始执行:");
System.out.println("方法参数是:{" + Arrays.asList(joinPoint.getArgs()) + "}"); } /**
* 方法执行之后(不管会不会出现异常都会执行)
* pointCut():使用公共的切点表达式
*/
@After("pointCut()")
public void after(JoinPoint joinPoint) {
System.out.println("after方法:{" + joinPoint.getSignature().getDeclaringTypeName() + "." +joinPoint.getSignature().getName() + "}执行结束。");
} /**
* 方法正常执行返回之后
*/
@AfterReturning(value = "pointCut()", returning = "returnResult")
public void afterReturn(JoinPoint joinPoint, Object returnResult) {
System.out.println("afterReturn方法:{" + joinPoint.getSignature().getDeclaringTypeName() + "." +joinPoint.getSignature().getName() + "}执行返回的结果是:{" + returnResult + "}。");
System.out.println("");
} /**
* 方法出现异常执行
*/
@AfterThrowing(value = "pointCut()", throwing = "ex")
public void afterThrowing(JoinPoint joinPoint, Exception ex) {
System.out.println("afterThrowing方法:{" + joinPoint.getSignature().getDeclaringTypeName() + "." +joinPoint.getSignature().getName() + "}发生异常:" + ex);
} }

五、第五步:测试

import org.junit.Test;
import org.springframework.context.annotation.AnnotationConfigApplicationContext; import com.lqy.spring.aop.Calculator;
import com.lqy.spring.config.AopConfig; public class TestAop { private AnnotationConfigApplicationContext ac = new AnnotationConfigApplicationContext(AopConfig.class); @Test
public void testDiv() {
Calculator cal = ac.getBean(Calculator.class);//Calculator类需要在spring容器才能使用aop
//System.out.println(cal.div(3, 0));
System.out.println(cal.add(3, 2));
System.out.println(cal.divInteger(3, 0));
} }

测试结果

===============================================================
before方法:{com.lqy.spring.aop.Calculator.add}开始执行:
方法参数是:{[3.0, 2.0]}
加法运算
after方法:{com.lqy.spring.aop.Calculator.add}执行结束。
afterReturn方法:{com.lqy.spring.aop.Calculator.add}执行返回的结果是:{5.0}。 5.0 ===============================================================
before方法:{com.lqy.spring.aop.Calculator.divInteger}开始执行:
方法参数是:{[3, 0]}
除法运算
after方法:{com.lqy.spring.aop.Calculator.divInteger}执行结束。
afterThrowing方法:{com.lqy.spring.aop.Calculator.divInteger}发生异常:java.lang.ArithmeticException: / by zero

(如果你觉得文章对你有帮助,欢迎捐赠,^_^,谢谢!)

================================

©Copyright 蕃薯耀 2020-01-21

https://www.cnblogs.com/fanshuyao/

spring aop使用,spring aop注解,Spring切面编程的更多相关文章

  1. Java实战之03Spring-03Spring的核心之AOP(Aspect Oriented Programming 面向切面编程)

    三.Spring的核心之AOP(Aspect Oriented Programming 面向切面编程) 1.AOP概念及原理 1.1.什么是AOP OOP:Object Oriented Progra ...

  2. Spring AOP中使用@Aspect注解 面向切面实现日志横切功能详解

    引言: AOP为Aspect Oriented Programming的缩写,意为:面向切面编程,通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术.AOP是OOP的延续,是软件开发中的一 ...

  3. Spring学习手札(二)面向切面编程AOP

    AOP理解 Aspect Oriented Program面向切面编程,通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术. 但是,这种说法有些片面,因为在软件工程中,AOP的价值体现的并 ...

  4. 04 Spring:01.Spring框架简介&&02.程序间耦合&&03.Spring的 IOC 和 DI&&08.面向切面编程 AOP&&10.Spring中事务控制

    spring共四天 第一天:spring框架的概述以及spring中基于XML的IOC配置 第二天:spring中基于注解的IOC和ioc的案例 第三天:spring中的aop和基于XML以及注解的A ...

  5. Spring之控制反转——IoC、面向切面编程——AOP

      控制反转——IoC 提出IoC的目的 为了解决对象之间的耦合度过高的问题,提出了IoC理论,用来实现对象之间的解耦. 什么是IoC IoC是Inversion of Control的缩写,译为控制 ...

  6. spring入门(四)【面向切面编程】

    开发过程中很多时候会用到日志.事务等操作,这些操作如果要写在业务代码中会相当麻烦,这时就会用到面向切面编程(AOP),AOP作为一种编程思想,和OOP有着不同的侧重点,面向对象侧重于万事万物皆对象,而 ...

  7. Spring详解(五)------面向切面编程

    .AOP 什么? AOP(Aspect Oriented Programming),通常称为面向切面编程.它利用一种称为"横切"的技术,剖解开封装的对象内部,并将那些影响了多个类的 ...

  8. Java AOP (2) runtime weaving 【Java 切面编程 (2) 运行时织入】

    接上一篇 Java AOP (1) compile time weaving [Java 切面编程 (1) 编译期织入] Dynamic proxy   动态代理 Befor talking abou ...

  9. SpringAop@Aspect注解实现切面编程

    SpringAOP在springboot中如何使用 #什么是aop## 概念> aop全称Aspect OrientedProgramming,面向切面,AOP主要实现的目的是针对业务处理过程中 ...

  10. Spring(4)——面向切面编程(AOP模块)

    Spring AOP 简介 如果说 IoC 是 Spring 的核心,那么面向切面编程就是 Spring 最为重要的功能之一了,在数据库事务中切面编程被广泛使用. AOP 即 Aspect Orien ...

随机推荐

  1. 记一个开发是遇到的坑之Oralce 字符串排序

    简单描述一下情况,就是存储过程中用一个字符串类型的字段作为患者就诊的排序号,结果莫名发现叫完1号后叫了11.12等患者.用户的反馈不一定准确,自己加了日志的,赶紧拷贝日志来观察一下.结果发现实际情况就 ...

  2. 【python数据挖掘】批量爬取站长之家的图片

    概述: 站长之家的图片爬取 使用BeautifulSoup解析html 通过浏览器的形式来爬取,爬取成功后以二进制保存,保存的时候根据每一页按页存放每一页的图片 第一页:http://sc.china ...

  3. 谈谈:这次疫情对一个普通iOS开发者的影响!

    “2019年已经很难了,2020年开局0-5那就更难了啊!”大家应该都很清楚,这次疫情对于国家的整体经济体系影响非常大,但是要说有多大,我也不了解,毕竟我只是个程序员!但是对iOS开发者影响有多大,我 ...

  4. python爬虫1:第一个爬虫

    1.python2.3的库名不同,如果版本不同记得改. Python2.x 有这些库名可用: urllib,urllib2,urllib3,httplib,httplib2,requests Pyth ...

  5. mybatis配置---> mybatisConfig.xml 配置加接数据源

    mybatisConfig.xml 配置主要作用是连接数据源配置的前提是在完成mybatis的jar包基础之上进行的同时要确保数据用户名和密码是否正确 一:密码写在 mybatisConfig.xml ...

  6. django-分页(非海量数据)

    views.py class AnalysisDataHandler(View): def get(self, request): analysis_data = MonitorCenterDataA ...

  7. Java Web 笔记(4)

    11.Filter (重点) Filter:过滤器 ,用来过滤网站的数据: 处理中文乱码 登录验证-. Filter开发步骤: 导包 编写过滤器 导包不要错 实现Filter接口,重写对应的方法即可 ...

  8. C#面向对象详解

    //封装就是将数据或函数等集合在一个个的单元中,我们称之为类,被封装的对象通常被称为抽象数据类型, //封装的意义在于保护或防止代码被我们无意中破坏, //封装既可以封装成员变量,又可以封装成员方法, ...

  9. Reg文件操作

    注册表REG脚本文件测试 1.新建主键 例如,想在主键[HKEY_CURRENT_USER\Software]下新建一个名叫“新建主键名称”的主键. 可以打开记事本,写入如下内容: Windows R ...

  10. c++精度