Springaop 简明教程

Spring AOP - Quick Guide

Spring AOP - Overview

Spring 框架一个主要组件是 Aspect Oriented Programming (AOP) 框架。面向方面的编程将程序逻辑分解成称为 so-called concerns 的不同部分。跨越应用程序多个点的功能被称为横切关注点。这些 cross-cutting concerns 在概念上独立于应用程序的业务逻辑。有许多方面的典型示例，如日志记录、审计、声明式事务、安全性、缓存等。

OOP 中模块性的一个主要单元是类，而 AOP 中的模块性单元是方面。依赖关系注入可帮助你解耦应用程序对象，而 AOP 可帮助你解耦横切关注点与它们影响的对象。AOP 类似于 Perl、.NET、Java 和其他编程语言中的触发器。

Spring AOP 模块让拦截器拦截应用程序。例如，当执行一个方法时，你可以在方法执行之前或之后添加额外的功能。

Spring AOP - Environment Setup

本章将在您开始使用 Spring 框架时，指导您如何准备开发环境。它还将教您在设置 Spring 框架之前如何在您的机器上设置 JDK、Maven 和 Eclipse −

Step 1 - Setup Java Development Kit (JDK)

你可以从 Oracle 的 Java 站点下载 SDK 的最新版本 − Java SE Downloads. 你在下载文件中可以找到安装 JDK 的说明，按照给定的说明进行安装和配置。最后设置 PATH 和 JAVA_HOME 环境变量以引用包含 java 和 javac 的目录，通常分别为 java_install_dir/bin 和 java_install_dir。

如果您运行的是 Windows 且在 C:\jdk-11.0.11 中安装了 JDK，那么您将不得不把以下代码行放入您的 C:\autoexec.bat 文件中。

set PATH=C:\jdk-11.0.11;%PATH%
set JAVA_HOME=C:\jdk-11.0.11

或者，在 Windows NT/2000/XP 中，你必须右键单击我的电脑，选择属性 → 高级 → 环境变量。然后，你将不得不更新 PATH 值并单击确定按钮。

在 Unix（Solaris、Linux 等）中，如果 SDK 安装在 /usr/local/jdk-11.0.11 且您使用 C shell，那么您将不得不把以下代码行放入您的 .cshrc 文件中。

setenv PATH /usr/local/jdk-11.0.11/bin:$PATH
setenv JAVA_HOME /usr/local/jdk-11.0.11

或者，如果你使用诸如 Borland JBuilder、Eclipse、IntelliJ IDEA 或 Sun ONE Studio 这样的集成开发环境 (IDE)，则必须编译并运行一个简单程序来确认 IDE 知道你在何处安装了 Java。否则，你必须按照 IDE 文档中给出的内容执行正确的设置。

Step 2 - Setup Eclipse IDE

本教程中的所有示例都是使用 Eclipse IDE 编写的。因此，我们建议你应该在你机器上安装 Eclipse 的最新版本。

要安装 Eclipse IDE，请从 https://www.eclipse.org/downloads/ 下载最新的 Eclipse 二进制文件。下载安装后，将二进制发行版解压缩到方便的位置。例如，在 Windows 上的 C:\eclipse，或在 Linux/Unix 上的 /usr/local/eclipse，最后适当设置 PATH 变量。

可以通过在 Windows 机器上执行以下命令启动 Eclipse，或者你只需双击 eclipse.exe

%C:\eclipse\eclipse.exe

可以通过在 Unix（Solaris、Linux 等）机器上执行以下命令启动 Eclipse −

$/usr/local/eclipse/eclipse

成功启动后，如果一切正常，它应该显示以下结果 −

Step 3 - Download Maven Archive

从 https://maven.apache.org/download.cgi 下载 Maven 3.8.4。

Archive name

Windows

apache-maven-3.8.4-bin.zip

Linux

apache-maven-3.8.4-bin.tar.gz

Mac

apache-maven-3.8.4-bin.tar.gz

Step 4 - Extract the Maven Archive

将存档解压到要安装 Maven 3.8.4 的目录。存档将创建一个子目录 apache-maven-3.8.4。

位置（根据你的安装而异）

Windows

C:\Program Files\Apache Software Foundation\apache-maven-3.8.4

Linux

/usr/local/apache-maven

Mac

/usr/local/apache-maven

Step 5 - Set Maven Environment Variables

将 M2_HOME、M2、MAVEN_OPTS 添加到环境变量。

Output

Windows

使用系统属性设置环境变量。M2_HOME=C:\Program Files\Apache Software Foundation\apache-maven-3.8.4 M2=%M2_HOME%\bin MAVEN_OPTS=-Xms256m -Xmx512m

Linux

打开命令终端并设置环境变量。 export M2_HOME=/usr/local/apache-maven/apache-maven-3.8.4 export M2=$M2_HOME/bin export MAVEN_OPTS=-Xms256m -Xmx512m

Mac

打开命令终端并设置环境变量。export M2_HOME=/usr/local/apache-maven/apache-maven-3.8.4export M2=$M2_HOME/bin export MAVEN_OPTS=-Xms256m -Xmx512m

Step 6 - Add Maven bin Directory Location to System Path

现在将 M2 变量附加到系统路径。

Output

Windows

将字符串 ;%M2% 附加到系统变量 Path 的末尾。

Linux

export PATH=$M2:$PATH

Mac

export PATH=$M2:$PATH

Step 7 - Verify Maven Installation

现在打开控制台并执行以下 mvn 命令。

Task

Command

Windows

Open Command Console

c:> mvn --version

Linux

