Spring AOP - Kurzanleitung

Eine der Schlüsselkomponenten von Spring Framework ist das Aspect Oriented Programming (AOP)Rahmen. Bei der aspektorientierten Programmierung wird die Programmlogik in verschiedene Teile zerlegt, die als aufgerufen werdenso-called concerns. Die Funktionen, die mehrere Punkte einer Anwendung umfassen, werden als Querschnittsthemen bezeichnet. Diesecross-cutting concernssind konzeptionell von der Geschäftslogik der Anwendung getrennt. Es gibt verschiedene Beispiele für Aspekte wie Protokollierung, Prüfung, deklarative Transaktionen, Sicherheit, Caching usw.

Die Schlüsseleinheit der Modularität in OOP ist die Klasse, während in AOP die Einheit der Modularität der Aspekt ist. Mit Dependency Injection können Sie Ihre Anwendungsobjekte voneinander entkoppeln, während Sie mit AOP Querschnittsthemen von den betroffenen Objekten entkoppeln können. AOP ist wie Trigger in Programmiersprachen wie Perl, .NET, Java und anderen.

Mit dem Spring AOP-Modul können Interceptors eine Anwendung abfangen. Wenn beispielsweise eine Methode ausgeführt wird, können Sie vor oder nach der Methodenausführung zusätzliche Funktionen hinzufügen.

Dieses Kapitel führt Sie durch die Einrichtung von Spring AOP auf Windows- und Linux-basierten Systemen. Spring AOP kann einfach installiert und in Ihre aktuelle Java-Umgebung und MAVEN integriert werden, indem einige einfache Schritte ohne komplexe Einrichtungsverfahren ausgeführt werden. Während der Installation ist eine Benutzerverwaltung erforderlich.

System Anforderungen

JDK Java SE 2 JDK 1.5 oder höher
Erinnerung 1 GB RAM (empfohlen)
Festplattenplatz Keine Mindestanforderung
Betriebssystemversion Windows XP oder höher, Linux

Schauen wir uns nun die Schritte zur Installation von Spring AOP an.

Schritt 1: Überprüfen Sie Ihre Java-Installation

Zunächst muss das Java Software Development Kit (SDK) auf Ihrem System installiert sein. Um dies zu überprüfen, führen Sie je nach Plattform, auf der Sie arbeiten, einen der beiden folgenden Befehle aus.

Wenn die Java-Installation ordnungsgemäß durchgeführt wurde, werden die aktuelle Version und die Spezifikation Ihrer Java-Installation angezeigt. Eine Beispielausgabe ist in der folgenden Tabelle angegeben.

Plattform Befehl Beispielausgabe
Windows

Öffnen Sie die Befehlskonsole und geben Sie - ein

\>java -version

Java-Version "1.7.0_60"

Java (TM) SE-Laufzeitumgebung (Build 1.7.0_60-b19)

Java Hotspot (TM) 64-Bit-Server-VM (Build 24.60-b09, gemischter Modus)

Linux

Befehlsterminal öffnen und - eingeben

$java -version

Java-Version "1.7.0_25"

Öffnen Sie die JDK-Laufzeitumgebung (rhel-2.3.10.4.el6_4-x86_64).

Öffnen Sie die JDK 64-Bit-Server-VM (Build 23.7-b01, gemischter Modus).

Wir gehen davon aus, dass die Leser dieses Tutorials Java SDK Version 1.7.0_60 auf ihrem System installiert haben.

Falls Sie kein Java SDK haben, laden Sie die aktuelle Version von herunter https://www.oracle.com/technetwork/java/javase/downloads/index.html und habe es installiert.

Schritt 2: Legen Sie Ihre Java-Umgebung fest

Stellen Sie die Umgebungsvariable JAVA_HOME so ein, dass sie auf den Speicherort des Basisverzeichnisses verweist, in dem Java auf Ihrem Computer installiert ist. Zum Beispiel,

Sr.Nr. Plattform & Beschreibung
1

Windows

Setzen Sie JAVA_HOME auf C: \ ProgramFiles \ java \ jdk1.7.0_60

2

Linux

Exportieren Sie JAVA_HOME = / usr / local / java-current

Hängen Sie den vollständigen Pfad des Java-Compiler-Speicherorts an den Systempfad an.

Sr.Nr. Plattform & Beschreibung
1

Windows

Fügen Sie die Zeichenfolge "C: \ Programme \ Java \ jdk1.7.0_60 \ bin" an das Ende der Systemvariablen Path an.

2

Linux

Export PATH = $ PATH: $ JAVA_HOME / bin /

Führen Sie den Befehl aus java -version an der Eingabeaufforderung wie oben erläutert.

Schritt 3: Laden Sie das Maven-Archiv herunter

Laden Sie Maven 3.3.3 von herunter https://maven.apache.org/download.cgi

Betriebssystem Archivname
Windows apache-maven-3.3.3-bin.zip
Linux apache-maven-3.3.3-bin.tar.gz
Mac apache-maven-3.3.3-bin.tar.gz

Schritt 4: Extrahieren Sie das Maven-Archiv

Extrahieren Sie das Archiv in das Verzeichnis, in dem Sie Maven 3.3.3 installieren möchten. Das Unterverzeichnis apache-maven-3.3.3 wird aus dem Archiv erstellt.

Betriebssystem Standort (kann je nach Installation unterschiedlich sein)
Windows C: \ Programme \ Apache Software Foundation \ apache-maven-3.3.3
Linux / usr / local / apache-maven
Mac / usr / local / apache-maven

Schritt 5: Maven-Umgebungsvariablen festlegen

Fügen Sie M2_HOME, M2, MAVEN_OPTS zu Umgebungsvariablen hinzu.

Betriebssystem Ausgabe
Windows

Legen Sie die Umgebungsvariablen mithilfe der Systemeigenschaften fest.

M2_HOME = C: \ Programme \ Apache Software Foundation \ apache-maven-3.3.3

M2 =% M2_HOME% \ bin

MAVEN_OPTS = -Xms256m -Xmx512m

Linux Öffnen Sie das Befehlsterminal und legen Sie die Umgebungsvariablen fest.

export M2_HOME = /usr/local/apache-maven/apache-maven-3.3.3

export M2 = $ M2_HOME / bin

export MAVEN_OPTS = -Xms256m -Xmx512m

Mac

Öffnen Sie das Befehlsterminal und legen Sie die Umgebungsvariablen fest.

export M2_HOME = /usr/local/apache-maven/apache-maven-3.3.3

export M2 = $ M2_HOME / bin

export MAVEN_OPTS = -Xms256m -Xmx512m

Schritt 6: Fügen Sie dem Systempfad den Speicherort des Maven Bin-Verzeichnisses hinzu

Hängen Sie nun die Variable M2 an den Systempfad an.

Betriebssystem Ausgabe
Windows Hängen Sie die Zeichenfolge% M2% an das Ende der Systemvariablen Path an.
Linux export PATH = $ M2: $ PATH
Mac export PATH = $ M2: $ PATH

Schritt 7: Überprüfen Sie die Installation von Maven

Öffnen Sie nun die Konsole und führen Sie Folgendes aus mvn Befehl.

Betriebssystem Aufgabe Befehl
Windows Öffnen Sie die Befehlskonsole c: \> mvn --version
Linux Öffnen Sie das Befehlsterminal $ mvn --version
Mac Terminal öffnen Maschine: <joseph $ mvn --version

