第十九章 Spring框架的AOP(Spring Framework3.1教程)

最新推荐文章于 2022-09-21 17:14:29 发布
最新推荐文章于 2022-09-21 17:14:29 发布
阅读量1.2k 收藏 7
点赞数 1
分类专栏： Spring

 Spring框架的一个关键组建是面向切面的编程(AOP)框架。面向切面的编程需要把程序的逻辑分解为不同的部分叫做关注点。这个功能跨越应用的多个点叫做横切关注点，并且这些横切关注点是从应用的业务逻辑的概念区分开来。有很多不同的公共的切面的例子如logging、auditing、declarative transactions、security、cache等。

OOP的基本单元模块是类，然而AOP的基本模块单元是方面。依赖注入帮助解耦你的应用对象并且AOP帮助你解耦他们影响的横切关注点对象。AOP像触发器在编程中，如Perl、.NET、Java和其他语言。

         Spring AOP模块提供了一个拦截器来拦截应用，例如，当一个方法执行，你可以增加额外的功能在这个方法执行前/后。

AOP术语

在我们开始SOP工作之前，让我们熟悉一下AOP的概念和术语。这些术语不特定于Spring，而是有关AOP。

术语                    

描述

方面                 

一个模块有一组APIs提供了跨越领域的需求。例如，一个日志模块叫做在日志记录上的AOP方面。一个应用可以有任意多个方面，这依赖于它的需要。

连接点

这个表示一个点在你的应用中你可以插入AOP方面。你可以说， 这是应用中使用Spring AOP框架插入行为的地方。                

通知

这是实际采取的行为，它在方法执行前/后。这实际是一个在程序执行时被Spring AOP框架调用的代码块。

切点

这是一组有一个或多个连接点通知将被执行。你能通过表达式或者模式指明切点，我们将在AOP的例子中看到。

引入

引入允许你给一个存在的类引入一个新的方法或属性。

目标对象

一个对象被一个或多个方面通知，这个对象通常是一个代理对象。通常建议称作通知对象（advised object)。

织入

织入是连接其他应用类型或者对象的方面去创建一个通知对象。可以在编译、加载或运行时完成。

通知类型

Spring 方面可以使用下面提及的五中通知工作：

通知

描述

Before(前)  

方法执行前运行通知。

after (后)

方法执行后运行通知，不管它的结果。

after-returning (返回后)

只在方法执行成功后运行通知。

after-throwing (抛出异常后)

只在方法执行抛出异常后运行通知。

around (环绕)

通知方法执行前和后运行通知。

实现自定义方面

Spring支持 @AspectJ注解风格的方法和基于schema风格方法实现定制方面。这两种方法将在下面两个子章节详细讲解。

方法

描述

基于XML模式

方面被实现通过通常的类附加基于XML的配置。

基于@AspectJ注解

@AspectJ引入了一个声明方面的风格随着普通的Java类带有Java 5注解。

Spring基于XML模式的AOP

本节为了使用aop命名空间标签，你需要导入spring-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:aop="http://www.springframework.org/schema/aop"
	xsi:schemaLocation="http://www.springframework.org/schema/beans 
       http://www.springframework.org/schema/beans/spring-beans-3.0.xsd 
       http://www.springframework.org/schema/aop 
       http://www.springframework.org/schema/aop/spring-aop-3.0.xsd ">

	<!-- bean definition & AOP specific configuration -->

</beans>

你的应用的类路径下需要如下的AspectJ库。这个库可以在AspectJ目录‘lib’目录下找到，否则你可以从internet上下载。

    * aspectjrt.jar

    * aspectjweaver.jar

    * aspectj.jar

声明一个方面

方面使用<aop:aspect>元素声明，并且向前引用的bean使用ref属性如下：

<aop:config>
	<aop:aspect id="myAspect" ref="aBean">
		...
	</aop:aspect>
</aop:config>

<bean id="aBean" class="...">
	...
</bean>

这里“aBean”将被配置并被依赖注入和你前面看到的章节看到的Spring bean一样。

声明切点（pointcut)

一个切点帮助在决定关注的连接点（即方法）被执行使用不同的通知。当使用基于XML模式的配置，切点将如下定义：

<aop:config>
	<aop:aspect id="myAspect" ref="aBean">

		<aop:pointcut id="businessService"
			expression="execution(* com.xyz.myapp.service.*.*(..))" />
		...
	</aop:aspect>