Open Command Terminal

$ mvn --version

Mac

Open Terminal

machine:~ joseph$ mvn --version

最后，验证上述命令的输出，其应如下所示 −

Output

Windows

Apache Maven 3.8.4 (9b656c72d54e5bacbed989b64718c159fe39b537)Maven 主目录：C:\Program Files\Apache Software Foundation\apache-maven-3.8.4Java 版本：11.0.11，供应商：Oracle Corporation，运行时：C:\Program Files\Java\jdk11.0.11\默认语言环境：en_IN，平台编码：Cp1252操作系统名称：“windows 10”，版本：“10.0”，体系结构：“amd64”，系列：“windows”

Linux

Apache Maven 3.8.4 (9b656c72d54e5bacbed989b64718c159fe39b537)Java 版本：11.0.11Java 主目录：/usr/local/java-current/jre

Mac

Apache Maven 3.8.4 (9b656c72d54e5bacbed989b64718c159fe39b537)Java 版本：11.0.11Java 主目录：/Library/Java/Home/jre

Spring AOP - Core Concepts

在我们开始使用 AOP 之前，让我们先熟悉 AOP 概念和术语。这些术语不仅仅针对 Spring，而是与 AOP 相关。

Sr.No.	Terms & Description
1	Aspect 一个模块，具有一组提供横切需求的 API。例如，一个日志记录模块将称为日志记录的 AOP 方面。一个应用程序可以根据需求拥有任意数量的方面。
2	Join point 它表示应用程序中你可以插入 AOP 方面的点。也可以说，它是应用程序中将使用 Spring AOP 框架执行操作的实际位置。
3	Advice 这是方法执行前或执行后要执行的实际操作。这是 Spring AOP 框架在程序执行期间调用的实际代码段。
4	PointCut 这是一组应执行增强的一个或多个联合点。你可以使用表达式或模式指定 PointCut，如下面的 AOP 示例所示。
5	Introduction 引入功能允许你向现有类添加新方法或属性。
6	Target object 一个或多个方面增强过的对象。此对象将始终是一个代理对象。也称为增强对象。
7	Weaving 编织是将方面与其他应用程序类型或对象链接以创建告知对象的过程。此操作可以在编译时、加载时或运行时完成。

Spring AOP - Advice Types

Spring 方面可用于以下表格中提到的五种建议。

Sr.No.	Advice & Description
1	before 在方法执行前运行建议。
2	after 在方法执行后运行建议，无论其执行结果为何。
3	after-returning 在方法执行后运行建议，仅在方法成功完成时运行建议。
4	after-throwing 在方法执行后通过抛出异常退出时运行建议。
5	around 在调用建议方法之前和之后运行建议。

Spring AOP - Implementations

Spring 支持 @AspectJ annotation style 方法和 schema-based 方法来实现自定义方面。

XML Schema Based

方面使用常规类和基于 XML 的配置进行实现。

若要使用本节中所述的 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>

Declaring an Aspect

aspect 使用 <aop:aspect> 元素声明，且背景 Bean 使用 ref 特性引用，如下所示。

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

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

这里，“aBean”将被配置且依赖注入，正如你在前几章所看到的那样。

Declaring a Pointcut

Pointcut 有助于确定要使用不同的建议执行的目标连接点（即方法）。在基于 XML 架构的配置中工作时，Pointcut 将被定义如下

<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”的 Pointcut，它将匹配 Student 类中可用 getName() 方法在 com.tutorialspoint 包中的执行。

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

Declaring Advices

你可以使用 <aop:{ADVICE NAME}> 元素在 <aop:aspect> 内声明任意五个建议，如下所示。

<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 或不同的方法。这些方法将被定义为方面模块的一部分。

@AspectJ based

@AspectJ 指一种将方面声明为使用 Java 5 注释注释的常规 Java 类的样式。通过在基于 XML 架构的配置文件中加入以下元素，可启用 @AspectJ 支持。

<aop:aspectj-autoproxy/>

Declaring an Aspect

方面类与任何其他常规 Bean 一样，可能有方法和字段，就像任何其他类一样，只不过它们将使用 @Aspect 注释，如下所示。

package org.xyz;

import org.aspectj.lang.annotation.Aspect;

@Aspect
public class AspectModule {
}

它们将在 XML 中配置，就像其他 Bean 一样，如下所示。

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

Declaring a Pointcut

Pointcut 有助于确定要使用不同的建议执行的目标连接点（即方法）。在基于 @AspectJ 的配置中工作时，Pointcut 声明有以下两个部分

一个 Pointcut 表达式，用于确定我们具体对哪些方法执行感兴趣。
一个 Pointcut 签名，包括一个名称和任意数量的参数。方法的实际主体无关紧要，事实上应该是空的。

以下示例定义了一个名为“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() {}

Declaring Advices

您可以使用 @{ADVICE-NAME} 注解声明以下任何五种建议。这假定您已定义了切点签名方法 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("execution(* com.xyz.myapp.service.*.*(..))")
public doBeforeTask(){
   ...
}

Spring AOP - XML Based Application

在本章中，我们将使用 Spring AOP 框架编写实际的 AOP 应用程序。在开始使用 Spring-WS 框架编写第一个示例之前，您必须确保已按照 Spring Web Services - Environment Setup 章节中的说明正确设置 Spring AOP 环境。

现在，继续编写一个简单的基于控制台的 Spring AOP 应用程序，该应用程序将演示 AOP 概念。

Create a Project

Step 1 − 打开命令控制台，转到 C:\MVN 目录并执行以下 mvn 命令。

