SpringAOP-クイックガイド

Spring Frameworkの重要なコンポーネントの1つは、 Aspect Oriented Programming (AOP)フレームワーク。アスペクト指向プログラミングでは、プログラムロジックを次のような個別の部分に分割する必要があります。so-called concerns。アプリケーションの複数のポイントにまたがる機能は、横断的関心事と呼ばれます。これらcross-cutting concernsアプリケーションのビジネスロジックから概念的に分離されています。ロギング、監査、宣言型トランザクション、セキュリティ、キャッシングなどの側面のさまざまな一般的な良い例があります。

OOPのモジュール性の主要な単位はクラスですが、AOPのモジュール性の単位はアスペクトです。依存性注入は、アプリケーションオブジェクトを相互に分離するのに役立ちますが、AOPは、横断的関心事をそれらが影響するオブジェクトから分離するのに役立ちます。AOPは、Perl、.NET、Javaなどのプログラミング言語のトリガーのようなものです。

Spring AOPモジュールを使用すると、インターセプターがアプリケーションをインターセプトできます。たとえば、メソッドが実行されるときに、メソッドの実行の前後に機能を追加できます。

この章では、WindowsおよびLinuxベースのシステムでSpringAOPをセットアップするプロセスについて説明します。Spring AOPは、複雑なセットアップ手順なしでいくつかの簡単な手順に従うことで、現在のJava環境およびMAVENに簡単にインストールして統合できます。インストール中にユーザー管理が必要です。

システム要求

JDK	Java SE 2 JDK1.5以降
記憶	1 GB RAM（推奨）
ディスクスペース	最小要件はありません
オペレーティングシステムのバージョン	Windows XP以降、Linux

SpringAOPをインストールする手順を見てみましょう。

ステップ1：Javaのインストールを確認する

まず、システムにJavaソフトウェア開発キット（SDK）をインストールする必要があります。これを確認するには、作業しているプラットフォームに応じて、次の2つのコマンドのいずれかを実行します。

Javaのインストールが適切に行われている場合は、Javaインストールの現在のバージョンと仕様が表示されます。次の表に出力例を示します。

プラットホーム	コマンド	サンプル出力
ウィンドウズ	コマンドコンソールを開き、「-」と入力します。 \>java -version	Javaバージョン「1.7.0_60」 Java（TM）SEランタイム環境（ビルド1.7.0_60-b19） Java Hotspot（TM）64ビットサーバーVM（ビルド24.60-b09、混合モード）
Linux	コマンドターミナルを開き、「-」と入力します。 $java -version	Javaバージョン「1.7.0_25」 JDKランタイム環境を開きます（rhel-2.3.10.4.el6_4-x86_64） JDK 64ビットサーバーVMを開きます（ビルド23.7-b01、混合モード）

このチュートリアルの読者は、JavaSDKバージョン1.7.0_60がシステムにインストールされていることを前提としています。

Java SDKをお持ちでない場合は、現在のバージョンをからダウンロードしてください。 https://www.oracle.com/technetwork/java/javase/downloads/index.html そしてそれをインストールしてもらいます。

ステップ2：Java環境を設定する

Javaがマシンにインストールされているベースディレクトリの場所を指すように環境変数JAVA_HOMEを設定します。例えば、

シニア番号	プラットフォームと説明
1	Windows JAVA_HOMEをC：\ ProgramFiles \ java \ jdk1.7.0_60に設定します
2	Linux エクスポートJAVA_HOME = / usr / local / java-current

Javaコンパイラの場所のフルパスをシステムパスに追加します。

シニア番号	プラットフォームと説明
1	Windows 文字列「C：\ ProgramFiles \ Java \ jdk1.7.0_60 \ bin」をシステム変数Pathの最後に追加します。
2	Linux エクスポートPATH = $ PATH：$ JAVA_HOME / bin /

コマンドを実行します java -version 上で説明したコマンドプロンプトから。

ステップ3：Mavenアーカイブをダウンロードする

Maven3.3.3をからダウンロード https://maven.apache.org/download.cgi

OS	アーカイブ名
ウィンドウズ	apache-maven-3.3.3-bin.zip
Linux	apache-maven-3.3.3-bin.tar.gz
マック	apache-maven-3.3.3-bin.tar.gz

ステップ4：Mavenアーカイブを抽出する

Maven3.3.3をインストールするディレクトリにアーカイブを抽出します。サブディレクトリapache-maven-3.3.3がアーカイブから作成されます。

OS	場所（インストールによって異なる場合があります）
ウィンドウズ	C：\ Program Files \ Apache Software Foundation \ apache-maven-3.3.3
Linux	/ usr / local / apache-maven
マック	/ usr / local / apache-maven

ステップ5：Maven環境変数を設定する

M2_HOME、M2、MAVEN_OPTSを環境変数に追加します。

OS	出力
ウィンドウズ	システムプロパティを使用して環境変数を設定します。 M2_HOME = C：\ Program Files \ Apache Software Foundation \ apache-maven-3.3.3 M2 =％M2_HOME％\ bin MAVEN_OPTS = -Xms256m -Xmx512m
Linux	コマンドターミナルを開き、環境変数を設定します。エクスポートM2_HOME = /usr/local/apache-maven/apache-maven-3.3.3 エクスポートM2 = $ M2_HOME / bin エクスポートMAVEN_OPTS = -Xms256m -Xmx512m
マック	コマンドターミナルを開き、環境変数を設定します。エクスポートM2_HOME = /usr/local/apache-maven/apache-maven-3.3.3 エクスポートM2 = $ M2_HOME / bin エクスポートMAVEN_OPTS = -Xms256m -Xmx512m

ステップ6：Mavenビンディレクトリの場所をシステムパスに追加する

次に、M2変数をシステムパスに追加します。

OS	出力
ウィンドウズ	文字列;％M2％をシステム変数Pathの最後に追加します。
Linux	PATH = $ M2：$ PATHをエクスポートします
マック	PATH = $ M2：$ PATHをエクスポートします

ステップ7：Mavenのインストールを確認する

コンソールを開き、以下を実行します mvn コマンド。

OS	仕事	コマンド
ウィンドウズ	コマンドコンソールを開く	c：\> mvn --version
Linux	コマンドターミナルを開く	$ mvn --version
マック	オープンターミナル	マシン：<joseph $ mvn --version

最後に、上記のコマンドの出力を確認します。これは次のようになります。