</aop:config>

<bean id="aBean" class="...">
	...
</bean>

接下来的示例定义了一个切点命名“businessService”它将匹配getName()方法的执行在包com.tutorialspoint中的Student类。

<aop:config>
	<aop:aspect id="myAspect" ref="aBean">

		<aop:pointcut id="businessService"
			expression="execution(* 
 com.tutorialspoint.Student.getName(..))" />
		...
	</aop:aspect>

</aop:config>

<bean id="aBean" class="...">
	...
</bean>

声明通知

你可以在<aop:aspect>中使用<aop:{通知类型名}>元素声明任意五中类型的通知，如下：

<aop:config>
	<aop:aspect id="myAspect" ref="aBean">
		<aop:pointcut id="businessService"
			expression="execution(* com.xyz.myapp.service.*.*(..))" />
	<!-- a before advice definition -->
		<aop:before pointcut-ref="businessService" method="doRequiredTask" />

		<!-- an after advice definition -->
		<aop:after pointcut-ref="businessService" method="doRequiredTask" />

		<!-- an after-returning advice definition -->
		<!--The doRequiredTask method must have parameter named retVal -- > <aop:after-returning 
			pointcut-ref="businessService" returning="retVal" method="doRequiredTask"/> 
			<!-- an after-throwing advice definition -->
		<!--The doRequiredTask method must have parameter named ex -->
		<aop:after-throwing pointcut-ref="businessService"
			throwing="ex" method="doRequiredTask" />

		<!-- an around advice definition -->
		<aop:around pointcut-ref="businessService" method="doRequiredTask" />
		...
	</aop:aspect>
</aop:config>

<bean id="aBean" class="...">
	...
</bean>

你可以使用"doRequiredTask"或者不同的方法对不同的通知。这些方法将被定义作为方面模块的一部分。

示例

为了理解上面基于XML模式的AOP相关涉及的概念，让我们写一个例子实现几个通知。写一个例子带有几个通知，让我们使用Eclipse IDE按着下面的步骤创建Spring应用。

步骤

描述

1

创建一个SpringExample的项目并在src目录下创建com.tutorialspoint包。所有的类都在这个包下。

2

在Add External JARs选项卡中添加Spring库如在Spring Hello World章节中所讲。

3

项目增加AOP特有的库 aspectjrt.jar、aspectjweaver.jar、aspectj.jar在项目中。

4

在com.tutorialspoint包中创建Logging、Student、MainApp类。

5

在src目录下创建配置文件Beans.xml

6

最后一步在Java类中和Bean配置文件中添加内容，并运行应用。

这是Logger的源代码。这实际上是一个简单的方面模块定义方法在不同的点的调用。

package com.tutorialspoint;

public class Logging {

    /**
     * This is the method which I would like to execute before a selected method
     * execution.
     */
    public void beforeAdvice() {
        System.out.println("Going to setup student profile.");
    }

    /**
     * This is the method which I would like to execute after a selected method
     * execution.
     */
    public void afterAdvice() {
        System.out.println("Student profile has been setup.");
    }

    /**
     * This is the method which I would like to execute when any method returns.
     */
    public void afterReturningAdvice(Object retVal) {
        System.out.println("Returning:" + retVal.toString());
    }

    /**
     * This is the method which I would like to execute if there is an exception
     * raised.
     */
    public void AfterThrowingAdvice(IllegalArgumentException ex) {
        System.out.println("There has been an exception: " + ex.toString());
    }
}

如下是Student类的源代码：

package com.tutorialspoint;

public class Student {
    private Integer age;
    private String name;
    public void setAge(Integer age) {
        this.age = age;
    }
    public Integer getAge() {
        System.out.println("Age : " + age);
        return age;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getName() {
        System.out.println("Name : " + name);
        return name;
    }
    public void printThrowException() {
        System.out.println("Exception raised");
        throw new IllegalArgumentException();
    }
}

如下是MainApp的源代码：

package com.tutorialspoint;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class MainApp {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");
        Student student = (Student) context.getBean("student");

        student.getName();
        student.getAge();

        student.printThrowException();
    }
}