Überprüfen Sie abschließend die Ausgabe der oben genannten Befehle, die wie folgt aussehen sollten:

Betriebssystem Ausgabe
Windows

Apache Maven 3.3.3 (7994120775791599e205a5524ec3e0dfe41d4a06; 2015-04-22T17: 27: 37 + 05: 30)

Maven-Startseite: C: \ Programme \ Apache Software Foundation \ apache-maven-3.3.3

Java-Version: 1.7.0_75, Hersteller: Oracle Corporation

Java-Startseite: C: \ Programme \ Java \ jdk1.7.0_75 \ jre

Standardgebietsschema: en_US, Plattformcodierung: Cp1252

Linux

Apache Maven 3.3.3 (7994120775791599e205a5524ec3e0dfe41d4a06; 2015-04-22T17: 27: 37 + 05: 30)

Maven nach Hause: /usr/local/apache-maven/apache-maven-3.3.3

Java-Version: 1.7.0_75, Hersteller: Oracle Corporation

Java-Startseite: /usr/local/java-current/jdk1.7.0_75/jre

Mac

Apache Maven 3.3.3 (7994120775791599e205a5524ec3e0dfe41d4a06; 2015-04-22T17: 27: 37 + 05: 30)

Maven nach Hause: /usr/local/apache-maven/apache-maven-3.3.3

Java-Version: 1.7.0_75, Hersteller: Oracle Corporation

Java-Startseite: /Library/Java/Home/jdk1.7.0_75/jre

Schritt 8 - Eclipse IDE einrichten

Alle Beispiele in diesem Tutorial wurden mit Eclipse IDE geschrieben. Daher würde ich vorschlagen, dass Sie die neueste Version von Eclipse auf Ihrem Computer installiert haben.

Laden Sie zum Installieren der Eclipse-IDE die neuesten Eclipse-Binärdateien von herunter https://www.eclipse.org/downloads/. Wenn Sie die Installation heruntergeladen haben, entpacken Sie die Binärdistribution an einem geeigneten Ort. Zum Beispiel in C: \ eclipse unter Windows oder / usr / local / eclipse unter Linux / Unix und setzen Sie schließlich die Variable PATH entsprechend.

Eclipse kann durch Ausführen der folgenden Befehle auf einem Windows-Computer gestartet werden, oder Sie können auf eclipse.exe doppelklicken

%C:\eclipse\eclipse.exe

Eclipse kann durch Ausführen der folgenden Befehle auf einem Unix-Computer (Solaris, Linux usw.) gestartet werden:

$/usr/local/eclipse/eclipse

Wenn nach einem erfolgreichen Start alles in Ordnung ist, sollte das folgende Ergebnis angezeigt werden:

Sobald Sie mit diesem letzten Schritt fertig sind, können Sie mit Ihrem ersten AOP-Beispiel fortfahren, das Sie im nächsten Kapitel sehen werden.

Before we start working with AOP, let us become familiar with the AOP concepts and terminologies. These terms are not specific to Spring, rather they are related to AOP.

Sr.No. Terms & Description
1

Aspect

A module which has a set of APIs providing cross-cutting requirements. For example, a logging module would be called AOP aspect for logging. An application can have any number of aspects depending on the requirement.

2

Join point

This represents a point in your application where you can plug-in AOP aspect. You can also say, it is the actual place in the application where an action will be taken using Spring AOP framework.

3

Advice

This is the actual action to be taken either before or after the method execution. This is the actual piece of code that is invoked during program execution by Spring AOP framework.

4

PointCut

This is a set of one or more joinpoints where an advice should be executed. You can specify PointCuts using expressions or patterns as we will see in our AOP examples.

5

Introduction

An introduction allows you to add new methods or attributes to existing classes.

6

Target object

The object being advised by one or more aspects. This object will always be a proxied object. Also referred to as the advised object.

7

Weaving

Weaving is the process of linking aspects with other application types or objects to create an advised object. This can be done at compile time, load time, or at runtime.

Spring aspects can work with five kinds of advice mentioned in the following table.

Sr.No. Advice & Description
1

before

Run advice before the method execution.

2

after

Run advice after the method execution, regardless of its outcome.

3

after-returning

Run advice after the method execution, only if the method completes successfully.

4

after-throwing

Run advice after the method execution, only if the method exits by throwing an exception.

5

around

Run advice before and after the advised method is invoked.

Spring supports the @AspectJ annotation style approach and the schema-based approach to implement custom aspects.

XML Schema Based

Aspects are implemented using regular classes along with XML based configuration.

To use the AOP namespace tags described in this section, you need to import the spring AOP schema, described as follows −

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

An aspect is declared using the <aop:aspect> element, and the backing bean is referenced using the ref attribute as follows.

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

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

Here "aBean" will be configured and dependency injected just like any other Spring bean as you have seen in the previous chapters.

Declaring a PointCut

A PointCut helps in determining the join points (i.e. methods) of interest to be executed with different advices. While working with XML Schema based configuration, PointCut will be defined as follows −

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

The following example defines a PointCut named 'businessService' that will match the execution of getName() method available in Student class under the package 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

You can declare any of the five advices inside an <aop:aspect> using the <aop:{ADVICE NAME}> element as follows.

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

You can use same doRequiredTask or different methods for different advices. These methods will be defined as a part of aspect module.

@AspectJ based

@AspectJ refers to a style of declaring aspects as regular Java classes annotated with Java 5 annotations. The @AspectJ support is enabled by including the following element inside your XML Schema-based configuration file.

<aop:aspectj-autoproxy/>

Declaring an Aspect

Aspects classes are like any other normal bean and may have methods and fields just like any other class, except that they will be annotated with @Aspect as follows.

package org.xyz;

import org.aspectj.lang.annotation.Aspect;

@Aspect
public class AspectModule {

}

They will be configured in XML like any other bean as follows.

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

Declaring a PointCut

A PointCut helps in determining the join points (i.e. methods) of interest to be executed with different advices. While working with @AspectJ based configuration, PointCut declaration has two parts −

  • A PointCut expression that determines exactly which method executions we are interested in.

  • A PointCut signature comprising a name and any number of parameters. The actual body of the method is irrelevant and in fact should be empty.

The following example defines a PointCut named 'businessService' that will match the execution of every method available in the classes under the package com.xyz.myapp.service.

import org.aspectj.lang.annotation.PointCut;

@PointCut("execution(* com.xyz.myapp.service.*.*(..))") // expression 
private void businessService() {}  // signature

The following example defines a PointCut named 'getname' that will match the execution of getName() method available in Student class under the package com.tutorialspoint.

import org.aspectj.lang.annotation.PointCut;

@PointCut("execution(* com.tutorialspoint.Student.getName(..))") 
private void getname() {}

Declaring Advices

You can declare any of the five advices using @{ADVICE-NAME} annotations as given below. This assumes that you already have defined a PointCut signature method 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(){
   ...
}

You can define PointCut inline for any of the advices. Following is an example to define inline PointCut for before advice.

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

In this chapter, we will write actual AOP applications using Spring AOP Framework. Before you start writing your first example using Spring-WS framework, you have to make sure that you have set up your Spring AOP environment properly as explained in Spring Web Services - Environment Setup chapter.

Now, proceed to write a simple console-ased Spring AOP Application, which will demonstrate AOP concepts.

Create a Project

Step 1 − Open a command console, go the C:\MVN directory and execute the following mvn command.

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

