Spring(4)--AOP(面向切面编程)

于 2022-03-08 14:46:44 发布
阅读量352 收藏
点赞数
分类专栏： Spring 文章标签： spring java 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/wuzj1314/article/details/123353476
版权
本文详细介绍了Spring AOP的概念，包括连接点、切入点、通知、目标、织入、代理等核心概念，并展示了如何基于XML配置和注解实现AOP的前置、后置、环绕和异常通知。通过具体的代码示例，阐述了如何在系统中实现日志管理、事务控制等功能，帮助开发者更好地理解和应用面向切面编程。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

1. Spring AOP 简介

Spring AOP 是基于 AOP 编程模式的一个框架，它的使用有效减少了系统间的重复代码，达到了模块间的耦合目的。

AOP 的全称是“Aspect Oriented Programming”，即面向切面编程，它将业务逻辑的各个部分进行隔离，使开发人员在编写业务逻辑时可以专心于核心业务，从而提高了开发效率。

程序需要------1.业务需求------需要实现程序的具体核心功能----添加用户

                       2.系统需求------实现程序的辅助功能----记录系统运行日志

AOP 采取横向抽取机制，取代了传统纵向继承体系的重复性代码，其应用主要体现在事务处理、日志管理、权限控制、异常处理等方面。
       目前最流行的 AOP 框架有两个，分别为 Spring AOP 和 AspectJ。Spring AOP包含了AspectJ，因此本文只演示Spring AOP。

AOP 的相关术语：

名称

说明

Joinpoint（连接点）

指那些被拦截到的点，在 Spring 中，可以被动态代理拦截目标类的方法。

Pointcut（切入点）

指要对哪些 Joinpoint 进行拦截，即被拦截的连接点。

Advice（通知）

指拦截到 Joinpoint 之后要做的事情，即对切入点增强的内容。

Target（目标）

指代理的目标对象。

Weaving（植入）

指把增强代码应用到目标上，生成代理对象的过程。

Proxy（代理）

指生成的代理对象。

Aspect（切面）

切入点和通知的结合。

       简单来说就是，一个类中有很多的方法，比作连接点，需要拦截的连接点（需要对这个方法进行配置），就是切入点，拦截后需要增强内容，就是通知，切入点和通知结合就叫切面。

       举例说明，添加、修改、删除、查询每个方法里面，以往可能需要每个方法里面需要日志管理的代码，现在全部剥离出来，单独创建一个类，日志管理的代码，然后通过AOP配置，进入到需要的方法中。

 

Spring 通知的 5 种类型：

名称

说明

org.springframework.aop.MethodBeforeAdvice（前置通知）

在方法之前自动执行的通知称为前置通知，可以应用于权限管理等功能。

org.springframework.aop.AfterReturningAdvice（后置通知）

在方法之后自动执行的通知称为后置通知，可以应用于关闭流、上传文件、删除临时文件等功能。

org.aopalliance.intercept.MethodInterceptor（环绕通知）

在方法前后自动执行的通知称为环绕通知，可以应用于日志、事务管理等功能。

org.springframework.aop.ThrowsAdvice（异常通知）

在方法抛出异常时自动执行的通知称为异常通知，可以应用于处理异常记录日志等功能。

org.springframework.aop.IntroductionInterceptor（引介通知）

在目标类中添加一些新的方法和属性，可以应用于修改旧版本程序（增强类）。


2. Spring AOP：基于XML

（1）依赖包：

<!-- https://mvnrepository.com/artifact/org.springframework/spring-context -->

    <dependency>

      <groupId>org.springframework</groupId>

      <artifactId>spring-context</artifactId>

      <version>5.1.5.RELEASE</version>

    </dependency>

    <dependency>

      <groupId>org.aspectj</groupId>

      <artifactId>aspectjweaver</artifactId>

      <version>1.9.4</version>

    </dependency>

  </dependencies>

（2）AOP配置

在xml中对切点和切面进行配置

目标对象（通知需要切入的类）和切面（通知类）注册bean

通过<aop:pointcut>配置切入点，使用expression中的execution()方法来实现对切入点的范围控制