C:\MVN>mvn archetype:generate -DgroupId=com.tutorialspoint
-DartifactId=Student -DarchetypeArtifactId=maven-archetype-quickstart
-DinteractiveMode=false

Maven 将开始处理并将创建完整的 Java 应用程序项目结构。

[INFO] Scanning for projects...
[INFO]
[INFO] ------------------< org.apache.maven:standalone-pom >-------------------
[INFO] Building Maven Stub Project (No POM) 1
[INFO] --------------------------------[ pom ]---------------------------------
[INFO]
[INFO] >>> maven-archetype-plugin:3.2.0:generate (default-cli) > generate-sources @ standalone-pom >>>
[INFO]
[INFO] <<< maven-archetype-plugin:3.2.0:generate (default-cli) < generate-sources @ standalone-pom <<<
[INFO]
[INFO]
[INFO] --- maven-archetype-plugin:3.2.0:generate (default-cli) @ standalone-pom ---
[INFO] Generating project in Batch mode
[INFO] ----------------------------------------------------------------------------
[INFO] Using following parameters for creating project from Old (1.x) Archetype: maven-archetype-quickstart:1.0
[INFO] ----------------------------------------------------------------------------
[INFO] Parameter: basedir, Value: C:\MVN
[INFO] Parameter: package, Value: com.tutorialspoint
[INFO] Parameter: groupId, Value: com.tutorialspoint
[INFO] Parameter: artifactId, Value: Student
[INFO] Parameter: packageName, Value: com.tutorialspoint
[INFO] Parameter: version, Value: 1.0-SNAPSHOT
[INFO] project created from Old (1.x) Archetype in dir: C:\MVN\Student
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time:  13.388 s
[INFO] Finished at: 2021-12-27T20:18:26+05:30
[INFO] ------------------------------------------------------------------------

Step 2 − 转到 C:/MVN 目录。您将看到一个 Java 应用程序项目已创建，名为 student（如 artifactId 中指定）。更新 POM.xml 以包括 Spring-AOP 依赖项。添加 MainApp.java、Student.java 和 Logging.java 文件。

POM.xml

<project xmlns = "http://maven.apache.org/POM/4.0.0"
   xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation = "http://maven.apache.org/POM/4.0.0
   http://maven.apache.org/maven-v4_0_0.xsd">
   <modelVersion>4.0.0</modelVersion>
   <groupId>com.tutorialspoint</groupId>
   <artifactId>Student</artifactId>
   <packaging>jar</packaging>
   <version>1.0-SNAPSHOT</version>
   <name>Student</name>
   <url>http://maven.apache.org</url>

   <properties>
      <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
      <maven.compiler.source>1.7</maven.compiler.source>
      <maven.compiler.target>1.7</maven.compiler.target>
   </properties>

   <dependencies>
      <dependency>
         <groupId>junit</groupId>
         <artifactId>junit</artifactId>
         <version>4.11</version>
         <scope>test</scope>
      </dependency>
      <dependency>
         <groupId>org.springframework</groupId>
         <artifactId>spring-aop</artifactId>
         <version>5.3.14</version>
      </dependency>
      <dependency>
         <groupId>org.springframework</groupId>
         <artifactId>spring-context</artifactId>
         <version>5.3.14</version>
      </dependency>
      <dependency>
         <groupId>org.aspectj</groupId>
         <artifactId>aspectjweaver</artifactId>
         <version>1.9.7</version>
      </dependency>
   </dependencies>
</project>

以下是 Logging.java 文件的内容。

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.java 文件的内容。

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.java 文件的内容。

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();
   }
}

Step 3 − 在 src > main > resources 文件夹下添加 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>

Step 4 − 打开命令控制台，转到 C:\MVN 目录并执行以下 mvn 命令。

C:\MVN>Student> mvn package

Maven 将开始处理和下载所需的库。

C:\MVN\Student>mvn package
[INFO] Scanning for projects...
[INFO]
[INFO] ---------------------< com.tutorialspoint:Student >---------------------
[INFO] Building Student 1.0-SNAPSHOT
[INFO] --------------------------------[ jar ]---------------------------------
[INFO]
[INFO] --- maven-resources-plugin:2.6:resources (default-resources) @ Student ---
[INFO] Using 'UTF-8' encoding to copy filtered resources.
[INFO] Copying 1 resource
[INFO]
[INFO] --- maven-compiler-plugin:3.1:compile (default-compile) @ Student ---
[INFO] Nothing to compile - all classes are up to date
[INFO]
[INFO] --- maven-resources-plugin:2.6:testResources (default-testResources) @ Student ---
[INFO] Using 'UTF-8' encoding to copy filtered resources.
[INFO] skip non existing resourceDirectory C:\MVN\Student\src\test\resources
[INFO]
[INFO] --- maven-compiler-plugin:3.1:testCompile (default-testCompile) @ Student ---
[INFO] Nothing to compile - all classes are up to date
[INFO]
[INFO] --- maven-surefire-plugin:2.12.4:test (default-test) @ Student ---
[INFO] Surefire report directory: C:\MVN\Student\target\surefire-reports

-------------------------------------------------------
 T E S T S
-------------------------------------------------------
Running com.tutorialspoint.AppTest
Tests run: 1, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 0.093 sec

Results :

Tests run: 1, Failures: 0, Errors: 0, Skipped: 0

[INFO]
[INFO] --- maven-jar-plugin:2.4:jar (default-jar) @ Student ---
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time:  4.213 s
[INFO] Finished at: 2021-12-27T20:42:00+05:30
[INFO] ------------------------------------------------------------------------
C:\MVN\Student>