OS	出力
ウィンドウズ	Apache Maven 3.3.3（7994120775791599e205a5524ec3e0dfe41d4a06; 2015-04-22T17：27：37 + 05：30） Mavenホーム：C：\ Program Files \ Apache Software Foundation \ apache-maven-3.3.3 Javaバージョン：1.7.0_75、ベンダー：Oracle Corporation Javaホーム：C：\ Program Files \ Java \ jdk1.7.0_75 \ jre デフォルトのロケール：en_US、プラットフォームエンコーディング：Cp1252
Linux	Apache Maven 3.3.3（7994120775791599e205a5524ec3e0dfe41d4a06; 2015-04-22T17：27：37 + 05：30） Mavenホーム：/usr/local/apache-maven/apache-maven-3.3.3 Javaバージョン：1.7.0_75、ベンダー：Oracle Corporation Javaホーム：/usr/local/java-current/jdk1.7.0_75/jre
マック	Apache Maven 3.3.3（7994120775791599e205a5524ec3e0dfe41d4a06; 2015-04-22T17：27：37 + 05：30） Mavenホーム：/usr/local/apache-maven/apache-maven-3.3.3 Javaバージョン：1.7.0_75、ベンダー：Oracle Corporation Javaホーム：/Library/Java/Home/jdk1.7.0_75/jre

ステップ8-EclipseIDEをセットアップする

このチュートリアルのすべての例は、EclipseIDEを使用して作成されています。したがって、最新バージョンのEclipseをマシンにインストールすることをお勧めします。

Eclipse IDEをインストールするには、から最新のEclipseバイナリをダウンロードします。 https://www.eclipse.org/downloads/。インストールをダウンロードしたら、バイナリディストリビューションを便利な場所に解凍します。たとえば、WindowsのC：\ eclipse、またはLinux / Unixの/ usr / local / eclipseで、最後にPATH変数を適切に設定します。

Eclipseは、Windowsマシンで次のコマンドを実行することで起動できます。または、eclipse.exeをダブルクリックすることもできます。

%C:\eclipse\eclipse.exe

Eclipseは、Unix（Solaris、Linuxなど）マシンで次のコマンドを実行することで起動できます。

$/usr/local/eclipse/eclipse

起動が成功した後、すべてが正常であれば、次の結果が表示されます-

この最後のステップが完了すると、次の章で説明する最初のAOPの例に進む準備が整います。

AOPの使用を開始する前に、AOPの概念と用語について理解しましょう。これらの用語はSpringに固有のものではなく、AOPに関連しています。

シニア番号	用語と説明
1	Aspect 分野横断的な要件を提供する一連のAPIを備えたモジュール。たとえば、ロギングモジュールはロギングのAOPアスペクトと呼ばれます。アプリケーションには、要件に応じてさまざまな側面があります。
2	Join point これは、AOPアスペクトをプラグインできるアプリケーションのポイントを表しています。また、SpringAOPフレームワークを使用してアクションが実行されるのはアプリケーション内の実際の場所であるとも言えます。
3	Advice これは、メソッドの実行前または実行後に実行される実際のアクションです。これは、SpringAOPフレームワークによるプログラムの実行中に呼び出される実際のコードです。
4	PointCut これは、アドバイスを実行する必要がある1つ以上の結合点のセットです。AOPの例で示すように、式またはパターンを使用してPointCutsを指定できます。
5	Introduction イントロダクションを使用すると、既存のクラスに新しいメソッドまたは属性を追加できます。
6	Target object 1つまたは複数の側面によってアドバイスされているオブジェクト。このオブジェクトは常にプロキシされたオブジェクトになります。アドバイス対象とも呼ばれます。
7	Weaving ウィービングは、アスペクトを他のアプリケーションタイプまたはオブジェクトとリンクして、アドバイスされたオブジェクトを作成するプロセスです。これは、コンパイル時、ロード時、または実行時に実行できます。

春の側面は、次の表に記載されている5種類のアドバイスで機能します。

シニア番号	アドバイスと説明
1	before メソッドを実行する前にアドバイスを実行します。
2	after 結果に関係なく、メソッドの実行後にアドバイスを実行します。
3	after-returning メソッドが正常に完了した場合にのみ、メソッドの実行後にアドバイスを実行します。
4	after-throwing メソッドが例外をスローして終了する場合にのみ、メソッドの実行後にアドバイスを実行します。
5	around アドバイスされたメソッドが呼び出される前後にアドバイスを実行します。

Springは @AspectJ annotation style アプローチと schema-based カスタムアスペクトを実装するためのアプローチ。

XMLスキーマベース

アスペクトは、XMLベースの構成とともに通常のクラスを使用して実装されます。

このセクションで説明されているAOP名前空間タグを使用するには、次のように説明されているSpringAOPスキーマをインポートする必要があります。

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

アスペクトの宣言

アン aspect を使用して宣言されます <aop:aspect> 要素であり、バッキングBeanは ref 次のように属性。

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

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

ここでは、前の章で見たように、他のSpring Beanと同じように、「aBean」が構成され、依存性が注入されます。

ポイントカットの宣言

A PointCutさまざまなアドバイスを使用して実行する対象のジョインポイント（つまり、メソッド）を決定するのに役立ちます。XMLスキーマベースの構成で作業している間、PointCutは次のように定義されます-

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

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

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

次の例では、パッケージcom.tutorialspointのStudentクラスで使用可能なgetName（）メソッドの実行に一致する「businessService」という名前のPointCutを定義します。

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

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

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

アドバイスの宣言

次のように、<aop：{ADVICE NAME}>要素を使用して、<aop：aspect>内で5つのアドバイスのいずれかを宣言できます。

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

      <!-- a before advice definition -->
      <aop:before PointCut-ref = "businessService" 
         method = "doRequiredTask"/>

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

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

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

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

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

あなたは同じを使うことができます doRequiredTaskまたは異なるアドバイスのための異なる方法。これらのメソッドは、アスペクトモジュールの一部として定義されます。

@AspectJベース

@AspectJは、Java5アノテーションが付けられた通常のJavaクラスとしてアスペクトを宣言するスタイルを指します。@AspectJのサポートは、XMLスキーマベースの構成ファイル内に次の要素を含めることで有効になります。

<aop:aspectj-autoproxy/>

アスペクトの宣言

Aspectsクラスは、他の通常のBeanと同様であり、次のように@Aspectアノテーションが付けられることを除いて、他のクラスと同じようにメソッドとフィールドを持つことができます。

package org.xyz;

import org.aspectj.lang.annotation.Aspect;

@Aspect
public class AspectModule {

}

これらは、他のBeanと同様に次のようにXMLで構成されます。

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

ポイントカットの宣言

A PointCutさまざまなアドバイスを使用して実行する対象のジョインポイント（つまり、メソッド）を決定するのに役立ちます。@AspectJベースの構成で作業している間、PointCut宣言には2つの部分があります-

関心のあるメソッドの実行を正確に決定するPointCut式。
名前と任意の数のパラメーターで構成されるPointCut署名。メソッドの実際の本体は無関係であり、実際には空である必要があります。