通过<aop:aspect ref="切面id">来实现切面类中的切面方法需要注入到哪一个切入点中

最重要的地方就是第二步，使用expression中的execution()方法

这个方法是为了找到切面需要织入的那个地方，可以是单个/多个方法，可以是整个类的所有方法

execution表达式的具体写法要求如下：

execution(

modifiers-pattern? —修饰符，比如public

ret-type-pattern —标识方法的返回值

declaring-type-pattern? —声明类型模式

name-pattern/param-pattern —指定方法名/指定方法参数的路径

throws-pattern? —抛出模式

)0

ret-type-pattern,name-pattern(param-pattern)是必须的.

ret-type-pattern:标识方法的返回值，需要使用全路径的类名如java.lang.String,也可以为*表示任何返回值；

name-pattern:指定方法名,*代表所有,例如set*,代表以set开头的所有方法.

param-pattern:指定方法参数(声明的类型)：

(..)代表所有参数

(*)代表一个参数

(*,String)代表第一个参数为任何值,第二个为String类型.

表达式例子如下：

任意公共方法的执行：

　　　　execution(public * *(..))

任何一个以“set”开始的方法的执行：

　　　　execution(* set*(..))

UserService接口的任意方法的执行：

　　　　execution(* com.cheng.aop.service.UserService.*(..))

定义在service包里的任意类和任意方法的执行：

　　　　execution(* com.cheng.aop.service.*.*(..))

定义在service包和所有子包里的任意类的任意方法的执行(比上面多了个点)：

　　　　execution(* com.cheng.aop.service..*.*(..))

定义在pointcutexp包和所有子包里的UserService的的任意方法的执行：

　　　　execution(* com.cheng.aop.service..UserService.*(..))

【注意】在java中默认使用的动态代理是JDK proxy基于接口的代理，在xml文件中配置如下代码：<aop:aspectj-autoproxy proxy-target-class="true"/>，测试类中getBean（）括号中可以为类可以为接口，否则必须注入到接口上。 不然报错：

was actually of type 'com.sun.proxy.$Proxy3'

 

（3）前置通知

<!-- 引入系统需求功能实现类-->

        <aop:aspect ref="myAspect">

            <!-- 配置切入点 -->

            <!--id:切入点名称-->

            <!--expression:切入点表达式-->

            <aop:pointcut id="point1" expression="execution(* com.weiwei.springAOPdemo1.service.impl.StudentServiceImpl.insertStudent())"/>

            <!--配置前置通知 -->

            <aop:before method="saveLog" pointcut-ref="point1"/>

        </aop:aspect>

（4）后置通知

<aop:aspect ref="myAspect">

            <aop:pointcut id="point2"  expression="execution(* com.weiwei.springAOPdemo1.service.impl.StudentServiceImpl.updateStudent())"/>

            <!--配置后置通知 -->

            <aop:after method="saveLog" pointcut-ref="point2"/>

        </aop:aspect>

（5）环绕通知

//实现环绕通知的具体方法

    public Object myAround(ProceedingJoinPoint proceedingJoinPoint)

            throws Throwable {

        xxxxx(); // 开始

        Object obj = proceedingJoinPoint.proceed(); // 执行当前目标方法

        xxxxx(); // 结束

        return obj;

    }

（6）异常通知

    //异常通知实现方法

    public void myAfterThrowing(JoinPoint joinPoint, Throwable e) {

        System.out.println("异常通知" + "出错了" + e.getMessage());

}

  <aop:aspect ref="myAspect">

            <aop:pointcut id="point4"  expression="execution(* com.weiwei.springAOPdemo1.service.impl.StudentServiceImpl.selectStudent())"/>

            <!--配置后置通知 -->

           <aop:after-throwing method="myAfterThrowing" pointcut-ref="point4" throwing="e"/>

        </aop:aspect>

(7)完整代码演示：

//系统功能



public class MyAspect {

    public void saveLog(){

        System.out.println("记录用户操作的日志");

    }



    //实现环绕通知的具体方法

