Spring AOP - Krótki przewodnik

Jednym z kluczowych składników Spring Framework jest Aspect Oriented Programming (AOP)struktura. Programowanie zorientowane na aspekt polega na rozbiciu logiki programu na odrębne części zwaneso-called concerns. Funkcje obejmujące wiele punktów aplikacji nazywane są zagadnieniami przekrojowymi. Tecross-cutting concernssą koncepcyjnie oddzielone od logiki biznesowej aplikacji. Istnieje wiele typowych dobrych przykładów aspektów, takich jak logowanie, audyt, transakcje deklaratywne, bezpieczeństwo, buforowanie itp.

Kluczową jednostką modułowości w OOP jest klasa, podczas gdy w AOP jednostką modułowości jest aspekt. Dependency Injection pomaga oddzielić obiekty aplikacji od siebie, a AOP pomaga oddzielić problemy związane z cięciem krzyżowym od obiektów, na które mają one wpływ. AOP jest jak wyzwalacze w językach programowania, takich jak Perl, .NET, Java i inne.

Moduł Spring AOP pozwala przechwytywaczom przechwycić aplikację. Na przykład, gdy metoda jest wykonywana, możesz dodać dodatkowe funkcje przed lub po wykonaniu metody.

Ten rozdział przedstawia proces konfigurowania Spring AOP w systemach opartych na Windows i Linux. Spring AOP można łatwo zainstalować i zintegrować z aktualnym środowiskiem Java i MAVEN, wykonując kilka prostych kroków bez skomplikowanych procedur konfiguracyjnych. Administracja użytkownikami jest wymagana podczas instalacji.

wymagania systemowe

JDK	Java SE 2 JDK 1.5 lub nowsza
Pamięć	1 GB RAM (zalecane)
Miejsca na dysku	Brak minimalnych wymagań
Wersja systemu operacyjnego	Windows XP lub nowszy, Linux

Przyjrzyjmy się teraz krokom instalacji Spring AOP.

Krok 1: Zweryfikuj instalację Java

Przede wszystkim musisz mieć zainstalowany zestaw Java Software Development Kit (SDK) w swoim systemie. Aby to sprawdzić, wykonaj dowolne z następujących dwóch poleceń w zależności od platformy, na której pracujesz.

Jeśli instalacja Java została wykonana poprawnie, wyświetli się aktualna wersja i specyfikacja instalacji Java. Przykładowe dane wyjściowe podano w poniższej tabeli.

Platforma	Komenda	Przykładowe wyjście
Windows	Otwórz konsolę poleceń i wpisz - \>java -version	Wersja Java „1.7.0_60” Środowisko wykonawcze Java (TM) SE (kompilacja 1.7.0_60-b19) Java Hotspot (TM) 64-bitowa maszyna wirtualna serwera (kompilacja 24.60-b09, tryb mieszany)
Linux	Otwórz terminal poleceń i wpisz - $java -version	wersja java „1.7.0_25” Otwórz środowisko wykonawcze JDK (rhel-2.3.10.4.el6_4-x86_64) Otwórz 64-bitową maszynę wirtualną serwera JDK (kompilacja 23.7-b01, tryb mieszany)

Zakładamy, że czytelnicy tego samouczka mają zainstalowany pakiet Java SDK w wersji 1.7.0_60 w swoim systemie.

Jeśli nie masz Java SDK, pobierz jego aktualną wersję z https://www.oracle.com/technetwork/java/javase/downloads/index.html i zainstaluj.

Krok 2: Skonfiguruj środowisko Java

Ustaw zmienną środowiskową JAVA_HOME, aby wskazywała lokalizację katalogu podstawowego, w którym na komputerze jest zainstalowana Java. Na przykład,

Sr.No.	Platforma i opis
1	Windows Ustaw JAVA_HOME na C: \ ProgramFiles \ java \ jdk1.7.0_60
2	Linux Eksportuj JAVA_HOME = / usr / local / java-current

Dołącz pełną ścieżkę lokalizacji kompilatora Java do ścieżki systemowej.

Sr.No.	Platforma i opis
1	Windows Dołącz ciąg „C: \ Program Files \ Java \ jdk1.7.0_60 \ bin” na końcu zmiennej systemowej Path.
2	Linux Export PATH = $ PATH: $ JAVA_HOME / bin /

Wykonaj polecenie java -version z wiersza polecenia, jak wyjaśniono powyżej.

Krok 3: Pobierz archiwum Maven

Pobierz Maven 3.3.3 z https://maven.apache.org/download.cgi

OS	Nazwa archiwum
Windows	apache-maven-3.3.3-bin.zip
Linux	apache-maven-3.3.3-bin.tar.gz
Prochowiec	apache-maven-3.3.3-bin.tar.gz

Krok 4: Rozpakuj archiwum Mavena

Wypakuj archiwum do katalogu, w którym chcesz zainstalować Maven 3.3.3. Z archiwum zostanie utworzony podkatalog apache-maven-3.3.3.

OS	Lokalizacja (może się różnić w zależności od instalacji)
Windows	C: \ Program Files \ Apache Software Foundation \ apache-maven-3.3.3
Linux	/ usr / local / apache-maven
Prochowiec	/ usr / local / apache-maven