次の例では、パッケージcom.xyz.myapp.serviceの下のクラスで使用可能なすべてのメソッドの実行に一致する「businessService」という名前のPointCutを定義します。

import org.aspectj.lang.annotation.PointCut;

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

次の例では、パッケージcom.tutorialspointのStudentクラスで使用可能なgetName（）メソッドの実行と一致する「getname」という名前のPointCutを定義しています。

import org.aspectj.lang.annotation.PointCut;

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

アドバイスの宣言

以下に示すように、@ {ADVICE-NAME}アノテーションを使用して、5つのアドバイスのいずれかを宣言できます。これは、PointCut署名メソッドbusinessService（）がすでに定義されていることを前提としています。

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

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

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

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

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

あらゆるアドバイスに対して、PointCutをインラインで定義できます。以下は、アドバイスの前にインラインPointCutを定義する例です。

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

この章では、Spring AOPFrameworkを使用して実際のAOPアプリケーションを作成します。Spring-WSフレームワークを使用して最初の例を書き始める前に、SpringWebサービス-環境設定の章で説明されているようにSpringAOP環境が正しく設定されていることを確認する必要があります。

次に、AOPの概念を示す簡単なコンソールベースのSpringAOPアプリケーションの作成に進みます。

プロジェクトを作成する

Step 1 −コマンドコンソールを開き、C：\ MVNディレクトリに移動して、以下を実行します mvn コマンド。

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

Mavenは処理を開始し、完全なJavaアプリケーションプロジェクト構造を作成します。

[INFO] Scanning for projects...
[INFO]
[INFO] ------------------------------------------------------------------------
[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− C：/ MVNディレクトリに移動します。（artifactIdで指定された）studentという名前のJavaアプリケーションプロジェクトが作成されているのがわかります。POM.xmlを更新して、Spring-AOPの依存関係を含めます。MainApp.java、Student.java、およびLogging.javaファイルを追加します。

POM.xml

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

以下は、の内容です Student.java ファイル。

package com.tutorialspoint;

public class Student {
   private Integer age;
   private String name;

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

   public void setName(String name) {
      this.name = name;
   }
   public String getName() {
      System.out.println("Name : " + name );
      return name;
   }
   
   public void printThrowException(){
      System.out.println("Exception raised");
      throw new IllegalArgumentException();
   }
}

以下は、の内容です MainApp.java ファイル。

package com.tutorialspoint;

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

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

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

      student.getName();
      student.getAge();
      
      student.printThrowException();
   }
}

Step 3 −構成ファイルを追加します Beans.xml 下 src > main > resources フォルダ。

<?xml version = "1.0" encoding = "UTF-8"?>
<beans xmlns = "http://www.springframework.org/schema/beans"
   xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance" 
   xmlns:aop = "http://www.springframework.org/schema/aop"
   xsi:schemaLocation = "http://www.springframework.org/schema/beans
   http://www.springframework.org/schema/beans/spring-beans-3.0.xsd 
   http://www.springframework.org/schema/aop 
   http://www.springframework.org/schema/aop/spring-aop-3.0.xsd ">

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

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

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

Step 4 −コマンドコンソールを開き、C：\ MVNディレクトリに移動して、以下を実行します。 mvn コマンド。

C:\MVN>Student> mvn package

Mavenは、必要なライブラリの処理とダウンロードを開始します。

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

Eclipseでプロジェクトをインポートする

Step 1 −Eclipseを開きます。

Step 2 −選択 File → Import → オプション。

Step 3−Mavenプロジェクトオプションを選択します。[次へ]ボタンをクリックします。

Step 4 −Mavenを使用してStudentプロジェクトが作成されたプロジェクトの場所を選択します。

Step 5 − [完了]ボタンをクリックします。

プロジェクトを実行する

ソースファイルと構成ファイルの作成が完了したら、アプリケーションを実行します。アプリケーションでMainApp.javaを右クリックして、run as Java Applicationコマンド。アプリケーションに問題がない場合は、次のメッセージが出力されます。

Going to setup student profile.
Name : Zara
Student profile has been setup.
Returning:Zara
Going to setup student profile.
Age : 11
Student profile has been setup.
Returning:11
Going to setup student profile.
Exception raised
Student profile has been setup.
There has been an exception: java.lang.IllegalArgumentException
Exception in thread "main" java.lang.IllegalArgumentException
   at com.tutorialspoint.Student.printThrowException(Student.java:25)
   
   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)

ジョインポイント

JoinPointは、AOPアスペクトをプラグインできるアプリケーション内のポイントを表します。また、SpringAOPフレームワークを使用してアクションが実行されるのはアプリケーション内の実際の場所であるとも言えます。次の例を検討してください-

パッケージに含まれるすべてのメソッドクラス。
クラスの特定のメソッド。

ポイントカット

PointCutは、アドバイスを実行する必要がある1つ以上のJoinPointのセットです。AOPの例で示すように、式またはパターンを使用してPointCutsを指定できます。Springでは、PointCutは特定のJoinPointを使用してアドバイスを適用するのに役立ちます。次の例を検討してください-

式= "execution（* com.tutorialspoint。*。*（..））"
式= "execution（* com.tutorialspoint.Student.getName（..））"

構文

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

どこ、

adviceClass −アドバイスメソッドを含むクラスの参照
PointCut-id −ポイントカットのID
execution( expression ) −アドバイスを適用する方法をカバーする表現。

JoinPointとPointCutに関連する上記の概念を理解するために、いくつかのPointCutを実装する例を書いてみましょう。いくつかのアドバイスを付けて例を書くために、動作するEclipse IDEを配置し、次の手順を使用してSpringアプリケーションを作成しましょう。

ステップ	説明
1	Spring AOP-Applicationの章で作成したプロジェクトStudentを更新します。
2	Bean構成を更新し、以下で説明するようにアプリケーションを実行します。

以下はの内容です Logging.javaファイル。これは実際にはアスペクトモジュールのサンプルであり、さまざまなポイントで呼び出されるメソッドを定義しています。

package com.tutorialspoint;

public class Logging {

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

以下は、の内容です Student.java ファイル。

package com.tutorialspoint;

public class Student {
   private Integer age;
   private String name;

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

   public void setName(String name) {
      this.name = name;
   }
   public String getName() {
      System.out.println("Name : " + name );
      return name;
   }
   