Import Project in Eclipse

Step 1 − 打开 Eclipse。

Step 2 − 选择 File → Import → 选项。

Step 3 − 选择 Maven 项目选项。单击“下一步”按钮。

Step 4 − 选择项目位置，即使用 Maven 创建 Student 项目的位置。

Step 5 − 单击“完成”按钮。

Run Project

创建源和配置文件后，运行您的应用程序。在应用程序中右键单击 MainApp.java 并使用 run as Java Application 命令。如果您的应用程序一切正常，它将打印以下消息。

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
Exception in thread "main" java.lang.IllegalArgumentException
	at com.tutorialspoint.Student.printThrowException(Student.java:25)
...

Spring AOP - XML Based PointCut

Join Point

结合点表示您可以插入 AOP 方面的应用程序中的一个点。您还可以说，这是使用 Spring AOP 框架将在应用程序中执行操作的实际位置。考虑以下示例 −

包含在包中所有的类方法。
类的特定方法。

PointCut

切点是一组或更多连接点，某些建议应该在其中执行。你可以使用表达式或模式来指定切点，就像我们在 AOP 示例中看到的。在 Spring 中，切点能够帮助使用特定的连接点来应用建议。考虑以下示例：

expression = "execution(* com.tutorialspoint..(..))"
expression = "execution(* com.tutorialspoint.Student.getName(..))"

Syntax

<aop:config>
   <aop:aspect id = "log" ref = "adviceClass">
      <aop:pointcut id = "PointCut-id" expression = "execution( expression )"/>
   </aop:aspect>
</aop:config>

其中，

adviceClass - 包含建议方法的类的引用
PointCut-id - 切点的 ID
execution( expression ) − 涵盖应用建议的方法的表达式。

为了理解与连接点和切点相关的上述概念，让我们写一个示例，该示例将实现一些切点。为了编写我们带有少许建议的示例，让我们使用现成的 Eclipse IDE，并使用以下步骤来创建 Spring 应用程序。

Step

Description

更新在章节 Spring AOP - Application 创建的学生项目。

更新 bean 配置并按如下说明运行应用程序。

以下是 Logging.java 文件的内容。这实际上是方面模块的一个示例，它定义了在各个点调用的方法。

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.");
   }
}

以下是 Student.java 文件的内容。

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.java 文件的内容。

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();
   }
}

以下是配置文件 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: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>

一旦你完成了创建源文件和 Bean 配置文件，就运行该应用程序。如果你的应用程序一切正常，它将打印以下信息。

Going to setup student profile.
Name : Zara
Going to setup student profile.
Age : 11

上面定义的 <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: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>

Run Project

Going to setup student profile.
Name : Zara
Age : 11

Spring AOP - XML Based Before Advice

Before 是一种建议类型，它确保建议在方法执行之前运行。以下是 before 建议的语法。

Syntax

<aop:config>
   <aop:aspect id = "log" ref = "logging">
      <aop:pointcut id = "PointCut-id" expression = "execution( expression )"/>
      <aop:before pointcut-ref = "PointCut-id" method = "methodName"/>
   </aop:aspect>
</aop:config>

其中，

PointCut-id - 切点的 ID
methodName - 在被调用的函数之前要被调用的函数的方法名

为了理解与 Before 建议相关的上述概念，让我们编写一个示例，它将实现 Before 建议。为了编写我们带有少许建议的示例，让我们使用现成的 Eclipse IDE，并使用以下步骤来创建 Spring 应用程序。

Step

Description

更新在章节 Spring AOP - Application 创建的学生项目。

更新 bean 配置并按如下说明运行应用程序。

以下是 Logging.java 文件的内容。这实际上是方面模块的一个示例，它定义了在各个点调用的方法。

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.");
   }
}

以下是 Student.java 文件的内容。

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.java 文件的内容。

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();
   }
}

以下是配置文件 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.Student.getName(..))"/>
         <aop:before pointcut-ref = "selectAll" method = "beforeAdvice"/>
      </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>

Run Project

一旦你完成了创建源文件和配置文件，就运行你的应用程序。在你的应用程序中右击 MainApp.java，并使用 run as Java Application 命令。如果你的应用程序一切正常，它将打印以下信息。

Going to setup student profile.
Name : Zara
Age : 11

Spring AOP - XML Based After Advice

After 是一种建议类型，它确保建议在方法执行之后运行。以下是 after 建议的语法。

Syntax

<aop:config>
   <aop:aspect id = "log" ref = "logging">
      <aop:pointcut id = "PointCut-id" expression = "execution( expression )"/>
      <aop:after pointcut-ref = "PointCut-id" method = "methodName"/>
   </aop:aspect>
</aop:config>

其中，

PointCut-id - 切点的 ID
methodName - 在被调用的函数之后要被调用的函数的方法名

为了理解与 After 建议相关的上述概念，让我们编写一个示例，它将实现 After 建议。为了编写我们带有少许建议的示例，让我们使用现成的 Eclipse IDE，并使用以下步骤来创建 Spring 应用程序。

Step

Description

更新在章节 Spring AOP - Application 创建的学生项目。

更新 bean 配置并按如下说明运行应用程序。

以下是 Logging.java 文件的内容。这实际上是方面模块的一个示例，它定义了在各个点调用的方法。

package com.tutorialspoint;

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

以下是 Student.java 文件的内容。

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.java 文件的内容。

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();
   }
}

以下是配置文件 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.Student.getAge(..))"/>
         <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>

Run Project