Maven will start processing and will create the complete Java application project structure.

[INFO] Scanning for projects...
[INFO]
[INFO] ------------------------------------------------------------------------
[INFO] Building Maven Stub Project (No POM) 1
[INFO] ------------------------------------------------------------------------
[INFO]
[INFO] >>> maven-archetype-plugin:2.4:generate (default-cli) > generate-sources
@ standalone-pom >>>
[INFO]
[INFO] <<< maven-archetype-plugin:2.4:generate (default-cli) < generate-sources
@ standalone-pom <<<
[INFO]
[INFO] --- maven-archetype-plugin:2.4:generate (default-cli) @ standalone-pom --
-
[INFO] Generating project in Batch mode
Downloading: https://repo.maven.apache.org/maven2/org/apache/maven/archetypes/ma
ven-archetype-quickstart/1.0/maven-archetype-quickstart-1.0.jar
Downloaded: https://repo.maven.apache.org/maven2/org/apache/maven/archetypes/mav
en-archetype-quickstart/1.0/maven-archetype-quickstart-1.0.jar (5 KB at 1.1 KB/s
ec)
Downloading: https://repo.maven.apache.org/maven2/org/apache/maven/archetypes/ma
ven-archetype-quickstart/1.0/maven-archetype-quickstart-1.0.pom
Downloaded: https://repo.maven.apache.org/maven2/org/apache/maven/archetypes/mav
en-archetype-quickstart/1.0/maven-archetype-quickstart-1.0.pom (703 B at 1.2 KB/
sec)
[INFO] -------------------------------------------------------------------------
---
[INFO] Using following parameters for creating project from Old (1.x) Archetype:
 maven-archetype-quickstart:1.0
[INFO] -------------------------------------------------------------------------
---
[INFO] Parameter: groupId, Value: com.tutorialspoint
[INFO] Parameter: packageName, Value: com.tutorialspoint
[INFO] Parameter: package, Value: com.tutorialspoint
[INFO] Parameter: artifactId, Value: Student
[INFO] Parameter: basedir, Value: C:\MVN
[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: 01:17 min
[INFO] Finished at: 2017-02-19T21:11:14+05:30
[INFO] Final Memory: 15M/114M
[INFO] ------------------------------------------------------------------------

Step 2 − Go to C:/MVN directory. You'll see a Java application project created, named student (as specified in artifactId). Update the POM.xml to include Spring-AOP dependencies. Add MainApp.java, Student.java, and Logging.java files.

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>
   
   <dependencies>
      <dependency>
         <groupId>junit</groupId>
         <artifactId>junit</artifactId>
         <version>3.8.1</version>
         <scope>test</scope>
      </dependency>
      
      <dependency>
         <groupId>org.springframework</groupId>
         <artifactId>spring-aop</artifactId>
         <version>4.1.0.RELEASE</version>
      </dependency>
      
      <dependency>
         <groupId>org.springframework</groupId>
         <artifactId>spring-context</artifactId>
         <version>4.1.4.RELEASE</version>
      </dependency>
      
      <dependency>
         <groupId>org.aspectj</groupId>
         <artifactId>aspectjweaver</artifactId>
         <version>1.6.8</version>
      </dependency>
      
   </dependencies>
</project>
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());   
   }
   
}

Following is the content of the Student.java file.

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

Following is the content of the MainApp.java file.

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 − Add the configuration file Beans.xml under src > main > resources folder.

<?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 − Open the command console, go the C:\MVN directory and execute the following mvn command.

C:\MVN>Student> mvn package

Maven will start processing and downloading the required libraries.

[INFO] Scanning for projects...
[INFO]
[INFO] ------------------------------------------------------------------------
[INFO] Building Student 1.0-SNAPSHOT
[INFO] ------------------------------------------------------------------------
Downloading: https://repo.maven.apache.org/maven2/org/apache/maven/plugins/maven
-jar-plugin/2.4/maven-jar-plugin-2.4.pom
Downloaded: https://repo.maven.apache.org/maven2/org/apache/maven/plugins/maven-
jar-plugin/2.4/maven-jar-plugin-2.4.pom (6 KB at 2.2 KB/sec)
Downloading: https://repo.maven.apache.org/maven2/org/apache/maven/plugins/maven
-jar-plugin/2.4/maven-jar-plugin-2.4.jar
Downloaded: https://repo.maven.apache.org/maven2/org/apache/maven/plugins/maven-
jar-plugin/2.4/maven-jar-plugin-2.4.jar (34 KB at 31.6 KB/sec)
Downloading: https://repo.maven.apache.org/maven2/org/springframework/spring-aop
/4.1.0.RELEASE/spring-aop-4.1.0.RELEASE.pom
Downloaded: https://repo.maven.apache.org/maven2/org/springframework/spring-aop/
4.1.0.RELEASE/spring-aop-4.1.0.RELEASE.pom (3 KB at 3.7 KB/sec)
Downloading: https://repo.maven.apache.org/maven2/org/springframework/spring-bea
ns/4.1.0.RELEASE/spring-beans-4.1.0.RELEASE.pom
Downloaded: https://repo.maven.apache.org/maven2/org/springframework/spring-bean
s/4.1.0.RELEASE/spring-beans-4.1.0.RELEASE.pom (3 KB at 4.1 KB/sec)
Downloading: https://repo.maven.apache.org/maven2/org/springframework/spring-cor
e/4.1.0.RELEASE/spring-core-4.1.0.RELEASE.pom
Downloaded: https://repo.maven.apache.org/maven2/org/springframework/spring-core
/4.1.0.RELEASE/spring-core-4.1.0.RELEASE.pom (3 KB at 4.0 KB/sec)
Downloading: https://repo.maven.apache.org/maven2/org/springframework/spring-aop
/4.1.0.RELEASE/spring-aop-4.1.0.RELEASE.jar
Downloading: https://repo.maven.apache.org/maven2/org/springframework/spring-cor
e/4.1.0.RELEASE/spring-core-4.1.0.RELEASE.jar
Downloading: https://repo.maven.apache.org/maven2/org/springframework/spring-bea
ns/4.1.0.RELEASE/spring-beans-4.1.0.RELEASE.jar
Downloaded: https://repo.maven.apache.org/maven2/org/springframework/spring-aop/
4.1.0.RELEASE/spring-aop-4.1.0.RELEASE.jar (351 KB at 43.9 KB/sec)
Downloaded: https://repo.maven.apache.org/maven2/org/springframework/spring-bean
s/4.1.0.RELEASE/spring-beans-4.1.0.RELEASE.jar (685 KB at 37.5 KB/sec)
Downloaded: https://repo.maven.apache.org/maven2/org/springframework/spring-core
/4.1.0.RELEASE/spring-core-4.1.0.RELEASE.jar (982 KB at 47.1 KB/sec)
[INFO]
[INFO] --- maven-resources-plugin:2.6:resources (default-resources) @ Student --
-
[WARNING] Using platform encoding (Cp1252 actually) to copy filtered resources,
i.e. build is platform dependent!
[INFO] skip non existing resourceDirectory C:\MVN\Student\src\main\resources
[INFO]
[INFO] --- maven-compiler-plugin:3.1:compile (default-compile) @ Student ---
[INFO] Changes detected - recompiling the module!
[WARNING] File encoding has not been set, using platform encoding Cp1252, i.e. b
uild is platform dependent!
[INFO] Compiling 1 source file to C:\MVN\Student\target\classes
[INFO]
[INFO] --- maven-resources-plugin:2.6:testResources (default-testResources) @ St
udent ---
[WARNING] Using platform encoding (Cp1252 actually) to copy filtered resources,
i.e. build is platform dependent!
[INFO] skip non existing resourceDirectory C:\MVN\Student\src\test\resources
[INFO]
[INFO] --- maven-compiler-plugin:3.1:testCompile (default-testCompile) @ Student
 ---