   public void printThrowException(){
      System.out.println("Exception raised");
      throw new IllegalArgumentException();
   }
}

以下は、の内容です MainApp.java ファイル。

package com.tutorialspoint;

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

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

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

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

以下は設定ファイルです Beans.xml。

<?xml version = "1.0" encoding = "UTF-8"?>
<beans xmlns = "http://www.springframework.org/schema/beans"
   xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance" 
   xmlns:aop = "http://www.springframework.org/schema/aop"
   xsi:schemaLocation = "http://www.springframework.org/schema/beans
   http://www.springframework.org/schema/beans/spring-beans-3.0.xsd 
   http://www.springframework.org/schema/aop 
   http://www.springframework.org/schema/aop/spring-aop-3.0.xsd ">

   <aop:config>
      <aop:aspect id = "log" ref = "logging">
         <aop:PointCut id = "selectAll" 
         expression = "execution(* com.tutorialspoint.*.*(..))"/>
         <aop:before PointCut-ref = "selectAll" method = "beforeAdvice"/>         
      </aop:aspect>
   </aop:config>

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

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

ソースとBeanの構成ファイルの作成が完了したら、アプリケーションを実行します。アプリケーションに問題がない場合は、次のメッセージが出力されます。

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

上記で定義された<aop：pointcut>は、パッケージcom.tutorialspointで定義されているすべてのメソッドを選択します。特定のメソッドの前後にアドバイスを実行したい場合、PointCut定義のスター（*）を実際のクラス名とメソッド名に置き換えることで、実行を絞り込むためにPointCutを定義できます。以下は、概念を示すために変更された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>

プロジェクトを実行する

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

Beforeメソッドの実行前にアドバイスが実行されるようにするアドバイスタイプです。以下は、アドバイス前の構文です。

構文

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

どこ、

PointCut-id −ポイントカットのID。
methodName −呼び出された関数の前に呼び出される関数のメソッド名。

Before Adviceに関連する上記の概念を理解するために、BeforeAdviceを実装する例を書いてみましょう。いくつかのアドバイスを付けて例を書くために、動作するEclipse IDEを配置し、次の手順を使用してSpringアプリケーションを作成しましょう。

ステップ	説明
1	Spring AOP-Applicationの章で作成したプロジェクトStudentを更新します。
2	Bean構成を更新し、以下で説明するようにアプリケーションを実行します。

package com.tutorialspoint;

public class Logging {

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

以下は、の内容です Student.java ファイル。

package com.tutorialspoint;

public class Student {
   private Integer age;
   private String name;

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

   public void setName(String name) {
      this.name = name;
   }
   
   public String getName() {
      System.out.println("Name : " + name );
      return name;
   }
   
   public void printThrowException(){
      System.out.println("Exception raised");
      throw new IllegalArgumentException();
   }
}

以下は、の内容です MainApp.java ファイル。

package com.tutorialspoint;

import org.springframework.context.ApplicationContext;

import org.springframework.context.support.ClassPathXmlApplicationContext;

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

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

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

以下は設定ファイルです Beans.xml。

<?xml version = "1.0" encoding = "UTF-8"?>
<beans xmlns = "http://www.springframework.org/schema/beans"
   xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance" 
   xmlns:aop = "http://www.springframework.org/schema/aop"
   xsi:schemaLocation = "http://www.springframework.org/schema/beans
   http://www.springframework.org/schema/beans/spring-beans-3.0.xsd 
   http://www.springframework.org/schema/aop 
   http://www.springframework.org/schema/aop/spring-aop-3.0.xsd ">

   <aop:config>
      <aop:aspect id = "log" ref = "logging">
         <aop:PointCut id = "selectAll" 
            expression = "execution(* com.tutorialspoint.Student.getName(..))"/>
         <aop:before PointCut-ref = "selectAll" method = "beforeAdvice"/>
      </aop:aspect>
   </aop:config>

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

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

プロジェクトを実行する

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

Afterメソッドの実行後にアドバイスが実行されるようにするアドバイスタイプです。以下は、アフターアドバイスの構文です。

構文

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

どこ、

PointCut-id −ポイントカットのID。
methodName −呼び出された関数の後に呼び出される関数のメソッド名。

アフターアドバイスに関連する上記の概念を理解するために、アフターアドバイスを実装する例を書いてみましょう。いくつかのアドバイスを付けて例を書くために、動作するEclipse IDEを配置し、次の手順を使用してSpringアプリケーションを作成しましょう。

ステップ	説明
1	Spring AOP-Applicationの章で作成したプロジェクトStudentを更新します。
2	Bean構成を更新し、以下で説明するようにアプリケーションを実行します。

package com.tutorialspoint;

public class Logging {

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

以下は、の内容です Student.java ファイル。

package com.tutorialspoint;

public class Student {
   private Integer age;
   private String name;

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

   public void setName(String name) {
      this.name = name;
   }
   public String getName() {
      System.out.println("Name : " + name );
      return name;
   }
   
   public void printThrowException(){
      System.out.println("Exception raised");
      throw new IllegalArgumentException();
   }
}

以下は、の内容です MainApp.java ファイル。

package com.tutorialspoint;

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

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

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

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

以下は設定ファイルです Beans.xml。

<?xml version = "1.0" encoding = "UTF-8"?>
<beans xmlns = "http://www.springframework.org/schema/beans"
   xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance" 
   xmlns:aop = "http://www.springframework.org/schema/aop"
   xsi:schemaLocation = "http://www.springframework.org/schema/beans
   http://www.springframework.org/schema/beans/spring-beans-3.0.xsd 
   http://www.springframework.org/schema/aop 
   http://www.springframework.org/schema/aop/spring-aop-3.0.xsd ">

   <aop:config>
      <aop:aspect id = "log" ref = "logging">
         <aop:PointCut id = "selectAll" 
            expression = "execution(* com.tutorialspoint.Student.getAge(..))"/>
         <aop:after PointCut-ref = "selectAll" method = "afterAdvice"/>
      </aop:aspect>
   </aop:config>

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

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

プロジェクトを実行する

ソースファイルと構成ファイルの作成が完了したら、アプリケーションを実行します。アプリケーションでMainApp.javaを右クリックして、run as Java Applicationコマンド。アプリケーションに問題がない場合は、次のメッセージが表示されます。

Name : Zara
Age : 11
Student profile setup complete.

Afterメソッドが正常に完了した場合にのみ、メソッドの実行後にアドバイスが実行されるようにするアドバイスタイプです。以下は、アフターアドバイスの構文です。

構文

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

どこ、

PointCut-id −ポイントカットのID。
methodName −呼び出された関数が正常に戻った後に呼び出される関数のメソッド名。

アフターリターンアドバイスに関連する上記の概念を理解するために、アフターリターンアドバイスを実装する例を書いてみましょう。いくつかのアドバイスを付けて例を書くために、動作するEclipse IDEを配置し、次の手順を使用してSpringアプリケーションを作成しましょう-

ステップ	説明
1	Spring AOP-Applicationの章で作成したプロジェクトStudentを更新します。
2	Bean構成を更新し、以下で説明するようにアプリケーションを実行します。

package com.tutorialspoint;

public class Logging {

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

以下は、の内容です Student.java ファイル。

package com.tutorialspoint;

public class Student {
   private Integer age;
   private String name;