一旦你完成了创建源文件和配置文件，就运行你的应用程序。在你的应用程序中右击 MainApp.java，并使用 run as Java Application 命令。如果你的应用程序一切正常，这将打印以下信息。

Name : Zara
Age : 11
Student profile setup complete.

Spring AOP - XML Based After Returning Advice

After 是一种建议类型，它确保仅在方法成功完成后，建议才会在方法执行之后运行。以下是 after 建议的语法。

Syntax

<aop:config>
   <aop:aspect id = "log" ref = "logging">
      <aop:pointcut id = "PointCut-id" expression = "execution( expression )"/>
      <aop:after-returning pointcut-ref = "PointCut-id"
         returning = "retVal" method = "methodName"/>
   </aop:aspect>
</aop:config>

其中，

PointCut-id - 切点的 ID
methodName - 在被调用的函数成功返回之后要被调用的函数的方法名

为了理解与 After Returning 建议相关的上述概念，让我们编写一个示例，它将实现 After Returning 建议。为了编写我们带有少许建议的示例，让我们使用现成的 Eclipse IDE，并使用以下步骤来创建 Spring 应用程序：

Step

Description

更新在章节 Spring AOP - Application 创建的学生项目。

更新 bean 配置并按如下说明运行应用程序。

以下是 Logging.java 文件的内容。这实际上是方面模块的一个示例，它定义了在各个点调用的方法。

package com.tutorialspoint;

public class Logging {
   /**
      * 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() );
   }
}

以下是 Student.java 文件的内容。

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 );
      System.out.println("Exception raised");
      throw new IllegalArgumentException();
      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.java 文件的内容。

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();
   }
}

以下是配置文件 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:after-returning pointcut-ref = "selectAll"
            method = "afterReturningAdvice" returning = "retVal"/>
      </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>

Run Project

Name : Zara
Returning : Name
Age : 11
Exception raised

Spring AOP - XML Based After Throwing Advice

After-throwing 是一种建议类型，它确保仅在方法通过抛出异常退出时，建议才会在方法执行之后运行。以下是 after-throwing 建议的语法。

Syntax

<aop:config>
   <aop:aspect id = "log" ref = "logging">
      <aop:pointcut id = "PointCut-id" expression = "execution( expression )"/>
      <aop:after-throwing pointcut-ref = "PointCut-id" throwing = "ex"
         method = "methodName"/>
   </aop:aspect>
</aop:config>

其中，

PointCut-id - 切点的 ID
ex − 要抛出的异常。
methodName − 函数的方法名称，在被调用的函数抛出异常并退出时被调用。

为了理解与 After Throwing Advice 相关的上述概念，让我们编写一个将实现 After Throwing Advice 的示例。为了用很少的建议编写示例，让我们使用现有的 Eclipse IDE，并按照以下步骤创建一个 Spring 应用程序 −

Step

Description

更新在章节 Spring AOP - Application 创建的学生项目。

更新 bean 配置并按如下说明运行应用程序。

以下是 Logging.java 文件的内容。这实际上是方面模块的一个示例，它定义了在各个点调用的方法。

package com.tutorialspoint;

public class Logging {
   /**
      * 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.java 文件的内容。

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.java 文件的内容。

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

Run Project

Exception raised
There has been an exception: java.lang.IllegalArgumentException
Exception in thread "main" java.lang.IllegalArgumentException
   at com.tutorialspoint.Student.printThrowException(Student.java:25)
...

Spring AOP - XML Based Around Advice

Around 是一种通知类型，它确保一个通知在方法执行之前和之后运行。以下是 around 通知的语法。

Syntax

<aop:config>
   <aop:aspect id = "log" ref = "logging">
      <aop:pointcut id = "PointCut-id" expression = "execution( expression )"/>
      <aop:around pointcut-ref = "PointCut-id" method = "methodName"/>
   </aop:aspect>
</aop:config>

其中，

PointCut-id - 切点的 ID
methodName - 在被调用的函数之前要被调用的函数的方法名

为了理解与 Around Advice 相关的上述概念，让我们编写一个将实现 Around Advice 的示例。为了用很少的建议编写示例，让我们使用现有的 Eclipse IDE，并按照以下步骤创建一个 Spring 应用程序 −

Step

Description

更新在章节 Spring AOP - Application 创建的学生项目。

更新 bean 配置并按如下说明运行应用程序。

以下是 Logging.java 文件的内容。这实际上是方面模块的一个示例，它定义了在各个点调用的方法。

package com.tutorialspoint;
import org.aspectj.lang.ProceedingJoinPoint;

public class Logging {
   /**
      * This is the method which I would like to execute
      * around a selected method execution.
   */
   public String aroundAdvice(ProceedingJoinPoint jp) throws Throwable{
      System.out.println("Around advice");
      Object[] args = jp.getArgs();
      if(args.length>0){
         System.out.print("Arguments passed: " );
         for (int i = 0; i < args.length; i++) {
            System.out.print("arg "+(i+1)+": "+args[i]);
         }
      }
      Object result = jp.proceed(args);
      System.out.println("Returning " + result);
      return result.toString();
   }
}

以下是 Student.java 文件的内容。

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.java 文件的内容。

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();
   }
}

以下是配置文件 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 = "selectName"
            expression = "execution(* com.tutorialspoint.Student.getName(..))"/>
         <aop:around pointcut-ref = "selectName" method = "aroundAdvice"/>
      </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>

Run Project

Around advice
Name : Zara
Returning Zara

Spring AOP - Annotation Based Application