Krok 5: Ustaw zmienne środowiskowe Mavena

Dodaj M2_HOME, M2, MAVEN_OPTS do zmiennych środowiskowych.

OS	Wynik
Windows	Ustaw zmienne środowiskowe za pomocą właściwości systemowych. M2_HOME = C: \ Program Files \ Apache Software Foundation \ apache-maven-3.3.3 M2 =% M2_HOME% \ bin MAVEN_OPTS = -Xms256m -Xmx512m
Linux	Otwórz terminal poleceń i ustaw zmienne środowiskowe. eksport M2_HOME = /usr/local/apache-maven/apache-maven-3.3.3 eksport M2 = $ M2_HOME / bin eksport MAVEN_OPTS = -Xms256m -Xmx512m
Prochowiec	Otwórz terminal poleceń i ustaw zmienne środowiskowe. eksport M2_HOME = /usr/local/apache-maven/apache-maven-3.3.3 eksport M2 = $ M2_HOME / bin eksport MAVEN_OPTS = -Xms256m -Xmx512m

Krok 6: Dodaj lokalizację katalogu Maven Bin do ścieżki systemowej

Teraz dołącz zmienną M2 do ścieżki systemowej.

OS	Wynik
Windows	Dołącz ciąg;% M2% na końcu zmiennej systemowej, Path.
Linux	export PATH = $ M2: $ PATH
Prochowiec	export PATH = $ M2: $ PATH

Krok 7: Sprawdź instalację Mavena

Teraz otwórz konsolę i wykonaj następujące czynności mvn Komenda.

OS	Zadanie	Komenda
Windows	Otwórz konsolę poleceń	c: \> mvn --version
Linux	Otwórz terminal poleceń	$ mvn --version
Prochowiec	Otwórz terminal	maszyna: <joseph $ mvn --version

Na koniec sprawdź wyjście powyższych poleceń, które powinno wyglądać następująco -

OS	Wynik
Windows	Apache Maven 3.3.3 (7994120775791599e205a5524ec3e0dfe41d4a06; 2015-04-22T17: 27: 37 + 05: 30) Strona główna Mavena: C: \ Program Files \ Apache Software Foundation \ apache-maven-3.3.3 Wersja Java: 1.7.0_75, producent: Oracle Corporation Strona główna Java: C: \ Program Files \ Java \ jdk1.7.0_75 \ jre Domyślne ustawienia regionalne: en_US, kodowanie platformy: Cp1252
Linux	Apache Maven 3.3.3 (7994120775791599e205a5524ec3e0dfe41d4a06; 2015-04-22T17: 27: 37 + 05: 30) Strona główna Mavena: /usr/local/apache-maven/apache-maven-3.3.3 Wersja Java: 1.7.0_75, producent: Oracle Corporation Strona główna Java: /usr/local/java-current/jdk1.7.0_75/jre
Prochowiec	Apache Maven 3.3.3 (7994120775791599e205a5524ec3e0dfe41d4a06; 2015-04-22T17: 27: 37 + 05: 30) Strona główna Mavena: /usr/local/apache-maven/apache-maven-3.3.3 Wersja Java: 1.7.0_75, producent: Oracle Corporation Strona główna Java: /Library/Java/Home/jdk1.7.0_75/jre

Krok 8 - Skonfiguruj Eclipse IDE

Wszystkie przykłady w tym samouczku zostały napisane przy użyciu Eclipse IDE. Sugerowałbym więc, abyś miał zainstalowaną najnowszą wersję Eclipse na swoim komputerze.

Aby zainstalować Eclipse IDE, pobierz najnowsze pliki binarne Eclipse z https://www.eclipse.org/downloads/. Po pobraniu instalacji rozpakuj dystrybucję binarną w dogodnej lokalizacji. Na przykład w C: \ eclipse w systemie Windows lub / usr / local / eclipse w systemie Linux / Unix i na koniec ustaw odpowiednio zmienną PATH.

Eclipse można uruchomić, wykonując następujące polecenia na komputerze z systemem Windows lub klikając dwukrotnie plik eclipse.exe

%C:\eclipse\eclipse.exe

Eclipse można uruchomić, wykonując następujące polecenia na komputerze z systemem Unix (Solaris, Linux itp.) -

$/usr/local/eclipse/eclipse

Po udanym uruchomieniu, jeśli wszystko jest w porządku, powinien wyświetlić następujący wynik -

Kiedy skończysz z ostatnim krokiem, możesz przejść do pierwszego przykładu AOP, który zobaczysz w następnym rozdziale.

Zanim zaczniemy pracę z AOP, zapoznajmy się z pojęciami i terminologią AOP. Te terminy nie są specyficzne dla Springa, są raczej związane z AOP.