   public void setAge(Integer age) {
      this.age = age;
   }
   
   public Integer getAge() {
      System.out.println("Age : " + age );
      System.out.println("Exception raised");
      throw new IllegalArgumentException();
      return age;
   }

   public void setName(String name) {
      this.name = name;
   }
   
   public String getName() {
      System.out.println("Name : " + name );
      return name;
   }
   
   public void printThrowException(){
      System.out.println("Exception raised");
      throw new IllegalArgumentException();
   }
}

以下は、の内容です MainApp.java ファイル。

package com.tutorialspoint;

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

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

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

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

以下は設定ファイルです Beans.xml。

<?xml version = "1.0" encoding = "UTF-8"?>
<beans xmlns = "http://www.springframework.org/schema/beans"
   xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance" 
   xmlns:aop = "http://www.springframework.org/schema/aop"
   xsi:schemaLocation = "http://www.springframework.org/schema/beans
   http://www.springframework.org/schema/beans/spring-beans-3.0.xsd 
   http://www.springframework.org/schema/aop 
   http://www.springframework.org/schema/aop/spring-aop-3.0.xsd ">

   <aop:config>
      <aop:aspect id = "log" ref = "logging">
         <aop:PointCut id = "selectAll" 
         expression = "execution(* com.tutorialspoint.*.*(..))"/>
         <aop:after-returning PointCut-ref = "selectAll" 
            method = "afterReturningAdvice" returning = "retVal"/>         
      </aop:aspect>
   </aop:config>

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

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

プロジェクトを実行する

Name : Zara
Returning : Name
Age : 11
Exception raised

After-throwingは、メソッドが例外をスローして終了した場合にのみ、メソッドの実行後にアドバイスが実行されるようにするアドバイスタイプです。以下は、スロー後のアドバイスの構文です。

構文

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

どこ、

PointCut-id −ポイントカットのID。
ex −スローされる例外。
methodName −呼び出された関数が例外をスローして終了したときに呼び出される関数のメソッド名。

アフタースローアドバイスに関連する上記の概念を理解するために、アフタースローアドバイスを実装する例を書いてみましょう。いくつかのアドバイスを付けて例を書くために、動作するEclipse IDEを配置し、次の手順を使用してSpringアプリケーションを作成しましょう-

ステップ	説明
1	Spring AOP-Applicationの章で作成したプロジェクトStudentを更新します。
2	Bean構成を更新し、以下で説明するようにアプリケーションを実行します。

package com.tutorialspoint;

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

以下は、の内容です Student.java ファイル。

package com.tutorialspoint;

public class Student {
   private Integer age;
   private String name;

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

   public void setName(String name) {
      this.name = name;
   }
   
   public String getName() {
      System.out.println("Name : " + name );
      return name;
   }
   
   public void printThrowException(){
      System.out.println("Exception raised");
      throw new IllegalArgumentException();
   }
}

以下は、の内容です MainApp.java ファイル。

package com.tutorialspoint;

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

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

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

      student.printThrowException();     
   }
}

以下は設定ファイルです Beans.xml。

<?xml version = "1.0" encoding = "UTF-8"?>
<beans xmlns = "http://www.springframework.org/schema/beans"
   xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance" 
   xmlns:aop = "http://www.springframework.org/schema/aop"
   xsi:schemaLocation = "http://www.springframework.org/schema/beans
   http://www.springframework.org/schema/beans/spring-beans-3.0.xsd 
   http://www.springframework.org/schema/aop 
   http://www.springframework.org/schema/aop/spring-aop-3.0.xsd ">

   <aop:config>
      <aop:aspect id = "log" ref = "logging">
         <aop:PointCut id = "selectAll" 
         expression = "execution(* com.tutorialspoint.*.*(..))"/>
         <aop:after-throwing PointCut-ref = "selectAll" 
            throwing = "ex" method = "afterThrowingAdvice"/>         
      </aop:aspect>
   </aop:config>

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

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

プロジェクトを実行する

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)

Aroundメソッドの実行の前後にアドバイスが実行されるようにするアドバイスタイプです。以下は、アラウンドアドバイスの構文です。

構文

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

どこ、

PointCut-id −ポイントカットのID。
methodName −呼び出された関数の前に呼び出される関数のメソッド名。

アラウンドアドバイスに関連する上記の概念を理解するために、アラウンドアドバイスを実装する例を書いてみましょう。いくつかのアドバイスを付けて例を書くために、動作するEclipse IDEを配置し、次の手順を使用してSpringアプリケーションを作成しましょう-

ステップ	説明
1	Spring AOP-Applicationの章で作成したプロジェクトStudentを更新します。
2	Bean構成を更新し、以下で説明するようにアプリケーションを実行します。

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

public class Logging {

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

      Object result = jp.proceed(args);
      System.out.println("Returning " + result);
      return result.toString();
   }   
}

以下は、の内容です Student.java ファイル。

package com.tutorialspoint;

public class Student {
   private Integer age;
   private String name;

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

   public void setName(String name) {
      this.name = name;
   }
   
   public String getName() {
      System.out.println("Name : " + name );
      return name;
   }
   
   public void printThrowException(){
      System.out.println("Exception raised");
      throw new IllegalArgumentException();
   }
}

以下は、の内容です MainApp.java ファイル。

package com.tutorialspoint;

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

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

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

      student.getName();    
   }
}

以下は設定ファイルです Beans.xml。

<?xml version = "1.0" encoding = "UTF-8"?>
<beans xmlns = "http://www.springframework.org/schema/beans"
   xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance" 
   xmlns:aop = "http://www.springframework.org/schema/aop"
   xsi:schemaLocation = "http://www.springframework.org/schema/beans
   http://www.springframework.org/schema/beans/spring-beans-3.0.xsd 
   http://www.springframework.org/schema/aop 
   http://www.springframework.org/schema/aop/spring-aop-3.0.xsd ">

   <aop:config>
      <aop:aspect id = "log" ref = "logging">
         <aop:PointCut id = "selectName" 
            expression = "execution(* com.tutorialspoint.Student.getName(..))"/>
         <aop:around PointCut-ref = "selectName" method = "aroundAdvice"/>
      </aop:aspect>
   </aop:config>

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

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

プロジェクトを実行する

Around advice
Name : Zara
Returning Zara