让我们编写一个基于注释的配置将实现通知的示例。为此，让我们使用现有的 Eclipse IDE，并按照以下步骤创建一个 Spring 应用程序。

Step

Description

更新在章节 Spring AOP - Application 创建的学生项目。

更新 bean 配置并按如下说明运行应用程序。

以下是 Logging.java 文件的内容。这实际上是方面模块的一个示例，它定义了在各个点调用的方法。

package com.tutorialspoint;

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;

@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.");
   }
}

以下是 Student.java 文件的内容。

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.java 文件的内容。

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();
   }
}

以下是配置文件 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>

Run Project

Going to setup student profile.
Name : Zara
Going to setup student profile.
Age : 11

Spring AOP - Annotation Based PointCut

JoinPoint

结合点表示您可以插入 AOP 方面的应用程序中的一个点。您还可以说，这是使用 Spring AOP 框架将在应用程序中执行操作的实际位置。考虑以下示例 −

包含在包中所有的类方法。
类的特定方法。

Pointcut

切入点是一组一个或更多个结合点，应在其中执行建议。您可以使用表达式或模式指定切入点，正如我们在 AOP 示例中看到的那样。在 Spring 中，切入点有助于使用特定的结合点来应用建议。考虑以下示例 −

@Pointcut("execution(* com.tutorialspoint..(..))")
@Pointcut("execution(* com.tutorialspoint.Student.getName(..))")

Syntax

@Aspect
public class Logging {
   @Pointcut("execution(* com.tutorialspoint.*.*(..))")
   private void selectAll(){}
}

其中，

@Aspect − 将类标记为包含建议方法的类。
@Pointcut − 将函数标记为切入点
execution( expression ) − 涵盖应用建议的方法的表达式。

为了理解与结合点和切入点相关的上述概念，让我们编写一个将实现几个切入点的示例。为了编写我们的一些建议的示例，让我们有一个正在运行的 Eclipse IDE，并使用以下步骤创建一个 Spring 应用程序 −

Step

Description

更新在章节 Spring AOP - Application 创建的学生项目。

更新 bean 配置并按如下说明运行应用程序。

以下是 Logging.java 文件的内容。这实际上是方面模块的一个示例，它定义了在各个点调用的方法。

package com.tutorialspoint;

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.annotation.Before;

@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.");
   }
}

以下是 Student.java 文件的内容。

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.java 文件的内容。

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();
   }
}

以下是配置文件 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>

Run Project

Going to setup student profile.
Name : Zara
Going to setup student profile.
Age : 11

上述定义的 @Pointcut 使用了一个表达式选择 com.tutorialspoint 包下定义的所有方法。@Before 增强使用了上述定义的 Pointcut 作为参数。方法 beforeAdvice() 实际上将在 Pointcut 涉及到的每个方法前被调用。

Spring AOP - Annotation Based Before Advice

@Before 是一种通知类型，它确保一个通知在方法执行之前运行。以下是 @Before 通知的语法。

Syntax

@Pointcut("execution(* com.tutorialspoint.Student.getName(..))")
private void selectGetName(){}

@Before("selectGetName()")
public void beforeAdvice(){
   System.out.println("Going to setup student profile.");
}

其中，

@Pointcut − 将函数标记为切入点
execution( expression ) − 涵盖应用建议的方法的表达式。
@Before − 将一个函数标记为一个通知，在切入点涵盖的方法之前执行。

为了理解与 @Before Advice 相关的上述概念，让我们编写一个将实现 @Before Advice 的示例。为了用很少的建议编写示例，让我们使用现有的 Eclipse IDE，并按照以下步骤创建一个 Spring 应用程序 −

Step

Description

更新在章节 Spring AOP - Application 创建的学生项目。

更新 bean 配置并按如下说明运行应用程序。

以下是 Logging.java 文件的内容。这实际上是方面模块的一个示例，它定义了在各个点调用的方法。

package com.tutorialspoint;

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.annotation.Before;

@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.Student.getName(..))")
   private void selectGetName(){}
   /**
      * This is the method which I would like to execute
      * before a selected method execution.
   */
   @Before("selectGetName()")
   public void beforeAdvice(){
      System.out.println("Going to setup student profile.");
   }
}

以下是 Student.java 文件的内容。

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.java 文件的内容。

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();
   }
}

以下是配置文件 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>

Run Project

Going to setup student profile.
Name : Zara
Age : 11

上面定义的 @Pointcut 使用一个表达式来选择在包 com.tutorialspoint 中的类中定义的方法 getAge() 。@After 通知使用上面定义的 Pointcut 作为参数。effectively afterAdvice() 方法将在上面 Pointcut 涵盖的每个方法之前被调用。

Spring AOP - Annotation Based After Advice

@After 是一种通知类型，它确保一个通知在方法执行之后运行。以下是 @After 通知的语法。

Syntax

@Pointcut("execution(* com.tutorialspoint.Student.getAge(..))")
private void selectGetName(){}

@After("selectGetAge()")
public void afterAdvice(){
   System.out.println("Student profile setup completed.");
}

其中，

@Pointcut − 将函数标记为切入点
execution( expression ) − 涵盖应用建议的方法的表达式。
@After − 将一个函数标记为一个通知，在切入点涵盖的方法之前执行。

为了理解与 @After Advice 相关的上述概念，让我们编写一个将实现 @After Advice 的示例。为了用很少的建议编写示例，让我们使用现有的 Eclipse IDE，并按照以下步骤创建一个 Spring 应用程序。

Step

Description

更新在章节 Spring AOP - Application 创建的学生项目。

更新 bean 配置并按如下说明运行应用程序。