Sr.No.	Warunki i opis
1	Aspect Moduł zawierający zestaw interfejsów API zapewniających wymagania przekrojowe. Na przykład moduł rejestrowania będzie nazywał się aspektem AOP do rejestrowania. Aplikacja może mieć wiele aspektów w zależności od wymagań.
2	Join point Stanowi to punkt w aplikacji, w którym można podłączyć aspekt AOP. Można też powiedzieć, że jest to rzeczywiste miejsce w aplikacji, w którym zostanie wykonana akcja z wykorzystaniem frameworka Spring AOP.
3	Advice Jest to rzeczywista akcja, która ma zostać podjęta przed lub po wykonaniu metody. To jest rzeczywisty fragment kodu, który jest wywoływany podczas wykonywania programu przez framework Spring AOP.
4	PointCut Jest to zestaw jednego lub więcej punktów złączenia, w których należy wykonać poradę. Możesz określić PointCuts za pomocą wyrażeń lub wzorców, jak zobaczymy w naszych przykładach AOP.
5	Introduction Wprowadzenie pozwala na dodanie nowych metod lub atrybutów do istniejących klas.
6	Target object Obiekt, na który zwraca uwagę jeden lub więcej aspektów. Ten obiekt zawsze będzie obiektem proxy. Nazywany również polecanym obiektem.
7	Weaving Tkanie to proces łączenia aspektów z innymi typami aplikacji lub obiektami w celu stworzenia zalecanego obiektu. Można to zrobić w czasie kompilacji, wczytywania lub w czasie wykonywania.

Aspekty wiosenne mogą działać z pięcioma rodzajami porad wymienionych w poniższej tabeli.

Sr.No.	Porady i opis
1	before Uruchom poradę przed wykonaniem metody.
2	after Uruchom poradę po wykonaniu metody, niezależnie od jej wyniku.
3	after-returning Uruchom poradę po wykonaniu metody, tylko jeśli metoda zakończy się pomyślnie.
4	after-throwing Uruchom poradę po wykonaniu metody, tylko jeśli metoda kończy działanie przez zgłoszenie wyjątku.
5	around Uruchom poradę przed i po wywołaniu zalecanej metody.

Wiosna wspiera @AspectJ annotation style podejście i schema-based podejście do wdrażania niestandardowych aspektów.

Oparte na schemacie XML

Aspekty są implementowane przy użyciu zwykłych klas wraz z konfiguracją opartą na XML.

Aby użyć znaczników przestrzeni nazw AOP opisanych w tej sekcji, musisz zaimportować schemat sprężynowego AOP, opisany w następujący sposób -

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

Deklarowanie aspektu

Na aspect jest deklarowana przy użyciu <aop:aspect> element, a do fasoli zapasowej odwołuje się przy użyciu ref atrybut w następujący sposób.

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

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

Tutaj "aBean" zostanie skonfigurowany i wstawiony zależność, tak jak każdy inny komponent Spring Bean, jak widzieliśmy w poprzednich rozdziałach.

Deklarowanie PointCut

ZA PointCutpomaga w określaniu punktów złączenia (tj. metod), które mają być wykonane, z różnymi radami. Podczas pracy z konfiguracją opartą na schemacie XML PointCut zostanie zdefiniowany w następujący sposób -

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

Poniższy przykład definiuje PointCut o nazwie „businessService”, który będzie pasował do metody getName () dostępnej w klasie Student w pakiecie 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>

Deklarowanie porad

Możesz zadeklarować dowolną z pięciu porad wewnątrz <aop: aspekt> za pomocą elementu <aop: {NAZWA PORADY}> w następujący sposób.

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

Możesz użyć tego samego doRequiredTasklub różne metody dla różnych porad. Metody te zostaną zdefiniowane jako część modułu aspektów.

Oparty na @AspectJ

@AspectJ odnosi się do stylu deklarowania aspektów jako zwykłych klas Java z adnotacjami Java 5. Obsługa @AspectJ jest włączana przez włączenie następującego elementu do pliku konfiguracyjnego opartego na schemacie XML.

<aop:aspectj-autoproxy/>

Deklarowanie aspektu

Klasy aspektów są podobne do innych normalnych beanów i mogą mieć metody i pola tak jak każda inna klasa, z tym wyjątkiem, że zostaną opatrzone adnotacją @Aspect w następujący sposób.

package org.xyz;

import org.aspectj.lang.annotation.Aspect;

@Aspect
public class AspectModule {

}

Zostaną skonfigurowane w XML, jak każdy inny bean w następujący sposób.

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

Deklarowanie PointCut

ZA PointCutpomaga w określaniu punktów złączenia (tj. metod), które mają być wykonane, z różnymi radami. Podczas pracy z konfiguracją opartą na @AspectJ, deklaracja PointCut składa się z dwóch części -

Wyrażenie PointCut, które dokładnie określa, które wykonania metod nas interesują.
Podpis PointCut zawierający nazwę i dowolną liczbę parametrów. Rzeczywista treść metody jest nieistotna i w rzeczywistości powinna być pusta.

Poniższy przykład definiuje PointCut o nazwie „businessService”, który będzie pasował do wykonania każdej metody dostępnej w klasach w pakiecie com.xyz.myapp.service.

import org.aspectj.lang.annotation.PointCut;

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

Poniższy przykład definiuje PointCut o nazwie „getname”, który będzie pasował do metody getName () dostępnej w klasie Student w pakiecie com.tutorialspoint.

import org.aspectj.lang.annotation.PointCut;

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

Deklarowanie porad