アノテーションベースの構成を使用してアドバイスを実装する例を書いてみましょう。このために、動作するEclipse IDEを配置し、次の手順を使用してSpringアプリケーションを作成します。

ステップ	説明
1	Spring AOP-Applicationの章で作成したプロジェクトStudentを更新します。
2	Bean構成を更新し、以下で説明するようにアプリケーションを実行します。

package com.tutorialspoint;

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

@Aspect
public class Logging {

   /** Following is the definition for a PointCut to select
    *  all the methods available. So advice will be called
    *  for all the methods.
    */
   @PointCut("execution(* com.tutorialspoint.*.*(..))")
   private void selectAll(){}

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

以下は、の内容です Student.java ファイル。

package com.tutorialspoint;

public class Student {
   private Integer age;
   private String name;

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

   public void setName(String name) {
      this.name = name;
   }
   
   public String getName() {
      System.out.println("Name : " + name );
      return name;
   }
   
   public void printThrowException(){
      System.out.println("Exception raised");
      throw new IllegalArgumentException();
   }
}

以下は、の内容です MainApp.java ファイル。

package com.tutorialspoint;

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

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

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

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

以下は設定ファイルです Beans.xml。

<?xml version = "1.0" encoding = "UTF-8"?>
<beans xmlns = "http://www.springframework.org/schema/beans"
   xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance" 
   xmlns:aop = "http://www.springframework.org/schema/aop"
   xsi:schemaLocation = "http://www.springframework.org/schema/beans
   http://www.springframework.org/schema/beans/spring-beans-3.0.xsd 
   http://www.springframework.org/schema/aop 
   http://www.springframework.org/schema/aop/spring-aop-3.0.xsd ">

   <aop:aspectj-autoproxy/>

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

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

プロジェクトを実行する

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

JoinPoint

パッケージに含まれるすべてのメソッドクラス。
クラスの特定のメソッド。

ポイントカット

@PointCut（ "execution（* com.tutorialspoint。*。*（..））"）
@PointCut（ "execution（* com.tutorialspoint.Student.getName（..））"）

構文

@Aspect
public class Logging {

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

}

どこ、

@Aspect −クラスをアドバイスメソッドを含むクラスとしてマークします。
@PointCut −関数をPointCutとしてマークします
execution( expression ) −アドバイスを適用する方法をカバーする表現。

JoinPointとPointCutに関連する上記の概念を理解するために、いくつかのPointCutを実装する例を書いてみましょう。いくつかのアドバイスを付けて例を書くために、動作するEclipse IDEを配置し、次の手順を使用してSpringアプリケーションを作成しましょう-

ステップ	説明
1	Spring AOP-Applicationの章で作成したプロジェクトStudentを更新します。
2	Bean構成を更新し、以下で説明するようにアプリケーションを実行します。

package com.tutorialspoint;

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

@Aspect
public class Logging {

   /** Following is the definition for a PointCut to select
    *  all the methods available. So advice will be called
    *  for all the methods.
    */
   @PointCut("execution(* com.tutorialspoint.*.*(..))")
   private void selectAll(){}

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

以下は、の内容です Student.java ファイル。

package com.tutorialspoint;

public class Student {
   private Integer age;
   private String name;

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

   public void setName(String name) {
      this.name = name;
   }
   
   public String getName() {
      System.out.println("Name : " + name );
      return name;
   }
   
   public void printThrowException(){
      System.out.println("Exception raised");
      throw new IllegalArgumentException();
   }
}

以下は、の内容です MainApp.java ファイル。

package com.tutorialspoint;

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

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

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

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

以下は設定ファイルです Beans.xml。

<?xml version = "1.0" encoding = "UTF-8"?>
<beans xmlns = "http://www.springframework.org/schema/beans"
   xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance" 
   xmlns:aop = "http://www.springframework.org/schema/aop"
   xsi:schemaLocation = "http://www.springframework.org/schema/beans
   http://www.springframework.org/schema/beans/spring-beans-3.0.xsd 
   http://www.springframework.org/schema/aop 
   http://www.springframework.org/schema/aop/spring-aop-3.0.xsd ">

   <aop:aspectj-autoproxy/>

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

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

プロジェクトを実行する

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

上記で定義された@Pointcutは、式を使用して、パッケージcom.tutorialspointで定義されているすべてのメソッドを選択します。@Before Adviceは、上記で定義されたPointCutをパラメーターとして使用します。事実上、beforeAdvice（）メソッドは、上記のPointCutでカバーされるすべてのメソッドの前に呼び出されます。

@Beforeメソッドの実行前にアドバイスが実行されるようにするアドバイスタイプです。以下は、@ Beforeアドバイスの構文です。

構文

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

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

どこ、

@PointCut −関数をPointCutとしてマークします
execution( expression ) −アドバイスを適用する方法をカバーする表現。
@Before −PointCutの対象となるメソッドの前に実行するアドバイスとして関数をマークします。

@Before Adviceに関連する上記の概念を理解するために、@ BeforeAdviceを実装する例を書いてみましょう。いくつかのアドバイスを付けて例を書くために、動作するEclipse IDEを配置し、次の手順を使用してSpringアプリケーションを作成しましょう-

ステップ	説明
1	Spring AOP-Applicationの章で作成したプロジェクトStudentを更新します。
2	Bean構成を更新し、以下で説明するようにアプリケーションを実行します。

package com.tutorialspoint;

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

@Aspect
public class Logging {

   /** Following is the definition for a PointCut to select
    *  all the methods available. So advice will be called
    *  for all the methods.
    */
   @PointCut("execution(* com.tutorialspoint.Student.getName(..))")
   private void selectGetName(){}

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

以下は、の内容です Student.java ファイル。

package com.tutorialspoint;

public class Student {
   private Integer age;
   private String name;

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

   public void setName(String name) {
      this.name = name;
   }
   
   public String getName() {
      System.out.println("Name : " + name );
      return name;
   }
   
   public void printThrowException(){
      System.out.println("Exception raised");
      throw new IllegalArgumentException();
   }
}

以下は、の内容です MainApp.java ファイル。

package com.tutorialspoint;

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

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

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

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

以下は設定ファイルです Beans.xml。

<?xml version = "1.0" encoding = "UTF-8"?>
<beans xmlns = "http://www.springframework.org/schema/beans"
   xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance" 
   xmlns:aop = "http://www.springframework.org/schema/aop"
   xsi:schemaLocation = "http://www.springframework.org/schema/beans
   http://www.springframework.org/schema/beans/spring-beans-3.0.xsd 
   http://www.springframework.org/schema/aop 
   http://www.springframework.org/schema/aop/spring-aop-3.0.xsd ">