    public Object myAround(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {

        saveLog(); // 开始

        Object obj = proceedingJoinPoint.proceed(); // 执行当前目标方法

        saveLog(); // 结束

        return obj;

    }

    //异常通知实现方法

    public void myAfterThrowing(JoinPoint joinPoint, Throwable e) {

        System.out.println("异常通知" + "出错了" + e.getMessage());

    }

    //异常通知实现方法

    public void myAfterThrowing1(JoinPoint joinPoint) {

        System.out.println("异常通知" + "出错了");

    }

}

package com.weiwei.springAOPdemo1.service.impl;



import com.weiwei.springAOPdemo1.service.StudentService;



//Target（目标）

//业务功能

public class StudentServiceImpl implements StudentService {



    //Joinpoint（连接点）

    @Override

    public void insertStudent() {

        System.out.println("实现添加学生的业务方法----insertStudent");

    }

    //Joinpoint（连接点）

    @Override

    public void updateStudent() {

        System.out.println("实现修改学生的业务方法----updateStudent");

    }

   // Joinpoint（连接点）

    @Override

    public void deleteStudent() {

        System.out.println("实现删除学生的业务方法----deleteStudent");

    }

    //Joinpoint（连接点）

    @Override

    public void selectStudent() {

        System.out.println("实现查询学生的业务方法----selectStudent");

        int a=10/0;

    }

}

package com.weiwei.springAOPdemo1.service;

public interface StudentService {

    void insertStudent();

    void updateStudent();

    void deleteStudent();

    void selectStudent();

}

<?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 id="studentService" class="com.weiwei.springAOPdemo1.service.impl.StudentServiceImpl"/>

<!-- 创建系统功能实现类对象   -->

    <bean id="myAspect" class="com.weiwei.springAOPdemo1.aspect.MyAspect"/>

<!--  AOP配置  -->

<!--    <aop:config proxy-target-class="true">-->

    <aop:config>

        <!-- 引入系统需求功能实现类-->

        <aop:aspect ref="myAspect">

            <!-- 配置切入点 -->

            <!--id:切入点名称-->

            <!--expression:切入点表达式-->

            <aop:pointcut id="point1" expression="execution(* com.weiwei.springAOPdemo1.service.impl.StudentServiceImpl.insertStudent())"/>

            <!--配置前置通知 -->

            <aop:before method="saveLog" pointcut-ref="point1"/>

        </aop:aspect>



        <aop:aspect ref="myAspect">

            <aop:pointcut id="point2"  expression="execution(* com.weiwei.springAOPdemo1.service.impl.StudentServiceImpl.updateStudent())"/>

            <!--配置后置通知 -->

            <aop:after method="saveLog" pointcut-ref="point2"/>

        </aop:aspect>



        <aop:aspect ref="myAspect">

            <aop:pointcut id="point3" expression="execution(* com.weiwei.springAOPdemo1.service.impl.StudentServiceImpl.deleteStudent())" />

            <!--配置环绕通知 -->

            <aop:around method="myAround" pointcut-ref="point3"/>

        </aop:aspect>



        <aop:aspect ref="myAspect">

            <aop:pointcut id="point4"  expression="execution(* com.weiwei.springAOPdemo1.service.impl.StudentServiceImpl.selectStudent())"/>

            <!--配置异常通知 -->

           <aop:after-throwing method="myAfterThrowing" pointcut-ref="point4" throwing="e"/>

        </aop:aspect>



        <aop:aspect ref="myAspect">

            <aop:pointcut id="point5"  expression="execution(* com.weiwei.springAOPdemo1.service.impl.StudentServiceImpl.selectStudent())"/>

            <!--配置异常通知 -->

            <aop:after-throwing method="myAfterThrowing1" pointcut-ref="point5"/>

        </aop:aspect>



    </aop:config>

</beans>

package com.weiwei.springAOPdemo1;



import com.weiwei.springAOPdemo1.service.StudentService;

import com.weiwei.springAOPdemo1.service.impl.StudentServiceImpl;

import org.springframework.context.ApplicationContext;

import org.springframework.context.support.ClassPathXmlApplicationContext;



public class Test {