Możesz zadeklarować dowolną z pięciu porad za pomocą adnotacji @ {ADVICE-NAME}, jak podano poniżej. Zakłada się, że zdefiniowano już metodę podpisu BusinessService () PointCut.

@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(){
   ...
}

Możesz zdefiniować PointCut w tekście dla dowolnej porady. Poniżej znajduje się przykład definiowania inline PointCut przed poradą.

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

W tym rozdziale będziemy pisać rzeczywiste aplikacje AOP przy użyciu Spring AOP Framework. Zanim zaczniesz pisać swój pierwszy przykład przy użyciu frameworka Spring-WS, musisz upewnić się, że środowisko Spring AOP zostało poprawnie skonfigurowane, jak wyjaśniono w rozdziale Spring Web Services - Konfiguracja środowiska .

Teraz przystąp do pisania prostej konsoli Spring AOP Application, która zademonstruje koncepcje AOP.

Utwórz projekt

Step 1 - Otwórz konsolę poleceń, przejdź do katalogu C: \ MVN i wykonaj następujące czynności mvn Komenda.

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

Maven rozpocznie przetwarzanie i utworzy pełną strukturę projektu aplikacji Java.

[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- Przejdź do katalogu C: / MVN. Zobaczysz utworzony projekt aplikacji Java o nazwie student (zgodnie z artifactId). Zaktualizuj plik POM.xml, aby uwzględnić zależności Spring-AOP. Dodaj pliki MainApp.java, Student.java i Logging.java.

POM.xml

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

Poniżej znajduje się zawartość Student.java plik.

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

Poniżej znajduje się zawartość MainApp.java plik.

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 - Dodaj plik konfiguracyjny Beans.xml pod src > main > resources teczka.

<?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 - Otwórz konsolę poleceń, przejdź do katalogu C: \ MVN i wykonaj następujące czynności mvn Komenda.

C:\MVN>Student> mvn package

Maven rozpocznie przetwarzanie i pobieranie wymaganych bibliotek.

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

Importuj projekt w Eclipse

Step 1 - Otwórz Eclipse.

Step 2 - Wybierz File → Import → opcja.

Step 3- Wybierz opcję Maven Projekty. Kliknij przycisk Dalej.

Step 4 - Wybierz lokalizację projektu, w której projekt Studenta został utworzony za pomocą Mavena.

Step 5 - Kliknij przycisk Zakończ.

Uruchom projekt

Po utworzeniu plików źródłowych i konfiguracyjnych uruchom aplikację. Kliknij prawym przyciskiem myszy MainApp.java w swojej aplikacji i użyjrun as Java ApplicationKomenda. Jeśli wszystko jest w porządku z Twoją aplikacją, wydrukuje następujący komunikat.

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)

Dołącz do punktu

JoinPoint reprezentuje punkt w aplikacji, w którym można podłączyć aspekt AOP. Można też powiedzieć, że jest to rzeczywiste miejsce w aplikacji, w którym zostanie wykonana akcja z wykorzystaniem frameworka Spring AOP. Rozważ następujące przykłady -

Wszystkie klasy metod zawarte w pakiecie (pakietach).
Konkretne metody klasy.

PointCut

PointCut to zestaw jednego lub więcej punktów JoinPoint, w których należy wykonać poradę. Możesz określić PointCuts za pomocą wyrażeń lub wzorców, jak zobaczymy w naszych przykładach AOP. Wiosną PointCut pomaga wykorzystać konkretne JoinPoints do zastosowania się do porady. Rozważ następujące przykłady -

wyrażenie = "wykonanie (* com.tutorialspoint. *. * (..))"
wyrażenie = "wykonanie (* com.tutorialspoint.Student.getName (..))"

Składnia

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

Gdzie,

adviceClass - ref klasy zawierającej metody doradcze
PointCut-id - identyfikator PointCut
execution( expression ) - Wyrażenie obejmujące metody, w odniesieniu do których mają być stosowane porady.

Aby zrozumieć powyższe koncepcje związane z JoinPoint i PointCut, napiszmy przykład, który zaimplementuje kilka PointCuts. Aby napisać nasz przykład z kilkoma radami, przygotujmy działające środowisko Eclipse IDE i wykonaj następujące kroki, aby utworzyć aplikację Spring.

Krok	Opis
1	Zaktualizuj projekt Studenta utworzony w rozdziale Wiosna AOP - Aplikacja .
2	Zaktualizuj konfigurację fasoli i uruchom aplikację, jak wyjaśniono poniżej.

Poniżej znajduje się treść Logging.javaplik. W rzeczywistości jest to przykład modułu aspektu, który definiuje metody, które mają być wywoływane w różnych punktach.

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

Poniżej znajduje się zawartość Student.java plik.

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

Poniżej znajduje się zawartość MainApp.java plik.

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

Poniżej znajduje się plik konfiguracyjny 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>

Po utworzeniu plików źródłowych i konfiguracyjnych komponentów bean uruchom aplikację. Jeśli wszystko jest w porządku z Twoją aplikacją, wydrukuje następujący komunikat.

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