如下是配置文件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:aop="http://www.springframework.org/schema/aop"

	xsi:schemaLocation="http://www.springframework.org/schema/beans 
     http://www.springframework.org/schema/beans/spring-beans-3.0.xsd 
     http://www.springframework.org/schema/aop 
     http://www.springframework.org/schema/aop/spring-aop-3.0.xsd ">

	<aop:config>
		<aop:aspect id="log" ref="logging">
			<aop:pointcut id="selectAll"
				expression="execution(* com.tutorialspoint.*.*(..))" />
			<aop:before pointcut-ref="selectAll" method="beforeAdvice" />
			<aop:after pointcut-ref="selectAll" method="afterAdvice" />
			<aop:after-returning pointcut-ref="selectAll"
				returning="retVal" method="afterReturningAdvice" />
			<aop:after-throwing pointcut-ref="selectAll"
				throwing="ex" method="AfterThrowingAdvice" />
		</aop:aspect>
	</aop:config>

	<!-- Definition for student bean -->
	<bean id="student" class="com.tutorialspoint.Student">
		<property name="name" value="Zara" />
		<property name="age" value="11" />
	</bean>

	<!-- Definition for logging aspect -->
	<bean id="logging" class="com.tutorialspoint.Logging" />

</beans>

一旦你完成了源代码和配置文件的创建，运行这个应用。如果应用一切正常，将会打印如下消息：

Going to setup student profile.
Name : Zara
Student profile has been setup.
Returning:Zara
Going to setup student profile.
Age : 11
Student profile has been setup.
Returning:11
Going to setup student profile.
Exception raised
Exception in thread "main" java.lang.IllegalArgumentException
Student profile has been setup.
There has been an exception: java.lang.IllegalArgumentException
…………other exception content

让我解释一下上面定义<aop:pointcut>选择包com.tutorialspoint包的所有方法。让我们假设，你想执行你的通知在一个特定的方法前或后，你可以在切点的定义中定义一个切点去缩小你执行的通知范围通过使用特定的类和方法名替代星号(*)。如下是修改的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:aop="http://www.springframework.org/schema/aop" xsi:schemaLocation="http://www.springframework.org/schema/beans 
      http://www.springframework.org/schema/beans/spring-beans-3.0.xsd 
      http://www.springframework.org/schema/aop 
      http://www.springframework.org/schema/aop/spring-aop-3.0.xsd ">
	<aop:config>
		<aop:aspect id="log" ref="logging">
			<aop:pointcut id="selectAll" expression="execution(* com.tutorialspoint.Student.getName(..))"/>
			<aop:before pointcut-ref="selectAll" method="beforeAdvice"/>
			<aop:after pointcut-ref="selectAll" method="afterAdvice"/>
		</aop:aspect>
	</aop:config>
	<!-- Definition for student bean -->
	<bean id="student" class="com.tutorialspoint.Student">
		<property name="name" value="Zara"/>
		<property name="age" value="11"/>
	</bean>
	<!-- Definition for logging aspect -->
	<bean id="logging" class="com.tutorialspoint.Logging"/>
</beans>

如果你用修改过的配置文件执行这个应用，将会打印如下消息：

Going to setup student profile.
Name : Zara
Student profile has been setup.
Age : 11
Exception raised
Exception in thread "main" java.lang.IllegalArgumentException
…………other exception content

Spring基于@AspectJ的AOP

@AspectJ指明了和Java 5类似的Java类注解的声明方面的风格。@AspectJ被支持通过在你的基于XML模式的配置文件中包含如下元素。

<aop:aspectj-autoproxy/>

 你的应用的类路径下需要如下的AspectJ库。这个库可以在AspectJ目录‘lib’目录下找到，否则你可以从internet上下载。

    *aspectjrt.jar

    *aspectjweaver.jar

    *aspectj.jar

声明一个方面

方面类和其它的有方法和域的其他通常的类一样，除非他们被@Aspect注解，如下：

package org.xyz; 
 import org.aspectj.lang.annotation.Aspect; 
 @Aspect 
 public class AspectModule { 
  }

这和如下的XML的配置一样：

<bean id="myAspect" class="org.xyz.AspectModule">
	<!-- configure properties of aspect here as normal -->
</bean>

声明一个切点

   切点决定连接点在感兴趣的地方执行不同的通知。当使用基于@AspectJ的配置，切点的声明需要两部分。

    * 一个切点表达式决定哪个方法的执行是我们感兴趣的。

    * 一个切点签名包含一个名字和任意数量的参数。方法的主体是不相关的实际上应该是空的。

接下来的例子定义了一个切点命名“businessService”匹配包com.xyz.myapp.service下的任何方法的执行：