    public static void main(String[] args) {

        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");

        StudentService studentService = applicationContext.getBean("studentService", StudentService.class);

//        StudentServiceImpl serviceimpl = applicationContext.getBean("studentService", StudentServiceImpl.class);

        studentService.insertStudent();

        System.out.println("------------------------------");

        studentService.updateStudent();

        System.out.println("------------------------------");

        studentService.deleteStudent();

        System.out.println("------------------------------");

        studentService.selectStudent();



    }

}

 

3. Spring AOP：基于Annotation

       配置文件中需要AOP命名空间

<?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: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

       http://www.springframework.org/schema/context

       http://www.springframework.org/schema/context/spring-context.xsd">

    <!--扫描含com.weiwei.springAOP包下的所有注解-->

    <context:component-scan base-package="com.weiwei.springAOP" />

    <!-- 使切面开启自动代理 默认使用的动态代理是JDK proxy基于接口的代理-->

    <aop:aspectj-autoproxy />

</beans>

package com.weiwei.springAOP;

import org.springframework.stereotype.Component;

@Component("stu")

public class StudentServiceImpl {

    public  void  insertStudent(){

        System.out.println("添加学生信息的业务方法---insertStudent");

    }

    public  void  updateStudent(){

        System.out.println("修改学生信息的业务方法---updateStudent");

    }

    public  void  deleteStudent(){

        System.out.println("删除学生信息的业务方法---deleteStudent");

    }

    public  void  selectStudent(){

        System.out.println("查询学生信息的业务方法---selectStudent");

        int a=10/0;

    }

}







package com.weiwei.springAOP;



import org.aspectj.lang.ProceedingJoinPoint;

import org.aspectj.lang.annotation.*;

import org.springframework.stereotype.Component;



@Component

@Aspect

public class myAspect {



    @Pointcut("execution(* com.weiwei.springAOP.StudentServiceImpl.insertStudent())")

    //切点，使用execution表达式设置insertStudent方法为切入点，保存到point1()中;

    public void point1(){}



    @Pointcut("execution(* com.weiwei.springAOP.StudentServiceImpl.deleteStudent())")

    public void point2(){}



    @Pointcut("execution(* com.weiwei.springAOP.StudentServiceImpl.updateStudent())")

    public void point3(){}



    @Pointcut("execution(* com.weiwei.springAOP.StudentServiceImpl.selectStudent())")

    public void point4(){}



    @Before("point1()")

    public  void saveLog1(){

        System.out.println("记录系统运行日志");

    }

    @After("point2()")

    public  void saveLog2(){

        System.out.println("记录系统运行日志");

    }

    //测试环绕通知

    @Around("point3()")

    public Object myAround(ProceedingJoinPoint proceedingJoinPoint)throws Throwable {

        saveLog1(); // 开始

        Object obj = proceedingJoinPoint.proceed(); // 执行当前目标方法

        saveLog1(); // 结束

        return obj;

    }



    @AfterThrowing(value = "point4()",throwing = "e")

    public void myAfterThrowing(Throwable e) {

        System.out.println("异常通知" + "出错了" + e.getMessage());

    }

}





package com.weiwei.springAOP;



import org.springframework.context.ApplicationContext;

import org.springframework.context.support.ClassPathXmlApplicationContext;



/**

 * Hello world!

 *

 */

public class App {