Zdefiniowane powyżej <aop: pointcut> wybiera wszystkie metody zdefiniowane w pakiecie com.tutorialspoint. Załóżmy, że chcesz wykonać swoją radę przed lub po określonej metodzie, możesz zdefiniować PointCut, aby zawęzić wykonanie, zastępując gwiazdki (*) w definicji PointCut rzeczywistymi nazwami klas i metod. Poniżej znajduje się zmodyfikowany plik konfiguracyjny XML, aby pokazać koncepcję.

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

Uruchom projekt

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

Beforejest typem porady, który zapewnia, że porada zostanie uruchomiona przed wykonaniem metody. Poniżej przedstawiono składnię funkcji przed poradą.

Składnia

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

Gdzie,

PointCut-id - identyfikator PointCut.
methodName - nazwa metody funkcji, która ma zostać wywołana przed wywołaną funkcją.

Aby zrozumieć powyższe koncepcje związane z Before Advice, napiszmy przykład, który zaimplementuje Before Advice. Aby napisać nasz przykład z kilkoma radami, przygotujmy działające środowisko Eclipse IDE i wykonaj następujące kroki, aby utworzyć aplikację Spring.

Krok	Opis
1	Zaktualizuj projekt Studenta utworzony w rozdziale Wiosna AOP - Aplikacja .
2	Zaktualizuj konfigurację fasoli i uruchom aplikację, jak wyjaśniono poniżej.

Poniżej znajduje się treść Logging.javaplik. W rzeczywistości jest to przykład modułu aspektu, który definiuje metody, które mają być wywoływane w różnych punktach.

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

Poniżej znajduje się zawartość Student.java plik.

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

Poniżej znajduje się zawartość MainApp.java plik.

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

Poniżej znajduje się plik konfiguracyjny 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>

Uruchom projekt

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

Afterjest typem porady, który zapewnia, że porada zostanie uruchomiona po wykonaniu metody. Poniżej znajduje się składnia porady po.

Składnia

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

Gdzie,

PointCut-id - identyfikator PointCut.
methodName - nazwa metody funkcji, która ma zostać wywołana po wywołanej funkcji.

Aby zrozumieć powyższe koncepcje związane z After Advice, napiszmy przykład, który zaimplementuje After Advice. Aby napisać nasz przykład z kilkoma radami, przygotujmy działające środowisko Eclipse IDE i wykonaj następujące kroki, aby utworzyć aplikację Spring.

Krok	Opis
1	Zaktualizuj projekt Studenta utworzony w rozdziale Wiosna AOP - Aplikacja .
2	Zaktualizuj konfigurację fasoli i uruchom aplikację, jak wyjaśniono poniżej.

Poniżej znajduje się treść Logging.javaplik. W rzeczywistości jest to przykład modułu aspektu, który definiuje metody, które mają być wywoływane w różnych punktach.

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

Poniżej znajduje się zawartość Student.java plik.

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

Poniżej znajduje się zawartość MainApp.java plik.

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

Poniżej znajduje się plik konfiguracyjny 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>

Uruchom projekt

Name : Zara
Age : 11
Student profile setup complete.

Afterjest typem porady, który zapewnia, że porada zostanie uruchomiona po wykonaniu metody tylko wtedy, gdy metoda zakończy się pomyślnie. Poniżej znajduje się składnia porady po.

Składnia

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

Gdzie,

PointCut-id - identyfikator PointCut.
methodName - Nazwa metody funkcji, która ma zostać wywołana po pomyślnym zakończeniu wywoływanej funkcji.

Aby zrozumieć powyższe pojęcia związane z poradą po zwrocie, napiszmy przykład, który będzie realizował poradę po zwrocie. Aby napisać nasz przykład z kilkoma radami, przygotujmy działające środowisko Eclipse IDE i wykonaj następujące kroki, aby utworzyć aplikację Spring -

Krok	Opis
1	Zaktualizuj projekt Studenta utworzony w rozdziale Wiosna AOP - Aplikacja .
2	Zaktualizuj konfigurację fasoli i uruchom aplikację, jak wyjaśniono poniżej.

Poniżej znajduje się treść Logging.javaplik. W rzeczywistości jest to przykład modułu aspektu, który definiuje metody, które mają być wywoływane w różnych punktach.

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

Poniżej znajduje się zawartość Student.java plik.

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

Poniżej znajduje się zawartość MainApp.java plik.

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

Poniżej znajduje się plik konfiguracyjny 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>

Uruchom projekt

Name : Zara
Returning : Name
Age : 11
Exception raised

After-throwingjest typem porady, który zapewnia, że porada zostanie uruchomiona po wykonaniu metody, tylko wtedy, gdy metoda zakończy działanie przez zgłoszenie wyjątku. Poniżej znajduje się składnia porad po rzuceniu.

Składnia

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

Gdzie,

PointCut-id - identyfikator PointCut.
ex - Wyjątek do wyrzucenia.
methodName - Nazwa metody funkcji, która ma zostać wywołana, gdy wywoływana funkcja zgłasza wyjątek i kończy działanie.

Aby zrozumieć wspomniane wyżej pojęcia związane z poradą po rzucie, napiszmy przykład, który będzie implementował porady po rzucie. Aby napisać nasz przykład z kilkoma radami, przygotujmy działające środowisko Eclipse IDE i wykonaj następujące kroki, aby utworzyć aplikację Spring -