import org.aspectj.lang.annotation.Pointcut; 
@Pointcut("execution(* com.xyz.myapp.service.*.*(..))") // 
expression 
private void businessService () {}  // signature

接下来的例子定义了一个切点命名“getname”将匹配com.tutorialspoint包下的类Student的getName()方法的执行。

import org.aspectj.lang.annotation.Pointcut; 
@Pointcut("execution(* com.tutorialspoint.Student.getName(..))") 
private void getname () {}

声明通知

你可以使用注解@{通知类型名}注解声明任意的5种通知。这个假设你已经定义了一个切点签名方法businessService()：

@Before("businessService()") 
    public void doBeforeTask (){ 
      ... 
    } 

    @After("businessService()") 
    public void doAfterTask (){ 
      ... 
    } 

    @AfterReturning(pointcut = "businessService()", returning="retVal") 
    public void doAfterReturnningTask (Object retVal){ 
       // you can intercept retVal here. 
       ... 
    } 

    @AfterThrowing(pointcut = "businessService()", throwing="ex") 
    public void doAfterThrowingTask (Exception ex){ 
       // you can intercept thrown exception here. 
       ... 
    } 

    @Around("businessService()") 
    public void doAroundTask (){ 
      ... 
    }

你可以定义切点内嵌在任何通知中。如下是定义一个内嵌的切点在before通知中。

  @Before("execution(* com.xyz.myapp.service.*.*(..))") 
    public doBeforeTask (){ 
      ... 
    }

示例

为了理解上面关于基于@AspectJ注解的概念，让我们写一个实现了几个通知的示例。这个示例带有几个通知，让我们使用Eclipe IDE按如下的步骤创建Spring应用。

 步骤  

 描述

 1

创建一个SpringExample的项目并在src目录下创建com.tutorialspoint包。所有的类都在这个包下。

 2

在Add External JARs选项卡中添加Spring库如在Spring Hello World章节中所讲。

 3

项目增加AOP特有的库 aspectjrt.jar、aspectjweaver.jar、aspectj.jar在项目中。

 4

在com.tutorialspoint包中创建Logging、Student、MainApp类。

 5

在src目录下创建配置文件Beans.xml

 6

最后一步在Java类中和Bean配置文件中添加内容，并运行应用。

如下是Logging类的源代码。这实际是一个方面模块的样例这定义了一个方法被不同的点调用。

package com.tutorialspoint;
import org.aspectj.lang.annotation.*;
@Aspect
public class Logging {
    /**
     * Following is the definition for a pointcut to select all the methods
     * available. So advice will be called for all the methods.
     */
    @Pointcut("execution(* com.tutorialspoint.*.*(..))")
    private void selectAll() {
    }
    /**
     * This is the method which I would like to execute before a selected method
     * execution.
     */
    @Before("selectAll()")
    public void beforeAdvice() {
        System.out.println("Going to setup student profile.");
    }
    /**
     * This is the method which I would like to execute after a selected method
     * execution.
     */
    @After("selectAll()")
    public void afterAdvice() {
        System.out.println("Student profile has been setup.");
    }
  /**
     * This is the method which I would like to execute when any method returns.
     */
    @AfterReturning(pointcut = "selectAll()", returning = "retVal")
    public void afterReturningAdvice(Object retVal) {
        System.out.println("Returning:" + retVal.toString());
    }
  
    /**
     * This is the method which I would like to execute if there is an exception
     * raised by any method.
     */
    @AfterThrowing(pointcut = "selectAll()", throwing = "ex")
    public void AfterThrowingAdvice(IllegalArgumentException ex) {
        System.out.println("There has been an exception: " + ex.toString());
    }
}

如下是Student类的源代码：

package com.tutorialspoint;
public class Student {
    private Integer age;
    private String name;
    public void setAge(Integer age) {
        this.age = age;
    }
    public Integer getAge() {
        System.out.println("Age : " + age);
        return age;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getName() {
        System.out.println("Name : " + name);
        return name;
    }

    public void printThrowException() {
        System.out.println("Exception raised");
        throw new IllegalArgumentException();
    }
}

如下是MainApp的源代码：

package com.tutorialspoint;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class MainApp {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");

        Student student = (Student) context.getBean("student");

        student.getName();
        student.getAge();

        student.printThrowException();
    }
}