   <aop:aspectj-autoproxy/>

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

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

プロジェクトを実行する

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

上記で定義された@Pointcutは、式を使用して、パッケージcom.tutorialspointの下のクラスで定義されたメソッドgetAge（）を選択します。@After Adviceは、上記で定義されたPointCutをパラメーターとして使用します。事実上、afterAdvice（）メソッドは、上記のPointCutでカバーされるすべてのメソッドの前に呼び出されます。

@Afterメソッドの実行後にアドバイスが実行されるようにするアドバイスタイプです。以下は、@ Afterアドバイスの構文です。

構文

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

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

どこ、

@PointCut −関数をPointCutとしてマークします
execution( expression ) −アドバイスを適用する方法をカバーする表現。
@After −PointCutの対象となるメソッドの前に実行するアドバイスとして関数をマークします。

@After Adviceに関連する上記の概念を理解するために、@ AfterAdviceを実装する例を書いてみましょう。いくつかのアドバイスを付けて例を書くために、動作するEclipse IDEを配置し、次の手順を使用してSpringアプリケーションを作成しましょう。

ステップ	説明
1	Spring AOP-Applicationの章で作成したプロジェクトStudentを更新します。
2	Bean構成を更新し、以下で説明するようにアプリケーションを実行します。

package com.tutorialspoint;

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

@Aspect
public class Logging {

   /** Following is the definition for a PointCut to select
    *  all the methods available. So advice will be called
    *  for all the methods.
    */
   @PointCut("execution(* com.tutorialspoint.Student.getAge(..))")
   private void selectGetAge(){}

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

以下は、の内容です Student.java ファイル。

package com.tutorialspoint;

public class Student {
   private Integer age;
   private String name;

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

   public void setName(String name) {
      this.name = name;
   }
   
   public String getName() {
      System.out.println("Name : " + name );
      return name;
   }
   
   public void printThrowException(){
      System.out.println("Exception raised");
      throw new IllegalArgumentException();
   }
}

以下は、の内容です MainApp.java ファイル。

package com.tutorialspoint;

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

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

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

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

以下は設定ファイルです Beans.xml。

<?xml version = "1.0" encoding = "UTF-8"?>
<beans xmlns = "http://www.springframework.org/schema/beans"
   xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance" 
   xmlns:aop = "http://www.springframework.org/schema/aop"
   xsi:schemaLocation = "http://www.springframework.org/schema/beans
   http://www.springframework.org/schema/beans/spring-beans-3.0.xsd 
   http://www.springframework.org/schema/aop 
   http://www.springframework.org/schema/aop/spring-aop-3.0.xsd ">

   <aop:aspectj-autoproxy/>

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

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

プロジェクトを実行する

Name : Zara
Age : 11
Student profile setup completed.

@AfterReturningはアドバイスタイプであり、メソッドが正常に実行された後にアドバイスが実行されるようにします。以下は、@ AfterReturningアドバイスの構文です。

構文

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

どこ、

@AfterReturning −メソッドが正常に戻った場合、PointCutの対象となるメソッドの前に実行するアドバイスとして関数をマークします。
PointCut −関数を選択するための式を提供します
execution( expression ) −アドバイスを適用する方法をカバーする表現。
returning −返される変数の名前。

@AfterReturning Adviceに関連する上記の概念を理解するために、@ AfterReturningAdviceを実装する例を書いてみましょう。いくつかのアドバイスを付けて例を書くために、動作するEclipse IDEを配置し、次の手順を使用してSpringアプリケーションを作成しましょう。

ステップ	説明
1	Spring AOP-Applicationの章で作成したプロジェクトStudentを更新します。
2	Bean構成を更新し、以下で説明するようにアプリケーションを実行します。

package com.tutorialspoint;

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

@Aspect
public class Logging {

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

以下は、の内容です Student.java ファイル。

package com.tutorialspoint;

public class Student {
   private Integer age;
   private String name;

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

   public void setName(String name) {
      this.name = name;
   }
   
   public String getName() {
      System.out.println("Name : " + name );
      return name;
   }
   
   public void printThrowException(){
      System.out.println("Exception raised");
      throw new IllegalArgumentException();
   }
}

以下は、の内容です MainApp.java ファイル。

package com.tutorialspoint;

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

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

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

      student.getAge();     
   }
}

以下は設定ファイルです Beans.xml。

<?xml version = "1.0" encoding = "UTF-8"?>
<beans xmlns = "http://www.springframework.org/schema/beans"
   xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance" 
   xmlns:aop = "http://www.springframework.org/schema/aop"
   xsi:schemaLocation = "http://www.springframework.org/schema/beans
   http://www.springframework.org/schema/beans/spring-beans-3.0.xsd 
   http://www.springframework.org/schema/aop 
   http://www.springframework.org/schema/aop/spring-aop-3.0.xsd ">

   <aop:aspectj-autoproxy/>

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

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

プロジェクトを実行する

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

@AfterThrowingメソッドが例外をスローした場合にアドバイスが実行されることを保証するアドバイスタイプです。以下は、@ AfterThrowingアドバイスの構文です。

構文

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

どこ、

@AfterThrowing −メソッドが例外をスローした場合、PointCutの対象となるメソッドの前に実行されるアドバイスとして関数をマークします。
PointCut −関数を選択するための式を提供します。
execution( expression ) −アドバイスを適用する方法をカバーする表現。
throwing −返される例外の名前。

@AfterThrowing Adviceに関連する上記の概念を理解するために、@ AfterThrowingAdviceを実装する例を書いてみましょう。いくつかのアドバイスを付けて例を書くために、動作するEclipse IDEを配置し、次の手順を使用してSpringアプリケーションを作成しましょう。

ステップ	説明
1	Spring AOP-Applicationの章で作成したプロジェクトStudentを更新します。
2	Bean構成を更新し、以下で説明するようにアプリケーションを実行します。

package com.tutorialspoint;

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

@Aspect
public class Logging {

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

以下は、の内容です Student.java ファイル。

package com.tutorialspoint;

public class Student {
   private Integer age;
   private String name;

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

   public void setName(String name) {
      this.name = name;
   }
   
   public String getName() {
      System.out.println("Name : " + name );
      return name;
   }
   
   public void printThrowException(){
      System.out.println("Exception raised");
      throw new IllegalArgumentException();
   }
}

以下は、の内容です MainApp.java ファイル。

package com.tutorialspoint;

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

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

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

      student.printThrowException();     
   }
}

以下は設定ファイルです Beans.xml。

<?xml version = "1.0" encoding = "UTF-8"?>
<beans xmlns = "http://www.springframework.org/schema/beans"
   xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance" 
   xmlns:aop = "http://www.springframework.org/schema/aop"
   xsi:schemaLocation = "http://www.springframework.org/schema/beans
   http://www.springframework.org/schema/beans/spring-beans-3.0.xsd 
   http://www.springframework.org/schema/aop 
   http://www.springframework.org/schema/aop/spring-aop-3.0.xsd ">