Krok	Opis
1	Zaktualizuj projekt Studenta utworzony w rozdziale Wiosna AOP - Aplikacja .
2	Zaktualizuj konfigurację fasoli i uruchom aplikację, jak wyjaśniono poniżej.

Poniżej znajduje się treść Logging.javaplik. W rzeczywistości jest to przykład modułu aspektu, który definiuje metody, które mają być wywoływane w różnych punktach.

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

Poniżej znajduje się zawartość Student.java plik.

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

Poniżej znajduje się zawartość MainApp.java plik.

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

Poniżej znajduje się plik konfiguracyjny 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>

Uruchom projekt

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)

Aroundjest typem porady, który zapewnia, że porada jest uruchamiana przed i po wykonaniu metody. Poniżej znajduje się składnia rady.

Składnia

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

Gdzie,

PointCut-id - identyfikator PointCut.
methodName - nazwa metody funkcji, która ma zostać wywołana przed wywołaną funkcją.

Aby zrozumieć powyższe koncepcje związane z Dookoła Doradztwa, napiszmy przykład, który zaimplementuje Dookoła Doradztwo. Aby napisać nasz przykład z kilkoma radami, przygotujmy działające środowisko Eclipse IDE i wykonaj następujące kroki, aby utworzyć aplikację Spring -

Krok	Opis
1	Zaktualizuj projekt Studenta utworzony w rozdziale Wiosna AOP - Aplikacja .
2	Zaktualizuj konfigurację fasoli i uruchom aplikację, jak wyjaśniono poniżej.

Poniżej znajduje się treść Logging.javaplik. W rzeczywistości jest to przykład modułu aspektu, który definiuje metody, które mają być wywoływane w różnych punktach.

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

Poniżej znajduje się zawartość Student.java plik.

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

Poniżej znajduje się zawartość MainApp.java plik.

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

Poniżej znajduje się plik konfiguracyjny 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>

Uruchom projekt

Around advice
Name : Zara
Returning Zara

Napiszmy przykład, który zaimplementuje porady przy użyciu konfiguracji opartej na adnotacjach. W tym celu przygotujmy działające środowisko Eclipse IDE i wykonaj następujące kroki, aby utworzyć aplikację Spring.

Krok	Opis
1	Zaktualizuj projekt Studenta utworzony w rozdziale Wiosna AOP - Aplikacja .
2	Zaktualizuj konfigurację fasoli i uruchom aplikację, jak wyjaśniono poniżej.

Poniżej znajduje się treść Logging.javaplik. W rzeczywistości jest to przykład modułu aspektu, który definiuje metody, które mają być wywoływane w różnych punktach.

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

Poniżej znajduje się zawartość Student.java plik.

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

Poniżej znajduje się zawartość MainApp.java plik.

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

Poniżej znajduje się plik konfiguracyjny 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>

Uruchom projekt

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

JoinPoint

Wszystkie klasy metod zawarte w pakiecie (pakietach).
Konkretne metody klasy.

PointCut

PointCut to zestaw jednego lub więcej JoinPoint, w którym należy wykonać poradę. Możesz określić PointCuts za pomocą wyrażeń lub wzorców, jak zobaczymy w naszych przykładach AOP. Wiosną PointCut pomaga wykorzystać konkretne JoinPoints do zastosowania się do porady. Rozważ następujące przykłady -

@PointCut ("wykonanie (* com.tutorialspoint. *. * (..))")
@PointCut ("wykonanie (* com.tutorialspoint.Student.getName (..))")

Składnia

@Aspect
public class Logging {

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

}

Gdzie,

@Aspect - Oznacz klasę jako klasę zawierającą metody doradcze.
@PointCut - Oznacz funkcję jako PointCut
execution( expression ) - Wyrażenie obejmujące metody, w odniesieniu do których mają być stosowane porady.

Krok	Opis
1	Zaktualizuj projekt Studenta utworzony w rozdziale Wiosna AOP - Aplikacja .
2	Zaktualizuj konfigurację fasoli i uruchom aplikację, jak wyjaśniono poniżej.

Poniżej znajduje się treść Logging.javaplik. W rzeczywistości jest to przykład modułu aspektu, który definiuje metody, które mają być wywoływane w różnych punktach.

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

Poniżej znajduje się zawartość Student.java plik.

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

Poniżej znajduje się zawartość MainApp.java plik.

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

Poniżej znajduje się plik konfiguracyjny 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>

Uruchom projekt

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

Zdefiniowane powyżej @Pointcut używa wyrażenia, aby wybrać wszystkie metody zdefiniowane w pakiecie com.tutorialspoint. @Before advice używa zdefiniowanego powyżej PointCut jako parametru. Efektywnie metoda beforeAdvice () zostanie wywołana przed każdą metodą objętą powyższym PointCut.

@Beforejest typem porady, który zapewnia, że porada zostanie uruchomiona przed wykonaniem metody. Poniżej znajduje się składnia @Before advice.

Składnia

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

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

Gdzie,