[INFO] Changes detected - recompiling the module!
[WARNING] File encoding has not been set, using platform encoding Cp1252, i.e. b
uild is platform dependent!
[INFO] Compiling 1 source file to C:\MVN\Student\target\test-classes
[INFO]
[INFO] --- maven-surefire-plugin:2.12.4:test (default-test) @ Student ---
[INFO] Surefire report directory: C:\MVN\Student\target\surefire-reports
Downloading: https://repo.maven.apache.org/maven2/org/apache/maven/surefire/sure
fire-junit3/2.12.4/surefire-junit3-2.12.4.pom
Downloaded: https://repo.maven.apache.org/maven2/org/apache/maven/surefire/suref
ire-junit3/2.12.4/surefire-junit3-2.12.4.pom (2 KB at 1.3 KB/sec)
Downloading: https://repo.maven.apache.org/maven2/org/apache/maven/surefire/sure
fire-junit3/2.12.4/surefire-junit3-2.12.4.jar
Downloaded: https://repo.maven.apache.org/maven2/org/apache/maven/surefire/suref
ire-junit3/2.12.4/surefire-junit3-2.12.4.jar (26 KB at 27.7 KB/sec)

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

Results :

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

[INFO]
[INFO] --- maven-jar-plugin:2.4:jar (default-jar) @ Student ---
Downloading: https://repo.maven.apache.org/maven2/classworlds/classworlds/1.1-al
pha-2/classworlds-1.1-alpha-2.jar
Downloaded: https://repo.maven.apache.org/maven2/classworlds/classworlds/1.1-alp
ha-2/classworlds-1.1-alpha-2.jar (37 KB at 35.8 KB/sec)
[INFO] Building jar: C:\MVN\Student\target\Student-1.0-SNAPSHOT.jar
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 38.441 s
[INFO] Finished at: 2017-02-19T21:18:59+05:30
[INFO] Final Memory: 18M/109M
[INFO] ------------------------------------------------------------------------

Import Project in Eclipse

Step 1 − Open Eclipse.

Step 2 − Select File → Import → option.

Step 3 − Select Maven Projects Option. Click the Next Button.

Step 4 − Select Project location, where Student project was created using Maven.

Step 5 − Click Finish Button.

Run Project

Once you are done creating the source and configuration files, run your application. Rightclick on MainApp.java in your application and use run as Java Application command. If everything is fine with your application, it will print the following message.

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)
   
   at com.tutorialspoint.Student$$FastClassBySpringCGLIB$$7dc55815.invoke(<generated>)
   
   at org.springframework.cglib.proxy.MethodProxy.invoke(MethodProxy.java:204)
   
   at org.springframework.aop.framework.CglibAopProxy$CglibMethodInvocation.invokeJoinpoint(CglibAopProxy.java:717) at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:157) at org.springframework.aop.framework.adapter.MethodBeforeAdviceInterceptor.invoke(MethodBeforeAdviceInterceptor.java:52) at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:179) at org.springframework.aop.aspectj.AspectJAfterAdvice.invoke(AspectJAfterAdvice.java:43) at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:179) at org.springframework.aop.framework.adapter.AfterReturningAdviceInterceptor.invoke(AfterReturningAdviceInterceptor.java:52) at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:179) at org.springframework.aop.aspectj.AspectJAfterThrowingAdvice.invoke(AspectJAfterThrowingAdvice.java:58) at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:179) at org.springframework.aop.interceptor.ExposeInvocationInterceptor.invoke(ExposeInvocationInterceptor.java:92) at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:179) at org.springframework.aop.framework.CglibAopProxy$DynamicAdvisedInterceptor.intercept(CglibAopProxy.java:653)
   
   at com.tutorialspoint.Student$$EnhancerBySpringCGLIB$$56a970f2.printThrowException(<generated>)
   
   at com.tutorialspoint.MainApp.main(MainApp.java:16)

Join Point

A JoinPoint represents a point in your application where you can plug-in AOP aspect. You can also say, it is the actual place in the application where an action will be taken using Spring AOP framework. Consider the following examples −

  • All methods classes contained in a package(s).

  • A particular methods of a class.

PointCut

PointCut is a set of one or more JoinPoints where an advice should be executed. You can specify PointCuts using expressions or patterns as we will see in our AOP examples. In Spring, PointCut helps to use specific JoinPoints to apply the advice. Consider the following examples −

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

Where,

  • adviceClass − ref of the class containing advice methods

  • PointCut-id − id of the PointCut

  • execution( expression ) − Expression covering methods on which advice is to be applied.

To understand the above-mentioned concepts related to JoinPoint and PointCut, let us write an example which will implement few of the PointCuts. To write our example with few advices, let us have a working Eclipse IDE in place and use the following steps to create a Spring application.

Step Description
1 Update the project Student created under chapter Spring AOP - Application.
2 Update the bean configuration and run the application as explained below.

Following is the content of Logging.java file. This is actually a sample of aspect module, which defines the methods to be called at various points.

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

Following is the content of the Student.java file.

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

Following is the content of the MainApp.java file.

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

Following is the configuration file 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>

Once you are done with creating the source and bean configuration files, run the application. If everything is fine with your application, it will print the following message.

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

The above-defined <aop:pointcut> selects all the methods defined under the package com.tutorialspoint. Let us suppose, you want to execute your advice before or after a particular method, you can define your PointCut to narrow down your execution by replacing stars (*) in PointCut definition with actual class and method names. Following is a modified XML configuration file to show the concept.

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

Once you are done creating the source and configuration files, run your application. Rightclick on MainApp.java in your application and use run as Java Application command. If everything is fine with your application, it will print the following message.

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

Before is an advice type which ensures that an advice runs before the method execution. Following is the syntax of before advice.

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>

Where,

  • PointCut-id − id of the PointCut.

  • methodName − Method name of the function to be called before a called function.

To understand the above-mentioned concepts related to Before Advice, let us write an example, which will implement Before Advice. To write our example with few advices, let us have a working Eclipse IDE in place and use the following steps to create a Spring application.

Schritt Beschreibung
1 Aktualisieren Sie das unter Student Spring AOP - Application erstellte Projekt Student .
2 Aktualisieren Sie die Bean-Konfiguration und führen Sie die Anwendung wie unten erläutert aus.

Es folgt der Inhalt von Logging.javaDatei. Dies ist eigentlich ein Beispiel eines Aspektmoduls, das die Methoden definiert, die an verschiedenen Stellen aufgerufen werden sollen.

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

Es folgt der Inhalt der Student.java Datei.

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

Es folgt der Inhalt der MainApp.java Datei.

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

Es folgt die Konfigurationsdatei 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>

Führen Sie das Projekt aus

Führen Sie Ihre Anwendung aus, sobald Sie mit dem Erstellen der Quell- und Konfigurationsdateien fertig sind. Klicken Sie in Ihrer Anwendung mit der rechten Maustaste auf MainApp.java und verwenden Sierun as Java ApplicationBefehl. Wenn mit Ihrer Anwendung alles in Ordnung ist, wird die folgende Meldung gedruckt.

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