以下是 Logging.java 文件的内容。这实际上是方面模块的一个示例，它定义了在各个点调用的方法。

package com.tutorialspoint;

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.annotation.After;

@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.Student.getAge(..))")
   private void selectGetAge(){}

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

以下是 Student.java 文件的内容。

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.java 文件的内容。

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();
   }
}

以下是配置文件 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>

Run Project

Name : Zara
Age : 11
Student profile setup completed.

Annotation Based After Returning Advice

@AfterReturning 是一个通知类型，它确保一个通知在方法成功执行后运行。以下是 @AfterReturning 通知的语法。

Syntax

@AfterReturning(Pointcut = "execution(* com.tutorialspoint.Student.*(..))", returning = "retVal")
public void afterReturningAdvice(JoinPoint jp, Object retVal){
   System.out.println("Method Signature: "  + jp.getSignature());
   System.out.println("Returning:" + retVal.toString() );
}

其中，

@AfterReturning − 将一个函数标记为一个通知，在切入点涵盖的方法之前执行，如果方法成功返回。
Pointcut − 提供一个表达式来选择一个函数。
execution( expression ) − 涵盖应用建议的方法的表达式。
returning − 将要返回的变量名称。

为了理解与 @AfterReturning Advice 相关的上述概念，让我们编写一个将实现 @AfterReturning Advice 的示例。为了用很少的建议编写示例，让我们使用现有的 Eclipse IDE，并按照以下步骤创建一个 Spring 应用程序。

Step

Description

更新在章节 Spring AOP - Application 创建的学生项目。

更新 bean 配置并按如下说明运行应用程序。

以下是 Logging.java 文件的内容。这实际上是方面模块的一个示例，它定义了在各个点调用的方法。

package com.tutorialspoint;

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.AfterReturning;

@Aspect
public class Logging {
   /**
      * This is the method which I would like to execute
      * after a selected method execution.
   */
   @AfterReturning(Pointcut = "execution(* com.tutorialspoint.Student.*(..))", returning = "retVal")
   public void afterReturningAdvice(JoinPoint jp, Object retVal){
      System.out.println("Method Signature: "  + jp.getSignature());
      System.out.println("Returning:" + retVal.toString() );
   }
}

以下是 Student.java 文件的内容。

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.java 文件的内容。

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.getAge();
   }
}

以下是配置文件 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>

Run Project

Age : 11
Method Signature: Integer com.tutorialspoint.Student.getAge()
Returning 11

Spring AOP - Annotation Based After Throwing Advice

@AfterThrowing 是一种通知类型，它确保在方法抛出一个异常时运行一个通知。以下是 @AfterThrowing 通知的语法。

Syntax

@AfterThrowing(Pointcut = "execution(* com.tutorialspoint.Student.*(..))", throwing = "error")
public void afterThrowingAdvice(JoinPoint jp, Throwable error){
   System.out.println("Method Signature: "  + jp.getSignature());
   System.out.println("Exception: "+error);
}

其中，

@AfterThrowing − 将方法标记为在切入点涵盖的方法抛出异常时执行的建议。
Pointcut − 提供选择某个函数的表达式。
execution( expression ) − 涵盖应用建议的方法的表达式。
throwing − 要返回的异常名称。

为了理解与 @AfterThrowing 相关建议已经提到的概念，我们来写一个将实施 @AfterThrowing 建议的示例。若要使用少量的建议来编写示例，我们先来设置一个可行的 Eclipse IDE，然后使用以下步骤来创建一个 Spring 应用程序：

Step

Description

更新在章节 Spring AOP - Application 创建的学生项目。

更新 bean 配置并按如下说明运行应用程序。

以下是 Logging.java 文件的内容。这实际上是方面模块的一个示例，它定义了在各个点调用的方法。

package com.tutorialspoint;

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.AfterThrowing;

@Aspect
public class Logging {
   /**
      * This is the method which I would like to execute
      * after a selected method execution throws exception.
   */
   @AfterThrowing(Pointcut = "execution(* com.tutorialspoint.Student.*(..))", throwing = "error")
   public void afterThrowingAdvice(JoinPoint jp, Throwable error){
      System.out.println("Method Signature: "  + jp.getSignature());
      System.out.println("Exception: "+error);
   }
}

以下是 Student.java 文件的内容。

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.java 文件的内容。

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.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>

Run Project

Exception raised
Method Signature: void com.tutorialspoint.Student.printThrowException()
Exception: java.lang.IllegalArgumentException
Exception in thread "main" java.lang.IllegalArgumentException

   at com.tutorialspoint.Student.printThrowException(Student.java:25)
   ...

Spring AOP - Annotation Based Around Advice

@Around 是建议类型，它确保建议可以在方法执行前后运行。以下是 @Around 建议的语法：

Syntax

@Pointcut("execution(* com.tutorialspoint.Student.getAge(..))")
private void selectGetName(){}

@Around("selectGetAge()")
public void aroundAdvice(ProceedingJoinPoint proceedingJoinPoint){
   System.out.println("Around advice");
   Object[] args = jp.getArgs();
   if(args.length>0){
      System.out.print("Arguments passed: " );
      for (int i = 0; i < args.length; i++) {
         System.out.print("arg "+(i+1)+": "+args[i]);
      }
   }
   Object result = jp.proceed(args);
   System.out.println("Returning " + result);
   return result.toString();
}

其中，

@Pointcut − 将函数标记为切入点
execution( expression ) − 涵盖应用建议的方法的表达式。
@Around − 将方法标记为在切入点涵盖的方法之前执行的建议。