@PointCut - Oznacz funkcję jako PointCut
execution( expression ) - Wyrażenie obejmujące metody, w odniesieniu do których mają być stosowane porady.
@Before - Oznacz funkcję jako poradę do wykonania przed metodami objętymi PointCut.

Aby zrozumieć wspomniane wyżej pojęcia związane z @Before Advice, napiszmy przykład, który zaimplementuje @Before Advice. Aby napisać nasz przykład z kilkoma radami, przygotujmy działające środowisko Eclipse IDE i wykonaj następujące kroki, aby utworzyć aplikację Spring -

Krok	Opis
1	Zaktualizuj projekt Studenta utworzony w rozdziale Wiosna AOP - Aplikacja .
2	Zaktualizuj konfigurację fasoli i uruchom aplikację, jak wyjaśniono poniżej.

Poniżej znajduje się treść Logging.javaplik. W rzeczywistości jest to przykład modułu aspektu, który definiuje metody, które mają być wywoływane w różnych punktach.

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

Poniżej znajduje się zawartość Student.java plik.

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

Poniżej znajduje się zawartość MainApp.java plik.

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

Poniżej znajduje się plik konfiguracyjny 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>

Uruchom projekt

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

Zdefiniowane powyżej @Pointcut używa wyrażenia do wyboru metody getAge () zdefiniowanej w klasach w pakiecie com.tutorialspoint. Porada @After używa zdefiniowanego powyżej PointCut jako parametru. Skutecznie metoda afterAdvice () zostanie wywołana przed każdą metodą objętą powyższym PointCut.

@Afterjest typem porady, który zapewnia, że porada zostanie uruchomiona po wykonaniu metody. Poniżej znajduje się składnia porady @After.

Składnia

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

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

Gdzie,

@PointCut - Oznacz funkcję jako PointCut
execution( expression ) - Wyrażenie obejmujące metody, w odniesieniu do których mają być stosowane porady.
@After - Oznacz funkcję jako poradę do wykonania przed metodami objętymi PointCut.

Aby zrozumieć wspomniane wyżej pojęcia związane z @After Advice, napiszmy przykład, który zaimplementuje @After Advice. Aby napisać nasz przykład z kilkoma radami, przygotujmy działające środowisko Eclipse IDE i wykonaj następujące kroki, aby utworzyć aplikację Spring.

Krok	Opis
1	Zaktualizuj projekt Studenta utworzony w rozdziale Wiosna AOP - Aplikacja .
2	Zaktualizuj konfigurację fasoli i uruchom aplikację, jak wyjaśniono poniżej.

Poniżej znajduje się treść Logging.javaplik. W rzeczywistości jest to przykład modułu aspektu, który definiuje metody, które mają być wywoływane w różnych punktach.

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

Poniżej znajduje się zawartość Student.java plik.

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

Poniżej znajduje się zawartość MainApp.java plik.

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

Poniżej znajduje się plik konfiguracyjny 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>

Uruchom projekt

Name : Zara
Age : 11
Student profile setup completed.

@AfterReturningjest typem porady, który gwarantuje, że porada zostanie uruchomiona po pomyślnym wykonaniu metody. Poniżej znajduje się składnia porady @AfterReturning.

Składnia

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

Gdzie,

@AfterReturning - Oznacz funkcję jako poradę do wykonania przed metodami objętymi przez PointCut, jeśli metoda zakończy się pomyślnie.
PointCut - Zawiera wyrażenie umożliwiające wybranie funkcji
execution( expression ) - Wyrażenie obejmujące metody, w odniesieniu do których mają być stosowane porady.
returning - nazwa zmiennej, która ma zostać zwrócona.

Aby zrozumieć powyższe pojęcia związane z @AfterReturning Advice, napiszmy przykład, który zaimplementuje @AfterReturning Advice. Aby napisać nasz przykład z kilkoma radami, przygotujmy działające środowisko Eclipse IDE i wykonaj następujące kroki, aby utworzyć aplikację Spring.

Krok	Opis
1	Zaktualizuj projekt Studenta utworzony w rozdziale Wiosna AOP - Aplikacja .
2	Zaktualizuj konfigurację fasoli i uruchom aplikację, jak wyjaśniono poniżej.

Poniżej znajduje się treść Logging.javaplik. W rzeczywistości jest to przykład modułu aspektu, który definiuje metody, które mają być wywoływane w różnych punktach.

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

Poniżej znajduje się zawartość Student.java plik.

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

Poniżej znajduje się zawartość MainApp.java plik.

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

Poniżej znajduje się plik konfiguracyjny 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>

Uruchom projekt

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

@AfterThrowingjest typem porady, który zapewnia, że porada zostanie uruchomiona, jeśli metoda zgłosi wyjątek. Poniżej znajduje się składnia porady @AfterThrowing.

Składnia

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

Gdzie,

@AfterThrowing - Oznacz funkcję jako poradę do wykonania przed metodami objętymi przez PointCut, jeśli metoda zgłosi wyjątek.
PointCut - Zawiera wyrażenie umożliwiające wybranie funkcji.
execution( expression ) - Wyrażenie obejmujące metody, w odniesieniu do których mają być stosowane porady.
throwing - nazwa wyjątku do zwrócenia.