Afterist ein Beratungstyp, der sicherstellt, dass ein Hinweis nach der Ausführung der Methode ausgeführt wird. Es folgt die Syntax von After Advice.

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>

Wo,

  • PointCut-id - ID des PointCut.

  • methodName - Methodenname der Funktion, die nach einer aufgerufenen Funktion aufgerufen werden soll.

Um die oben genannten Konzepte im Zusammenhang mit After Advice zu verstehen, schreiben wir ein Beispiel, das After Advice implementiert. Um unser Beispiel mit wenigen Ratschlägen zu schreiben, lassen Sie uns eine funktionierende Eclipse-IDE einrichten und führen Sie die folgenden Schritte aus, um eine Spring-Anwendung zu erstellen.

Schritt Beschreibung
1 Aktualisieren Sie das unter Student Spring AOP - Application erstellte Projekt Student .
2 Aktualisieren Sie die Bean-Konfiguration und führen Sie die Anwendung wie unten erläutert aus.

Es folgt der Inhalt von Logging.javaDatei. Dies ist eigentlich ein Beispiel eines Aspektmoduls, das die Methoden definiert, die an verschiedenen Stellen aufgerufen werden sollen.

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

Es folgt der Inhalt der Student.java Datei.

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

Es folgt der Inhalt der MainApp.java Datei.

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

Es folgt die Konfigurationsdatei 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>

Führen Sie das Projekt aus

Führen Sie Ihre Anwendung aus, sobald Sie mit dem Erstellen der Quell- und Konfigurationsdateien fertig sind. Klicken Sie in Ihrer Anwendung mit der rechten Maustaste auf MainApp.java und verwenden Sierun as Java ApplicationBefehl. Wenn mit Ihrer Anwendung alles in Ordnung ist, wird die folgende Meldung gedruckt.

Name : Zara
Age : 11
Student profile setup complete.

Afterist ein Beratungstyp, der sicherstellt, dass ein Hinweis nach der Methodenausführung nur ausgeführt wird, wenn die Methode erfolgreich abgeschlossen wurde. Es folgt die Syntax von After Advice.

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>

Wo,

  • PointCut-id - ID des PointCut.

  • methodName - Methodenname der Funktion, die aufgerufen werden soll, nachdem eine aufgerufene Funktion erfolgreich zurückgegeben wurde.

Um die oben genannten Konzepte im Zusammenhang mit After Returning Advice zu verstehen, schreiben wir ein Beispiel, das After Returning Advice implementiert. Um unser Beispiel mit wenigen Ratschlägen zu schreiben, lassen Sie uns eine funktionierende Eclipse-IDE einrichten und führen Sie die folgenden Schritte aus, um eine Spring-Anwendung zu erstellen:

Schritt Beschreibung
1 Aktualisieren Sie das unter Student Spring AOP - Application erstellte Projekt Student .
2 Aktualisieren Sie die Bean-Konfiguration und führen Sie die Anwendung wie unten erläutert aus.

Es folgt der Inhalt von Logging.javaDatei. Dies ist eigentlich ein Beispiel eines Aspektmoduls, das die Methoden definiert, die an verschiedenen Stellen aufgerufen werden sollen.

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

Es folgt der Inhalt der Student.java Datei.

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

Es folgt der Inhalt der MainApp.java Datei.

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

Es folgt die Konfigurationsdatei 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>

Führen Sie das Projekt aus

Führen Sie Ihre Anwendung aus, sobald Sie die Quell- und Konfigurationsdateien erstellt haben. Klicken Sie in Ihrer Anwendung mit der rechten Maustaste auf MainApp.java und verwenden Sierun as Java ApplicationBefehl. Wenn mit Ihrer Anwendung alles in Ordnung ist, wird die folgende Meldung gedruckt.

Name : Zara
Returning : Name
Age : 11
Exception raised

After-throwingist ein Beratungstyp, der sicherstellt, dass ein Hinweis nach der Methodenausführung nur ausgeführt wird, wenn die Methode durch Auslösen einer Ausnahme beendet wird. Es folgt die Syntax der Ratschläge nach dem Werfen.

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>

Wo,

  • PointCut-id - ID des PointCut.

  • ex - Ausnahme zu werfen.

  • methodName - Methodenname der Funktion, die aufgerufen werden soll, wenn eine aufgerufene Funktion eine Ausnahme auslöst und beendet wird.

Um die oben genannten Konzepte im Zusammenhang mit After Throwing Advice zu verstehen, schreiben wir ein Beispiel, das After Throwing Advice implementiert. Um unser Beispiel mit wenigen Ratschlägen zu schreiben, lassen Sie uns eine funktionierende Eclipse-IDE einrichten und führen Sie die folgenden Schritte aus, um eine Spring-Anwendung zu erstellen:

Schritt Beschreibung
1 Aktualisieren Sie das unter Student Spring AOP - Application erstellte Projekt Student .
2 Aktualisieren Sie die Bean-Konfiguration und führen Sie die Anwendung wie unten erläutert aus.

Es folgt der Inhalt von Logging.javaDatei. Dies ist eigentlich ein Beispiel eines Aspektmoduls, das die Methoden definiert, die an verschiedenen Stellen aufgerufen werden sollen.

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

Es folgt der Inhalt der Student.java Datei.

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

Es folgt der Inhalt der MainApp.java Datei.

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

Es folgt die Konfigurationsdatei 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>

Führen Sie das Projekt aus

Führen Sie Ihre Anwendung aus, sobald Sie die Quell- und Konfigurationsdateien erstellt haben. Klicken Sie in Ihrer Anwendung mit der rechten Maustaste auf MainApp.java und verwenden Sierun as Java ApplicationBefehl. Wenn mit Ihrer Anwendung alles in Ordnung ist, wird die folgende Meldung gedruckt.

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)
	
   at com.tutorialspoint.Student$$FastClassBySpringCGLIB$$7dc55815.invoke(<generated>>)
	
   at org.springframework.cglib.proxy.MethodProxy.invoke(MethodProxy.java:204)
	
   at org.springframework.aop.framework.CglibAopProxy$CglibMethodInvocation.invokeJoinpoint(CglibAopProxy.java:717) at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:157) at org.springframework.aop.aspectj.AspectJAfterThrowingAdvice.invoke(AspectJAfterThrowingAdvice.java:58) at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:179) at org.springframework.aop.interceptor.ExposeInvocationInterceptor.invoke(ExposeInvocationInterceptor.java:92) at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:179) at org.springframework.aop.framework.CglibAopProxy$DynamicAdvisedInterceptor.intercept(CglibAopProxy.java:653)
	
   at com.tutorialspoint.Student$$EnhancerBySpringCGLIB$$8514cd8.printThrowException(<generated>)
	
   at com.tutorialspoint.MainApp.main(MainApp.java:15)

Aroundist ein Beratungstyp, der sicherstellt, dass ein Hinweis vor und nach der Ausführung der Methode ausgeführt wird. Im Folgenden finden Sie die Syntax von Around-Ratschlägen.

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>

Wo,

  • PointCut-id - ID des PointCut.

  • methodName - Methodenname der Funktion, die vor einer aufgerufenen Funktion aufgerufen werden soll.