    public static void main( String[] args ) {

       ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");

        StudentServiceImpl stu = applicationContext.getBean("stu", StudentServiceImpl.class);

        stu.insertStudent();

        System.out.println("---------------------------");

        stu.deleteStudent();

        System.out.println("---------------------------");

        stu.updateStudent();

        System.out.println("---------------------------");

        stu.selectStudent();



    }

}

输出:

记录系统运行日志

添加学生信息的业务方法---insertStudent

---------------------------

删除学生信息的业务方法---deleteStudent

记录系统运行日志

---------------------------

记录系统运行日志

修改学生信息的业务方法---updateStudent

记录系统运行日志

---------------------------

查询学生信息的业务方法---selectStudent

异常通知出错了/ by zero

Exception in thread "main" java.lang.ArithmeticException: / by zero

AOP面向切面编程
weixin_45723046的博客
03-26 980
AOP 什么是AOP AOP (Aspect Oriented programming)意为:面向切面编程，通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性。 Aop在Spring中的作用：提供声明式的事务，允许用户自定义切面 横切关注点:跨越应用程序多个模块的方法或功能。即是
【Spring】 AOP面向切面编程
Orion
02-23 1623
横切关注点从每个方法中抽取出来的同一类非核心业务。在同一个项目中，我们可以使用多个横切关注点对相关方法进行多个不同方面的增强。有十个附加功能，就有十个横切关注点。AOP核心关注点和横切关注点。业务处理的主要流程是核心关注点，非核心代码是横切关注点。横切关注点的一个特点是，他们经常发生在核心关注点的多处，而各处基本相似，比如权限认证、日志、事务、异常等。AOP的作用在于分离系统中的各种关注点，将核心关注点和横切关注点分离开来。(分离核心业务代码与非核心代码通知(增强)每一个横切关注点。
spring4 AOP 面向切面编程@Aspect
08-10
NULL 博文链接：https://zw7534313.iteye.com/blog/2221200
Spring 4 - AOP
m0_51945098的博客
12-11 569
Spring - AOP
【Spring】AOP：基本概念及aop示例（包括xml、注解）
A minor
12-05 2581
1.AOP简介 1.1 定义 面向切面编程，通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。 1.2 优点 利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。 1.3 原理 aop底层将采用代理机制进行实现。 接口 + 实现类：spring 默认采用 jdk 的动态代理 Proxy。 实现类：spring 默认采用 cglib 字节码增强。 1.4 基本概念 target：目标类，需要被代理的类。例如：Use
SPRING系列教材 （四）- AOP 面向切面编程
海鸥传奇的专栏
06-19 357
AOP 即 Aspect Oriented Program 面向切面编程 首先，在面向切面编程的思想里面，把功能分为核心业务功能，和周边功能。 所谓的核心业务，比如登陆，增加数据，删除数据都叫核心业务 所谓的周边功能，比如性能统计，日志，事务管理等等 周边功能在Spring的面向切面编程AOP思想里，即被定义为切面 在面向切面编程AOP的思想里面，核心业务功能和切面功能分别独立进行开发...
Spring系列教材 （四）- aop 面向切面编程
java_zdc的博客
04-19 329
AOP 即 Aspect Oriented Program 面向切面编程 首先，在面向切面编程的思想里面，把功能分为核心业务功能，和周边功能。 所谓的核心业务，比如登陆，增加数据，删除数据都叫核心业务 所谓的周边功能，比如性能统计，日志，事务管理等等周边功能在Spring的面向切面编程AOP思想里，即被定义为切面在面向切面编程AOP的思想里面，核心业务功能和切面功能分别独立进行...
16.2 Spring框架-AOP面向切面编程
最新发布
04-12
面向切面编程（AOP，Aspect Oriented Programming）是Spring框架中的一个重要组成部分，它提供了一种模块化和声明式的方式来处理程序中的横切关注点，如日志、事务管理、性能监控等。在传统的OOP（面向对象编程）中...
Spring AOP面向切面编程实现原理方法详解
08-18
Spring AOP面向切面编程实现原理方法详解 面向切面编程（AOP）是Spring框架中的一个重要内容，通过预编译方式和运行期动态代理实现，在不修改源代码的情况下，给程序动态统一添加功能的一种技术。AOP可以对业务逻辑...
spring-AOP面向切面编程所需jar包.zip
06-22
该压缩包包含--学习笔记(05):轻松搞定Spring全家桶(初识篇)-面向切片编程AOP：--系列博客中新需要的三个jar包。包括spring-aspects-5.2.7.RELEASE.jar和spring-aop-5.2.7.RELEASE.jar和...
Spring4学习笔记-AOP（基于注解的方式）
weixin_33951761的博客
09-24 144
1.加入jar包com.springsource.org.aopalliance-1.0.0.jarcom.springsource.org.aspectj.weaver-1.6.8.RELEASE.jarcommons-logging-1.1.3.jarspring-aop-4.1.0.RELEASE.jarspring-aspects-4.1.0.RELEASE.jars...
Spring Aop
muzililee的博客
08-22 288
1.Spring 的 AOP 简介 1.1 什么是 AOP AOP 为 Aspect Oriented Programming 的缩写，意思为面向切面编程，是通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。 AOP 是 OOP 的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。 1.2 AOP 的作用及其优势 作用：在程
Spring 4.x——AOP
午夜阳光
12-10 474
1.简介         AOP(Aspect-Oriented Programming, 面向切面编程): 是一种新的方法论， 是对传统 OOP(Object-Oriented Programming, 面向对象编程) 的补充。AOP 的主要编程对象是切面(aspect), 而切面模块化横切关注点。在应用 AOP 编程时, 仍然需要定义公共功能, 但可以明确的定义这个功能在哪里, 以什么方式应...
Spring4 之 AOP
Dusty丶one的博客
11-14 260
Spring4 之 AOP本节我们学习一下Spring AOP 并通过示例来详细了解 SpringAOP 机制。概念 AOP(Aspect-Oriented Programming, 面向切面编程): 是一种新的方法论, 是对传统 OOP(Object-Oriented Programming, 面向对象编程) 的补充。 AOP 的主要编程对象是切面(aspect), 而切面模块化横切关注点。 在应
Spring-4-AOP
SevenSongyun的博客
01-19 292
一、AOP概念 AOP 的全称是“Aspect Oriented Programming”，即面向切面编程，它将业务逻辑的各个部分进行隔离，使开发人员在编写业务逻辑时可以专心于核心业务，从而提高了开发效率。 面向切面编程，即在不修改源代码的基础上对原有功能的增强。 AOP使用了横向抽取机制，取代了传统纵向继承体系的重复性代码，其应用主要体现在事务处理、日志管理、权限控制、异常处理等方面。 二、...
SSM-Spring-4-AOP
weixin_43541094的博客
07-15 376
文章目录1 AOP概念2 AOP的底层实现2.1 基于JDK的动态代理2.2 基于cglib的动态代理3 AOP相关概念3.1 AOP相关术语3.2 AOP开发有关事项4 AOP快速入门4.1 切点表达式的写法4.2 增强(通知)的种类4.3 切点表达式的抽取5 基于注解的AOP开发5.1 快速入门5.2 注解增强种类&抽取切点表达式 1 AOP概念 AOP为Aspect Oriented Programming的缩写，意为面向切面编程，是通过预编译方式和运行期动态代理实现程序功能的统一维护的
Spring4-AOP(三)
有点想法的专栏
02-01 220
文章目录1.AOP1.1 `代理`1.2 `AOP简介`1.3 `AspectJ`1.4 `通知`1.4.1 前置通知1.4.2 后置通知1.4.3 返回通知1.4.5 异常通知1.4.6 环绕通知1.5 `切面优先级设置`1.6 `重用切入点定义`1.7 `引入通知`2.基于XML配置2.1 `声明切面`2.2 `声明切点`2.3 `声明通知`2.4 `声明引用` 1.AOP 背景： 1.1 ...
Spring4实现AOP
weixin_30367945的博客
01-18 124
AOP又称面向切面编程，可以不变改变原有业务的基础上进行功能的扩展，例如我们声明一个service类来处理servlet传过来的数据，每一次调用service中的验证登录信息方法的时候的都要进行日志的记录，在不改变该验证方法的基础上，我们可以利用AOP思想借助spring的提供的类，进行面向切面编程，将该方法当作切点，配置前置通知和后置通...
SpringFramework(四) SpringAOP
weixin_42242898的博客
05-23 113
什么是AOP ? AOP：面向切面编程Aspect Oriented Programming。AOP是一种思想，其主要用于对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性。 也就是说要解决其横切性问题。 横切性问题：不会影响主业务逻辑的操作，例如权限，日志，事务。 AOP应用场景 AOP常用的使用场景： 日志 权限 事务 监控 SpringAOP和AOP的关系 AOP是一种设计思想。而SpringAOP是AOP思想的实现。 扩展：SpringAOP和Aspect
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Java-请多指教

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值