为了理解与 @Around 相关建议已经提到的概念，我们来写一个将实施 @Around 建议的示例。若要使用少量的建议来编写示例，我们先来设置一个可行的 Eclipse IDE，然后使用以下步骤来创建一个 Spring 应用程序：

Step

Description

更新在章节 Spring AOP - Application 创建的学生项目。

更新 bean 配置并按如下说明运行应用程序。

以下是 Logging.java 文件的内容。这实际上是方面模块的一个示例，它定义了在各个点调用的方法。

package com.tutorialspoint;

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.ProceedingJoinPoint;

@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.Student.getAge(..))")
   private void selectGetAge(){}

   /**
      * This is the method which I would like to execute
      * around a selected method execution.
   */
   @Around("selectGetAge()")
   public void aroundAdvice(ProceedingJoinPoint proceedingJoinPoint) throws Throwable{
      System.out.println("Around advice");
      Object[] args = proceedingJoinPoint.getArgs();
      if(args.length>0){
         System.out.print("Arguments passed: " );
         for (int i = 0; i < args.length; i++) {
            System.out.print("arg "+(i+1)+": "+args[i]);
         }
      }
      Object result = proceedingJoinPoint.proceed(args);
      System.out.println("Returning " + result);
   }
}

以下是 Student.java 文件的内容。

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.java 文件的内容。

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.getAge();
   }
}

以下是配置文件 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>

Run Project

Around advice
Age : 11
Returning 11

Spring AOP - Proxy

到目前为止，我们已经使用 <aop:config> 或 < aop:aspectj-autoproxy> 声明了方面。我们可以以编程方式创建代理，也可以使用代理对象以编程方式调用方面。

Syntax

//Create object to be proxied
Student student = new Student();

//Create the Proxy Factory
AspectJProxyFactory proxyFactory = new AspectJProxyFactory(student);

//Add Aspect class to the factory
proxyFactory.addAspect(Logging.class);

//Get the proxy object
Student proxyStudent = proxyFactory.getProxy();

//Invoke the proxied method.
proxyStudent.getAge();

其中，

AspectJProxyFactory − 创建代理对象的工厂类。
Logging.class − 包含建议的切面类。
Student − 待建议的目标业务类。

为了理解与代理相关的上述概念，我们来写一个将实施代理的示例。若要使用少量的建议来编写示例，我们先来设置一个可行的 Eclipse IDE，然后使用以下步骤来创建一个 Spring 应用程序：

Step

Description

更新在章节 Spring AOP - Application 创建的学生项目。

更新 bean 配置并按如下说明运行应用程序。

以下是 Logging.java 文件的内容。这实际上是方面模块的一个示例，它定义了在各个点调用的方法。

package com.tutorialspoint;

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.PointCut;
import org.aspectj.lang.annotation.Before;

@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.Student.getAge(..))")
   private void selectGetAge(){}

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

以下是 Student.java 文件的内容。

package com.tutorialspoint;

public class Student {
   private Integer age;
   public void setAge(Integer age) {
      this.age = age;
   }
   public Integer getAge() {
      System.out.println("Age : " + age );
      return age;
   }
}

以下是 MainApp.java 文件的内容。

package com.tutorialspoint;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.aop.aspectj.annotation.AspectJProxyFactory;

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

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

      //Create the Proxy Factory
      AspectJProxyFactory proxyFactory = new AspectJProxyFactory(student);

      //Add Aspect class to the factory
      proxyFactory.addAspect(Logging.class);

      //Get the proxy object
      Student proxyStudent = proxyFactory.getProxy();

      //Invoke the proxied method.
      proxyStudent.getAge();
   }
}

以下是配置文件 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 ">

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

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

Run Project

Going to setup student profile.
Age : 11

Spring AOP - Custom Annotation

根据切入点表达式，它们可能会应用于不适用于此建议的其他 Bean。例如，考虑以下表达式。

execution(* com.tutorialspoint.*.getAge(..))

将添加 getAge() 方法的新 Spring Bean，并且建议将开始应用于它，即使它可能不是预期的。为实现此目的，我们可以创建一个自定义注释并注释应用建议的方法。

@Before("@annotation(com.tutorialspoint.Loggable)")

为了理解与 @Before 相关建议已经提到的概念，我们来写一个将实施 @Before 建议的示例。若要使用少量的建议来编写示例，我们先来设置一个可行的 Eclipse IDE，然后使用以下步骤来创建一个 Spring 应用程序。

Step

Description

更新在章节 Spring AOP - Application 创建的学生项目。

更新 bean 配置并按如下说明运行应用程序。

以下是 Logging.java 文件的内容。这实际上是方面模块的一个示例，它定义了在各个点调用的方法。

package com.tutorialspoint;

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;

@Aspect
public class Logging {
   /**
      * This is the method which I would like to execute
      * before a selected method execution.
   */
   @Before("@annotation(com.tutorialspoint.Loggable)")
   public void beforeAdvice(){
      System.out.println("Going to setup student profile.");
   }
}

以下是 Loggable.java 文件的内容：

package com.tutorialspoint;
public @interface Loggable {
}

以下是 Student.java 文件的内容。

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;
   }
   @Loggable
   public String getName() {
      System.out.println("Name : " + name );
      return name;
   }
   public void printThrowException(){
      System.out.println("Exception raised");
      throw new IllegalArgumentException();
   }
}

以下是 MainApp.java 文件的内容。

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();
   }
}

以下是配置文件 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>

Run Project

Going to setup student profile.
Name : Zara
Age : 11