Um die oben genannten Konzepte in Bezug auf Around Advice zu verstehen, schreiben wir ein Beispiel, das Around Advice implementiert. Um unser Beispiel mit wenigen Ratschlägen zu schreiben, lassen Sie uns eine funktionierende Eclipse-IDE einrichten und führen Sie die folgenden Schritte aus, um eine Spring-Anwendung zu erstellen:

Schritt Beschreibung
1 Aktualisieren Sie das unter Student Spring AOP - Application erstellte Projekt Student .
2 Aktualisieren Sie die Bean-Konfiguration und führen Sie die Anwendung wie unten erläutert aus.

Es folgt der Inhalt von Logging.javaDatei. Dies ist eigentlich ein Beispiel eines Aspektmoduls, das die Methoden definiert, die an verschiedenen Stellen aufgerufen werden sollen.

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

Es folgt der Inhalt der Student.java Datei.

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

Es folgt der Inhalt der MainApp.java Datei.

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

Es folgt die Konfigurationsdatei 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>

Führen Sie das Projekt aus

Führen Sie Ihre Anwendung aus, sobald Sie die Quell- und Konfigurationsdateien erstellt haben. Klicken Sie in Ihrer Anwendung mit der rechten Maustaste auf MainApp.java und verwenden Sierun as Java ApplicationBefehl. Wenn mit Ihrer Anwendung alles in Ordnung ist, wird die folgende Meldung gedruckt.

Around advice
Name : Zara
Returning Zara

Lassen Sie uns ein Beispiel schreiben, das Ratschläge unter Verwendung einer auf Anmerkungen basierenden Konfiguration implementiert. Lassen Sie uns dazu eine funktionierende Eclipse-IDE einrichten und führen Sie die folgenden Schritte aus, um eine Spring-Anwendung zu erstellen.

Schritt Beschreibung
1 Aktualisieren Sie das unter Student Spring AOP - Application erstellte Projekt Student .
2 Aktualisieren Sie die Bean-Konfiguration und führen Sie die Anwendung wie unten erläutert aus.

Es folgt der Inhalt von Logging.javaDatei. Dies ist eigentlich ein Beispiel eines Aspektmoduls, das die Methoden definiert, die an verschiedenen Stellen aufgerufen werden sollen.

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

Es folgt der Inhalt der Student.java Datei.

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

Es folgt der Inhalt der MainApp.java Datei.

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

Es folgt die Konfigurationsdatei 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>

Führen Sie das Projekt aus

Führen Sie Ihre Anwendung aus, sobald Sie die Quell- und Konfigurationsdateien erstellt haben. Klicken Sie in Ihrer Anwendung mit der rechten Maustaste auf MainApp.java und verwenden Sierun as Java ApplicationBefehl. Wenn mit Ihrer Anwendung alles in Ordnung ist, wird die folgende Meldung gedruckt.

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

JoinPoint

Ein JoinPoint stellt einen Punkt in Ihrer Anwendung dar, an dem Sie den AOP-Aspekt einbinden können. Sie können auch sagen, dass dies der tatsächliche Ort in der Anwendung ist, an dem mithilfe des Spring AOP-Frameworks eine Aktion ausgeführt wird. Betrachten Sie die folgenden Beispiele -

  • Alle in einem Paket enthaltenen Methodenklassen.

  • Eine bestimmte Methode einer Klasse.

PointCut

PointCut ist ein Satz von einem oder mehreren JoinPoint, in denen ein Rat ausgeführt werden soll. Sie können PointCuts mithilfe von Ausdrücken oder Mustern angeben, wie wir in unseren AOP-Beispielen sehen werden. Im Frühjahr hilft PointCut dabei, bestimmte JoinPoints zu verwenden, um die Ratschläge anzuwenden. Betrachten Sie die folgenden Beispiele -

  • @PointCut ("Ausführung (* com.tutorialspoint. *. * (..))")

  • @PointCut ("Ausführung (* com.tutorialspoint.Student.getName (..))")

Syntax

@Aspect
public class Logging {

   @PointCut("execution(* com.tutorialspoint.*.*(..))")
   private void selectAll(){}

}

Wo,

  • @Aspect - Markieren Sie eine Klasse als eine Klasse, die Beratungsmethoden enthält.

  • @PointCut - Markieren Sie eine Funktion als PointCut

  • execution( expression ) - Ausdruck, der Methoden abdeckt, auf die Ratschläge anzuwenden sind.

Um die oben genannten Konzepte in Bezug auf JoinPoint und PointCut zu verstehen, schreiben wir ein Beispiel, in dem einige der PointCuts implementiert werden. Um unser Beispiel mit wenigen Ratschlägen zu schreiben, lassen Sie uns eine funktionierende Eclipse-IDE einrichten und führen Sie die folgenden Schritte aus, um eine Spring-Anwendung zu erstellen:

Schritt Beschreibung
1 Aktualisieren Sie das unter Student Spring AOP - Application erstellte Projekt Student .
2 Aktualisieren Sie die Bean-Konfiguration und führen Sie die Anwendung wie unten erläutert aus.

Es folgt der Inhalt von Logging.javaDatei. Dies ist eigentlich ein Beispiel eines Aspektmoduls, das die Methoden definiert, die an verschiedenen Stellen aufgerufen werden sollen.

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

Es folgt der Inhalt der Student.java Datei.

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

Es folgt der Inhalt der MainApp.java Datei.

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

Es folgt die Konfigurationsdatei 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>

Führen Sie das Projekt aus

Führen Sie Ihre Anwendung aus, sobald Sie die Quell- und Konfigurationsdateien erstellt haben. Klicken Sie in Ihrer Anwendung mit der rechten Maustaste auf MainApp.java und verwenden Sierun as Java ApplicationBefehl. Wenn mit Ihrer Anwendung alles in Ordnung ist, wird die folgende Meldung gedruckt.

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

Der oben definierte @Pointcut verwendet einen Ausdruck, um alle unter dem Paket com.tutorialspoint definierten Methoden auszuwählen. @Before Advice verwendet den oben definierten PointCut als Parameter. Die Methode beforeAdvice () wird effektiv vor jeder Methode aufgerufen, die von PointCut oben behandelt wird.

@Beforeist ein Beratungstyp, der sicherstellt, dass ein Hinweis vor der Ausführung der Methode ausgeführt wird. Es folgt die Syntax von @Before Advice.

Syntax

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

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

Wo,

  • @PointCut - Markieren Sie eine Funktion als PointCut

  • execution( expression ) - Ausdruck, der Methoden abdeckt, auf die Ratschläge anzuwenden sind.

  • @Before - Markieren Sie eine Funktion als Hinweis, der vor den von PointCut abgedeckten Methoden ausgeführt werden soll.

Um die oben genannten Konzepte im Zusammenhang mit @Before Advice zu verstehen, schreiben wir ein Beispiel, das @Before Advice implementiert. Um unser Beispiel mit wenigen Ratschlägen zu schreiben, lassen Sie uns eine funktionierende Eclipse-IDE einrichten und führen Sie die folgenden Schritte aus, um eine Spring-Anwendung zu erstellen:

Schritt Beschreibung
1 Aktualisieren Sie das unter Student Spring AOP - Application erstellte Projekt Student .
2 Aktualisieren Sie die Bean-Konfiguration und führen Sie die Anwendung wie unten erläutert aus.

Es folgt der Inhalt von Logging.javaDatei. Dies ist eigentlich ein Beispiel eines Aspektmoduls, das die Methoden definiert, die an verschiedenen Stellen aufgerufen werden sollen.

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

