春-クイックガイド
Springは、エンタープライズJavaで最も人気のあるアプリケーション開発フレームワークです。世界中の何百万もの開発者がSpringFrameworkを使用して、パフォーマンスが高く、テストが容易で、再利用可能なコードを作成しています。
SpringフレームワークはオープンソースのJavaプラットフォームです。当初はRodJohnsonによって作成され、2003年6月にApache2.0ライセンスの下で最初にリリースされました。
サイズと透明度に関しては、Springは軽量です。Springフレームワークの基本バージョンは約2MBです。
Spring Frameworkのコア機能は、任意のJavaアプリケーションの開発に使用できますが、JavaEEプラットフォーム上にWebアプリケーションを構築するための拡張機能があります。Spring Frameworkは、POJOベースのプログラミングモデルを有効にすることで、J2EE開発を使いやすくし、優れたプログラミング手法を促進することを目標としています。
SpringFrameworkを使用する利点
以下は、SpringFrameworkを使用することのいくつかの大きな利点のリストです-
Springを使用すると、開発者はPOJOを使用してエンタープライズクラスのアプリケーションを開発できます。POJOのみを使用する利点は、アプリケーションサーバーなどのEJBコンテナ製品は必要ありませんが、Tomcatや一部の商用製品などの堅牢なサーブレットコンテナのみを使用するオプションがあることです。
春はモジュール方式で構成されています。パッケージとクラスの数はかなりの数ですが、必要なものだけを気にし、残りは無視する必要があります。
Springは車輪の再発明ではなく、いくつかのORMフレームワーク、ロギングフレームワーク、JEE、Quartz、JDKタイマー、その他のビューテクノロジーなどの既存のテクノロジーのいくつかを実際に利用しています。
Springで記述されたアプリケーションのテストは、環境に依存するコードがこのフレームワークに移動されるため、簡単です。さらに、JavaBeanstyle POJOを使用することで、依存性注入を使用してテストデータを注入することが容易になります。
SpringのWebフレームワークは、適切に設計されたWeb MVCフレームワークであり、Strutsやその他の過剰に設計されたWebフレームワークやあまり人気のないWebフレームワークなどのWebフレームワークの優れた代替手段を提供します。
Springは、テクノロジー固有の例外（JDBC、Hibernate、またはJDOなどによってスローされる）を一貫性のある未チェックの例外に変換するための便利なAPIを提供します。
軽量のIoCコンテナは、特にEJBコンテナと比較した場合、軽量になる傾向があります。これは、メモリとCPUリソースが限られているコンピューターでアプリケーションを開発および展開する場合に役立ちます。
Springは、（たとえば、単一のデータベースを使用して）ローカルトランザクションにスケールダウンし、（たとえば、JTAを使用して）グローバルトランザクションにスケールアップできる一貫したトランザクション管理インターフェイスを提供します。
依存性注入（DI）
Springが最もよく知られているテクノロジーは Dependency Injection (DI)制御の反転のフレーバー。ザ・Inversion of Control (IoC)は一般的な概念であり、さまざまな方法で表現できます。依存性注入は、制御の反転の具体的な例の1つにすぎません。
複雑なJavaアプリケーションを作成する場合、アプリケーションクラスは他のJavaクラスから可能な限り独立している必要があります。これにより、これらのクラスを再利用し、単体テスト中に他のクラスから独立してテストできるようになります。依存性注入は、これらのクラスを結合すると同時に、それらを独立させるのに役立ちます。
依存性注入とは正確には何ですか？これらの2つの単語を別々に見てみましょう。ここで、依存関係の部分は2つのクラス間の関連付けに変換されます。たとえば、クラスAはクラスBに依存しています。次に、2番目の部分であるインジェクションを見てみましょう。つまり、クラスBはIoCによってクラスAに注入されます。
依存性注入は、コンストラクターにパラメーターを渡す方法で、またはsetterメソッドを使用した構築後に発生する可能性があります。依存性注入はSpringFrameworkの中心であるため、この概念については、関連する例を使用して別の章で説明します。
アスペクト指向プログラミング（AOP）
Springの重要なコンポーネントの1つは Aspect Oriented Programming (AOP)フレームワーク。アプリケーションの複数のポイントにまたがる関数が呼び出されますcross-cutting concernsそして、これらの横断的関心事は、アプリケーションのビジネスロジックから概念的に分離されています。ロギング、宣言型トランザクション、セキュリティ、キャッシングなど、さまざまな側面の一般的な良い例があります。
OOPのモジュール性の主要な単位はクラスですが、AOPのモジュール性の単位はアスペクトです。DIは、アプリケーションオブジェクトを相互に分離するのに役立ち、AOPは、横断的関心事をそれらが影響するオブジェクトから分離するのに役立ちます。
Spring FrameworkのAOPモジュールは、アスペクト指向プログラミングの実装を提供します。これにより、メソッドインターセプターとポイントカットを定義して、分離する必要のある機能を実装するコードを明確に分離できます。Spring AOPの概念については、別の章で詳しく説明します。
Springは、すべてのエンタープライズアプリケーションのワンストップショップになる可能性があります。ただし、Springはモジュール式であるため、残りのモジュールを持ち込むことなく、適用可能なモジュールを選択できます。次のセクションでは、SpringFrameworkで使用可能なすべてのモジュールについて詳しく説明します。
Spring Frameworkは、アプリケーションの要件に基づいて使用できる約20のモジュールを提供します。
コアコンテナ
コアコンテナは、コア、Bean、コンテキスト、および式言語モジュールで構成されており、その詳細は次のとおりです。
ザ・ Core モジュールは、IoCおよび依存性注入機能を含むフレームワークの基本的な部分を提供します。
ザ・ Bean モジュールは、ファクトリパターンの高度な実装であるBeanFactoryを提供します。
ザ・ Contextモジュールは、CoreモジュールとBeansモジュールによって提供される堅固な基盤の上に構築されており、定義および構成されたオブジェクトにアクセスするための媒体です。ApplicationContextインターフェースは、Contextモジュールの焦点です。
ザ・ SpEL モジュールは、実行時にオブジェクトグラフをクエリおよび操作するための強力な式言語を提供します。
データアクセス/統合
データアクセス/統合レイヤーは、JDBC、ORM、OXM、JMS、およびトランザクションモジュールで構成されています。詳細は次のとおりです。
ザ・ JDBC モジュールは、面倒なJDBC関連のコーディングの必要性を排除するJDBC抽象化レイヤーを提供します。
ザ・ ORM モジュールは、JPA、JDO、Hibernate、iBatisなどの一般的なオブジェクトリレーショナルマッピングAPIの統合レイヤーを提供します。
ザ・ OXM モジュールは、JAXB、Castor、XMLBeans、JiBX、およびXStreamのオブジェクト/ XMLマッピング実装をサポートする抽象化レイヤーを提供します。
Javaメッセージングサービス JMS モジュールには、メッセージを生成および消費するための機能が含まれています。
ザ・ Transaction モジュールは、特別なインターフェイスを実装するクラスおよびすべてのPOJOのプログラムおよび宣言型トランザクション管理をサポートします。
ウェブ
Webレイヤーは、Web、Web-MVC、Web-Socket、およびWeb-Portletモジュールで構成されており、その詳細は次のとおりです。
ザ・ Web モジュールは、マルチパートファイルアップロード機能やサーブレットリスナーとWeb指向のアプリケーションコンテキストを使用したIoCコンテナの初期化などの基本的なWeb指向の統合機能を提供します。
ザ・ Web-MVC モジュールには、Webアプリケーション用のSpringのModel-View-Controller（MVC）実装が含まれています。
ザ・ Web-Socket モジュールは、Webアプリケーションのクライアントとサーバー間のWebSocketベースの双方向通信のサポートを提供します。
ザ・ Web-Portlet モジュールは、ポートレット環境で使用されるMVC実装を提供し、Webサーブレットモジュールの機能をミラーリングします。
その他
AOP、アスペクト、インストルメンテーション、Web、テストモジュールのような他の重要なモジュールはほとんどありません。詳細は次のとおりです。
ザ・ AOP モジュールはアスペクト指向プログラミングの実装を提供し、メソッドインターセプターとポイントカットを定義して、分離する必要のある機能を実装するコードを明確に分離できるようにします。
ザ・ Aspects モジュールは、強力で成熟したAOPフレームワークであるAspectJとの統合を提供します。
ザ・ Instrumentation モジュールは、特定のアプリケーションサーバーで使用されるクラスインストルメンテーションサポートとクラスローダー実装を提供します。
ザ・ Messagingモジュールは、アプリケーションで使用するWebSocketサブプロトコルとしてSTOMPのサポートを提供します。また、WebSocketクライアントからのSTOMPメッセージをルーティングおよび処理するための注釈プログラミングモデルもサポートしています。
ザ・ Test モジュールは、JUnitまたはTestNGフレームワークを使用したSpringコンポーネントのテストをサポートします。
この章では、SpringFrameworkで作業を開始するための開発環境を準備する方法について説明します。また、Spring Frameworkをセットアップする前に、マシンにJDK、Tomcat、およびEclipseをセットアップする方法についても説明します。
ステップ1-JavaDevelopment Kit（JDK）をセットアップする
SDKの最新バージョンは、OracleのJavaサイト-Java SEDownloadsからダウンロードできます。ダウンロードしたファイルにJDKをインストールする手順が記載されています。所定の手順に従って、セットアップをインストールおよび構成してください。最後に、PATHおよびJAVA_HOME環境変数を設定して、javaおよびjavacを含むディレクトリ（通常はそれぞれjava_install_dir / binおよびjava_install_dir）を参照します。
Windowsを実行していて、JDKをC：\ jdk1.6.0_15にインストールしている場合は、C：\ autoexec.batファイルに次の行を入力する必要があります。
set PATH=C:\jdk1.6.0_15\bin;%PATH%
set JAVA_HOME=C:\jdk1.6.0_15または、Windows NT / 2000 / XPでは、[マイコンピュータ]を右クリックして、[プロパティ]→[詳細設定]→[環境変数]を選択する必要があります。次に、PATH値を更新して、[OK]ボタンをクリックする必要があります。
Unix（Solaris、Linuxなど）で、SDKが/usr/local/jdk1.6.0_15にインストールされていて、Cシェルを使用している場合は、以下を.cshrcファイルに入れる必要があります。
setenv PATH /usr/local/jdk1.6.0_15/bin:$PATH
setenv JAVA_HOME /usr/local/jdk1.6.0_15または、Borland JBuilder、Eclipse、IntelliJ IDEA、Sun ONE Studioなどの統合開発環境（IDE）を使用する場合は、簡単なプログラムをコンパイルして実行し、IDEがJavaのインストール場所を認識していることを確認する必要があります。それ以外の場合は、IDEのドキュメントに記載されている適切なセットアップを実行する必要があります。
ステップ2-ApacheCommon LoggingAPIをインストールします
Apache Commons LoggingAPIの最新バージョンはからダウンロードできます。 https://commons.apache.org/logging/。インストールをダウンロードしたら、バイナリディストリビューションを便利な場所に解凍します。たとえば、Windowsの場合はC：\ commons-logging-1.1.1、Linux / Unixの場合は/usr/local/commons-logging-1.1.1にあります。このディレクトリには、次のjarファイルやその他のサポートドキュメントなどが含まれます。
このディレクトリにCLASSPATH変数を正しく設定してください。そうしないと、アプリケーションの実行中に問題が発生します。
ステップ3-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.exeEclipseは、Unix（Solaris、Linuxなど）マシンで次のコマンドを実行することで起動できます。
$/usr/local/eclipse/eclipse起動が成功した後、すべてが正常であれば、次の結果が表示されます-
ステップ4-SpringFrameworkライブラリをセットアップする
これですべてが正常であれば、Springフレームワークのセットアップに進むことができます。以下は、フレームワークをダウンロードしてマシンにインストールするための簡単な手順です。
SpringをWindowsまたはUnixのどちらにインストールするかを選択してから、次の手順に進み、Windowsの場合は.zipファイルを、Unixの場合は.tzファイルをダウンロードします。
Springフレームワークバイナリの最新バージョンをからダウンロードします https://repo.spring.io/release/org/springframework/spring。
このチュートリアルの開発時には、 spring-framework-4.1.6.RELEASE-dist.zipWindowsマシンにダウンロードされました。ダウンロードしたファイルを解凍すると、E：\ spring内に次のディレクトリ構造が表示されます。
すべてのSpringライブラリはディレクトリにあります E:\spring\libs。このディレクトリにCLASSPATH変数を正しく設定してください。そうしないと、アプリケーションの実行中に問題が発生します。Eclipseを使用している場合、すべての設定はEclipseを介して行われるため、CLASSPATHを設定する必要はありません。
この最後のステップが完了したら、次の章の最初のSpringの例に進む準備ができています。
SpringFrameworkで実際のプログラミングを始めましょう。Springフレームワークを使用して最初の例を書き始める前に、Spring-環境設定の章で説明されているように、Spring環境が正しく設定されていることを確認する必要があります。また、EclipseIDEに関する実用的な知識があることを前提としています。
それでは、「HelloWorld！」を出力する簡単なSpringアプリケーションの作成に進みましょう。または、SpringBeans構成ファイルで行われた構成に基づくその他のメッセージ。
ステップ1-Javaプロジェクトを作成する
最初のステップは、EclipseIDEを使用して単純なJavaプロジェクトを作成することです。オプションに従ってくださいFile → New → Project 最後に選択します Java Projectウィザードリストからのウィザード。プロジェクトに次の名前を付けますHelloSpring 次のようにウィザードウィンドウを使用する-
プロジェクトが正常に作成されると、次のコンテンツが作成されます。 Project Explorer −
ステップ2-必要なライブラリを追加する
2番目のステップとして、SpringFrameworkと一般的なロギングAPIライブラリをプロジェクトに追加しましょう。これを行うには、プロジェクト名を右クリックしますHelloSpring 次に、コンテキストメニューで使用可能な次のオプションに従います- Build Path → Configure Build Path 次のようにJavaビルドパスウィンドウを表示するには-
今すぐ使用 Add External JARs の下で利用可能なボタン Libraries [SpringFramework]および[CommonLogging]インストールディレクトリから次のコアJARを追加するタブ-
commons-logging-1.1.1
spring-aop-4.1.6.RELEASE
spring-aspects-4.1.6.RELEASE
spring-beans-4.1.6.RELEASE
spring-context-4.1.6.RELEASE
spring-context-support-4.1.6.RELEASE
spring-core-4.1.6.RELEASE
spring-expression-4.1.6.RELEASE
spring-instrument-4.1.6.RELEASE
spring-instrument-tomcat-4.1.6.RELEASE
spring-jdbc-4.1.6.RELEASE
spring-jms-4.1.6.RELEASE
spring-messaging-4.1.6.RELEASE
spring-orm-4.1.6.RELEASE
spring-oxm-4.1.6.RELEASE
spring-test-4.1.6.RELEASE
spring-tx-4.1.6.RELEASE
spring-web-4.1.6.RELEASE
spring-webmvc-4.1.6.RELEASE
spring-webmvc-portlet-4.1.6.RELEASE
spring-websocket-4.1.6.RELEASE
ステップ3-ソースファイルを作成する
それでは、実際のソースファイルを HelloSpring事業。まず、というパッケージを作成する必要がありますcom.tutorialspoint。これを行うには、右クリックしますsrc パッケージエクスプローラーセクションで、オプションに従ってください- New → Package。
次に作成します HelloWorld.java そして MainApp.java com.tutorialspointパッケージの下のファイル。
これがの内容です HelloWorld.java ファイル-
package com.tutorialspoint;
public class HelloWorld {
private String message;
public void setMessage(String message){
this.message = message;
}
public void getMessage(){
System.out.println("Your Message : " + message);
}
}以下は2番目のファイルの内容です 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");
HelloWorld obj = (HelloWorld) context.getBean("helloWorld");
obj.getMessage();
}
}メインプログラムについては、以下の2つの重要な点に注意する必要があります。
最初のステップは、フレームワークAPIを使用したアプリケーションコンテキストを作成することです ClassPathXmlApplicationContext()。このAPIはBean構成ファイルをロードし、最終的には提供されたAPIに基づいて、すべてのオブジェクト、つまり構成ファイルに記載されているBeanの作成と初期化を処理します。
2番目のステップは、を使用して必要なBeanを取得するために使用されます getBean()作成されたコンテキストのメソッド。このメソッドは、Bean IDを使用してジェネリックオブジェクトを返し、最終的に実際のオブジェクトにキャストできます。オブジェクトを取得したら、このオブジェクトを使用して任意のクラスメソッドを呼び出すことができます。
ステップ4-Bean構成ファイルを作成する
XMLファイルであり、Bean、つまりクラスを結合するセメントとして機能するBean構成ファイルを作成する必要があります。このファイルは、src 次のスクリーンショットに示すディレクトリ-
通常、開発者はこのファイルに次の名前を付けます Beans.xml、しかしあなたはあなたが好きな名前を選ぶために独立しています。MainApp.javaファイルに示されているように、アプリケーションコンテキストを作成するときは、このファイルがCLASSPATHで使用可能であり、メインアプリケーションで同じ名前を使用していることを確認する必要があります。
Beans.xmlは、異なるBeanに一意のIDを割り当て、Springソースファイルに影響を与えることなく、異なる値を持つオブジェクトの作成を制御するために使用されます。たとえば、次のファイルを使用すると、「message」変数に任意の値を渡すことができ、HelloWorld.javaファイルとMainApp.javaファイルに影響を与えることなくメッセージのさまざまな値を出力できます。それがどのように機能するか見てみましょう-
<?xml version = "1.0" encoding = "UTF-8"?>
<beans xmlns = "http://www.springframework.org/schema/beans"
xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation = "http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">
<bean id = "helloWorld" class = "com.tutorialspoint.HelloWorld">
<property name = "message" value = "Hello World!"/>
</bean>
</beans>Springアプリケーションがメモリにロードされると、Frameworkは上記の構成ファイルを使用して、定義されているすべてのBeanを作成し、で定義されているように一意のIDを割り当てます。 <bean>鬼ごっこ。使用できます<property> オブジェクトの作成時に使用されるさまざまな変数の値を渡すタグ。
ステップ5-プログラムの実行
ソースとBeanの構成ファイルの作成が完了したら、プログラムをコンパイルして実行するこのステップの準備が整います。これを行うには、MainApp.Javaファイルタブをアクティブのままにして、いずれかを使用しますRun EclipseIDEで利用可能なオプションまたは使用 Ctrl + F11 コンパイルして実行するには MainApp応用。アプリケーションに問題がない場合は、EclipseIDEのコンソールに次のメッセージが表示されます-
Your Message : Hello World!おめでとうございます。最初のSpringアプリケーションが正常に作成されました。「message」プロパティの値を変更し、両方のソースファイルを変更しないことで、上記のSpringアプリケーションの柔軟性を確認できます。
SpringコンテナはSpringFrameworkの中核です。コンテナは、オブジェクトを作成し、それらを相互に配線し、構成し、作成から破棄までの完全なライフサイクルを管理します。Springコンテナは、DIを使用して、アプリケーションを構成するコンポーネントを管理します。これらのオブジェクトはSpringBeansと呼ばれ、次の章で説明します。
コンテナーは、提供された構成メタデータを読み取ることにより、インスタンス化、構成、およびアセンブルするオブジェクトに関する指示を取得します。構成メタデータは、XML、Javaアノテーション、またはJavaコードのいずれかで表すことができます。次の図は、Springがどのように機能するかを大まかに示しています。Spring IoCコンテナーは、Java POJOクラスと構成メタデータを利用して、完全に構成された実行可能なシステムまたはアプリケーションを生成します。
Springは、次の2つの異なるタイプのコンテナーを提供します。
| シニア番号 | コンテナと説明 |
|---|---|
| 1 | SpringBeanFactoryコンテナ これは、DIの基本的なサポートを提供する最も単純なコンテナーであり、org.springframework.beans.factory.BeanFactoryインターフェースによって定義されます。BeanFactoryと、BeanFactoryAware、InitializingBean、DisposableBeanなどの関連インターフェースは、Springと統合する多数のサードパーティフレームワークとの下位互換性を目的として、Springに引き続き存在します。 |
| 2 | SpringApplicationContextコンテナ このコンテナは、プロパティファイルからテキストメッセージを解決する機能や、関心のあるイベントリスナーにアプリケーションイベントを公開する機能など、エンタープライズ固有の機能を追加します。このコンテナーは、org.springframework.context.ApplicationContextインターフェースによって定義されます。 |
ApplicationContextののコンテナは、すべての機能が含まれたBeanFactoryのそれは一般的に上で推奨されるように、コンテナをたBeanFactory。BeanFactoryは、データ量と速度が重要なモバイルデバイスやアプレットベースのアプリケーションなどの軽量アプリケーションにも引き続き使用できます。
アプリケーションのバックボーンを形成し、SpringIoCコンテナーによって管理されるオブジェクトは呼び出されます beans。Beanは、Spring IoCコンテナーによってインスタンス化、アセンブル、またはその他の方法で管理されるオブジェクトです。これらのBeanは、コンテナーに提供する構成メタデータを使用して作成されます。たとえば、前の章ですでに見たXML <bean />定義の形式です。
Bean定義には、という情報が含まれています configuration metadata、これはコンテナが次のことを知るために必要です-
- Beanの作成方法
- Beanのライフサイクルの詳細
- Beanの依存関係
上記のすべての構成メタデータは、各Bean定義を構成する次のプロパティのセットに変換されます。
| シニア番号 | プロパティと説明 |
|---|---|
| 1 | class この属性は必須であり、Beanの作成に使用されるBeanクラスを指定します。 |
| 2 | name この属性は、Bean識別子を一意に指定します。XMLベースの構成メタデータでは、id属性やname属性、あるいはその両方を使用してBean識別子を指定します。 |
| 3 | scope この属性は、特定のBean定義から作成されたオブジェクトのスコープを指定します。これについては、Beanスコープの章で説明します。 |
| 4 | constructor-arg これは依存関係を注入するために使用され、後続の章で説明します。 |
| 5 | properties これは依存関係を注入するために使用され、後続の章で説明します。 |
| 6 | autowiring mode これは依存関係を注入するために使用され、後続の章で説明します。 |
| 7 | lazy-initialization mode 遅延初期化されたBeanは、起動時ではなく、最初に要求されたときにBeanインスタンスを作成するようにIoCコンテナーに指示します。 |
| 8 | initialization method Beanで必要なすべてのプロパティがコンテナによって設定された直後に呼び出されるコールバック。これについては、Beanのライフサイクルの章で説明します。 |
| 9 | destruction method Beanを含むコンテナが破棄されたときに使用されるコールバック。これについては、Beanのライフサイクルの章で説明します。 |
Spring構成メタデータ
Spring IoCコンテナーは、この構成メタデータが実際に書き込まれる形式から完全に切り離されています。以下は、SpringContainerに構成メタデータを提供するための3つの重要な方法です。
- XMLベースの構成ファイル。
- 注釈ベースの構成
- Javaベースの構成
XMLベースの構成メタデータがコンテナーに提供される方法についてはすでに説明しましたが、レイジー初期化、初期化方法、破棄方法など、さまざまなBean定義を持つ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"
xsi:schemaLocation = "http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">
<!-- A simple bean definition -->
<bean id = "..." class = "...">
<!-- collaborators and configuration for this bean go here -->
</bean>
<!-- A bean definition with lazy init set on -->
<bean id = "..." class = "..." lazy-init = "true">
<!-- collaborators and configuration for this bean go here -->
</bean>
<!-- A bean definition with initialization method -->
<bean id = "..." class = "..." init-method = "...">
<!-- collaborators and configuration for this bean go here -->
</bean>
<!-- A bean definition with destruction method -->
<bean id = "..." class = "..." destroy-method = "...">
<!-- collaborators and configuration for this bean go here -->
</bean>
<!-- more bean definitions go here -->
</beans>Spring Hello World Exampleをチェックして、Spring Beanを定義、構成、および作成する方法を理解できます。
注釈ベースの構成については、別の章で説明します。Spring Dependency Injection with Annotationsでプログラミングを開始する前に、他のいくつかの重要なSpringの概念を理解してほしいので、別の章で意図的に説明します。
<bean>を定義するとき、そのBeanのスコープを宣言するオプションがあります。たとえば、Springに必要になるたびに新しいBeanインスタンスを生成させるには、Beanのスコープ属性を次のように宣言する必要があります。prototype。同様に、Springが必要になるたびに同じBeanインスタンスを返すようにする場合は、Beanのスコープ属性を次のように宣言する必要があります。singleton。
Spring Frameworkは、次の5つのスコープをサポートします。そのうちの3つは、Web対応のApplicationContextを使用する場合にのみ使用できます。
| シニア番号 | 範囲と説明 |
|---|---|
| 1 | singleton これにより、Bean定義がSpring IoCコンテナーごとに1つのインスタンスにスコープされます（デフォルト）。 |
| 2 | prototype これは、単一のBean定義をスコープして、任意の数のオブジェクトインスタンスを持ちます。 |
| 3 | request これは、Bean定義をHTTPリクエストにスコープします。Web対応のSpringApplicationContextのコンテキストでのみ有効です。 |
| 4 | session これは、Bean定義をHTTPセッションにスコープします。Web対応のSpringApplicationContextのコンテキストでのみ有効です。 |
| 5 | global-session これは、Bean定義をグローバルHTTPセッションにスコープします。Web対応のSpringApplicationContextのコンテキストでのみ有効です。 |
この章では、最初の2つのスコープについて説明し、残りの3つについては、Web対応のSpringApplicationContextについて説明します。
シングルトンスコープ
スコープがシングルトンに設定されている場合、Spring IoCコンテナーは、そのBean定義によって定義されたオブジェクトのインスタンスを1つだけ作成します。この単一インスタンスは、そのようなシングルトンBeanのキャッシュに格納され、その名前付きBeanに対する後続のすべての要求と参照は、キャッシュされたオブジェクトを返します。
デフォルトのスコープは常にシングルトンです。ただし、Beanのインスタンスが1つだけ必要な場合は、scope プロパティに singleton 次のコードスニペットに示すように、Bean構成ファイル内-
<!-- A bean definition with singleton scope -->
<bean id = "..." class = "..." scope = "singleton">
<!-- collaborators and configuration for this bean go here -->
</bean>例
動作するEclipseIDEを配置し、次の手順を実行してSpringアプリケーションを作成しましょう-
| ステップ | 説明 |
|---|---|
| 1 | SpringExampleという名前のプロジェクトを作成し、その下にcom.tutorialspointパッケージを作成します。src 作成したプロジェクトのフォルダ。 |
| 2 | Spring Hello Worldの例の章で説明されているように、[外部JARの追加]オプションを使用して必要なSpringライブラリを追加します。 |
| 3 | com.tutorialspointパッケージの下にJavaクラスHelloWorldとMainAppを作成します。 |
| 4 | Beans構成ファイルBeans.xmlをsrc フォルダ。 |
| 5 | 最後のステップは、すべてのJavaファイルとBean構成ファイルのコンテンツを作成し、以下で説明するようにアプリケーションを実行することです。 |
これがの内容です HelloWorld.java ファイル-
package com.tutorialspoint;
public class HelloWorld {
private String message;
public void setMessage(String message){
this.message = message;
}
public void getMessage(){
System.out.println("Your Message : " + message);
}
}以下は、の内容です 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");
HelloWorld objA = (HelloWorld) context.getBean("helloWorld");
objA.setMessage("I'm object A");
objA.getMessage();
HelloWorld objB = (HelloWorld) context.getBean("helloWorld");
objB.getMessage();
}
}以下は設定ファイルです 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"
xsi:schemaLocation = "http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">
<bean id = "helloWorld" class = "com.tutorialspoint.HelloWorld" scope = "singleton">
</bean>
</beans>ソースとBeanの構成ファイルの作成が完了したら、アプリケーションを実行しましょう。アプリケーションに問題がない場合は、次のメッセージが出力されます-
Your Message : I'm object A
Your Message : I'm object Aプロトタイプスコープ
スコープがプロトタイプに設定されている場合、Spring IoCコンテナーは、その特定のBeanの要求が行われるたびに、オブジェクトの新しいBeanインスタンスを作成します。原則として、すべてのステートフルBeanにはプロトタイプスコープを使用し、ステートレスBeanにはシングルトンスコープを使用します。
プロトタイプスコープを定義するには、 scope プロパティに prototype 次のコードスニペットに示すように、Bean構成ファイル内-
<!-- A bean definition with prototype scope -->
<bean id = "..." class = "..." scope = "prototype">
<!-- collaborators and configuration for this bean go here -->
</bean>例
Eclipse IDEを配置し、次の手順に従ってSpringアプリケーションを作成しましょう-
| ステップ | 説明 |
|---|---|
| 1 | SpringExampleという名前のプロジェクトを作成し、その下にcom.tutorialspointパッケージを作成します。src 作成したプロジェクトのフォルダ。 |
| 2 | Spring Hello Worldの例の章で説明されているように、[外部JARの追加]オプションを使用して必要なSpringライブラリを追加します。 |
| 3 | com.tutorialspointパッケージの下にJavaクラスHelloWorldとMainAppを作成します。 |
| 4 | Beans構成ファイルBeans.xmlをsrc フォルダ。 |
| 5 | 最後のステップは、すべてのJavaファイルとBean構成ファイルのコンテンツを作成し、以下で説明するようにアプリケーションを実行することです。 |
これがの内容です HelloWorld.java ファイル
package com.tutorialspoint;
public class HelloWorld {
private String message;
public void setMessage(String message){
this.message = message;
}
public void getMessage(){
System.out.println("Your Message : " + message);
}
}以下は、の内容です 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");
HelloWorld objA = (HelloWorld) context.getBean("helloWorld");
objA.setMessage("I'm object A");
objA.getMessage();
HelloWorld objB = (HelloWorld) context.getBean("helloWorld");
objB.getMessage();
}
}以下は設定ファイルです 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"
xsi:schemaLocation = "http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">
<bean id = "helloWorld" class = "com.tutorialspoint.HelloWorld" scope = "prototype">
</bean>
</beans>ソースとBeanの構成ファイルの作成が完了したら、アプリケーションを実行しましょう。アプリケーションに問題がない場合は、次のメッセージが出力されます-
Your Message : I'm object A
Your Message : null春の豆のライフサイクルは理解しやすいです。Beanがインスタンス化されると、使用可能な状態にするために初期化を実行する必要がある場合があります。同様に、Beanが不要になり、コンテナから削除されると、クリーンアップが必要になる場合があります。
Beanのインスタンス化とその破棄の間に舞台裏で行われるアクティビティのリストがありますが、この章では、Beanの初期化と破棄のときに必要な2つの重要なBeanライフサイクルコールバックメソッドについてのみ説明します。
Beanのセットアップとティアダウンを定義するには、<bean>を次のように宣言するだけです。 initmethod および/または destroy-methodパラメーター。init-method属性は、インスタンス化の直後にBeanで呼び出されるメソッドを指定します。同様に、destroymethodは、Beanがコンテナーから削除される直前に呼び出されるメソッドを指定します。
初期化コールバック
org.springframework.beans.factory.InitializingBeanインターフェースは、単一のメソッドを指定します-
void afterPropertiesSet() throws Exception;したがって、上記のインターフェイスを実装するだけで、次のようにafterPropertiesSet（）メソッド内で初期化作業を行うことができます。
public class ExampleBean implements InitializingBean {
public void afterPropertiesSet() {
// do some initialization work
}
}XMLベースの構成メタデータの場合、 init-methodvoid引数なしシグニチャを持つメソッドの名前を指定する属性。例-
<bean id = "exampleBean" class = "examples.ExampleBean" init-method = "init"/>以下はクラス定義です-
public class ExampleBean {
public void init() {
// do some initialization work
}
}破壊コールバック
org.springframework.beans.factory.DisposableBeanインタフェースは、単一のメソッドを指定します-
void destroy() throws Exception;したがって、上記のインターフェイスを実装するだけで、次のようにdestroy（）メソッド内でファイナライズ作業を行うことができます。
public class ExampleBean implements DisposableBean {
public void destroy() {
// do some destruction work
}
}XMLベースの構成メタデータの場合、 destroy-methodvoid引数なしシグニチャを持つメソッドの名前を指定する属性。例-
<bean id = "exampleBean" class = "examples.ExampleBean" destroy-method = "destroy"/>以下はクラス定義です-
public class ExampleBean {
public void destroy() {
// do some destruction work
}
}Web以外のアプリケーション環境でSpringのIoCコンテナを使用している場合。たとえば、リッチクライアントデスクトップ環境では、シャットダウンフックをJVMに登録します。そうすることで、正常なシャットダウンが保証され、シングルトンBeanの関連するdestroyメソッドが呼び出されて、すべてのリソースが解放されます。
XML構成ではメソッドの命名に関して非常に柔軟性があるため、InitializingBeanまたはDisposableBeanコールバックを使用しないことをお勧めします。
例
動作するEclipseIDEを配置し、次の手順を実行してSpringアプリケーションを作成しましょう-
| ステップ | 説明 |
|---|---|
| 1 | SpringExampleという名前のプロジェクトを作成し、その下にcom.tutorialspointパッケージを作成します。src 作成したプロジェクトのフォルダ。 |
| 2 | Spring Hello Worldの例の章で説明されているように、[外部JARの追加]オプションを使用して必要なSpringライブラリを追加します。 |
| 3 | com.tutorialspointパッケージの下にJavaクラスHelloWorldとMainAppを作成します。 |
| 4 | Beans構成ファイルBeans.xmlをsrc フォルダ。 |
| 5 | 最後のステップは、すべてのJavaファイルとBean構成ファイルのコンテンツを作成し、以下で説明するようにアプリケーションを実行することです。 |
これがの内容です HelloWorld.java ファイル-
package com.tutorialspoint;
public class HelloWorld {
private String message;
public void setMessage(String message){
this.message = message;
}
public void getMessage(){
System.out.println("Your Message : " + message);
}
public void init(){
System.out.println("Bean is going through init.");
}
public void destroy() {
System.out.println("Bean will destroy now.");
}
}以下は、の内容です MainApp.javaファイル。ここでシャットダウンフックを登録する必要がありますregisterShutdownHook()AbstractApplicationContextクラスで宣言されているメソッド。これにより、正常なシャットダウンが保証され、関連するdestroyメソッドが呼び出されます。
package com.tutorialspoint;
import org.springframework.context.support.AbstractApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class MainApp {
public static void main(String[] args) {
AbstractApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");
HelloWorld obj = (HelloWorld) context.getBean("helloWorld");
obj.getMessage();
context.registerShutdownHook();
}
}以下は設定ファイルです Beans.xml initおよびdestroyメソッドに必要-
<?xml version = "1.0" encoding = "UTF-8"?>
<beans xmlns = "http://www.springframework.org/schema/beans"
xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation = "http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">
<bean id = "helloWorld" class = "com.tutorialspoint.HelloWorld" init-method = "init"
destroy-method = "destroy">
<property name = "message" value = "Hello World!"/>
</bean>
</beans>ソースとBeanの構成ファイルの作成が完了したら、アプリケーションを実行しましょう。アプリケーションに問題がない場合は、次のメッセージが出力されます-
Bean is going through init.
Your Message : Hello World!
Bean will destroy now.デフォルトの初期化および破棄メソッド
同じ名前の初期化メソッドやdestroyメソッドを持つBeanが多すぎる場合は、宣言する必要はありません。 init-method そして destroy-method個々のBeanに。代わりに、フレームワークは、を使用してそのような状況を構成する柔軟性を提供しますdefault-init-method そして default-destroy-method <beans>要素の属性は次のとおりです-
<beans xmlns = "http://www.springframework.org/schema/beans"
xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation = "http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd"
default-init-method = "init"
default-destroy-method = "destroy">
<bean id = "..." class = "...">
<!-- collaborators and configuration for this bean go here -->
</bean>
</beans>ザ・ BeanPostProcessor インターフェースは、独自のインスタンス化ロジック、依存関係解決ロジックなどを提供するために実装できるコールバックメソッドを定義します。1つ以上のBeanPostProcessor実装をプラグインすることにより、SpringコンテナーがBeanのインスタンス化、構成、および初期化を完了した後に、いくつかのカスタムロジックを実装することもできます。 。
複数のBeanPostProcessorインターフェースを構成でき、これらのBeanPostProcessorインターフェースが実行される順序を制御するには、 order BeanPostProcessorが実装する場合のプロパティ Ordered インターフェース。
BeanPostProcessorsはBean（またはオブジェクト）インスタンスで動作します。つまり、Spring IoCコンテナーがBeanインスタンスをインスタンス化し、BeanPostProcessorインターフェースがその作業を実行します。
アン ApplicationContext の実装で定義されたBeanを自動的に検出します BeanPostProcessor これらのBeanをインターフェースし、ポストプロセッサーとして登録し、Beanの作成時にコンテナーによって適切に呼び出されるようにします。
例
次の例は、ApplicationContextのコンテキストでBeanPostProcessorsを作成、登録、および使用する方法を示しています。
動作するEclipseIDEを配置し、次の手順を実行してSpringアプリケーションを作成しましょう-
| ステップ | 説明 |
|---|---|
| 1 | SpringExampleという名前のプロジェクトを作成し、その下にcom.tutorialspointパッケージを作成します。src 作成したプロジェクトのフォルダ。 |
| 2 | Spring Hello Worldの例の章で説明されているように、[外部JARの追加]オプションを使用して必要なSpringライブラリを追加します。 |
| 3 | com.tutorialspointパッケージの下にJavaクラスHelloWorld、InitHelloWorld、およびMainAppを作成します。 |
| 4 | Beans構成ファイルBeans.xmlをsrc フォルダ。 |
| 5 | 最後のステップは、すべてのJavaファイルとBean構成ファイルのコンテンツを作成し、以下で説明するようにアプリケーションを実行することです。 |
これがの内容です HelloWorld.java ファイル-
package com.tutorialspoint;
public class HelloWorld {
private String message;
public void setMessage(String message){
this.message = message;
}
public void getMessage(){
System.out.println("Your Message : " + message);
}
public void init(){
System.out.println("Bean is going through init.");
}
public void destroy(){
System.out.println("Bean will destroy now.");
}
}これは、Beanの初期化の前後にBean名を出力するBeanPostProcessorを実装する非常に基本的な例です。両方のポストプロセッサメソッド内のBeanオブジェクトにアクセスできるため、Beanを初期化する前後に、より複雑なロジックを実装できます。
これがの内容です InitHelloWorld.java ファイル-
package com.tutorialspoint;
import org.springframework.beans.factory.config.BeanPostProcessor;
import org.springframework.beans.BeansException;
public class InitHelloWorld implements BeanPostProcessor {
public Object postProcessBeforeInitialization(Object bean, String beanName)
throws BeansException {
System.out.println("BeforeInitialization : " + beanName);
return bean; // you can return any other object as well
}
public Object postProcessAfterInitialization(Object bean, String beanName)
throws BeansException {
System.out.println("AfterInitialization : " + beanName);
return bean; // you can return any other object as well
}
}以下は、の内容です MainApp.javaファイル。ここでシャットダウンフックを登録する必要がありますregisterShutdownHook()AbstractApplicationContextクラスで宣言されているメソッド。これにより、正常なシャットダウンが保証され、関連するdestroyメソッドが呼び出されます。
package com.tutorialspoint;
import org.springframework.context.support.AbstractApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class MainApp {
public static void main(String[] args) {
AbstractApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");
HelloWorld obj = (HelloWorld) context.getBean("helloWorld");
obj.getMessage();
context.registerShutdownHook();
}
}以下は設定ファイルです Beans.xml initおよびdestroyメソッドに必要-
<?xml version = "1.0" encoding = "UTF-8"?>
<beans xmlns = "http://www.springframework.org/schema/beans"
xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation = "http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">
<bean id = "helloWorld" class = "com.tutorialspoint.HelloWorld"
init-method = "init" destroy-method = "destroy">
<property name = "message" value = "Hello World!"/>
</bean>
<bean class = "com.tutorialspoint.InitHelloWorld" />
</beans>ソースとBeanの構成ファイルの作成が完了したら、アプリケーションを実行しましょう。アプリケーションに問題がない場合は、次のメッセージが出力されます-
BeforeInitialization : helloWorld
Bean is going through init.
AfterInitialization : helloWorld
Your Message : Hello World!
Bean will destroy now.Bean定義には、コンストラクター引数、プロパティ値、初期化メソッド、静的ファクトリメソッド名などのコンテナー固有の情報など、多くの構成情報を含めることができます。
子Bean定義は、親定義から構成データを継承します。子定義は、必要に応じて、一部の値をオーバーライドしたり、他の値を追加したりできます。
Spring Bean定義の継承は、Javaクラスの継承とは関係ありませんが、継承の概念は同じです。親Bean定義をテンプレートとして定義でき、他の子Beanは親Beanから必要な構成を継承できます。
XMLベースの構成メタデータを使用する場合は、を使用して子Bean定義を指定します。 parent 属性。この属性の値として親Beanを指定します。
例
動作するEclipseIDEを配置し、次の手順を実行してSpringアプリケーションを作成しましょう-
| ステップ | 説明 |
|---|---|
| 1 | SpringExampleという名前のプロジェクトを作成し、その下にcom.tutorialspointパッケージを作成します。src 作成したプロジェクトのフォルダ。 |
| 2 | Spring Hello Worldの例の章で説明されているように、[外部JARの追加]オプションを使用して必要なSpringライブラリを追加します。 |
| 3 | com.tutorialspointパッケージの下にJavaクラスHelloWorld、HelloIndia、およびMainAppを作成します。 |
| 4 | Beans構成ファイルBeans.xmlをsrc フォルダ。 |
| 5 | 最後のステップは、すべてのJavaファイルとBean構成ファイルのコンテンツを作成し、以下で説明するようにアプリケーションを実行することです。 |
以下は設定ファイルです Beans.xmlここで、message1とmessage2の2つのプロパティを持つ「helloWorld」Beanを定義しました。次の「helloIndia」Beanは、を使用して「helloWorld」Beanの子として定義されています。parent属性。子ビーン継承メッセージ2プロパティがあり、そしてオーバーライドとしてメッセージ1プロパティと紹介1つの以上のプロパティmessage3。
<?xml version = "1.0" encoding = "UTF-8"?>
<beans xmlns = "http://www.springframework.org/schema/beans"
xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation = "http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">
<bean id = "helloWorld" class = "com.tutorialspoint.HelloWorld">
<property name = "message1" value = "Hello World!"/>
<property name = "message2" value = "Hello Second World!"/>
</bean>
<bean id ="helloIndia" class = "com.tutorialspoint.HelloIndia" parent = "helloWorld">
<property name = "message1" value = "Hello India!"/>
<property name = "message3" value = "Namaste India!"/>
</bean>
</beans>これがの内容です HelloWorld.java ファイル-
package com.tutorialspoint;
public class HelloWorld {
private String message1;
private String message2;
public void setMessage1(String message){
this.message1 = message;
}
public void setMessage2(String message){
this.message2 = message;
}
public void getMessage1(){
System.out.println("World Message1 : " + message1);
}
public void getMessage2(){
System.out.println("World Message2 : " + message2);
}
}これがの内容です HelloIndia.java ファイル-
package com.tutorialspoint;
public class HelloIndia {
private String message1;
private String message2;
private String message3;
public void setMessage1(String message){
this.message1 = message;
}
public void setMessage2(String message){
this.message2 = message;
}
public void setMessage3(String message){
this.message3 = message;
}
public void getMessage1(){
System.out.println("India Message1 : " + message1);
}
public void getMessage2(){
System.out.println("India Message2 : " + message2);
}
public void getMessage3(){
System.out.println("India Message3 : " + message3);
}
}以下は、の内容です 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");
HelloWorld objA = (HelloWorld) context.getBean("helloWorld");
objA.getMessage1();
objA.getMessage2();
HelloIndia objB = (HelloIndia) context.getBean("helloIndia");
objB.getMessage1();
objB.getMessage2();
objB.getMessage3();
}
}ソースとBeanの構成ファイルの作成が完了したら、アプリケーションを実行しましょう。アプリケーションに問題がない場合は、次のメッセージが出力されます-
World Message1 : Hello World!
World Message2 : Hello Second World!
India Message1 : Hello India!
India Message2 : Hello Second World!
India Message3 : Namaste India!ここで観察した場合、「helloIndia」Beanの作成中にmessage2を渡さなかったが、Bean定義の継承のために渡された。
Bean定義テンプレート
Bean定義テンプレートを作成できます。これは、他の子Bean定義で多くの労力をかけずに使用できます。Bean定義テンプレートを定義するときは、class 属性と指定する必要があります abstract 属性であり、次の値で抽象属性を指定する必要があります true 次のコードスニペットに示すように-
<?xml version = "1.0" encoding = "UTF-8"?>
<beans xmlns = "http://www.springframework.org/schema/beans"
xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation = "http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">
<bean id = "beanTeamplate" abstract = "true">
<property name = "message1" value = "Hello World!"/>
<property name = "message2" value = "Hello Second World!"/>
<property name = "message3" value = "Namaste India!"/>
</bean>
<bean id = "helloIndia" class = "com.tutorialspoint.HelloIndia" parent = "beanTeamplate">
<property name = "message1" value = "Hello India!"/>
<property name = "message3" value = "Namaste India!"/>
</bean>
</beans>親Beanは不完全であるため、それ自体でインスタンス化することはできません。また、抽象として明示的にマークされています。定義がこのように抽象的である場合、子定義の親定義として機能する純粋なテンプレートBean定義としてのみ使用できます。
すべてのJavaベースのアプリケーションには、エンドユーザーが機能しているアプリケーションと見なすものを提示するために連携して機能するいくつかのオブジェクトがあります。複雑なJavaアプリケーションを作成する場合、アプリケーションクラスは他のJavaクラスから可能な限り独立している必要があります。これにより、これらのクラスを再利用し、単体テスト中に他のクラスから独立してテストできるようになります。依存性注入（またはワイヤリングと呼ばれることもあります）は、これらのクラスを結合すると同時に、それらを独立させるのに役立ちます。
テキストエディタコンポーネントを備えたアプリケーションがあり、スペルチェックを提供したいとします。標準コードは次のようになります-
public class TextEditor {
private SpellChecker spellChecker;
public TextEditor() {
spellChecker = new SpellChecker();
}
}ここで行ったことは、TextEditorとSpellCheckerの間に依存関係を作成することです。制御の反転シナリオでは、代わりに次のようなことを行います-
public class TextEditor {
private SpellChecker spellChecker;
public TextEditor(SpellChecker spellChecker) {
this.spellChecker = spellChecker;
}
}ここで、TextEditorはSpellCheckerの実装について心配する必要はありません。SpellCheckerは独立して実装され、TextEditorのインスタンス化時にTextEditorに提供されます。この手順全体は、SpringFrameworkによって制御されます。
ここでは、TextEditorから完全な制御を削除し、それを別の場所（つまり、XML構成ファイル）に保持し、依存関係（つまり、クラスSpellChecker）をクラスTextEditorに挿入しています。 Class Constructor。したがって、依存性を何らかの外部システムに効果的に委任したため、制御の流れは依存性注入（DI）によって「反転」されました。
依存関係を注入する2番目の方法は Setter MethodsSpellCheckerインスタンスを作成するTextEditorクラスの このインスタンスは、TextEditorのプロパティを初期化するためのsetterメソッドを呼び出すために使用されます。
したがって、DIは2つの主要なバリアントで存在し、次の2つのサブチャプターで両方を例で説明します。
| シニア番号 | 依存性注入のタイプと説明 |
|---|---|
| 1 | コンストラクターベースの依存性注入 コンストラクターベースのDIは、コンテナーが、それぞれが他のクラスへの依存関係を表すいくつかの引数を持つクラスコンストラクターを呼び出すときに実行されます。 |
| 2 | セッターベースの依存性注入 セッターベースのDIは、Beanをインスタンス化するために引数なしのコンストラクターまたは引数なしの静的ファクトリメソッドを呼び出した後、コンテナーがBeanのsetterメソッドを呼び出すことによって実現されます。 |
コンストラクターベースのDIとセッターベースのDIの両方を混在させることができますが、必須の依存関係にはコンストラクター引数を使用し、オプションの依存関係にはセッターを使用することをお勧めします。
コードはDIの原則によりクリーンであり、オブジェクトに依存関係が提供されている場合、デカップリングはより効果的です。オブジェクトはその依存関係を検索せず、依存関係の場所やクラスを認識しません。むしろ、すべてがSpringFrameworkによって処理されます。
ご存知のように、Java内部クラスは他のクラスのスコープ内で定義されています。 inner beans別のBeanのスコープ内で定義されているBeanです。したがって、<property />または<constructor-arg />要素内の<bean />要素は内部Beanと呼ばれ、以下に示されています。
<?xml version = "1.0" encoding = "UTF-8"?>
<beans xmlns = "http://www.springframework.org/schema/beans"
xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation = "http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">
<bean id = "outerBean" class = "...">
<property name = "target">
<bean id = "innerBean" class = "..."/>
</property>
</bean>
</beans>例
Eclipse IDEを配置し、次の手順に従ってSpringアプリケーションを作成しましょう-
| ステップ | 説明 |
|---|---|
| 1 | SpringExampleという名前のプロジェクトを作成し、その下にcom.tutorialspointパッケージを作成します。src 作成したプロジェクトのフォルダ。 |
| 2 | Spring Hello Worldの例の章で説明されているように、[外部JARの追加]オプションを使用して必要なSpringライブラリを追加します。 |
| 3 | com.tutorialspointパッケージの下にJavaクラスTextEditor、SpellChecker、およびMainAppを作成します。 |
| 4 | Beans構成ファイルBeans.xmlをsrc フォルダ。 |
| 5 | 最後のステップは、すべてのJavaファイルとBean構成ファイルのコンテンツを作成し、以下で説明するようにアプリケーションを実行することです。 |
これがの内容です TextEditor.java ファイル-
package com.tutorialspoint;
public class TextEditor {
private SpellChecker spellChecker;
// a setter method to inject the dependency.
public void setSpellChecker(SpellChecker spellChecker) {
System.out.println("Inside setSpellChecker." );
this.spellChecker = spellChecker;
}
// a getter method to return spellChecker
public SpellChecker getSpellChecker() {
return spellChecker;
}
public void spellCheck() {
spellChecker.checkSpelling();
}
}以下は、別の従属クラスファイルの内容です SpellChecker.java −
package com.tutorialspoint;
public class SpellChecker {
public SpellChecker(){
System.out.println("Inside SpellChecker constructor." );
}
public void checkSpelling(){
System.out.println("Inside checkSpelling." );
}
}以下は、の内容です 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");
TextEditor te = (TextEditor) context.getBean("textEditor");
te.spellCheck();
}
}以下は設定ファイルです Beans.xml セッターベースの注入用の構成がありますが、 inner beans −
<?xml version = "1.0" encoding = "UTF-8"?>
<beans xmlns = "http://www.springframework.org/schema/beans"
xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation = "http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">
<!-- Definition for textEditor bean using inner bean -->
<bean id = "textEditor" class = "com.tutorialspoint.TextEditor">
<property name = "spellChecker">
<bean id = "spellChecker" class = "com.tutorialspoint.SpellChecker"/>
</property>
</bean>
</beans>ソースとBeanの構成ファイルの作成が完了したら、アプリケーションを実行しましょう。アプリケーションに問題がない場合は、次のメッセージが出力されます-
Inside SpellChecker constructor.
Inside setSpellChecker.
Inside checkSpelling.を使用してプリミティブデータ型を構成する方法を見てきました value を使用した属性とオブジェクトの参照 refBean構成ファイルの<property>タグの属性。どちらの場合も、Beanに特異値を渡すことを扱います。
ここで、List、Set、Map、PropertiesなどのJavaコレクションタイプのような複数の値を渡したい場合はどうでしょうか。この状況に対処するために、Springは次の4種類のコレクション構成要素を提供しています。
| シニア番号 | 要素と説明 |
|---|---|
| 1 | <list> これは、配線、つまり値のリストの挿入に役立ち、重複を許可します。 |
| 2 | <set> これは、値のセットを配線するのに役立ちますが、重複はありません。 |
| 3 | <map> これを使用して、名前と値のペアのコレクションを挿入できます。名前と値は任意のタイプにすることができます。 |
| 4 | <props> これを使用して、名前と値が両方とも文字列である名前と値のペアのコレクションを挿入できます。 |
<list>または<set>のいずれかを使用して、java.util.Collectionまたは array。
（a）コレクションの直接値を渡すことと、（b）コレクション要素の1つとしてBeanの参照を渡すことの2つの状況に遭遇します。
例
動作するEclipseIDEを配置し、次の手順を実行してSpringアプリケーションを作成しましょう-
| ステップ | 説明 |
|---|---|
| 1 | SpringExampleという名前のプロジェクトを作成し、その下にcom.tutorialspointパッケージを作成します。src 作成したプロジェクトのフォルダ。 |
| 2 | Spring Hello Worldの例の章で説明されているように、[外部JARの追加]オプションを使用して必要なSpringライブラリを追加します。 |
| 3 | com.tutorialspointパッケージの下にJavaクラスJavaCollectionおよびMainAppを作成します。 |
| 4 | Beans構成ファイルBeans.xmlをsrc フォルダ。 |
| 5 | 最後のステップは、すべてのJavaファイルとBean構成ファイルのコンテンツを作成し、以下で説明するようにアプリケーションを実行することです。 |
これがの内容です JavaCollection.java ファイル-
package com.tutorialspoint;
import java.util.*;
public class JavaCollection {
List addressList;
Set addressSet;
Map addressMap;
Properties addressProp;
// a setter method to set List
public void setAddressList(List addressList) {
this.addressList = addressList;
}
// prints and returns all the elements of the list.
public List getAddressList() {
System.out.println("List Elements :" + addressList);
return addressList;
}
// a setter method to set Set
public void setAddressSet(Set addressSet) {
this.addressSet = addressSet;
}
// prints and returns all the elements of the Set.
public Set getAddressSet() {
System.out.println("Set Elements :" + addressSet);
return addressSet;
}
// a setter method to set Map
public void setAddressMap(Map addressMap) {
this.addressMap = addressMap;
}
// prints and returns all the elements of the Map.
public Map getAddressMap() {
System.out.println("Map Elements :" + addressMap);
return addressMap;
}
// a setter method to set Property
public void setAddressProp(Properties addressProp) {
this.addressProp = addressProp;
}
// prints and returns all the elements of the Property.
public Properties getAddressProp() {
System.out.println("Property Elements :" + addressProp);
return addressProp;
}
}以下は、の内容です 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");
JavaCollection jc=(JavaCollection)context.getBean("javaCollection");
jc.getAddressList();
jc.getAddressSet();
jc.getAddressMap();
jc.getAddressProp();
}
}以下は設定ファイルです 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"
xsi:schemaLocation = "http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">
<!-- Definition for javaCollection -->
<bean id = "javaCollection" class = "com.tutorialspoint.JavaCollection">
<!-- results in a setAddressList(java.util.List) call -->
<property name = "addressList">
<list>
<value>INDIA</value>
<value>Pakistan</value>
<value>USA</value>
<value>USA</value>
</list>
</property>
<!-- results in a setAddressSet(java.util.Set) call -->
<property name = "addressSet">
<set>
<value>INDIA</value>
<value>Pakistan</value>
<value>USA</value>
<value>USA</value>
</set>
</property>
<!-- results in a setAddressMap(java.util.Map) call -->
<property name = "addressMap">
<map>
<entry key = "1" value = "INDIA"/>
<entry key = "2" value = "Pakistan"/>
<entry key = "3" value = "USA"/>
<entry key = "4" value = "USA"/>
</map>
</property>
<!-- results in a setAddressProp(java.util.Properties) call -->
<property name = "addressProp">
<props>
<prop key = "one">INDIA</prop>
<prop key = "one">INDIA</prop>
<prop key = "two">Pakistan</prop>
<prop key = "three">USA</prop>
<prop key = "four">USA</prop>
</props>
</property>
</bean>
</beans>ソースとBeanの構成ファイルの作成が完了したら、アプリケーションを実行しましょう。アプリケーションに問題がない場合は、次のメッセージが出力されます-
List Elements :[INDIA, Pakistan, USA, USA]
Set Elements :[INDIA, Pakistan, USA]
ap Elements :{1 = INDIA, 2 = Pakistan, 3 = USA, 4 = USA}
Property Elements :{two = Pakistan, one = INDIA, three = USA, four = USA}Bean参照の注入
次のBean定義は、コレクションの要素の1つとしてBean参照を挿入する方法を理解するのに役立ちます。次のコードスニペットに示すように、参照と値をすべて一緒に混在させることもできます-
<?xml version = "1.0" encoding = "UTF-8"?>
<beans xmlns = "http://www.springframework.org/schema/beans"
xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation = "http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">
<!-- Bean Definition to handle references and values -->
<bean id = "..." class = "...">
<!-- Passing bean reference for java.util.List -->
<property name = "addressList">
<list>
<ref bean = "address1"/>
<ref bean = "address2"/>
<value>Pakistan</value>
</list>
</property>
<!-- Passing bean reference for java.util.Set -->
<property name = "addressSet">
<set>
<ref bean = "address1"/>
<ref bean = "address2"/>
<value>Pakistan</value>
</set>
</property>
<!-- Passing bean reference for java.util.Map -->
<property name = "addressMap">
<map>
<entry key = "one" value = "INDIA"/>
<entry key = "two" value-ref = "address1"/>
<entry key = "three" value-ref = "address2"/>
</map>
</property>
</bean>
</beans>上記のBean定義を使用するには、参照も処理できるようにセッターメソッドを定義する必要があります。
nullと空の文字列値を挿入する
空の文字列を値として渡す必要がある場合は、次のように渡すことができます-
<bean id = "..." class = "exampleBean">
<property name = "email" value = ""/>
</bean>上記の例は、Javaコードと同等です：exampleBean.setEmail（ ""）
NULL値を渡す必要がある場合は、次のように渡すことができます-
<bean id = "..." class = "exampleBean">
<property name = "email"><null/></property>
</bean>上記の例は、Javaコードと同等です：exampleBean.setEmail（null）
XML構成ファイルで<bean>要素を使用してBeanを宣言し、<constructor-arg>要素と<property>要素を使用して<bean>を注入する方法を学習しました。
春のコンテナはできます autowire <constructor-arg>要素と<property>要素を使用せずにコラボレーションするBean間の関係。これにより、Springベースの大規模なアプリケーション用に作成するXML構成の量を削減できます。
自動配線モード
以下は、依存性注入に自動配線を使用するようにSpringコンテナーに指示するために使用できる自動配線モードです。<bean />要素のautowire属性を使用して指定しますautowire Bean定義のモード。
| シニア番号 | モードと説明 |
|---|---|
| 1 | no これはデフォルト設定であり、自動配線がないことを意味します。配線には明示的なBean参照を使用する必要があります。この配線には特別なことは何もありません。これは、依存性注入の章ですでに見たものです。 |
| 2 | 名前で プロパティ名による自動配線。Springコンテナーは、XML構成ファイルでautowire属性がbyNameに設定されているBeanのプロパティーを調べます。次に、そのプロパティを構成ファイルで同じ名前で定義されたBeanと照合してワイヤリングしようとします。 |
| 3 | byType プロパティデータ型による自動配線。Springコンテナーは、XML構成ファイルでautowire属性がbyTypeに設定されているBeanのプロパティーを調べます。次に、プロパティのマッチングとワイヤリングを試みます。type構成ファイル内のBean名の1つと正確に一致します。そのようなBeanが複数存在する場合、致命的な例外がスローされます。 |
| 4 | constructor Similar to byType, but type applies to constructor arguments. If there is not exactly one bean of the constructor argument type in the container, a fatal error is raised. |
| 5 | autodetect Spring first tries to wire using autowire by constructor, if it does not work, Spring tries to autowire by byType. |
You can use byType or constructor autowiring mode to wire arrays and other typed-collections.
Limitations with autowiring
Autowiring works best when it is used consistently across a project. If autowiring is not used in general, it might be confusing for developers to use it to wire only one or two bean definitions. Though, autowiring can significantly reduce the need to specify properties or constructor arguments but you should consider the limitations and disadvantages of autowiring before using them.
| Sr.No. | Limitations & Description |
|---|---|
| 1 | Overriding possibility You can still specify dependencies using <constructor-arg> and <property> settings which will always override autowiring. |
| 2 | Primitive data types You cannot autowire so-called simple properties such as primitives, Strings, and Classes. |
| 3 | Confusing nature Autowiring is less exact than explicit wiring, so if possible prefer using explict wiring. |
Starting from Spring 2.5 it became possible to configure the dependency injection using annotations. So instead of using XML to describe a bean wiring, you can move the bean configuration into the component class itself by using annotations on the relevant class, method, or field declaration.
Annotation injection is performed before XML injection. Thus, the latter configuration will override the former for properties wired through both approaches.
Annotation wiring is not turned on in the Spring container by default. So, before we can use annotation-based wiring, we will need to enable it in our Spring configuration file. So consider the following configuration file in case you want to use any annotation in your Spring application.
<?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:context = "http://www.springframework.org/schema/context"
xsi:schemaLocation = "http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-3.0.xsd">
<context:annotation-config/>
<!-- bean definitions go here -->
</beans>Once <context:annotation-config/> is configured, you can start annotating your code to indicate that Spring should automatically wire values into properties, methods, and constructors. Let us look at a few important annotations to understand how they work −
| Sr.No. | Annotation & Description |
|---|---|
| 1 | @Required The @Required annotation applies to bean property setter methods. |
| 2 | @Autowired The @Autowired annotation can apply to bean property setter methods, non-setter methods, constructor and properties. |
| 3 | @Qualifier The @Qualifier annotation along with @Autowired can be used to remove the confusion by specifiying which exact bean will be wired. |
| 4 | JSR-250 Annotations Spring supports JSR-250 based annotations which include @Resource, @PostConstruct and @PreDestroy annotations. |
So far you have seen how we configure Spring beans using XML configuration file. If you are comfortable with XML configuration, then it is really not required to learn how to proceed with Java-based configuration as you are going to achieve the same result using either of the configurations available.
Java-based configuration option enables you to write most of your Spring configuration without XML but with the help of few Java-based annotations explained in this chapter.
@Configuration & @Bean Annotations
Annotating a class with the @Configuration indicates that the class can be used by the Spring IoC container as a source of bean definitions. The @Bean annotation tells Spring that a method annotated with @Bean will return an object that should be registered as a bean in the Spring application context. The simplest possible @Configuration class would be as follows −
package com.tutorialspoint;
import org.springframework.context.annotation.*;
@Configuration
public class HelloWorldConfig {
@Bean
public HelloWorld helloWorld(){
return new HelloWorld();
}
}The above code will be equivalent to the following XML configuration −
<beans>
<bean id = "helloWorld" class = "com.tutorialspoint.HelloWorld" />
</beans>Here, the method name is annotated with @Bean works as bean ID and it creates and returns the actual bean. Your configuration class can have a declaration for more than one @Bean. Once your configuration classes are defined, you can load and provide them to Spring container using AnnotationConfigApplicationContext as follows −
public static void main(String[] args) {
ApplicationContext ctx = new AnnotationConfigApplicationContext(HelloWorldConfig.class);
HelloWorld helloWorld = ctx.getBean(HelloWorld.class);
helloWorld.setMessage("Hello World!");
helloWorld.getMessage();
}You can load various configuration classes as follows −
public static void main(String[] args) {
AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext();
ctx.register(AppConfig.class, OtherConfig.class);
ctx.register(AdditionalConfig.class);
ctx.refresh();
MyService myService = ctx.getBean(MyService.class);
myService.doStuff();
}Example
Let us have a working Eclipse IDE in place and take the following steps to create a Spring application −
| Steps | Description |
|---|---|
| 1 | Create a project with a name SpringExample and create a package com.tutorialspoint under the src folder in the created project. |
| 2 | Add required Spring libraries using Add External JARs option as explained in the Spring Hello World Example chapter. |
| 3 | Because you are using Java-based annotations, so you also need to add CGLIB.jar from your Java installation directory and ASM.jar library which can be downloaded from asm.ow2.org. |
| 4 | Create Java classes HelloWorldConfig, HelloWorld and MainApp under the com.tutorialspoint package. |
| 5 | The final step is to create the content of all the Java files and Bean Configuration file and run the application as explained below. |
Here is the content of HelloWorldConfig.java file
package com.tutorialspoint;
import org.springframework.context.annotation.*;
@Configuration
public class HelloWorldConfig {
@Bean
public HelloWorld helloWorld(){
return new HelloWorld();
}
}Here is the content of HelloWorld.java file
package com.tutorialspoint;
public class HelloWorld {
private String message;
public void setMessage(String message){
this.message = message;
}
public void getMessage(){
System.out.println("Your Message : " + message);
}
}Following is the content of the MainApp.java file
package com.tutorialspoint;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.*;
public class MainApp {
public static void main(String[] args) {
ApplicationContext ctx =
new AnnotationConfigApplicationContext(HelloWorldConfig.class);
HelloWorld helloWorld = ctx.getBean(HelloWorld.class);
helloWorld.setMessage("Hello World!");
helloWorld.getMessage();
}
}Once you are done creating all the source files and adding the required additional libraries, let us run the application. You should note that there is no configuration file required. If everything is fine with your application, it will print the following message −
Your Message : Hello World!Injecting Bean Dependencies
When @Beans have dependencies on one another, expressing that the dependency is as simple as having one bean method calling another as follows −
package com.tutorialspoint;
import org.springframework.context.annotation.*;
@Configuration
public class AppConfig {
@Bean
public Foo foo() {
return new Foo(bar());
}
@Bean
public Bar bar() {
return new Bar();
}
}Here, the foo bean receives a reference to bar via the constructor injection. Now let us look at another working example.
Example
Let us have a working Eclipse IDE in place and take the following steps to create a Spring application −
| Steps | Description |
|---|---|
| 1 | Create a project with a name SpringExample and create a package com.tutorialspoint under the src folder in the created project. |
| 2 | Add required Spring libraries using Add External JARs option as explained in the Spring Hello World Example chapter. |
| 3 | Because you are using Java-based annotations, so you also need to add CGLIB.jar from your Java installation directory and ASM.jar library which can be downloaded from asm.ow2.org. |
| 4 | Create Java classes TextEditorConfig, TextEditor, SpellChecker and MainApp under the com.tutorialspoint package. |
| 5 | The final step is to create the content of all the Java files and Bean Configuration file and run the application as explained below. |
Here is the content of TextEditorConfig.java file
package com.tutorialspoint;
import org.springframework.context.annotation.*;
@Configuration
public class TextEditorConfig {
@Bean
public TextEditor textEditor(){
return new TextEditor( spellChecker() );
}
@Bean
public SpellChecker spellChecker(){
return new SpellChecker( );
}
}Here is the content of TextEditor.java file
package com.tutorialspoint;
public class TextEditor {
private SpellChecker spellChecker;
public TextEditor(SpellChecker spellChecker){
System.out.println("Inside TextEditor constructor." );
this.spellChecker = spellChecker;
}
public void spellCheck(){
spellChecker.checkSpelling();
}
}Following is the content of another dependent class file SpellChecker.java
package com.tutorialspoint;
public class SpellChecker {
public SpellChecker(){
System.out.println("Inside SpellChecker constructor." );
}
public void checkSpelling(){
System.out.println("Inside checkSpelling." );
}
}Following is the content of the MainApp.java file
package com.tutorialspoint;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.*;
public class MainApp {
public static void main(String[] args) {
ApplicationContext ctx =
new AnnotationConfigApplicationContext(TextEditorConfig.class);
TextEditor te = ctx.getBean(TextEditor.class);
te.spellCheck();
}
}Once you are done creating all the source files and adding the required additional libraries, let us run the application. You should note that there is no configuration file required. If everything is fine with your application, it will print the following message −
Inside SpellChecker constructor.
Inside TextEditor constructor.
Inside checkSpelling.The @Import Annotation
The @Import annotation allows for loading @Bean definitions from another configuration class. Consider a ConfigA class as follows −
@Configuration
public class ConfigA {
@Bean
public A a() {
return new A();
}
}You can import above Bean declaration in another Bean Declaration as follows −
@Configuration
@Import(ConfigA.class)
public class ConfigB {
@Bean
public B b() {
return new B();
}
}Now, rather than needing to specify both ConfigA.class and ConfigB.class when instantiating the context, only ConfigB needs to be supplied as follows −
public static void main(String[] args) {
ApplicationContext ctx = new AnnotationConfigApplicationContext(ConfigB.class);
// now both beans A and B will be available...
A a = ctx.getBean(A.class);
B b = ctx.getBean(B.class);
}ライフサイクルコールバック
@Beanアノテーションは、Bean要素のSpring XMLのinit-methodおよびdestroy-method属性と同様に、任意の初期化および破棄コールバックメソッドの指定をサポートします。
public class Foo {
public void init() {
// initialization logic
}
public void cleanup() {
// destruction logic
}
}
@Configuration
public class AppConfig {
@Bean(initMethod = "init", destroyMethod = "cleanup" )
public Foo foo() {
return new Foo();
}
}Beanスコープの指定
デフォルトのスコープはシングルトンですが、次のように@Scopeアノテーションでこれをオーバーライドできます-
@Configuration
public class AppConfig {
@Bean
@Scope("prototype")
public Foo foo() {
return new Foo();
}
}あなたはすべての章で春の核心が ApplicationContext、Beanの完全なライフサイクルを管理します。ApplicationContextは、Beanをロードするときに特定のタイプのイベントを公開します。たとえば、ContextStartedEventはコンテキストの開始時に公開され、ContextStoppedEventはコンテキストの停止時に公開されます。
イベント処理のApplicationContextを介して提供されApplicationEventのクラスとApplicationListenerのインタフェース。したがって、BeanがApplicationListenerを実装している場合、ApplicationEventがApplicationContextに公開されるたびに、そのBeanに通知されます。
Springは次の標準イベントを提供します-
| シニア番号 | 春のビルトインイベントと説明 |
|---|---|
| 1 | ContextRefreshedEvent このイベントは、ApplicationContextが初期化または更新されたときに公開されます。これは、ConfigurableApplicationContextインターフェイスのrefresh（）メソッドを使用して発生させることもできます。 |
| 2 | ContextStartedEvent このイベントは、ConfigurableApplicationContextインターフェイスのstart（）メソッドを使用してApplicationContextが開始されたときに公開されます。このイベントを受信した後、データベースをポーリングするか、停止したアプリケーションを再起動できます。 |
| 3 | ContextStoppedEvent このイベントは、ConfigurableApplicationContextインターフェイスでstop（）メソッドを使用してApplicationContextが停止されたときに公開されます。このイベントを受け取った後、必要なハウスキーピング作業を行うことができます。 |
| 4 | ContextClosedEvent このイベントは、ConfigurableApplicationContextインターフェイスでclose（）メソッドを使用してApplicationContextが閉じられたときに公開されます。閉じたコンテキストは寿命に達します。更新または再起動することはできません。 |
| 5 | RequestHandledEvent これは、HTTPリクエストが処理されたことをすべてのBeanに通知するWeb固有のイベントです。 |
Springのイベント処理はシングルスレッドであるため、イベントが公開された場合、すべての受信者がメッセージを受信するまで、プロセスはブロックされ、フローは続行されません。したがって、イベント処理を使用する場合は、アプリケーションを設計するときに注意が必要です。
コンテキストイベントを聞く
コンテキストイベントをリッスンするには、Beanはメソッドが1つしかないApplicationListenerインターフェースを実装する必要がありますonApplicationEvent()。それでは、イベントがどのように伝播するか、特定のイベントに基づいて必要なタスクを実行するためにコードを配置する方法を確認するための例を書いてみましょう。
動作するEclipseIDEを配置し、次の手順を実行してSpringアプリケーションを作成しましょう-
| ステップ | 説明 |
|---|---|
| 1 | SpringExampleという名前のプロジェクトを作成し、その下にcom.tutorialspointパッケージを作成します。src 作成したプロジェクトのフォルダ。 |
| 2 | Spring Hello Worldの例の章で説明されているように、[外部JARの追加]オプションを使用して必要なSpringライブラリを追加します。 |
| 3 | com.tutorialspointパッケージの下にJavaクラスHelloWorld、CStartEventHandler、CStopEventHandler、およびMainAppを作成します。 |
| 4 | Beans構成ファイルBeans.xmlをsrc フォルダ。 |
| 5 | 最後のステップは、すべてのJavaファイルとBean構成ファイルのコンテンツを作成し、以下で説明するようにアプリケーションを実行することです。 |
これがの内容です HelloWorld.java ファイル
package com.tutorialspoint;
public class HelloWorld {
private String message;
public void setMessage(String message){
this.message = message;
}
public void getMessage(){
System.out.println("Your Message : " + message);
}
}以下は、の内容です CStartEventHandler.java ファイル
package com.tutorialspoint;
import org.springframework.context.ApplicationListener;
import org.springframework.context.event.ContextStartedEvent;
public class CStartEventHandler
implements ApplicationListener<ContextStartedEvent>{
public void onApplicationEvent(ContextStartedEvent event) {
System.out.println("ContextStartedEvent Received");
}
}以下は、の内容です CStopEventHandler.java ファイル
package com.tutorialspoint;
import org.springframework.context.ApplicationListener;
import org.springframework.context.event.ContextStoppedEvent;
public class CStopEventHandler
implements ApplicationListener<ContextStoppedEvent>{
public void onApplicationEvent(ContextStoppedEvent event) {
System.out.println("ContextStoppedEvent Received");
}
}以下は、の内容です MainApp.java ファイル
package com.tutorialspoint;
import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class MainApp {
public static void main(String[] args) {
ConfigurableApplicationContext context =
new ClassPathXmlApplicationContext("Beans.xml");
// Let us raise a start event.
context.start();
HelloWorld obj = (HelloWorld) context.getBean("helloWorld");
obj.getMessage();
// Let us raise a stop event.
context.stop();
}
}以下は設定ファイルです 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"
xsi:schemaLocation = "http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">
<bean id = "helloWorld" class = "com.tutorialspoint.HelloWorld">
<property name = "message" value = "Hello World!"/>
</bean>
<bean id = "cStartEventHandler" class = "com.tutorialspoint.CStartEventHandler"/>
<bean id = "cStopEventHandler" class = "com.tutorialspoint.CStopEventHandler"/>
</beans>ソースとBeanの構成ファイルの作成が完了したら、アプリケーションを実行しましょう。アプリケーションに問題がない場合は、次のメッセージが出力されます-
ContextStartedEvent Received
Your Message : Hello World!
ContextStoppedEvent Received必要に応じて、独自のカスタムイベントを公開し、後で同じイベントをキャプチャして、それらのカスタムイベントに対してアクションを実行できます。独自のカスタムイベントの作成に興味がある場合は、Springのカスタムイベントを確認できます。
独自のカスタムイベントを作成して公開するには、いくつかの手順を実行する必要があります。この章に記載されている手順に従って、カスタムSpringイベントを作成、公開、および処理します。
| ステップ | 説明 |
|---|---|
| 1 | SpringExampleという名前のプロジェクトを作成し、その下にcom.tutorialspointパッケージを作成します。src作成したプロジェクトのフォルダ。すべてのクラスはこのパッケージの下に作成されます。 |
| 2 | Spring Hello Worldの例の章で説明されているように、[外部JARの追加]オプションを使用して必要なSpringライブラリを追加します。 |
| 3 | 拡張してイベントクラスCustomEventを作成しますApplicationEvent。このクラスは、ApplicationEventクラスからコンストラクターを継承するデフォルトのコンストラクターを定義する必要があります。 |
| 4 | イベントクラスを定義したら、任意のクラスから公開できます。たとえば、ApplicationEventPublisherAwareを実装するEventClassPublisherとしましょう。また、コンテナーがApplicationEventPublisherAwareインターフェースを実装しているため、コンテナーがBeanをイベントパブリッシャーとして識別できるように、XML構成ファイルでこのクラスをBeanとして宣言する必要があります。 |
| 5 | 公開されたイベントはクラスで処理できます。たとえば、ApplicationListenerインターフェイスを実装し、カスタムイベントのonApplicationEventメソッドを実装するEventClassHandlerとしましょう。 |
| 6 | 下にBean構成ファイルBeans.xmlを作成します。srcフォルダとSpringアプリケーションとして機能するMainAppクラス。 |
| 7 | 最後のステップは、すべてのJavaファイルとBean構成ファイルのコンテンツを作成し、以下で説明するようにアプリケーションを実行することです。 |
これがの内容です CustomEvent.java ファイル
package com.tutorialspoint;
import org.springframework.context.ApplicationEvent;
public class CustomEvent extends ApplicationEvent{
public CustomEvent(Object source) {
super(source);
}
public String toString(){
return "My Custom Event";
}
}以下は、の内容です CustomEventPublisher.java ファイル
package com.tutorialspoint;
import org.springframework.context.ApplicationEventPublisher;
import org.springframework.context.ApplicationEventPublisherAware;
public class CustomEventPublisher implements ApplicationEventPublisherAware {
private ApplicationEventPublisher publisher;
public void setApplicationEventPublisher (ApplicationEventPublisher publisher) {
this.publisher = publisher;
}
public void publish() {
CustomEvent ce = new CustomEvent(this);
publisher.publishEvent(ce);
}
}以下は、の内容です CustomEventHandler.java ファイル
package com.tutorialspoint;
import org.springframework.context.ApplicationListener;
public class CustomEventHandler implements ApplicationListener<CustomEvent> {
public void onApplicationEvent(CustomEvent event) {
System.out.println(event.toString());
}
}以下は、の内容です MainApp.java ファイル
package com.tutorialspoint;
import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class MainApp {
public static void main(String[] args) {
ConfigurableApplicationContext context =
new ClassPathXmlApplicationContext("Beans.xml");
CustomEventPublisher cvp =
(CustomEventPublisher) context.getBean("customEventPublisher");
cvp.publish();
cvp.publish();
}
}以下は設定ファイルです 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"
xsi:schemaLocation = "http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">
<bean id = "customEventHandler" class = "com.tutorialspoint.CustomEventHandler"/>
<bean id = "customEventPublisher" class = "com.tutorialspoint.CustomEventPublisher"/>
</beans>ソースとBeanの構成ファイルの作成が完了したら、アプリケーションを実行しましょう。アプリケーションに問題がない場合は、次のメッセージが出力されます-
y Custom Event
y Custom EventSpring Frameworkの重要なコンポーネントの1つは、 Aspect oriented programming (AOP)フレームワーク。アスペクト指向プログラミングでは、プログラムロジックをいわゆる懸念事項と呼ばれる個別の部分に分割する必要があります。アプリケーションの複数のポイントにまたがる関数が呼び出されますcross-cutting concernsそして、これらの横断的関心事は、アプリケーションのビジネスロジックから概念的に分離されています。ロギング、監査、宣言型トランザクション、セキュリティ、キャッシングなどの側面のさまざまな一般的な良い例があります。
OOPのモジュール性の主要な単位はクラスですが、AOPのモジュール性の単位はアスペクトです。依存性注入は、アプリケーションオブジェクトを相互に分離するのに役立ち、AOPは、横断的関心事をそれらが影響するオブジェクトから分離するのに役立ちます。AOPは、Perl、.NET、Javaなどのプログラミング言語のトリガーのようなものです。
Spring AOPモジュールは、アプリケーションをインターセプトするためのインターセプターを提供します。たとえば、メソッドが実行されるときに、メソッドの実行の前後に機能を追加できます。
AOPの用語
AOPの使用を開始する前に、AOPの概念と用語について理解しましょう。これらの用語はSpringに固有のものではなく、AOPに関連しています。
| シニア番号 | 用語と説明 |
|---|---|
| 1 | Aspect これは、分野横断的な要件を提供する一連のAPIを備えたモジュールです。たとえば、ロギングモジュールはロギングのAOPアスペクトと呼ばれます。アプリケーションには、要件に応じてさまざまな側面があります。 |
| 2 | Join point これは、AOPアスペクトをプラグインできるアプリケーションのポイントを表しています。また、SpringAOPフレームワークを使用してアクションが実行されるのはアプリケーション内の実際の場所であるとも言えます。 |
| 3 | Advice これは、メソッドの実行前または実行後に実行される実際のアクションです。これは、SpringAOPフレームワークによるプログラムの実行中に呼び出される実際のコードです。 |
| 4 | Pointcut これは、アドバイスを実行する必要がある1つ以上のジョインポイントのセットです。AOPの例で示すように、式またはパターンを使用してポイントカットを指定できます。 |
| 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カスタムアスペクトを実装するためのアプローチ。これらの2つのアプローチについては、次のセクションで詳しく説明します。
| シニア番号 | アプローチと説明 |
|---|---|
| 1 | XMLスキーマベース アスペクトは、XMLベースの構成とともに通常のクラスを使用して実装されます。 |
| 2 | @AspectJベース @AspectJは、Java5アノテーションが付けられた通常のJavaクラスとしてアスペクトを宣言するスタイルを指します。 |
プレーンな古いJDBCを使用してデータベースを操作している間、例外を処理したり、データベース接続を開いたり閉じたりするために不要なコードを書くのは面倒になります。 SQLステートメントを実行し、例外を処理し、トランザクションを処理して、最後に接続を閉じます。
したがって、接続パラメーターを定義し、実行するSQLステートメントを指定して、データベースからデータをフェッチしながら、各反復に必要な作業を実行するだけです。
Spring JDBCは、データベースとインターフェースするためのいくつかのアプローチとそれに対応する異なるクラスを提供します。私は古典的で最も人気のあるアプローチを採用するつもりですJdbcTemplateフレームワークのクラス。これは、すべてのデータベース通信と例外処理を管理する中央フレームワーククラスです。
JdbcTemplateクラス
JDBCテンプレートクラスは、SQLクエリを実行し、ステートメントを更新し、プロシージャコールを格納し、ResultSetに対して反復を実行し、返されたパラメータ値を抽出します。また、JDBC例外をキャッチし、org.springframework.daoパッケージで定義されている一般的でより有益な例外階層に変換します。
JdbcTemplateクラスのインスタンスは、一度構成されるとスレッドセーフになります。したがって、JdbcTemplateの単一インスタンスを構成してから、この共有参照を複数のDAOに安全に挿入できます。
JDBCテンプレートクラスを使用する場合の一般的な方法は、Spring構成ファイルでデータソースを構成してから、その共有データソースBeanをDAOクラスに依存性注入することです。JdbcTemplateはデータソースのセッターに作成されます。
データソースの構成
データベーステーブルを作成しましょう Student 私たちのデータベースで TEST。MySQLデータベースを使用していることを前提としています。他のデータベースを使用している場合は、それに応じてDDLおよびSQLクエリを変更できます。
CREATE TABLE Student(
ID INT NOT NULL AUTO_INCREMENT,
NAME VARCHAR(20) NOT NULL,
AGE INT NOT NULL,
PRIMARY KEY (ID)
);次に、データソースをJDBCテンプレートに提供して、データベースアクセスを取得するように自身を構成できるようにする必要があります。次のコードスニペットに示すように、XMLファイルのデータソースをコードで構成できます。
<bean id = "dataSource"
class = "org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name = "driverClassName" value = "com.mysql.jdbc.Driver"/>
<property name = "url" value = "jdbc:mysql://localhost:3306/TEST"/>
<property name = "username" value = "root"/>
<property name = "password" value = "password"/>
</bean>データアクセスオブジェクト（DAO）
DAOはDataAccess Objectの略で、データベースの相互作用に一般的に使用されます。DAOは、データベースに対してデータを読み書きする手段を提供するために存在し、アプリケーションの残りの部分がDAOにアクセスするためのインターフェイスを介してこの機能を公開する必要があります。
SpringでのDAOサポートにより、JDBC、Hibernate、JPA、JDOなどのデータアクセステクノロジーを一貫した方法で簡単に操作できます。
SQLステートメントの実行
SQLおよびJDBCテンプレートオブジェクトを使用して、データベーステーブルに対してCRUD（作成、読み取り、更新、および削除）操作を実行する方法を見てみましょう。
Querying for an integer
String SQL = "select count(*) from Student";
int rowCount = jdbcTemplateObject.queryForInt( SQL );Querying for a long
String SQL = "select count(*) from Student";
long rowCount = jdbcTemplateObject.queryForLong( SQL );A simple query using a bind variable
String SQL = "select age from Student where id = ?";
int age = jdbcTemplateObject.queryForInt(SQL, new Object[]{10});Querying for a String
String SQL = "select name from Student where id = ?";
String name = jdbcTemplateObject.queryForObject(SQL, new Object[]{10}, String.class);Querying and returning an object
String SQL = "select * from Student where id = ?";
Student student = jdbcTemplateObject.queryForObject(
SQL, new Object[]{10}, new StudentMapper());
public class StudentMapper implements RowMapper<Student> {
public Student mapRow(ResultSet rs, int rowNum) throws SQLException {
Student student = new Student();
student.setID(rs.getInt("id"));
student.setName(rs.getString("name"));
student.setAge(rs.getInt("age"));
return student;
}
}Querying and returning multiple objects
String SQL = "select * from Student";
List<Student> students = jdbcTemplateObject.query(
SQL, new StudentMapper());
public class StudentMapper implements RowMapper<Student> {
public Student mapRow(ResultSet rs, int rowNum) throws SQLException {
Student student = new Student();
student.setID(rs.getInt("id"));
student.setName(rs.getString("name"));
student.setAge(rs.getInt("age"));
return student;
}
}Inserting a row into the table
String SQL = "insert into Student (name, age) values (?, ?)";
jdbcTemplateObject.update( SQL, new Object[]{"Zara", 11} );Updating a row into the table
String SQL = "update Student set name = ? where id = ?";
jdbcTemplateObject.update( SQL, new Object[]{"Zara", 10} );Deleting a row from the table
String SQL = "delete Student where id = ?";
jdbcTemplateObject.update( SQL, new Object[]{20} );DDLステートメントの実行
あなたは使用することができます execute(..)jdbcTemplateのメソッドを使用して、SQLステートメントまたはDDLステートメントを実行します。以下は、CREATEステートメントを使用してテーブルを作成する例です-
String SQL = "CREATE TABLE Student( " +
"ID INT NOT NULL AUTO_INCREMENT, " +
"NAME VARCHAR(20) NOT NULL, " +
"AGE INT NOT NULL, " +
"PRIMARY KEY (ID));"
jdbcTemplateObject.execute( SQL );SpringJDBCフレームワークの例
上記の概念に基づいて、SpringでのJDBCフレームワークの使用法を理解するのに役立ついくつかの重要な例を確認しましょう。
| シニア番号 | 例と説明 |
|---|---|
| 1 | SpringJDBCの例 この例では、単純なJDBCベースのSpringアプリケーションを作成する方法を説明します。 |
| 2 | SpringのSQLストアドプロシージャ SpringでJDBCを使用しながらSQLストアドプロシージャを呼び出す方法を学びます。 |
データベーストランザクションは、単一の作業単位として扱われる一連のアクションです。これらのアクションは、完全に完了するか、まったく効果がないかのいずれかです。トランザクション管理は、データの整合性と一貫性を確保するためのRDBMS指向のエンタープライズアプリケーションの重要な部分です。トランザクションの概念は、次の4つの主要なプロパティで説明できます。ACID −
Atomicity −トランザクションは、単一の操作単位として扱う必要があります。これは、一連の操作全体が成功または失敗することを意味します。
Consistency −これは、データベースの参照整合性、テーブル内の一意の主キーなどの一貫性を表します。
Isolation−同じデータセットで同時に多くのトランザクション処理が行われる可能性があります。データの破損を防ぐために、各トランザクションは他のトランザクションから分離する必要があります。
Durability −トランザクションが完了すると、このトランザクションの結果を永続的にする必要があり、システム障害のためにデータベースから消去することはできません。
実際のRDBMSデータベースシステムは、各トランザクションの4つのプロパティすべてを保証します。SQLを使用してデータベースに発行されたトランザクションの単純なビューは次のとおりです。
begintransactionコマンドを使用してトランザクションを開始します。
SQLクエリを使用して、さまざまな削除、更新、または挿入操作を実行します。
すべての操作が成功した場合は、コミットを実行します。それ以外の場合は、すべての操作をロールバックします。
Spring Frameworkは、基盤となるさまざまなトランザクション管理APIの上に抽象レイヤーを提供します。Springのトランザクションサポートは、POJOにトランザクション機能を追加することにより、EJBトランザクションの代替手段を提供することを目的としています。Springは、プログラムによるトランザクション管理と宣言型のトランザクション管理の両方をサポートしています。EJBにはアプリケーションサーバーが必要ですが、Springトランザクション管理はアプリケーションサーバーを必要とせずに実装できます。
ローカルトランザクションとグローバルトランザクション
ローカルトランザクションはJDBC接続のような単一のトランザクションリソースに固有ですが、グローバルトランザクションは分散システムのトランザクションのように複数のトランザクションリソースにまたがることができます。
ローカルトランザクション管理は、アプリケーションコンポーネントとリソースが単一のサイトに配置され、トランザクション管理に単一のマシンで実行されているローカルデータマネージャーのみが関与する集中型コンピューティング環境で役立ちます。ローカルトランザクションは実装が簡単です。
グローバルトランザクション管理は、すべてのリソースが複数のシステムに分散されている分散コンピューティング環境で必要です。このような場合、トランザクション管理はローカルレベルとグローバルレベルの両方で実行する必要があります。分散トランザクションまたはグローバルトランザクションは複数のシステム間で実行され、その実行には、グローバルトランザクション管理システムと関連するすべてのシステムのすべてのローカルデータマネージャー間の調整が必要です。
プログラマティックvs.宣言型
Springは2種類のトランザクション管理をサポートしています-
プログラムによるトランザクション管理-これは、プログラミングの助けを借りてトランザクションを管理する必要があることを意味します。それはあなたに極端な柔軟性を与えますが、維持するのは難しいです。
宣言型トランザクション管理-これは、トランザクション管理をビジネスコードから分離することを意味します。トランザクションの管理には、注釈またはXMLベースの構成のみを使用します。
宣言型トランザクション管理は、コードを介してトランザクションを制御できるプログラマティックトランザクション管理よりも柔軟性が劣りますが、プログラマティックトランザクション管理よりも適しています。しかし、一種の横断的関心事として、宣言型トランザクション管理はAOPアプローチでモジュール化できます。Springは、SpringAOPフレームワークを通じて宣言型トランザクション管理をサポートします。
Springトランザクションの抽象化
Springトランザクションの抽象化の鍵は、org.springframework.transaction.PlatformTransactionManagerインターフェースによって定義されます。これは次のとおりです。
public interface PlatformTransactionManager {
TransactionStatus getTransaction(TransactionDefinition definition);
throws TransactionException;
void commit(TransactionStatus status) throws TransactionException;
void rollback(TransactionStatus status) throws TransactionException;
}| シニア番号 | 方法と説明 |
|---|---|
| 1 | TransactionStatus getTransaction(TransactionDefinition definition) このメソッドは、指定された伝播動作に従って、現在アクティブなトランザクションを返すか、新しいトランザクションを作成します。 |
| 2 | void commit(TransactionStatus status) このメソッドは、ステータスに関して、指定されたトランザクションをコミットします。 |
| 3 | void rollback(TransactionStatus status) このメソッドは、指定されたトランザクションのロールバックを実行します。 |
TransactionDefinitionはスプリングでトランザクション・サポートのコアインタフェースであり、以下のように定義されます-
public interface TransactionDefinition {
int getPropagationBehavior();
int getIsolationLevel();
String getName();
int getTimeout();
boolean isReadOnly();
}| シニア番号 | 方法と説明 |
|---|---|
| 1 | int getPropagationBehavior() このメソッドは、伝播動作を返します。Springは、EJBCMTでおなじみのすべてのトランザクション伝播オプションを提供します。 |
| 2 | int getIsolationLevel() このメソッドは、このトランザクションが他のトランザクションの作業から分離されている度合いを返します。 |
| 3 | String getName() このメソッドは、このトランザクションの名前を返します。 |
| 4 | int getTimeout() このメソッドは、トランザクションが完了する必要がある時間を秒単位で返します。 |
| 5 | boolean isReadOnly() このメソッドは、トランザクションが読み取り専用かどうかを返します。 |
分離レベルの可能な値は次のとおりです-
| シニア番号 | 分離と説明 |
|---|---|
| 1 | TransactionDefinition.ISOLATION_DEFAULT これはデフォルトの分離レベルです。 |
| 2 | TransactionDefinition.ISOLATION_READ_COMMITTED ダーティリードが防止されていることを示します。繰り返し不可能な読み取りとファントム読み取りが発生する可能性があります。 |
| 3 | TransactionDefinition.ISOLATION_READ_UNCOMMITTED ダーティ読み取り、繰り返し不可能な読み取り、およびファントム読み取りが発生する可能性があることを示します。 |
| 4 | TransactionDefinition.ISOLATION_REPEATABLE_READ ダーティ読み取りと繰り返し不可能な読み取りが防止されていることを示します。ファントム読み取りが発生する可能性があります。 |
| 5 | TransactionDefinition.ISOLATION_SERIALIZABLE ダーティ読み取り、繰り返し不可能な読み取り、およびファントム読み取りが防止されていることを示します。 |
以下は、伝播タイプの可能な値です-
| シニア番号 | 伝播と説明 |
|---|---|
| 1 | TransactionDefinition.PROPAGATION_MANDATORY 現在のトランザクションをサポートします。現在のトランザクションが存在しない場合、例外をスローします。 |
| 2 | TransactionDefinition.PROPAGATION_NESTED 現在のトランザクションが存在する場合、ネストされたトランザクション内で実行されます。 |
| 3 | TransactionDefinition.PROPAGATION_NEVER 現在のトランザクションをサポートしていません。現在のトランザクションが存在する場合、例外をスローします。 |
| 4 | TransactionDefinition.PROPAGATION_NOT_SUPPORTED 現在のトランザクションをサポートしていません。むしろ常に非トランザクションで実行します。 |
| 5 | TransactionDefinition.PROPAGATION_REQUIRED 現在のトランザクションをサポートします。存在しない場合は新しいものを作成します。 |
| 6 | TransactionDefinition.PROPAGATION_REQUIRES_NEW 新しいトランザクションを作成し、現在のトランザクションが存在する場合は一時停止します。 |
| 7 | TransactionDefinition.PROPAGATION_SUPPORTS 現在のトランザクションをサポートします。何も存在しない場合、非トランザクションで実行されます。 |
| 8 | TransactionDefinition.TIMEOUT_DEFAULT 基礎となるトランザクションシステムのデフォルトのタイムアウトを使用します。タイムアウトがサポートされていない場合はnoneを使用します。 |
TransactionStatusのインタフェースは、トランザクションの実行とクエリのトランザクションの状態を制御するために、トランザクションコードのための簡単な方法を提供します。
public interface TransactionStatus extends SavepointManager {
boolean isNewTransaction();
boolean hasSavepoint();
void setRollbackOnly();
boolean isRollbackOnly();
boolean isCompleted();
}| シニア番号 | 方法と説明 |
|---|---|
| 1 | boolean hasSavepoint() このメソッドは、このトランザクションが内部でセーブポイントを保持しているかどうか、つまり、セーブポイントに基づいてネストされたトランザクションとして作成されているかどうかを返します。 |
| 2 | boolean isCompleted() このメソッドは、このトランザクションが完了したかどうか、つまり、すでにコミットされているかロールバックされているかを返します。 |
| 3 | boolean isNewTransaction() 現在のトランザクションが新しい場合、このメソッドはtrueを返します。 |
| 4 | boolean isRollbackOnly() このメソッドは、トランザクションがロールバックのみとしてマークされているかどうかを返します。 |
| 5 | void setRollbackOnly() このメソッドは、トランザクションをロールバックのみとして設定します。 |
Spring Web MVCフレームワークは、柔軟で疎結合のWebアプリケーションの開発に使用できるModel-View-Controller（MVC）アーキテクチャーとすぐに使用できるコンポーネントを提供します。MVCパターンにより、アプリケーションのさまざまな側面（入力ロジック、ビジネスロジック、およびUIロジック）が分離され、これらの要素間の疎結合が提供されます。
ザ・ Model アプリケーションデータをカプセル化し、通常はPOJOで構成されます。
ザ・ View モデルデータのレンダリングを担当し、一般に、クライアントのブラウザが解釈できるHTML出力を生成します。
ザ・ Controller ユーザーリクエストの処理と適切なモデルの構築を担当し、レンダリングのためにビューに渡します。
DispatcherServlet
Spring Webモデルビューコントローラー（MVC）フレームワークは、すべてのHTTP要求と応答を処理するDispatcherServletを中心に設計されています。Spring Web MVC DispatcherServletのリクエスト処理ワークフローを次の図に示します-
以下は、着信HTTP要求に対応する一連のイベントでのDispatcherServlet -
HTTPリクエストを受信した後、DispatcherServletはHandlerMappingを参照して、適切なコントローラーを呼び出します。
コントローラは、要求を受け取り、使用GETまたはPOSTメソッドに基づいて、適切なサービスメソッドを呼び出します。serviceメソッドは、定義されたビジネスロジックに基づいてモデルデータを設定し、ビュー名をDispatcherServletに返します。
DispatcherServletはからの助けを取るViewResolverピックアップへの要求のために定義されたビューを。
ビューが完成すると、DispatcherServletはモデルデータをビューに渡し、ビューは最終的にブラウザにレンダリングされます。
上記のすべてのコンポーネント、つまりHandlerMapping、Controller、およびViewResolverは、Webアプリケーションに必要ないくつかの追加機能を備えたプレーンなApplicationContextの拡張であるWebApplicationContextwの一部です。
必要な構成
でURLマッピングを使用して、DispatcherServletで処理するリクエストをマッピングする必要があります。web.xmlファイル。以下は、の宣言とマッピングを示す例です。HelloWeb DispatcherServletの例-
<web-app id = "WebApp_ID" version = "2.4"
xmlns = "http://java.sun.com/xml/ns/j2ee"
xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation = "http://java.sun.com/xml/ns/j2ee
http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd">
<display-name>Spring MVC Application</display-name>
<servlet>
<servlet-name>HelloWeb</servlet-name>
<servlet-class>
org.springframework.web.servlet.DispatcherServlet
</servlet-class>
<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>HelloWeb</servlet-name>
<url-pattern>*.jsp</url-pattern>
</servlet-mapping>
</web-app>ザ・ web.xmlファイルは、WebアプリケーションのWebContent / WEB-INFディレクトリに保存されます。初期化時HelloWeb DispatcherServlet、フレームワークは、という名前のファイルからアプリケーションコンテキストを読み込もうとします [servlet-name]-servlet.xmlアプリケーションのWebContent / WEB-INFディレクトリにあります。この場合、ファイルは次のようになります。HelloWebservlet.xml。
次に、<servlet-mapping>タグは、どのURLがどのDispatcherServletによって処理されるかを示します。ここで、で終わるすべてのHTTPリクエスト.jsp によって処理されます HelloWeb DispatcherServlet。
デフォルトのファイル名を[servlet-name] -servlet.xml、デフォルトの場所をWebContent / WEB-INFにしたくない場合は、web.xmlファイルにサーブレットリスナーContextLoaderListenerを追加することで、このファイル名と場所をカスタマイズできます。次のように-
<web-app...>
<!-------- DispatcherServlet definition goes here----->
....
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>/WEB-INF/HelloWeb-servlet.xml</param-value>
</context-param>
<listener>
<listener-class>
org.springframework.web.context.ContextLoaderListener
</listener-class>
</listener>
</web-app>それでは、必要な構成を確認しましょう。 HelloWeb-servlet.xmlWebアプリケーションのWebContent / WEB-INFディレクトリに配置されたファイル-
<beans xmlns = "http://www.springframework.org/schema/beans"
xmlns:context = "http://www.springframework.org/schema/context"
xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation = "http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-3.0.xsd">
<context:component-scan base-package = "com.tutorialspoint" />
<bean class = "org.springframework.web.servlet.view.InternalResourceViewResolver">
<property name = "prefix" value = "/WEB-INF/jsp/" />
<property name = "suffix" value = ".jsp" />
</bean>
</beans>以下は、についての重要なポイントです HelloWeb-servlet.xml ファイル-
[サーブレット名] -servlet.xmlファイルは、グローバルスコープ内の同じ名前で定義された任意の豆の定義をオーバーライドする、定義された豆を作成するために使用されるであろう。
<コンテキスト：コンポーネント・スキャン...>タグはなど@Controllerと@RequestMappingのような注釈を利用することを可能にするアクティブSpring MVCの注釈スキャン機能に使用されます
InternalResourceViewResolverは、ビュー名を解決するために定義されたルールがあります。上記で定義されたルールに従って、hello/WEB-INF/jsp/hello.jspにあるビュー実装に委任されます。
次のセクションでは、実際のコンポーネント（Controller、Model、View）を作成する方法を説明します。
コントローラーの定義
DispatcherServletは、要求をコントローラーに委任して、それに固有の機能を実行します。ザ・@Controller注釈は、特定のクラスがコントローラーの役割を果たすことを示します。ザ・@RequestMapping アノテーションは、URLをクラス全体または特定のハンドラーメソッドにマップするために使用されます。
@Controller
@RequestMapping("/hello")
public class HelloController {
@RequestMapping(method = RequestMethod.GET)
public String printHello(ModelMap model) {
model.addAttribute("message", "Hello Spring MVC Framework!");
return "hello";
}
}ザ・ @Controllerアノテーションは、クラスをSpringMVCコントローラーとして定義します。ここで、の最初の使用法@RequestMapping このコントローラーのすべての処理方法がに関連していることを示します /hello道。次の注釈@RequestMapping(method = RequestMethod.GET)は、HTTP GET要求を処理するためのコントローラーのデフォルトのサービスメソッドとしてprintHello（）メソッドを宣言するために使用されます。同じURLでPOSTリクエストを処理する別のメソッドを定義できます。
上記のコントローラーは、次のように@RequestMappingに属性を追加できる別の形式で記述できます。
@Controller
public class HelloController {
@RequestMapping(value = "/hello", method = RequestMethod.GET)
public String printHello(ModelMap model) {
model.addAttribute("message", "Hello Spring MVC Framework!");
return "hello";
}
}ザ・ value 属性は、ハンドラーメソッドがマップされるURLと method属性は、HTTPGETリクエストを処理するためのサービスメソッドを定義します。上記で定義したコントローラーについて、以下の重要な点に注意してください。
サービスメソッド内で必要なビジネスロジックを定義します。要件に応じて、このメソッド内で別のメソッドを呼び出すことができます。
定義されたビジネスロジックに基づいて、このメソッド内にモデルを作成します。セッターのさまざまなモデル属性を使用できます。これらの属性には、ビューからアクセスして最終結果を表示します。この例では、属性「message」を使用してモデルを作成します。
定義されたサービスメソッドは、の名前を含む文字列を返すことができます viewモデルのレンダリングに使用されます。この例では、論理ビュー名として「hello」が返されます。
JSPビューの作成
Spring MVCは、さまざまなプレゼンテーションテクノロジのさまざまな種類のビューをサポートしています。これらには、JSP、HTML、PDF、Excelワークシート、XML、Velocityテンプレート、XSLT、JSON、AtomおよびRSSフィード、JasperReportsなどが含まれます。ただし、最も一般的には、JSTLで記述されたJSPテンプレートを使用します。
簡単に書いてみましょう hello /WEB-INF/hello/hello.jspで表示−
<html>
<head>
<title>Hello Spring MVC</title>
</head>
<body>
<h2>${message}</h2>
</body>
</html>ここに ${message}コントローラ内で設定した属性です。ビュー内に複数の属性を表示することができます。
Spring WebMVCフレームワークの例
上記の概念に基づいて、SpringWebアプリケーションの構築に役立ついくつかの重要な例を確認しましょう-
| シニア番号 | 例と説明 |
|---|---|
| 1 | Spring MVC HelloWorldの例 この例では、単純なSpring Web HelloWorldアプリケーションの作成方法を説明します。 |
| 2 | SpringMVCフォーム処理の例 この例では、HTMLフォームを使用してSpring Webアプリケーションを作成し、データをコントローラーに送信して、処理された結果を表示する方法を説明します。 |
| 3 | Springページリダイレクトの例 Spring MVCFrameworkでページリダイレクト機能を使用する方法を学びます。 |
| 4 | Spring静的ページの例 Spring MVCFrameworkで動的ページとともに静的ページにアクセスする方法を学びます。 |
| 5 | Spring例外処理の例 Spring MVCFrameworkで例外を処理する方法を学びます。 |
これは、Springアプリケーション内で非常に使いやすいLog4J機能です。次の例では、Log4JとSpringの簡単な統合を説明する簡単な手順を説明します。
私たちはあなたがすでに持っていると仮定します log4Jマシンにインストールされています。お持ちでない場合は、からダウンロードできますhttps://logging.apache.org/zipファイルを任意のフォルダに解凍するだけです。のみ使用しますlog4j-x.y.z.jar 私たちのプロジェクトで。
次に、動作するEclipse IDEを配置し、次の手順を実行して、Spring WebFrameworkを使用して動的フォームベースのWebアプリケーションを開発します。
| ステップ | 説明 |
|---|---|
| 1 | SpringExampleという名前のプロジェクトを作成し、その下にcom.tutorialspointパッケージを作成します。src 作成したプロジェクトのフォルダ。 |
| 2 | Spring Hello Worldの例の章で説明されているように、[外部JARの追加]オプションを使用して必要なSpringライブラリを追加します。 |
| 3 | Add External JARsを使用して、プロジェクトにlog4jライブラリlog4j-xyzjarも追加します。 |
| 4 | com.tutorialspointパッケージの下にJavaクラスHelloWorldとMainAppを作成します。 |
| 5 | Beans構成ファイルBeans.xmlをsrc フォルダ。 |
| 6 | log4J構成ファイルlog4j.propertiesをsrc フォルダ。 |
| 7 | 最後のステップは、すべてのJavaファイルとBean構成ファイルのコンテンツを作成し、以下で説明するようにアプリケーションを実行することです。 |
これがの内容です HelloWorld.java ファイル
package com.tutorialspoint;
public class HelloWorld {
private String message;
public void setMessage(String message){
this.message = message;
}
public void getMessage() {
System.out.println("Your Message : " + message);
}
}以下は2番目のファイルの内容です MainApp.java
package com.tutorialspoint;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.apache.log4j.Logger;
public class MainApp {
static Logger log = Logger.getLogger(MainApp.class.getName());
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");
log.info("Going to create HelloWord Obj");
HelloWorld obj = (HelloWorld) context.getBean("helloWorld");
obj.getMessage();
log.info("Exiting the program");
}
}あなたは生成することができます debug そして error情報メッセージを生成したのと同様の方法でメッセージを送信します。さて、の内容を見てみましょう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"
xsi:schemaLocation = "http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">
<bean id = "helloWorld" class = "com.tutorialspoint.HelloWorld">
<property name = "message" value = "Hello World!"/>
</bean>
</beans>以下はの内容です log4j.properties Log4Jがログメッセージを生成するために必要な標準ルールを定義します
# Define the root logger with appender file
log4j.rootLogger = DEBUG, FILE
# Define the file appender
log4j.appender.FILE=org.apache.log4j.FileAppender
# Set the name of the file
log4j.appender.FILE.File=C:\\log.out
# Set the immediate flush to true (default)
log4j.appender.FILE.ImmediateFlush=true
# Set the threshold to debug mode
log4j.appender.FILE.Threshold=debug
# Set the append to false, overwrite
log4j.appender.FILE.Append=false
# Define the layout for file appender
log4j.appender.FILE.layout=org.apache.log4j.PatternLayout
log4j.appender.FILE.layout.conversionPattern=%m%nソースとBeanの構成ファイルの作成が完了したら、アプリケーションを実行しましょう。アプリケーションに問題がない場合は、Eclipseコンソールに次のメッセージが出力されます-
Your Message : Hello World!C：\\ドライブを確認すると、ログファイルが見つかります。 log.out 次のようなさまざまなログメッセージがあります-
<!-- initialization log messages -->
Going to create HelloWord Obj
Returning cached instance of singleton bean 'helloWorld'
Exiting the programJakarta Commons Logging（JCL）API
または、 Jakarta Commons Logging (JCL)Springアプリケーションでログを生成するためのAPI。JCLはからダウンロードできますhttps://jakarta.apache.org/commons/logging/。このパッケージから技術的に必要な唯一のファイルはcommons-logging-xyzjarファイルです。これは、上記の例でlog4j-xyzjarを配置したのと同様の方法でクラスパスに配置する必要があります。
ロギング機能を使用するには、org.apache.commons.logging.Logオブジェクトが必要です。次に、要件に応じて次のいずれかのメソッドを呼び出すことができます。
- fatal（オブジェクトメッセージ）
- エラー（オブジェクトメッセージ）
- 警告（オブジェクトメッセージ）
- info（オブジェクトメッセージ）
- debug（オブジェクトメッセージ）
- trace（オブジェクトメッセージ）
以下は、JCLAPIを利用するMainApp.javaの置き換えです。
package com.tutorialspoint;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.apache.commons.logging. Log;
import org.apache.commons.logging. LogFactory;
public class MainApp {
static Log log = LogFactory.getLog(MainApp.class.getName());
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");
log.info("Going to create HelloWord Obj");
HelloWorld obj = (HelloWorld) context.getBean("helloWorld");
obj.getMessage();
log.info("Exiting the program");
}
}プログラムをコンパイルして実行する前に、プロジェクトにcommons-logging-xyzjarファイルが含まれていることを確認する必要があります。
上記の例で残りの構成とコンテンツを変更せずに、アプリケーションをコンパイルして実行すると、Log4JAPIを使用した場合と同様の結果が得られます。