   <aop:aspectj-autoproxy/>

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

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

プロジェクトを実行する

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)

@Aroundはアドバイスタイプであり、メソッドの実行の前後にアドバイスを実行できるようにします。以下は、@ Aroundアドバイスの構文です。

構文

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

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

   Object result = jp.proceed(args);
   System.out.println("Returning " + result);
   return result.toString();   
}

どこ、

@PointCut −関数をPointCutとしてマークします
execution( expression ) −アドバイスを適用する方法をカバーする表現。
@Around −PointCutの対象となるメソッドの前に実行するアドバイスとして関数をマークします。

@Around Adviceに関連する上記の概念を理解するために、@ AroundAdviceを実装する例を書いてみましょう。いくつかのアドバイスを付けて例を書くために、動作するEclipse IDEを配置し、次の手順を使用してSpringアプリケーションを作成しましょう-

ステップ	説明
1	Spring AOP-Applicationの章で作成したプロジェクトStudentを更新します。
2	Bean構成を更新し、以下で説明するようにアプリケーションを実行します。

package com.tutorialspoint;

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

@Aspect
public class Logging {

   /** Following is the definition for a PointCut to select
    *  all the methods available. So advice will be called
    *  for all the methods.
    */
   @PointCut("execution(* com.tutorialspoint.Student.getAge(..))")
   private void selectGetAge(){}

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

      Object result = proceedingJoinPoint.proceed(args);
      System.out.println("Returning " + result);
   }  
}

以下は、の内容です Student.java ファイル。

package com.tutorialspoint;

public class Student {
   private Integer age;
   private String name;

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

   public void setName(String name) {
      this.name = name;
   }
   
   public String getName() {
      System.out.println("Name : " + name );
      return name;
   }
   
   public void printThrowException(){
      System.out.println("Exception raised");
      throw new IllegalArgumentException();
   }
}

以下は、の内容です MainApp.java ファイル。

package com.tutorialspoint;

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

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

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

      student.getAge();     
   }
}

以下は設定ファイルです Beans.xml。

<?xml version = "1.0" encoding = "UTF-8"?>
<beans xmlns = "http://www.springframework.org/schema/beans"
   xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance" 
   xmlns:aop = "http://www.springframework.org/schema/aop"
   xsi:schemaLocation = "http://www.springframework.org/schema/beans
   http://www.springframework.org/schema/beans/spring-beans-3.0.xsd 
   http://www.springframework.org/schema/aop 
   http://www.springframework.org/schema/aop/spring-aop-3.0.xsd ">

   <aop:aspectj-autoproxy/>

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

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

プロジェクトを実行する

Around advice
Age : 11
Returning 11

これまでのところ、を使用してアスペクトを宣言しました <aop:config> または < aop:aspectj-autoproxy>。プログラムでプロキシを作成することも、プロキシオブジェクトを使用してプログラムでアスペクトを呼び出すこともできます。

構文

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

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

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

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

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

どこ、

AspectJProxyFactory −プロキシオブジェクトを作成するためのファクトリクラス。
Logging.class −アドバイスを含むアスペクトのクラス。
Student −アドバイスされるビジネスクラス。

プロキシに関連する上記の概念を理解するために、プロキシを実装する例を書いてみましょう。いくつかのアドバイスを付けて例を書くために、動作するEclipse IDEを配置し、次の手順を使用してSpringアプリケーションを作成しましょう-

ステップ	説明
1	Spring AOP-Applicationの章で作成したプロジェクトStudentを更新します。
2	Bean構成を更新し、以下で説明するようにアプリケーションを実行します。

package com.tutorialspoint;

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

@Aspect
public class Logging {

   /** Following is the definition for a PointCut to select
    *  all the methods available. So advice will be called
    *  for all the methods.
    */
   @PointCut("execution(* com.tutorialspoint.Student.getAge(..))")
   private void selectGetAge(){}

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

以下は、の内容です Student.java ファイル。

package com.tutorialspoint;

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

以下は、の内容です MainApp.java ファイル。

package com.tutorialspoint;

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

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

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

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

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

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

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

以下は設定ファイルです Beans.xml。

<?xml version = "1.0" encoding = "UTF-8"?>
<beans xmlns = "http://www.springframework.org/schema/beans"
   xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance" 
   xmlns:aop = "http://www.springframework.org/schema/aop"
   xsi:schemaLocation = "http://www.springframework.org/schema/beans
   http://www.springframework.org/schema/beans/spring-beans-3.0.xsd 
   http://www.springframework.org/schema/aop 
   http://www.springframework.org/schema/aop/spring-aop-3.0.xsd ">

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

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

プロジェクトを実行する

Going to setup student profile.
Age : 11

PointCutの式に従って、アドバイスが意図されていない他のBeanに適用される場合があります。たとえば、次の式について考えてみます。

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

getAge（）メソッドを使用して新しいSpring Beanが追加され、意図されていない場合でもアドバイスが適用され始めます。これを実現するために、カスタムアノテーションを作成し、アドバイスを適用するメソッドにアノテーションを付けることができます。

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

@Before Adviceに関連する上記の概念を理解するために、@ BeforeAdviceを実装する例を書いてみましょう。いくつかのアドバイスを付けて例を書くために、動作するEclipse IDEを配置し、次の手順を使用してSpringアプリケーションを作成しましょう。

ステップ	説明
1	Spring AOP-Applicationの章で作成したプロジェクトStudentを更新します。
2	Bean構成を更新し、以下で説明するようにアプリケーションを実行します。

package com.tutorialspoint;

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

@Aspect
public class Logging {

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

以下は、の内容です Loggable.java ファイル-

package com.tutorialspoint;

public @interface Loggable {

}

以下は、の内容です Student.java ファイル。

package com.tutorialspoint;

public class Student {
   private Integer age;
   private String name;

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

以下は、の内容です MainApp.java ファイル。

package com.tutorialspoint;

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

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

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

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

以下は設定ファイルです Beans.xml。

<?xml version = "1.0" encoding = "UTF-8"?>
<beans xmlns = "http://www.springframework.org/schema/beans"
   xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance" 
   xmlns:aop = "http://www.springframework.org/schema/aop"
   xsi:schemaLocation = "http://www.springframework.org/schema/beans
   http://www.springframework.org/schema/beans/spring-beans-3.0.xsd 
   http://www.springframework.org/schema/aop 
   http://www.springframework.org/schema/aop/spring-aop-3.0.xsd ">

   <aop:aspectj-autoproxy/>

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

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

プロジェクトを実行する

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