Es folgt der Inhalt der Student.java Datei.

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

Es folgt der Inhalt der MainApp.java Datei.

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

Es folgt die Konfigurationsdatei 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>

Führen Sie das Projekt aus

Führen Sie Ihre Anwendung aus, sobald Sie die Quell- und Konfigurationsdateien erstellt haben. Klicken Sie in Ihrer Anwendung mit der rechten Maustaste auf MainApp.java und verwenden Sierun as Java ApplicationBefehl. Wenn mit Ihrer Anwendung alles in Ordnung ist, wird die folgende Meldung gedruckt.

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

Der oben definierte @Pointcut verwendet einen Ausdruck, um die in Klasse (n) unter dem Paket com.tutorialspoint definierte Methode getAge () auszuwählen. @After Beratung verwendet den oben definierten PointCut als Parameter. Die Methode afterAdvice () wird effektiv vor jeder Methode aufgerufen, die vom obigen PointCut abgedeckt wird.

@Afterist ein Beratungstyp, der sicherstellt, dass ein Hinweis nach der Ausführung der Methode ausgeführt wird. Es folgt die Syntax von @After Ratschlägen.

Syntax

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

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

Wo,

  • @PointCut - Markieren Sie eine Funktion als PointCut

  • execution( expression ) - Ausdruck, der Methoden abdeckt, auf die Ratschläge anzuwenden sind.

  • @After - Markieren Sie eine Funktion als Hinweis, der vor den von PointCut abgedeckten Methoden ausgeführt werden soll.

Um die oben genannten Konzepte im Zusammenhang mit @After Advice zu verstehen, schreiben wir ein Beispiel, das @After Advice implementiert. Um unser Beispiel mit wenigen Ratschlägen zu schreiben, lassen Sie uns eine funktionierende Eclipse-IDE einrichten und führen Sie die folgenden Schritte aus, um eine Spring-Anwendung zu erstellen.

Schritt Beschreibung
1 Aktualisieren Sie das unter Student Spring AOP - Application erstellte Projekt Student .
2 Aktualisieren Sie die Bean-Konfiguration und führen Sie die Anwendung wie unten erläutert aus.

Es folgt der Inhalt von Logging.javaDatei. Dies ist eigentlich ein Beispiel eines Aspektmoduls, das die Methoden definiert, die an verschiedenen Stellen aufgerufen werden sollen.

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

Es folgt der Inhalt der Student.java Datei.

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

Es folgt der Inhalt der MainApp.java Datei.

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

Es folgt die Konfigurationsdatei 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>

Führen Sie das Projekt aus

Führen Sie Ihre Anwendung aus, sobald Sie die Quell- und Konfigurationsdateien erstellt haben. Klicken Sie in Ihrer Anwendung mit der rechten Maustaste auf MainApp.java und verwenden Sierun as Java ApplicationBefehl. Wenn mit Ihrer Anwendung alles in Ordnung ist, wird die folgende Meldung gedruckt.

Name : Zara
Age : 11
Student profile setup completed.

Der oben definierte @Pointcut verwendet einen Ausdruck, um die in Klasse (n) unter dem Paket com.tutorialspoint definierte Methode getAge () auszuwählen. @After Beratung verwendet den oben definierten PointCut als Parameter. Die Methode afterAdvice () wird effektiv vor jeder Methode aufgerufen, die vom obigen PointCut abgedeckt wird.

@AfterReturningist ein Beratungstyp, der sicherstellt, dass ein Hinweis ausgeführt wird, nachdem die Methode erfolgreich ausgeführt wurde. Es folgt die Syntax des @ AfterReturning-Hinweises.

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

Wo,

  • @AfterReturning - Markieren Sie eine Funktion als Hinweis, der vor den von PointCut abgedeckten Methoden ausgeführt werden soll, wenn die Methode erfolgreich zurückgegeben wird.

  • PointCut - Stellt einen Ausdruck zur Auswahl einer Funktion bereit

  • execution( expression ) - Ausdruck, der Methoden abdeckt, auf die Ratschläge anzuwenden sind.

  • returning - Name der zurückzugebenden Variablen.

Um die oben genannten Konzepte im Zusammenhang mit @AfterReturning Advice zu verstehen, schreiben wir ein Beispiel, in dem @AfterReturning Advice implementiert wird. Um unser Beispiel mit wenigen Ratschlägen zu schreiben, lassen Sie uns eine funktionierende Eclipse-IDE einrichten und führen Sie die folgenden Schritte aus, um eine Spring-Anwendung zu erstellen.

Schritt Beschreibung
1 Aktualisieren Sie das unter Student Spring AOP - Application erstellte Projekt Student .
2 Aktualisieren Sie die Bean-Konfiguration und führen Sie die Anwendung wie unten erläutert aus.

Es folgt der Inhalt von Logging.javaDatei. Dies ist eigentlich ein Beispiel eines Aspektmoduls, das die Methoden definiert, die an verschiedenen Stellen aufgerufen werden sollen.

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

Es folgt der Inhalt der Student.java Datei.

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

Es folgt der Inhalt der MainApp.java Datei.

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

Es folgt die Konfigurationsdatei 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>

Führen Sie das Projekt aus

Führen Sie Ihre Anwendung aus, sobald Sie die Quell- und Konfigurationsdateien erstellt haben. Klicken Sie in Ihrer Anwendung mit der rechten Maustaste auf MainApp.java und verwenden Sierun as Java ApplicationBefehl. Wenn mit Ihrer Anwendung alles in Ordnung ist, wird die folgende Meldung gedruckt.

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

@AfterThrowingist ein Beratungstyp, der sicherstellt, dass ein Hinweis ausgeführt wird, wenn die Methode eine Ausnahme auslöst. Es folgt die Syntax des @ AfterThrowing-Hinweises.

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

Wo,

  • @AfterThrowing - Markieren Sie eine Funktion als Hinweis, der vor den von PointCut abgedeckten Methoden ausgeführt werden soll, wenn die Methode eine Ausnahme auslöst.

  • PointCut - Stellt einen Ausdruck zur Auswahl einer Funktion bereit.

  • execution( expression ) - Ausdruck, der Methoden abdeckt, auf die Ratschläge anzuwenden sind.

  • throwing - Name der zurückzugebenden Ausnahme.

Um die oben genannten Konzepte im Zusammenhang mit @AfterThrowing Advice zu verstehen, schreiben wir ein Beispiel, das @AfterThrowing Advice implementiert. Um unser Beispiel mit wenigen Ratschlägen zu schreiben, lassen Sie uns eine funktionierende Eclipse-IDE einrichten und führen Sie die folgenden Schritte aus, um eine Spring-Anwendung zu erstellen.

Schritt Beschreibung
1 Aktualisieren Sie das unter Student Spring AOP - Application erstellte Projekt Student .
2 Aktualisieren Sie die Bean-Konfiguration und führen Sie die Anwendung wie unten erläutert aus.

Es folgt der Inhalt von Logging.javaDatei. Dies ist eigentlich ein Beispiel eines Aspektmoduls, das die Methoden definiert, die an verschiedenen Stellen aufgerufen werden sollen.

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

Es folgt der Inhalt der Student.java Datei.

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

Es folgt der Inhalt der MainApp.java Datei.

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

Es folgt die Konfigurationsdatei 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>

Führen Sie das Projekt aus