如下是配置文件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:aop="http://www.springframework.org/schema/aop" xsi:schemaLocation="http://www.springframework.org/schema/beans 
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd 
http://www.springframework.org/schema/aop 
http://www.springframework.org/schema/aop/spring-aop-3.0.xsd ">

	<aop:aspectj-autoproxy/>

	<!-- Definition for student bean -->
	<bean id="student" class="com.tutorialspoint.Student">
		<property name="name" value="Zara"/>
		<property name="age" value="11"/>
	</bean>

	<!-- Definition for logging aspect -->
	<bean id="logging" class="com.tutorialspoint.Logging"/>

</beans>

一旦你完成了源代码和配置文件的创建，运行这个应用。如果应用一切正常，将会打印如下消息：


Going to setup student profile.
Name : Zara
Student profile has been setup.
Returning:Zara
Going to setup student profile.
Age : 11
Student profile has been setup.
Returning:11
Going to setup student profile.
Exception raised
Student profile has been setup.
There has been an exception: java.lang.IllegalArgumentException
…………other exception content

























pangjingji
关注
  • 1
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
Spring-boot框架使用手册之三——Spring AOP
kuaidi100的博客
09-07 298
快递100是专业的快递物流互联网平台，为数以亿记的用户提供快递物流的查、寄件服务。快递100的各种服务已经稳定高效的运行了多年，为中国的快递物流行业的快速发展做出了很大的贡献，这一切都离不开背后默默贡献的程序猿们。 从第一个独立站点上线至今，快递100已经走过了10个年头，10年沧海桑田，10年经历了一次又一次的技术、架构升级。近年来，由于spring-boot、spring-cloud技术的兴起，快递100技术团队也开始对后端服务进行重构，基于spring-boot、spring-cloud...
Spring框架学习之Spring-AOP
weixin_50943926的博客
07-05 610
Spring学习之AOP（7.5）
从头认识Spring-3.1 简单的AOP日志实现-某方法之前的前后记录日志
weixin_34101784的博客
07-16 98
这一章节我们引入简单的AOP日志实现。1.domain蛋糕类：package com.raylee.my_new_spring.my_new_spring.ch03.topic_1_1; public class Cake { private String name = ""; public String getName() { return name; } public...
Spring框架学习（3.1）基于xml配置文件的AOP实现
key_768的博客
01-11 383
前言 记录学习历程 AOP(Aspect Oriented Programming 面向切面编程）是一种编程范式，通过允许横切关注点的分离，提高模块化，AOP提供切面来将跨越对象关注点模块化 简介 日志、事务、安全验证等散布在系统各处的需要在实现业务逻辑时关注的事情称为“切面”、“关注点”，AOP要做的就是从系统中分离出“切面”，然后集中实现，从而独立地编写业务代码和方面代码，在系统运行时，在将方...
Spring3.1 AOP开发依赖jar包
码农小札
08-24 1469
spring3.1不再把那些依赖的第三方jar包打包进来。，除了引入spring框架dist目录下的org.springframework.aop-3.1.1.RELEASE.jar之外， 还需要自己下载第三方依赖包： aspectjrt.jar，aspectjweaver.jar，aopalliance.jar 下载地址：
3.1.3 Spring之AOP
weixin_30702887的博客
04-22 111
三、Spring之AOP 1.代理模式 (1)什么是代理模式？ 代理模式是面向对象编程的23种基础设计模式之一。为其他对象（代理对象）提供一种代理以控制对这个对象（源对象）的访问。 就是说，声明一个代理对象去控制对源的对象的访问。代理模式的作用就是提供一个代理对象对源对象的控制访问。 (2)为什么使用代理？ 可以隐藏目标类的具体实现；在不修改目标类代码的情况下能够对其功能...
spring3.1.0 jar包详解说明
天翔空水木的专栏
10-29 1102
spring3.1.0 jar包详解说明Spring 3.1包详解 Spring 3.1与之前的 2.X 的不一样，新版本把原来的包分解了，功能分工明确： org.springframework.aop-3.1.0.M1.jar —- —-spring 的面向切面编程，提供AOP（面向切面编程）实现， org.springframework.asm-3.1.0.M1.jar —- —-spring
Spring Framework 3.1 官方教程
09-05
Spring Framework官方教程不仅包含了框架核心概念的讲解，还提供了最佳实践和高级特性教程，比如如何在项目中集成Spring MVC、Spring的AOP编程模型、事务管理以及Spring与其他技术如JPA和JMS的集成。通过这些教程，...
Spring3.1 AOP倚赖jar 包汇总
05-21
`org.springframework.aop-3.1.1.RELEASE.jar`是Spring AOP模块的核心库，它包含了一系列接口和实现，用于定义切面、切点、通知和代理。在这个版本中，Spring AOP提供了一个纯Java的实现，可以与Spring IoC容器紧密...
spring3.1 官方全部jar包
04-26
org.springframework.aop-3.1.RELEASE.jar org.springframework.asm-3.1.RELEASE.jar org.springframework.aspects-3.1.RELEASE.jar org.springframework.beans-3.1.RELEASE.jar org.springframework.context....
spring framework 3.1 reference
01-10
《Spring Framework 3.1 参考文档》深入解析与应用指南 一、Spring框架概览 Spring框架作为企业级应用开发的首选框架之一，其3.1版本在继承了原有强大功能的基础上，进一步增强了对Java 5的支持，优化了模块组织...
Spring的AOP（整合第三方框架）
最新发布
qq_64268646的博客
09-21 532
spring整合第三方框架
Spring3.1.0实现原理分析(九).AOP之创建代理对象的过程
chengyueshi2102的博客
05-19 156
大家好，今天我会用一个例子来讲解Spring创建bean代理对象的过程，为大家揭开Spring AOP的神秘面纱。在看这篇博客前我强烈建议读者先看下这两篇博客《Spring3.1.0实现原理分析(六).实例化》，《Spring3.1.0实现原理分析(七).填充Bean属性，初始...
Spring入门（六）基于 AOP 的 XML架构
乌云踏雪
08-04 291
理解aop执行过程 &lt;aop:config&gt; &lt;aop:aspect id="log" ref="logging"&gt; &lt;aop:pointcut id="selectAll" expression="execution(* com.tutorialspoint.*.*(..))"/&gt;
spring框架中的AOP
qq_38320255的博客
07-29 247
在spring框架中学习与测试AOP。 第一步：需要导入对应的所需要的jar包： 链接：https://pan.baidu.com/s/1KrhAz-gP2U0j1PTrO5MS4Q 密码：zcqb 第二步：在Beans.xml文件中进行配置（命名标签的配置）： 注意：要在配置中加入我注释的那三行。 第一次把第一行漏掉了，导致我在接下来的步骤中报错，直接无法找到对应的命名标签。 ...
Spring学习——面向切面编程(AOP)
qq_40929531的博客
02-24 398
1.通知（Advice） 　　就是你想要的功能，也就是上面说的安全，事物，日志等。你给先定义好把，然后在想用的地方用一下。 2.连接点（JoinPoint） 　　这个更好解释了，就是spring允许你使用通知的地方，那可真就多了，基本每个方法的前，后（两者都有也行），或抛出异常时都可以是连接点，spring只支持方法连接点.其他如aspectJ还可以让你在构造器或属性注入时都行，不过那不是...
Spring AOP中pointcut expression表达式解析 及匹配多个条件
热门推荐
静风落叶的博客
12-18 1万+
Spring中事务控制相关配置： 　　 　　　　 　　 　　 　　　　 　　　　　　 　　　　　　 　　　　　　 　　　　 　　 　　 　　　　 　　　　 　　 　　其中的“aop:pointcut”标签中"expression"的写法规则如下：      execution(modifiers-pattern? ret-type-pattern decl
Spring3.0 学习-AOP面向切面编程_Spring AOP的XML配置模式
༺ bestcxx的专栏 ༻
10-01 6926
1、通行理论 在软件中，有些行为是通用的。比如日志、安全和事务管理，他们有一个共同的特点，分布于应用中的多处，这种功能被称为横切关注点（cross-cutting concerns）。 DI（依赖注入）有助于应用对象之间的解耦，而AOP可以实现横切关注点与他们所影响的对象之间的解耦。 应用切面的常见范例：日志、声明式事务、安全和缓存。 下面涉及的内容包括Spring对切面的支持，包括如何把...
AOP实现（三）——Spring 2.0中Pointcut的定义
野人地带
11-17 450
在Spring 2.0中，Pointcut的定义包括两个部分：Pointcut表示式(expression)和Pointcut签名(signature)。让我们先看看execution表示式的格式： java 代码 execution(modifier-pattern?           ret-type-pattern           decla...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值