Spring系列教程六：AOP详细讲解

最新推荐文章于 2023-07-04 18:30:00 发布
最新推荐文章于 2023-07-04 18:30:00 发布
阅读量149 收藏
点赞数
文章标签： java python
原文链接：https://my.oschina.net/u/4115727/blog/3051472
版权

2019独角兽企业重金招聘Python工程师标准>>> hot3.png

AOP 概述

什么是 AOP

AOP：全称是 Aspect Oriented Programming 即：面向切面编程。

189ba989b187db7315970078747a1216d6b.jpg

AOP技术是对OOP技术的一种延伸，AOP是面向纵向，OOP是面向横向。简单的说它就是把我们程序重复的代码抽取出来，在需要执行的时候，使用动态代理的技术，在不修改源码的
基础上，对我们的已有方法进行增强。

AOP 的作用以及优势

作用：在程序运行期间，不修改源码对已有方法前面和后面进行增强。
优势：减少重复代码、提高开发效率、维护方便

AOP实现方式

使用动态代理技术

基于xml方式的aop配置

实现步骤如下

fb48f5b34033b8fa3d4b459c199e4ac2c44.jpg

导入spring-aop jar包

<dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>5.0.2.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>4.3.6.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>commons-dbutils</groupId>
            <artifactId>commons-dbutils</artifactId>
            <version>1.6</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.6</version>
        </dependency>
        <dependency>
            <groupId>c3p0</groupId>
            <artifactId>c3p0</artifactId>
            <version>0.9.1.2</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
        下面几个是必须要导的包
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.9.2</version>
        </dependency>
        <dependency>
            <groupId>aopalliance</groupId>
            <artifactId>aopalliance</artifactId>
            <version>1.0</version>
        </dependency>
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.12</version>
        </dependency>

需要增强方法的StudentDao类，和写增强方法的Userlogger类

package com.ithema.jdbc.dao;

public class StudentDao {
    //在执行add方法之前执行日志

    public int add(int a,int b){
        System.out.println("执行了add方法");
        return a+b;
    }
    public  int jian(int a,int b){
        System.out.println("执行了减法");
        return a-b;
    }
   /* public void testexe(){
        int i=10/0;
    }*/
}

package com.ithema.jdbc.aop;

import org.apache.log4j.Logger;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;

import java.util.Arrays;

/**
 * 切面：
 * 前置增强、后置增强、异常增强、最终增强、环绕增强
 *
 * Spring aop完全是用动态代理实现的
 * 但是动态代理又有两种，jdkk代理，cglib代理(更强大一些)
 * spirng aop:默认使用jdk代理，但是你的目标类没接口，会自动切换到cglib代理
 */
public class UserLogger {

    //在目标方法调用之前执行该方法
    Logger logger=Logger.getLogger(UserLogger.class);
    public void before(JoinPoint jp){
        logger.info("前置增强，目标类名"+jp.getTarget()+"里面的"+jp.getSignature().getName()+
                "参数为："+ Arrays.toString(jp.getArgs()));
    }
    //在目标方法调用之后执行该方法
    //当方法抛出异常就不会执行了，所有该方法不适合做日志收集，因为发生了异常不执行该方法无法将日志保存下来
    //所有后置增强用的很少
    public void after(JoinPoint jp,Object result){
        logger.info("后置增强，执行完类"+jp.getTarget()+"里面的"+jp.getSignature().getName()+
                "方法，结果为："+ result);
    }
    //在方法抛出异常后就会增强、没有异常就不会执行、如果用户try-catch,也不会增强
    //执行错误的话，非常适合该增强(异常增强)
    //Java异常体系，根类是Throwable
    public void afterThorwing(JoinPoint jp,Throwable e){
        logger.info("异常增强，执行类"+jp.getTarget()+"里面的"+jp.getSignature().getName()+
                "方法抛出异常："+e.getMessage());
    }
    //最终增强：无论是否有异常，都会执行，类似与finally，可以或者是认为是后置增强的升级版
    public void finalafter(JoinPoint jp){
        logger.info("最终增强:执行完类"+jp.getTarget()+"里面的"+jp.getSignature().getName());
    }
    //环绕增强，集合了前置添加后置，并且更加强大、当执行方法发生异常后面的就不执行了
    //1、可以修改方法的参数 2、也可以修改方法的返回值( return result)
    public Object around(ProceedingJoinPoint jp)throws Throwable{
        Object [] args=jp.getArgs();//获取方法参数
        //可以修改方法的参数
        //args = new Object[]{20,1};
        logger.info("环绕增强：方法为："+jp.getArgs());
        Object result=jp.proceed();//执行目标方法
        //也可以修改方法的返回值
        //return 100;
        return result;
    }
}