Führen Sie Ihre Anwendung aus, sobald Sie die Quell- und Konfigurationsdateien erstellt haben. Klicken Sie in Ihrer Anwendung mit der rechten Maustaste auf MainApp.java und verwenden Sierun as Java ApplicationBefehl. Wenn mit Ihrer Anwendung alles in Ordnung ist, wird die folgende Meldung gedruckt.

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)
   
   at com.tutorialspoint.Student$$FastClassBySpringCGLIB$$7dc55815.invoke(<generated>)
   
   at org.springframework.cglib.proxy.MethodProxy.invoke(MethodProxy.java:204)
   
   at org.springframework.aop.framework.CglibAopProxy$CglibMethodInvocation.invokeJoinpoint(CglibAopProxy.java:717) at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:157) at org.springframework.aop.aspectj.AspectJAfterThrowingAdvice.invoke(AspectJAfterThrowingAdvice.java:58) at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:179) at org.springframework.aop.interceptor.ExposeInvocationInterceptor.invoke(ExposeInvocationInterceptor.java:92) at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:179) at org.springframework.aop.framework.CglibAopProxy$DynamicAdvisedInterceptor.intercept(CglibAopProxy.java:653)
   
   at com.tutorialspoint.Student$$EnhancerBySpringCGLIB$$99b0a988.printThrowException(<generated>)
   
   at com.tutorialspoint.MainApp.main(MainApp.java:13)

@Aroundist ein Beratungstyp, der sicherstellt, dass ein Hinweis vor und nach der Ausführung der Methode ausgeführt werden kann. Es folgt die Syntax des @ Round-Hinweises.

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

Wo,

  • @PointCut - Markieren Sie eine Funktion als PointCut

  • execution( expression ) - Ausdruck, der Methoden abdeckt, auf die Ratschläge anzuwenden sind.

  • @Around - Markieren Sie eine Funktion als Hinweis, der vor den von PointCut abgedeckten Methoden ausgeführt werden soll.

Um die oben genannten Konzepte in Bezug auf @Around Advice zu verstehen, schreiben wir ein Beispiel, das @Around Advice implementiert. Um unser Beispiel mit wenigen Ratschlägen zu schreiben, lassen Sie uns eine funktionierende Eclipse-IDE einrichten und führen Sie die folgenden Schritte aus, um eine Spring-Anwendung zu erstellen:

Schritt Beschreibung
1 Aktualisieren Sie das unter Student Spring AOP - Application erstellte Projekt Student .
2 Aktualisieren Sie die Bean-Konfiguration und führen Sie die Anwendung wie unten erläutert aus.

Es folgt der Inhalt von Logging.javaDatei. Dies ist eigentlich ein Beispiel eines Aspektmoduls, das die Methoden definiert, die an verschiedenen Stellen aufgerufen werden sollen.

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

Es folgt der Inhalt der Student.java Datei.

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

Es folgt der Inhalt der MainApp.java Datei.

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

Es folgt die Konfigurationsdatei 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>

Führen Sie das Projekt aus

Führen Sie Ihre Anwendung aus, sobald Sie die Quell- und Konfigurationsdateien erstellt haben. Klicken Sie in Ihrer Anwendung mit der rechten Maustaste auf MainApp.java und verwenden Sierun as Java ApplicationBefehl. Wenn mit Ihrer Anwendung alles in Ordnung ist, wird die folgende Meldung gedruckt.

Around advice
Age : 11
Returning 11

Bisher haben wir Aspekte mit deklariert <aop:config> oder < aop:aspectj-autoproxy>. Wir können einen Proxy programmgesteuert erstellen und die Aspekte mithilfe des Proxy-Objekts programmgesteuert aufrufen.

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

Wo,

  • AspectJProxyFactory - Factory-Klasse zum Erstellen eines Proxy-Objekts.

  • Logging.class - Klasse des Aspekts mit Ratschlägen.

  • Student - Business Class zu beraten.

Um die oben genannten Konzepte in Bezug auf Proxy zu verstehen, schreiben wir ein Beispiel, das Proxy implementiert. Um unser Beispiel mit wenigen Ratschlägen zu schreiben, lassen Sie uns eine funktionierende Eclipse-IDE einrichten und führen Sie die folgenden Schritte aus, um eine Spring-Anwendung zu erstellen:

Schritt Beschreibung
1 Aktualisieren Sie das unter Student Spring AOP - Application erstellte Projekt Student .
2 Aktualisieren Sie die Bean-Konfiguration und führen Sie die Anwendung wie unten erläutert aus.

Es folgt der Inhalt von Logging.javaDatei. Dies ist eigentlich ein Beispiel eines Aspektmoduls, das die Methoden definiert, die an verschiedenen Stellen aufgerufen werden sollen.

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

Es folgt der Inhalt der Student.java Datei.

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

Es folgt der Inhalt der MainApp.java Datei.

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

Es folgt die Konfigurationsdatei 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>

Führen Sie das Projekt aus

Führen Sie Ihre Anwendung aus, sobald Sie die Quell- und Konfigurationsdateien erstellt haben. Klicken Sie in Ihrer Anwendung mit der rechten Maustaste auf MainApp.java und verwenden Sierun as Java ApplicationBefehl. Wenn mit Ihrer Anwendung alles in Ordnung ist, wird die folgende Meldung gedruckt.

Going to setup student profile.
Age : 11

Gemäß PointCut-Ausdrücken kann es vorkommen, dass sie auf einige andere Beans angewendet werden, für die keine Beratung vorgesehen ist. Betrachten Sie beispielsweise den folgenden Ausdruck.

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

Mit der Methode getAge () wird eine neue Spring Bean hinzugefügt, und der Rat wird darauf angewendet, obwohl dies möglicherweise nicht beabsichtigt ist. Um dies zu erreichen, können wir eine benutzerdefinierte Anmerkung erstellen und die Methoden mit Anmerkungen versehen, auf die der Rat angewendet werden soll.

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

Um die oben genannten Konzepte im Zusammenhang mit @Before Advice zu verstehen, schreiben wir ein Beispiel, das @Before Advice implementiert. Um unser Beispiel mit wenigen Ratschlägen zu schreiben, lassen Sie uns eine funktionierende Eclipse-IDE einrichten und führen Sie die folgenden Schritte aus, um eine Spring-Anwendung zu erstellen.

Schritt Beschreibung
1 Aktualisieren Sie das unter Student Spring AOP - Application erstellte Projekt Student .
2 Aktualisieren Sie die Bean-Konfiguration und führen Sie die Anwendung wie unten erläutert aus.

Es folgt der Inhalt von Logging.javaDatei. Dies ist eigentlich ein Beispiel eines Aspektmoduls, das die Methoden definiert, die an verschiedenen Stellen aufgerufen werden sollen.

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

Es folgt der Inhalt der Loggable.java Datei -

package com.tutorialspoint;

public @interface Loggable {

}

Es folgt der Inhalt der Student.java Datei.

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

Es folgt der Inhalt der MainApp.java Datei.

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

Es folgt die Konfigurationsdatei 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>

Führen Sie das Projekt aus

Führen Sie Ihre Anwendung aus, sobald Sie die Quell- und Konfigurationsdateien erstellt haben. Klicken Sie in Ihrer Anwendung mit der rechten Maustaste auf MainApp.java und verwenden Sierun as Java ApplicationBefehl. Wenn mit Ihrer Anwendung alles in Ordnung ist, wird die folgende Meldung gedruckt.

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