Aby zrozumieć wspomniane wyżej pojęcia związane z @AfterThrowing Advice, napiszmy przykład, który zaimplementuje @AfterThrowing Advice. Aby napisać nasz przykład z kilkoma radami, przygotujmy działające środowisko Eclipse IDE i wykonaj następujące kroki, aby utworzyć aplikację Spring.

Krok	Opis
1	Zaktualizuj projekt Studenta utworzony w rozdziale Wiosna AOP - Aplikacja .
2	Zaktualizuj konfigurację fasoli i uruchom aplikację, jak wyjaśniono poniżej.

Poniżej znajduje się treść Logging.javaplik. W rzeczywistości jest to przykład modułu aspektu, który definiuje metody, które mają być wywoływane w różnych punktach.

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

Poniżej znajduje się zawartość Student.java plik.

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

Poniżej znajduje się zawartość MainApp.java plik.

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

Poniżej znajduje się plik konfiguracyjny 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>

Uruchom projekt

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)

@Aroundjest typem porady, który zapewnia, że porada może zostać uruchomiona przed i po wykonaniu metody. Poniżej znajduje się składnia porady @Around.

Składnia

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

Gdzie,

@PointCut - Oznacz funkcję jako PointCut
execution( expression ) - Wyrażenie obejmujące metody, w odniesieniu do których mają być stosowane porady.
@Around - Oznacz funkcję jako poradę do wykonania przed metodami objętymi PointCut.

Aby zrozumieć wspomniane wyżej pojęcia związane z @Around Advice, napiszmy przykład, który zaimplementuje @Around Advice. Aby napisać nasz przykład z kilkoma radami, przygotujmy działające środowisko Eclipse IDE i wykonaj następujące kroki, aby utworzyć aplikację Spring -

Krok	Opis
1	Zaktualizuj projekt Studenta utworzony w rozdziale Wiosna AOP - Aplikacja .
2	Zaktualizuj konfigurację fasoli i uruchom aplikację, jak wyjaśniono poniżej.

Poniżej znajduje się treść Logging.javaplik. W rzeczywistości jest to przykład modułu aspektu, który definiuje metody, które mają być wywoływane w różnych punktach.

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

Poniżej znajduje się zawartość Student.java plik.

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

Poniżej znajduje się zawartość MainApp.java plik.

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

Poniżej znajduje się plik konfiguracyjny 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>

Uruchom projekt

Around advice
Age : 11
Returning 11

Do tej pory deklarowaliśmy aspekty przy użyciu <aop:config> lub < aop:aspectj-autoproxy>. Możemy stworzyć proxy programowo, jak również wywołać aspekty programowo przy użyciu obiektu proxy.

Składnia

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

Gdzie,

AspectJProxyFactory - Klasa fabryczna do tworzenia obiektu proxy.
Logging.class - Klasa aspektu zawierająca porady.
Student - Klasa biznes, którą należy doradzić.

Aby zrozumieć powyższe pojęcia związane z proxy, napiszmy przykład, który zaimplementuje proxy. Aby napisać nasz przykład z kilkoma radami, przygotujmy działające środowisko Eclipse IDE i wykonaj następujące kroki, aby utworzyć aplikację Spring -

Krok	Opis
1	Zaktualizuj projekt Studenta utworzony w rozdziale Wiosna AOP - Aplikacja .
2	Zaktualizuj konfigurację fasoli i uruchom aplikację, jak wyjaśniono poniżej.

Poniżej znajduje się treść Logging.javaplik. W rzeczywistości jest to przykład modułu aspektu, który definiuje metody, które mają być wywoływane w różnych punktach.

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

Poniżej znajduje się zawartość Student.java plik.

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

Poniżej znajduje się zawartość MainApp.java plik.

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

Poniżej znajduje się plik konfiguracyjny 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>

Uruchom projekt

Going to setup student profile.
Age : 11

Zgodnie z wyrażeniami PointCut, może się zdarzyć, że zostaną zastosowane do innych fasoli, dla których porady nie są przeznaczone. Weźmy na przykład pod uwagę następujące wyrażenie.

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

Za pomocą metody getAge () dodaje się nową fasolkę jarą i zacznie się do niej stosować porady, chociaż może to nie być zamierzone. Aby to osiągnąć, możemy utworzyć niestandardową adnotację i opisać metody, do których mają być stosowane porady.

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

Krok	Opis
1	Zaktualizuj projekt Studenta utworzony w rozdziale Wiosna AOP - Aplikacja .
2	Zaktualizuj konfigurację fasoli i uruchom aplikację, jak wyjaśniono poniżej.

Poniżej znajduje się treść Logging.javaplik. W rzeczywistości jest to przykład modułu aspektu, który definiuje metody, które mają być wywoływane w różnych punktach.

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

Poniżej znajduje się zawartość Loggable.java plik -

package com.tutorialspoint;

public @interface Loggable {

}

Poniżej znajduje się zawartość Student.java plik.

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

Poniżej znajduje się zawartość MainApp.java plik.

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

Poniżej znajduje się plik konfiguracyjny 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>

Uruchom projekt

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