配置aop约束到配置文件中，并实现ioc配置

<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns="http://www.springframework.org/schema/beans"
       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就是一个对象>
    <bean id="studentDao" class="com.ithema.jdbc.dao.StudentDao">
    </bean>
    <bean id="userLogger" class="com.ithema.jdbc.aop.UserLogger">
    </bean>

使用 aop:aspect 配置切面，使用 aop:pointcut  配置切入点表达式

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns="http://www.springframework.org/schema/beans"
       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 id="studentDao" class="com.ithema.jdbc.dao.StudentDao">
    </bean>
    <bean id="userLogger" class="com.ithema.jdbc.aop.UserLogger">
    </bean>
    <!--aop配置，实现dao里面的方法前后增强-->
    <aop:config>
        <!--定义切入点-->
        <!--标准写法格式：(返回值：全类名(包名.类名.方法名(参数类型列表))-->
        <aop:pointcut id="pointcut" expression="execution(* com.ithema.jdbc..*.*(..))"></aop:pointcut>
        <!--组织增强-->
        <!--切面ref:应用其他bean对象-->
        <aop:aspect ref="userLogger">
            <aop:before method="before" pointcut-ref="pointcut"></aop:before>
            <aop:after-returning method="after" pointcut-ref="pointcut" returning="result"></aop:after-returning>
            <aop:after-throwing method="afterThorwing" pointcut-ref="pointcut" throwing="e"></aop:after-throwing>
            <aop:after method="finalafter" pointcut-ref="pointcut"></aop:after>
            <aop:around method="around" pointcut-ref="pointcut"></aop:around>
        </aop:aspect>
    </aop:config>
</beans>

7c9d49daf07705566af1097d84ec717d40c.jpg

基于注解方式的aop配置

导入spring-aop jar包

<dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>5.0.2.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>4.3.6.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>commons-dbutils</groupId>
            <artifactId>commons-dbutils</artifactId>
            <version>1.6</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.6</version>
        </dependency>
        <dependency>
            <groupId>c3p0</groupId>
            <artifactId>c3p0</artifactId>
            <version>0.9.1.2</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
        下面几个是必须要导的包
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.9.2</version>
        </dependency>
        <dependency>
            <groupId>aopalliance</groupId>
            <artifactId>aopalliance</artifactId>
            <version>1.0</version>
        </dependency>
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.12</version>
        </dependency>

配置aop约束到配置文件中，在配置文件中指定 spring 要扫描的包，开启 spring 对注解 AOP 的支持

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns="http://www.springframework.org/schema/beans"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:p="http://www.springframework.org/schema/p"
       xmlns:context="http://www.springframework.org/schema/context"
       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
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd">
    <!--告诉Spring容器在创建的时候要扫描包，配置所需要的标签不在bean约束中，而是
    在一个叫做context的空降名称和约束中-->
    <context:component-scan base-package="com.bdqn"></context:component-scan>
   <!-- 开启注解aop-->
   <aop:aspectj-autoproxy></aop:aspectj-autoproxy>
</beans>

使用注解配置增强方法

package com.bdqn.aop;

import org.apache.log4j.Logger;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;

import java.util.Arrays;

@Component
@Aspect
public class UserLogger {

    //在目标方法调用之前执行该方法
    Logger logger=Logger.getLogger(UserLogger.class);
    //定义切点
    @Pointcut("execution(* com.bdqn.aop..*.*(..))")
    public void pointcut(){}
    @Before("pointcut()")
    public void before(JoinPoint jp){
        logger.info("前置增强，目标类名"+jp.getTarget()+"里面的"+jp.getSignature().getName()+
                "参数为："+ Arrays.toString(jp.getArgs()));
    }
    //在目标方法调用之后执行该方法
    //当方法抛出异常就不会执行了，所有该方法不适合做日志收集，因为发生了异常不执行该方法无法将日志保存下来
    //所有后置增强用的很少
    public void after(JoinPoint jp,Object result){
        logger.info("后置增强，执行完类"+jp.getTarget()+"里面的"+jp.getSignature().getName()+
                "方法，结果为："+ result);
    }
    //在方法抛出异常后就会增强、没有异常就不会执行、如果用户try-catch,也不会增强
    //执行错误的话，非常适合该增强(异常增强)
    //Java异常体系，根类是Throwable
    @AfterThrowing(pointcut = "execution(* com.bdqn.aop..*.*(..))",throwing = "e")
    public void afterThorwing(JoinPoint jp,Throwable e){
        logger.info("异常增强，执行类"+jp.getTarget()+"里面的"+jp.getSignature().getName()+
                "方法抛出异常："+e.getMessage());
    }
    //最终增强：无论是否有异常，都会执行，类似与finally，可以或者是认为是后置增强的升级版
    @After("execution(* com.bdqn.aop..*.*(..))")
    public void finalafter(JoinPoint jp){
        logger.info("最终增强:执行完类"+jp.getTarget()+"里面的"+jp.getSignature().getName());
    }
    //环绕增强，集合了前置添加后置，并且更加强大、当执行方法发生异常后面的就不执行了
    //1、可以修改方法的参数 2、也可以修改方法的返回值( return result)
    @Around("execution(* com.bdqn.aop..*.*(..))")
    public Object around(ProceedingJoinPoint jp)throws Throwable{
        Object [] args=jp.getArgs();//获取方法参数
        //可以修改方法的参数
        //args = new Object[]{20,1};
        logger.info("环绕增强：方法为："+jp.getArgs());
        Object result=jp.proceed();//执行目标方法
        //也可以修改方法的返回值
        //return 100;
        return result;
    }
}

使用spring整合junit4的方式写测试类

package com.bdqn.test;

import com.bdqn.dao.StudentDao;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:ApplicationContext.xml")
public class Testaop {
    @Autowired
    private StudentDao studentDao;
    @Test
    public  void testaop(){
        studentDao.add();
        studentDao.jian(3,1);
        System.out.println("执行了减法，结果为：");
    }
}

 

转载于:https://my.oschina.net/u/4115727/blog/3051472

weixin_34062329
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Spring本质系列（2）AOP共3页.pdf.zip
10-30
【描述】"Spring本质系列（2）AOP共3页.pdf.zip" 的描述简单明了，没有额外的技术细节，但可以推测文档可能是系列教程的一部分，专注于讲解Spring框架的核心特性——AOP。这个系列可能旨在逐步深入剖析Spring的工作...
spring3教程
03-08
每个章节都详细讲解了相关知识点，包括理论介绍、代码示例和实战指导，是学习Spring3的宝贵资料。 总结，Spring3作为一款强大且全面的Java开发框架，为开发者提供了众多实用工具和优秀设计模式，旨在降低企业级应用...
Spring学习总结（4）——Spring AOP教程
weixin_34217773的博客
08-02 93
2019独角兽企业重金招聘Python工程师标准>>> ...
最新 Spring 系列教程，都在这了
茅坤宝骏氹的博客
05-16 573
转载自最新 Spring 系列教程，都在这了 Spring Boot 系列 什么是SpringBoot? 公司不用 Spring Boot，果断离职了！ 告诉你，Spring Boot 真是个牛逼货！ 年轻人的第一个 Spring Boot 应用！ 一份超详细 Spring Boot 知识清单 Spring Boot 开启的 2 种方式 Spring Boot 启动，1 秒搞定！ Spring Boot 主类及目录结构介绍 运行 Spring Boot 应用的 3 种方式！ S...
Spring 6面向切面编程aop详解
CXYCMY的博客
11-17 506
Spring 6面向切面编程aop详解
最新 Spring 系列教程，都在这了！
Java技术栈，分享最主流的Java技术
01-03 429
Java技术栈www.javastack.cn优秀的Java技术公众号以下是Java技术栈微信公众号发布的关于 Spring/ Spring MVC/ Spring Boot/ Spri...
SPRING系列教材 （一）- 教程
海鸥传奇的专栏
06-18 418
Spring是一个基于IOC和AOP的结构J2EE系统的框架 IOC 反转控制 是Spring的基础，Inversion Of Control 简单说就是创建对象由以前的程序员自己new 构造方法来调用，变成了交由Spring创建对象 DI 依赖注入 Dependency Inject. 简单地说就是拿到的对象的属性，已经被注入好相关值了，直接使用即可。 必读：基于框架的程序要成功运行，...
Spring视频教程（1）
01-23
本系列视频教程“Spring视频教程（1）”是针对初学者精心设计的，旨在帮助你快速入门Spring框架。 在教程的第一部分，你将首先了解到Spring的基本概念和架构概述。在“001_Spring概述.avi”中，讲解者会介绍Spring...
Spring高级之注解驱动开发视频教程
11-05
视频详细讲解，需要的小伙伴自行百度网盘下载，链接见附件，永久有效。 1、课程简介 Spring框架是一系列应用框架的核心，也可以说是整合其他应用框架的基座。同时还是SpringBoot的基础。在当下的市场开发环境中，...
Spring视频教程（4）
01-23
【Spring视频教程（4）】是系列教程的第四部分，主要涵盖了Spring框架在实际项目中的应用，特别是与Struts和Hibernate集成的SSH（Struts、Spring、Hibernate）架构的使用。教程面向Java开发者，旨在深化对Spring的...
spring 系列教程一：概述
weixin_33834137的博客
04-15 169
2019独角兽企业重金招聘Python工程师标准>>> ...
Spring AOP 使用教程
东京易冷
11-18 720
文章目录Spring AOP基本概念使用方法 Spring AOP 本文讲解如何通过注解实现AOP功能。 基本概念 个人认为，广义上的Spring AOP指的是Spring框架中AspectJ的使用，下面都是个人的理解，如有雷同，纯属巧合。 AspectJ中的几个概念： 目标（Target） 代理（Proxy） 切面（Aspect） 切入点（PointCut） 通知（Advice） 连接点（Jo...
Spring详细教程入门(一)
qq_33408235的博客
10-20 2608
1. Spring 的概述 1.1 什么是 Spring pring 是一个开源框架，Spring 是于 2003 年兴起的一个轻量级的 Java 开发框架，由 Rod Johnson在其著作 Expert One-On-One J2EE Development and Design 中阐述的部分理念和原型衍生而来。它是为了解决企业应用开发的复杂性而创建的。框架的主要优势之一就是其分层架构
Spring 最全入门教程详解
最新发布
lucky_fd的博客
07-04 5475
Spring 基础框架，可以视为Spring 基础设施，基本上任何其他 Spring 项目都是以 SpringFramework 为基础的。Spring 5 的模块结构图: lOC: Inversion of Control，翻译过来是反转控制。把对象创建和对象之间的调用过程，交给 Spring 进行管理Spring 的IOC 容器就是IOC 思想的一个落地的产品实现。IOC 容器中管理的组件也叫做 bean。在创建 bean 之前，首先需要创建IOC容器。Spring 提供了IOC容器的两种实现方式：
玩转Spring框架教程01之Spring介绍
itcodeschool的博客
05-27 1734
欢迎进群交流（QQ群：655019021）一、Srping介绍1、什么是Spring？Spring是一个开放源代码的设计层面框架，他解决的是业务逻辑层和其他各层的松耦合问题，因此它将面向接口的编程思想贯穿整个系统应用。Spring是于2003 年兴起的一个轻量级的Java 开发框架，由Rod Johnson创建。简单来说，Spring是一个分层的JavaSE/EE full-stack(一站式) ...
玩转Spring框架教程02之Spring入门案例
itcodeschool的博客
05-27 450
 一、Spring入门程序第一步：下载Spring开发环境：STS3.9 + Spring5.*开发工具：STS全称Spring Tool Suite，基于Eclipse定制的Srping应用程序工具也可以选择Eclipse安装sts插件或使用Idea下载地址：http://repo.springsource.org/libs-release-local/org/springframework/s...
spring 笔记简单概述
whaleluo的博客
08-19 1079
spring系列教程 https://spring.io/docs/reference Spring框架文档版本5.1.0.RC2 https://docs.spring.io/spring/docs/5.1.0.RC2/spring-framework-reference/ 这部分参考文档涵盖了Spring Framework绝对不可或缺的所有技术。  主要涉及到 IOC 和  D...
AOP五种增强执行时机及@around增强注意事情
zzu_wlan的博客
02-06 1987
AOP的执行时机，一共有五个。分别为前置增强befor，后置增强after，返回后增强afterRunturning，异常后增强afterThorwing，环绕增强around 正如他们的名字一样，前置增强是在目标方法执行之前执行，后置增强在目标方法执行之后执行，返回后增强在目标方法执行return之后执行，异常增强则是在目标方法抛出异常后执行，而环绕增强在它修饰的方法中可以同时实现以上所...
Spring框架入门教程：实战IOC与AOP
"Spring学习笔记，主要讲解在J2EE中的SSH框架中Spring的使用，特别是Spring如何通过IOC（控制反转）和AOP（面向切面编程）实现横切控制。" Spring是一个广泛应用的Java企业级应用程序框架，尤其在J2EE环境中，它...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值