Spring Framework

[Java][NetBeans]Spring Framework 2.5とJSFの連携

kazuki@wankuma.com (かずき) — Mon, 18 May 2009 23:44:00 GMT

昨日に引き続きSpring Frameworkを触っていきます！
今回は、Spring FrameworkとJSFの連携をやってみようと思います。

Spring Frameworkは、2.x系から確かrequestスコープとsessionスコープをサポートしているので、結構お手軽に連携できたりします。
とりあえず、やってみませふ。

早速作り始め

Webアプリケーションを新規作成します。
プロジェクト名はspringjsfにして、フレームワークにJavaServer Facesを選択します。

連携のための設定

新規作成したら、ライブラリにSpring Framework 2.5を追加します。
そして、web.xmlに以下の設定を追加します。これでWebアプリケーションでSpringが使えるようになるのに加えてrequestスコープとsessionスコープが使えるようになりまう。

<listener>
    <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>
<filter>
    <filter-name>requestContextFilter</filter-name>
    <filter-class>org.springframework.web.filter.RequestContextFilter</filter-class>
</filter>
<filter-mapping>
    <filter-name>requestContextFilter</filter-name>
    <url-pattern>/*</url-pattern>
</filter-mapping>

次に、JSFの管理ビーンとしてSpringが管理してるビーンを使えるように設定します。
設定方法は、faces-config.xmlに以下の記述を追加します。

<?xml version='1.0' encoding='UTF-8'?>

<faces-config version="1.2" 
    xmlns="http://java.sun.com/xml/ns/javaee" 
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
    xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-facesconfig_1_2.xsd">
    <application>
        <!-- Spring連携用 -->
        <variable-resolver>org.springframework.web.jsf.DelegatingVariableResolver</variable-resolver>
    </application>
</faces-config>

そして、WEB-INF/applicationContext.xmlにSpring XML 構成ファイルを作成します。Spring名前空間には、contextを追加しておきます。

applicationContext.xmlを作成したら、以下のように編集して、springjsf以下のアノテーションつきのクラスを自動登録するように構成します。

<?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-2.5.xsd
       http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd">
    <context:component-scan base-package="springjsf" />
</beans>

Springの管理するビーンの作成

下準備が出来たので、プログラミングを行います。
まず、welcomeJSF.jspに対応する管理ビーンを作成します。

普通ならJSFの管理ビーンとして作成するのですが、今回はSpring用のビーンとして作成します。
普通のクラスの新規作成で、「springjsf.WelcomeJSFPage」というクラスを作成します。
作成したら、さくっと以下のように編集します。

特に説明のいらないHello worldクラスのプログラムです。

package springjsf;

import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Component;

// requestスコープでwelcomeJSFという名前でSpringに登録する
@Component("welcomeJSF")
@Scope("request")
public class WelcomeJSFPage {
    // 入力用
    private String inputMessage;

    // 出力用
    private String outputMessage;

    // 入力メッセージから出力メッセージを作成する
    public String createOutputMessage() {
        outputMessage = inputMessage + "と入力しましたね！";
        return null;
    }

    public String getInputMessage() {
        return inputMessage;
    }

    public void setInputMessage(String inputMessage) {
        this.inputMessage = inputMessage;
    }

    public String getOutputMessage() {
        return outputMessage;
    }

    public void setOutputMessage(String outputMessage) {
        this.outputMessage = outputMessage;
    }
}

最後に、このSpringに登録されているWelcomeJSFPageクラスを使うようにwelcomeJSF.jspを以下のように編集します。

<%@page contentType="text/html" pageEncoding="UTF-8"%>

<%@taglib prefix="f" uri="http://java.sun.com/jsf/core"%>
<%@taglib prefix="h" uri="http://java.sun.com/jsf/html"%>

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
    "http://www.w3.org/TR/html4/loose.dtd">

<f:view>
    <html>
        <head>
            <meta http-equiv="Content-Type" content="text/html; charset=UTF-8"/>
            <title>うぇるかむ</title>
        </head>
        <body>
            <h:form>
                入力：<h:inputText value="#{welcomeJSF.inputMessage}" />
                <br />
                <h:commandButton value="加工" action="#{welcomeJSF.createOutputMessage}" />
                <br />
                出力：<h:outputText value="#{welcomeJSF.outputMessage}" />
            </h:form>
        </body>
    </html>
</f:view>

注目は、管理ビーンに登録されていないのにEL式でwelcomeJSFと使ってる点です。
これで、Springに登録したwelcomeJSFというビーンが使えます。

ちょっと悲しいのは、NetBeansの補間機能が働かないといったところでしょうか・・・

実行すると

画面が表示され

何か入力して加工ボタンを押すと

ちゃんと動いてることが確認できます。

以上簡単にですが、SpringとJSFの連携についてでした。

[NetBeans][Java]Spring Framework 2.5 とJPAの連携

kazuki@wankuma.com (かずき) — Sun, 17 May 2009 23:12:00 GMT

久しくさぼってたSpring Frameworkですが、NetBeans 6.7 Beta版が出たのでつっついてみたいと思います。
今日のお題はSpring Framework + JPAを試してみようと思います。

データベースの作成

とりあえず、お試しようのデータベースを作成します。
SpringとJPAの連携がメインなので、DBはシンプルに外部キーとかのない１テーブルのみのDBにします。

サーバウィンドウのデータベースの下のJavaDBで右クリックしてデータベースを作成を選択します。

DB名、ユーザ名、パスワードすべてjpaeduのデータベースを作成します。

DBが作成されると、DBの接続も出来るので右クリックして接続を選択します。

APPの下の表の右クリックメニューからコマンドを実行を選択します。

以下のSQLを打ち込んで実行してテスト用のテーブルを作成します。

create table Person (
    id int primary key,
    name varchar(255));

以上でDBの作成は完了です。

プロジェクトの作成

DBの準備が終わったので、Javaのプロジェクトを作成していきます。
springjpaeduという名前で、Java アプリケーションのプロジェクトを作成します。

エンティティクラスの作成

プロジェクトを作成したら、springjpaedu.entitiesというパッケージを作成して、そこに新規→データベースからのエンティティクラスを選択してエンティティクラスを作成します。

先ほど作ったjpaeduデータベースを選択して、PERSONテーブルを選択します。

次の画面で、持続性ユニットを作成を選択して持続性ユニットを作成します。

持続性ユニットを作成したら、その他の項目はデフォルトのまま作成します。
作成が完了すると、springjpaedu.entities.Personクラスが作成されます。

作成されたら、ちゃんと動くかの確認も兼ねて、テスト用データ作成プログラムを作ります。
JPAを使うこと自体が主題ではないので、プログラムだけのせます。
とりあえずDBをクリアして、1000件データを作成しているだけのプログラムです。

package springjpaedu;

import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.EntityTransaction;
import javax.persistence.Persistence;
import springjpaedu.entities.Person;

public class Main {

    private static final String PU = "springjpaeduPU";

    public static void main(String[] args) {
        EntityManagerFactory emf = null;
        EntityManager em = null;
        try {
            emf = Persistence.createEntityManagerFactory(PU);
            em = emf.createEntityManager();
            execute(em);
        } finally {
            if (em != null) {
                em.close();
            }
            if (emf != null) {
                emf.close();
            }
        }
    }

    private static void execute(EntityManager em) {
        EntityTransaction tx = em.getTransaction();
        try {
            tx.begin();
            int deleted = em.createQuery("delete from Person").executeUpdate();
            for (int i = 1; i <= 1000; i++) {
                Person p = new Person();
                p.setId(i);
                p.setName("田中　太郎" + i);
                em.persist(p);
            }
            tx.commit();
            System.out.println(deleted + "件のデータを削除しました");
            System.out.println("1000件のデータを作成しました");
        } catch (RuntimeException e) {
            tx.rollback();
            System.out.println("失敗");
            e.printStackTrace();
        }
    }
}

このまま実行すると、恐らくエラーがおきてしまいます。
JavaDBのJDBCドライバをライブラリについかしていないのが原因なので、JavaDBのドライバをライブラリに追加します。

最近のJavaを何も意識せずに入れていると、C:\Program Files\Sun\JavaDB\lib\derbyclient.jarにJavaDBのJDBCドライバがあるので、それをライブラリに追加します。

実行すると、↓のような文字列が出力ウィンドウに表示されるはずです。

run:
[EL Info]: 2009.05.17 18:35:44.959--ServerSession(25197736)--EclipseLink, version: Eclipse Persistence Services - 1.0.1 (Build 20080905)
[EL Info]: 2009.05.17 18:35:45.118--ServerSession(25197736)--file:/C:/Users/Kazuki/Documents/NetBeansProjects/springjpaedu/src/-springjpaeduPU login successful
0件のデータを削除しました
1000件のデータを作成しました
[EL Info]: 2009.05.17 18:35:46.252--ServerSession(25197736)--file:/C:/Users/Kazuki/Documents/NetBeansProjects/springjpaedu/src/-springjpaeduPU logout successful
構築成功 (合計時間: 2 秒)

Springの設定

ついにSpring Frameworkのほうに入ります！
まず、ライブラリからSpring Framework 2.5を選択して追加します。これには、以下の３つのjarファイルが含まれています。

spring-2.5.jar
cglib-2.2.jar
commons-logging-1.1.jar

凝ったことをしないのであればこれでいいのですが、今回はちょっとこれだけだと都合が悪いので、aspectjrt.jarもライブラリに追加します。
これは、Spring Frameworkのページから一式入ったものをダウンロードした中に入っているので、それを追加しました。

つぎに、このspringjpaedu.DaoTestMainクラスを作成して、mainメソッドを作っておきます。

package springjpaedu;

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

public class DaoTestMain {

    public static void main(String[] args) {
        AbstractApplicationContext ctx = null;
        try {
            ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
            // TODO : ここに処理を書いていく予定
        } finally {
            ctx.close();
        }
    }
}

次に、デフォルトパッケージにapplicationContext.xmlを作成します。ソースパッケージの右クリックメニューから新規→その他からSpring XML 構成ファイルを選択します。

ファイル名をapplicationContext(xmlはつけない)にして次へ

名前空間には、contextとtxを選んで完了を押してください。

DaoTestMainを実行して、エラーが出ないことを確認すれば下準備完了です。

やっとDAO

ついにSpringとJPAの連携の機能を作りこんでいきます！長かった…

Spring FrameworkとJPAの連携は、2通りの方法があります。

Hibernateとかと同じように***DaoSupportと***Templateクラスを使う方法
JPAのAPIをそのまま使う方法

今回は２番のJPAのAPIをそのまま使う方法をやってみます。
何故かというと、１の方法でもあまりうれしさが感じれないからです。Hibernateとかで経験がある人が、自然に使いはじめれるという利点があるくらいなのかな？

とりあえずDAOを作っていきます！

springjpaedu.daoパッケージを作成して、そこにPersonDaoインターフェースとPersonDaoImplクラスを作成します。

PersonDaoに、CRUD用のメソッドを一通り作成します。

package springjpaedu.dao;

import java.util.List;
import springjpaedu.entities.Person;

public interface PersonDao {
    List<Person> findAll();
    Person get(int id);
    void update(Person p);
    void insert(Person p);
    void delete(Person p);
}

PersonDaoImplで、これを実装していきます。

package springjpaedu.dao;

import java.util.List;
import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;
import org.springframework.stereotype.Repository;
import org.springframework.transaction.annotation.Transactional;
import springjpaedu.entities.Person;

// トランザクションの定義
@Transactional
// Springに自動登録してもらうための印
@Repository("personDao")
public class PersonDaoImpl implements PersonDao {

    // PersistenceContextをつけておくとSpringが適切にインスタンスをセットしてくれる
    @PersistenceContext
    private EntityManager entityManager;

    @Transactional(readOnly=true)
    public List<Person> findAll() {
        return entityManager.
                createQuery("select p from Person p order by p.id").
                getResultList();
    }

    // 以下のメソッドでEntityManagerを使って色々処理を書く
    @Transactional(readOnly=true)
    public Person get(int id) {
        return entityManager.find(Person.class, id);
    }

    public void update(Person p) {
        entityManager.merge(p);
    }

    public void insert(Person p) {
        entityManager.persist(p);
    }

    public void delete(Person p) {
        entityManager.remove(p);
    }

}

特別なことは別にしてなくて、EJB3のコンテナでもそのまま動きそう。

これを使うようにSpringの定義ファイルを書いていきます。

<?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"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
       http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd
       http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd">
    <!-- EntityManagerFactoryとTransactionManagerを定義 -->
    <bean id="entityManagerFactory" class="org.springframework.orm.jpa.LocalEntityManagerFactoryBean">
        <property name="persistenceUnitName" value="springjpaeduPU" />
    </bean>
    <bean id="transactionManager" class="org.springframework.orm.jpa.JpaTransactionManager">
        <property name="entityManagerFactory" ref="entityManagerFactory" />
    </bean>

    <!-- JPAの例外をSpringの例外に変換してくれる -->
    <bean class="org.springframework.dao.annotation.PersistenceExceptionTranslationPostProcessor" />
    <!-- PersistenceContextアノテーションにEntityManagerをインジェクションしてくれる -->
    <bean class="org.springframework.orm.jpa.support.PersistenceAnnotationBeanPostProcessor" />

    <!-- DAOを自動登録（今回の場合１つしかないからあまりありがたみは無いかも -->
    <context:component-scan base-package="springjpaedu.dao" />

    <!-- アノテーションベースのトランザクション制御 -->
    <tx:annotation-driven />
</beans>

こいつが動くかどうか簡単に確認してみようと思います。
動作を確認するために、CRUDを一通りするプログラムを作成してみました。

package springjpaedu;

import java.util.List;
import org.springframework.context.support.AbstractApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import springjpaedu.dao.PersonDao;
import springjpaedu.entities.Person;

public class DaoTestMain {

    public static void main(String[] args) {
        AbstractApplicationContext ctx = null;
        try {
            ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
            PersonDao dao = (PersonDao) ctx.getBean("personDao");
            
            // 全件表示
            List<Person> people = dao.findAll();
            System.out.println("## 全データ出力");
            System.out.println(people);

            // 1件取得して更新
            Person p = dao.get(1);
            p.setName("田中　麻呂");
            dao.update(p);

            // 更新された値を確認
            Person p2 = dao.get(1);
            System.out.println("更新後の名前: " + p2.getName());

            // 新しい人を登録
            Person newPerson = new Person();
            newPerson.setId(1001);
            newPerson.setName("木村　きむきむ");
            dao.insert(newPerson);

            // 新しく登録された人を確認
            Person newPerson2 = dao.get(1001);
            System.out.println("追加した人の名前: " + newPerson2.getName());
        } finally {
            ctx.close();
        }
    }
}

実行すると

## 全データ出力
[springjpaedu.entities.Person[id=1], springjpaedu.entities.Person[id=2], springjpaedu.entities.Person[id=3], spri...省略]
更新後の名前: 田中　麻呂
追加した人の名前: 木村　きむきむ

ちゃんと更新とかもされているっぽいです。
META-INF/persistence.xmlを以下のようにすると、

<?xml version="1.0" encoding="UTF-8"?>
<persistence version="1.0" xmlns="http://java.sun.com/xml/ns/persistence" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/persistence http://java.sun.com/xml/ns/persistence/persistence_1_0.xsd">
  <persistence-unit name="springjpaeduPU" transaction-type="RESOURCE_LOCAL">
    <provider>org.eclipse.persistence.jpa.PersistenceProvider</provider>
    <class>springjpaedu.entities.Person</class>
    <properties>
      <property name="eclipselink.jdbc.password" value="jpaedu"/>
      <property name="eclipselink.jdbc.user" value="jpaedu"/>
      <property name="eclipselink.jdbc.driver" value="org.apache.derby.jdbc.ClientDriver"/>
      <property name="eclipselink.jdbc.url" value="jdbc:derby://localhost:1527/jpaedu"/>
      <!-- SQLのログを出力 -->
      <property name="eclipselink.logging.level" value="FINE" />
    </properties>
  </persistence-unit>
</persistence>

実際に発行されているSQL文も表示されていい感じになりそうです。
データ作成用のMainを起動してDBを初期化して、Javaのファイル以外を更新したので生成物を削除して構築をしてDaoTestMainを実行すると…

[EL Fine]: 2009.05.17 23:08:16.602--ServerSession(2719739)--Connection(6586390)--Thread(Thread[main,5,main])--SELECT ID, NAME FROM PERSON ORDER BY ID ASC
## 全データ出力
[springjpaedu.entities.Person[id=1], springjpaedu.entities.Person[id=2], springjpaedu.entities.Person[id=3], springjpaedu.entities.Person[id=4], springjp...省略]]
[EL Fine]: 2009.05.17 23:08:16.802--ClientSession(20804180)--Connection(27660658)--Thread(Thread[main,5,main])--UPDATE PERSON SET NAME = ? WHERE (ID = ?)
        bind => [田中　麻呂, 1]
更新後の名前: 田中　麻呂
[EL Fine]: 2009.05.17 23:08:16.809--ClientSession(24809582)--Connection(9870377)--Thread(Thread[main,5,main])--INSERT INTO PERSON (ID, NAME) VALUES (?, ?)
        bind => [1001, 木村　きむきむ]
追加した人の名前: 木村　きむきむ

うん。大丈夫そう。

[Java]Spring Framework 2.5入門「BeanFactoryAwareインターフェース」

kazuki@wankuma.com (かずき) — Fri, 20 Feb 2009 13:02:00 GMT

今回は、BeanFactoryAwareインターフェースについてです。このインターフェースはvoid setBeanFactory(BeanFactory factory)というメソッドを１つ備えただけの単純なインターフェースです。
最初に言っておくと、このインターフェースはめったに使いません。というか使わなければならなくなったら、本当に使わなければならないのだろうか？としっかり考えた上で使うことが必要です。

このインターフェースを実装したクラスをSpringが見つけると、setBeanFactoryメソッドからBeanFactoryのインスタンスを渡してくれます。つまり、BeanFactoryをがりがり使って色んなステキなことが出来そうな気がします。

ただし、Springにがっつり依存してしまうことになるので、POJOに比べて格段にテストしにくいものになってしまいます。大体のケースでは、きっともっといい方法があるはずなので、使う時は慎重に。

ということで使ってみよう。「springaware」というプロジェクトを作ってSpring Framework 2.5のライブラリを追加します。
そして、springaware.SpringDependBeanを作成します。このクラスにBeanFactoryAwareインターフェースを実装しちゃいます。

package springaware;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.BeanFactoryAware;

public class SpringDependBean implements BeanFactoryAware {
    private BeanFactory factory;

    public void setBeanFactory(BeanFactory factory) throws BeansException {
        this.factory = factory;
    }

    public void printValue() {
        // ファクトリからvalueという名前で登録されているものをプリントする
        System.out.println("value: " + factory.getBean("value"));
    }
}

そして、Springの定義ファイルを書きます。

<?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-2.5.xsd">
    <!-- このInteger型を印字する -->
    <bean id="value" class="java.lang.Integer">
        <constructor-arg type="int" value="100" />
    </bean>

    <bean id="awareBean" class="springaware.SpringDependBean" />
</beans>

後は、いつもどおりApplicationContextを作ってgetBeanでインスタンスを取得して使えます。

package springaware;

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

public class Main {
    public static void main(String[] args) {
        ApplicationContext ctx = new ClassPathXmlApplicationContext("application.xml");
        SpringDependBean bean = (SpringDependBean) ctx.getBean("awareBean");
        bean.printValue(); // value: 100と表示される
    }
}

簡単ですね。

[Java]Spring Framework 2.5入門「ファクトリメソッドの指定」

kazuki@wankuma.com (かずき) — Fri, 20 Feb 2009 00:04:00 GMT

Spring Framework 2.5には、クラスのインスタンスを生成するときにコンストラクタじゃなくてクラスのメソッドを指定することができる。
メソッドの指定は、beanタグのfactory-method属性で指定できます。

たとえば、以下のような典型的なSingletonパターンで作られてしまったようなクラスがあったとします。

package springfactorymethod;

public class SingletonObject {
    // 唯一のインスタンス
    private static final SingletonObject instance = new SingletonObject();

    // 外部からのインスタンス化禁止
    private SingletonObject() {}

    // 唯一のインスタンス取得口
    public static SingletonObject getInstance() {
        return instance;
    }
}

これをSpringに登録して使うときには、以下のような定義を行います。

<!-- factory-method属性で、インスタンスを生成するメソッドを指定する -->
<bean id="singletonObject" class="springfactorymethod.SingletonObject"
    factory-method="getInstance" />

この定義を読み込ませて、ApplicationContextのgetBeanメソッドからインスタンスを取得すると、getInstanceが呼ばれてインスタンスが返されます。
factory-methodに引数がある場合は、constructor-arg要素で指定できるようです。

factory-bean属性も追加すると、別のbeanの特定のインスタンスからインスタンスを取得するようにも出来るみたいです。

[Java]Spring Framework 2.5入門「beanのコールバックメソッド」

kazuki@wankuma.com (かずき) — Wed, 18 Feb 2009 22:51:00 GMT

前回は、beanのスコープについて軽く学んだ。
今回は、beanのコールバックメソッドについて学んでみようと思います。

Springは、インスタンスが生成されたタイミング（厳密にいうと少し違うけど）と、インスタンスが破棄されるタイミングで、特定の処理を走らせることが出来るようになっています。
インスタンスが生成されたタイミングというのは、コンストラクタっていうのがすでにJavaにあるじゃん？といった感じですが、処理が実行されるタイミングが微妙に違って、Springによってプロパティの初期化が行われたあとに呼ばれます。

このコールバックメソッドの指定方法には、３つの方法が提供されています。

所定のインターフェースのメソッドを実装する
OOPをしたことがある人にとって、恐らくもっともわかりやすい方法。
ただし、クラスがSpringのインターフェースに依存してしまう。
Springの定義ファイルにメソッド名を指定する
Springの定義ファイルで、初期化時と、破棄時に呼ぶメソッドを名前で指定します。
クラスがSpringに依存しなくなります。
アノテーションを使用する。
JSR-220のアノテーションを使用することも出来ます。
最近流行のアノテーションなので、カッコいい気がします。

個人的には、２か３のどちらかかなぁと思っていますが、確か３はJavaSE6から普通に使えるようになってるらしいのでJavaSE5の人は、２あたりを使っておくのが一番つぶしがきくかもしれません。

ということで実験

NetBeans6.5を立ち上げて、springlifecycleというプロジェクトを作成してライブラリにSpring Frameowrk 2.5を追加する。ここら辺までは手馴れてきた。

上の画面では、すでに作っていますが、springlifecycle.beansパッケージを作成します。ここにクラスを定義していきます。
まずは、インターフェースを定義するタイプのクラスを作成します。
インターフェースは、初期化用と破棄用の２つが用意されていて、org.springframework.beans.factory.InitializingBeanインターフェースとorg.springframework.beans.factory.DisposableBeanインターフェースになります。

InitializingBeanにはafterPropertiesSetメソッドが定義されていて、DisposableBeanにはdestroyメソッドが定義されています。ということで早速実装したクラスを定義します。
クラス名はInitDestoryBean1にしました。

package springlifecycle.beans;

import org.springframework.beans.factory.DisposableBean;
import org.springframework.beans.factory.InitializingBean;

public class InitDestroyBean1 implements InitializingBean, DisposableBean {

    private Integer value;

    public InitDestroyBean1() {
        System.out.println(this + ":InitDestroyBean1 " + value);
    }

    public void afterPropertiesSet() throws Exception {
        System.out.println(this + ":afterPropertiesSet " + value);
    }

    public void destroy() throws Exception {
        System.out.println(this + ":destroy " + value);
    }

    public void setValue(Integer value) {
        this.value = value;
    }


}

そして、Springの定義ファイルとしてapplication.xmlを作成して以下のbeanの定義を追加します。

<bean id="initDestoryBean1" class="springlifecycle.beans.InitDestroyBean1">
    <property name="value" value="100" />
</bean>

予想としては、まず、InitDestroyBean1のコンストラクタが実行されます。このタイミングではDIがされていないので、valueはnullと表示されます。
その次に、afterPropertiesSetが呼ばれます。この段階では、DIが行われているので、valueは100と表示されるはずです。
そして、最後にコンテナが破棄されるタイミングでdestroyが実行されます。

ということで以下のMainを書いて早速実行！

package springlifecycle;

import org.springframework.context.support.AbstractApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import springlifecycle.beans.InitDestroyBean1;

public class Main {
    public static void main(String[] args) {
        // closeメソッドを呼ぶので、AbstractApplicationContextクラスを使う
        AbstractApplicationContext ctx = new ClassPathXmlApplicationContext("application.xml");
        InitDestroyBean1 bean1 = (InitDestroyBean1) ctx.getBean("initDestroyBean1");
        ctx.close(); // コンテナを破棄
    }
}

実行結果は…

springlifecycle.beans.InitDestroyBean1@bfc8e0:InitDestroyBean1 null
springlifecycle.beans.InitDestroyBean1@bfc8e0:afterPropertiesSet 100
springlifecycle.beans.InitDestroyBean1@bfc8e0:destroy 100

予想通り！！

次に、Springの定義ファイルで指定する方法を実験してみます。
Springの定義ファイルで指定する場合は、特定のインターフェースとかは実装しなくてもOKです。とりあえず初期化メソッドをinit、破棄のメソッドをdestroyにして実装してみました。

package springlifecycle.beans;

public class InitDestroyBean2 {

    private Integer value;

    public InitDestroyBean2() {
        System.out.println(this + ":InitDestroyBean2 " + value);
    }

    public void init() {
        System.out.println(this + ":init " + value);
    }

    public void destroy() {
        System.out.println(this + ":destroy " + value);
    }

    public void setValue(Integer value) {
        this.value = value;
    }
}

このメソッドを初期化時と、破棄時に呼び出すようにするには定義ファイルのbean属性にinit-method属性と、destroy-method属性にメソッド名を設定します。

<bean id="initDestroyBean2" 
        class="springlifecycle.beans.InitDestroyBean2"
        init-method="init"
        destroy-method="destroy">
    <property name="value" value="100" />
</bean>

Mainも実装します。

package springlifecycle;

import org.springframework.context.support.AbstractApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import springlifecycle.beans.InitDestroyBean2;

public class Main {
    public static void main(String[] args) {
        AbstractApplicationContext ctx = new ClassPathXmlApplicationContext("application.xml");
        InitDestroyBean2 bean2 = (InitDestroyBean2) ctx.getBean("initDestroyBean2");
        ctx.close(); // コンテナを破棄
    }
}

これの実行結果も、インターフェースを実装したときと同じになります。

springlifecycle.beans.InitDestroyBean2@bfc8e0:InitDestroyBean2 null
springlifecycle.beans.InitDestroyBean2@bfc8e0:init 100
springlifecycle.beans.InitDestroyBean2@bfc8e0:destroy 100

コンストラクタでは、nullのフィールドが、initでは値が表示されてることがわかります。

ちなみに、このinit-method属性とdestroy-method属性は、beansタグにdefault-init-method属性と、default-destroy-method属性で複数のbeanに対して一括で設定できます。

最後に、属性を使った場合について書きます。
属性は、以下の２つを使います。

javax.annotation.PostConstruct
初期化時のメソッドを指定します。
javax.annotation.PreDestroy
破棄時のメソッドを指定します。

これも、さくっと実装します。

package springlifecycle.beans;

import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;

public class InitDestroyBean3 {

    private Integer value;

    public InitDestroyBean3() {
        System.out.println(this + ":InitDestroyBean2 " + value);
    }

    @PostConstruct
    public void init() {
        System.out.println(this + ":init " + value);
    }

    @PreDestroy
    public void destroy() {
        System.out.println(this + ":destroy " + value);
    }

    public void setValue(Integer value) {
        this.value = value;
    }
}

そして、application.xmlへの定義も行います。この場合は、追加の属性で、init-methodやdestroy-methodの指定は行いません。
その代わりに、以下のクラスを定義する必要があります。

<bean class="org.springframework.context.annotation.CommonAnnotationBeanPostProcessor" />

このクラスを定義しておくことで、アノテーションによる設定が有効になります。

続けてInitDestroyBean3を定義します。

<bean id="initDestroyBean3"
        class="springlifecycle.beans.InitDestroyBean3">
    <property name="value" value="100" />
</bean>

そして、Mainをぱぱっと書きます。

これを実行して結果を見てみると、過去の２つと同じ結果になりました。（細かい文言はきしないで）

springlifecycle.beans.InitDestroyBean3@a46701:InitDestroyBean2 null
springlifecycle.beans.InitDestroyBean3@a46701:init 100
springlifecycle.beans.InitDestroyBean3@a46701:destroy 100

[Java]Spring Framework2.5入門「beanのスコープ」

kazuki@wankuma.com (かずき) — Tue, 17 Feb 2009 12:56:00 GMT

今回はbeanのスコープについてのお話です。
beanのスコープというのは、Springが、どの範囲でbeanのインスタンスを生成・破棄するかを指定するものになります。
Spring Framework2.5では、以下の５つのスコープがあります。

singleton
１つのコンテナ内で１つのインスタンス（デフォルトはこれになる）
prototype
コンテナからbeanを取得するたびにインスタンスを生成する
request
Webアプリ専用。HTTPのRequest単位でインスタンスを生成する。
session
Webアプリ専用。HTTPのSession単位でインスタンスを生成する。
global session
ポートレット専用。詳しくないのでよくわからない。グローバルセッションというものがあるらしい。

3以降は、Web系でしか使えないので、コンソールアプリとかで少し試すぶんにはsingletonとprototypeの２つになります。
今回は、この２つの動きについて見ていこうと思います。残りの部分については、勧めていく過程で使えるようになったら使っていきます。

Springがインスタンスを生成したことがわかるように、コンストラクタにログを吐くように作ったクラスを１つ定義します。

springscope/MyBean.java

package springscope;

public class MyBean {
    public MyBean() {
        System.out.println("MyBean コンストラクタ");
    }
    public void execute() {
        System.out.println("MyBean#execute()実行");
    }
}

これをSpringに登録して、singletonとprototypeで出力されるメッセージの違いを観察します。
スコープの指定は、Springの定義ファイルで、beanタグにscope属性として指定します。

application.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-2.5.xsd">
    <!-- プロトタイプ -->
    <bean id="prototypeBean" class="springscope.MyBean" scope="prototype" />

    <!-- シングルトン(scope属性を省略しても同じ) -->
    <bean id="singletonBean" class="springscope.MyBean" scope="singleton" />
</beans>

この定義ファイルを読み込んでごにょごにょやるプログラムを書きます。

package springscope;

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

public class Main {

    public static void main(String[] args) {
        System.out.println("ApplicationContextを作成");

        System.out.println("======================================");
        ApplicationContext ctx = new ClassPathXmlApplicationContext("application.xml");
        System.out.println("プロトタイプのBeanを２つ取得");
        MyBean prototype1 = (MyBean) ctx.getBean("prototypeBean");
        MyBean prototype2 = (MyBean) ctx.getBean("prototypeBean");
        System.out.println("処理を実行");
        prototype1.execute();
        prototype2.execute();

        System.out.println("======================================");
        System.out.println("シングルトンのBeanを２つ取得");
        MyBean singleton1 = (MyBean) ctx.getBean("singletonBean");
        MyBean singleton2 = (MyBean) ctx.getBean("singletonBean");
        System.out.println("処理を実行");
        singleton1.execute();
        singleton2.execute();
    }

}

これを実行して、動きを確認します。
予想としては、プロトタイプのほうはインスタンスを取得するタイミングで2回コンストラクタを実行するログが出るはずです。シングルトンのほうは、1回何処かででるはず。

ということで実行！

ApplicationContextを作成
======================================
MyBean コンストラクタ
プロトタイプのBeanを２つ取得
MyBean コンストラクタ
MyBean コンストラクタ
処理を実行
MyBean#execute()実行
MyBean#execute()実行
======================================
シングルトンのBeanを２つ取得
処理を実行
MyBean#execute()実行
MyBean#execute()実行

ApplicationContextのインスタンス作成直後のタイミング（3行目）でMyBeanのインスタンスが１つ作られていることが確認できます。
これが、シングルトンのMyBeanのインスタンスが作成されるタイミングです。

その後プロトタイプが２つ作られているのがわかります。最後のシングルトンのインスタンスを取得している所ではインスタンスが作られていないことも確認できます。

ということでまとめ。

scopeは、Springのコンテナがbeanのインスタンスをどの単位で管理するかを指定するもの
scopeは、５つある。
webアプリ以外ではprototypeとsingletonの２つが使える。
singletonはコンテナが作成されたタイミングでインスタンスが作成されて、それが使いまわされる。
prototypeは、beanが取得されるたびにインスタンスが作られる。

以上です。

[Java]Spring Framework 2.5入門「ListやMapやProperties」

kazuki@wankuma.com (かずき) — Mon, 16 Feb 2009 21:35:00 GMT

今回も引き続き、Spring Framework2.5の超基本的なところを抑えていこうと思います。
今回は、Springの定義ファイル内で、ListやMapやPropertiesを使いたくなったときにどうするかについて勉強します。

といっても非常に簡単で、Listはlistタグ、Mapはmapタグ、Propertiesはpropsタグを使って定義します。
実際に試してみるために、以下のようなクラスを定義します。

package springbean;

import java.util.List;
import java.util.Map;
import java.util.Properties;

public class MyBean {
    private Map map;
    private List list;
    private Properties props;

    public List getList() {
        return list;
    }

    public void setList(List list) {
        this.list = list;
    }

    public Map getMap() {
        return map;
    }

    public void setMap(Map map) {
        this.map = map;
    }

    public Properties getProps() {
        return props;
    }

    public void setProps(Properties props) {
        this.props = props;
    }
}

Map, List, Properties型のプロパティをもっただけのBeanです。このクラスのプロパティのListとMapとPropertiesに値をセットする定義ファイルを書いてみます。

<bean id="myBean" class="springbean.MyBean">
    <property name="list">
        <!-- Listの定義はlistタグ -->
        <list>
            <!-- valueタグ、refタグ、beanタグなどを定義していくことで
            リストに要素を追加できる 
            この例では["aaaa", "bbbb", MyBeanのインスタンス]というListを定義している-->
            <value>aaaa</value>
            <value>bbbb</value>
            <bean id="sample" class="springbean.MyBean" />
        </list>
    </property>

    <property name="map">
        <!-- Mapの定義はmapタグ -->
        <map>
            <!-- entryタグでkeyとvalueのペアをあらわす 
            この例では、["a" => "あ", "b" => "い"]といったMapを定義している-->
            <entry key="a" value="あ" />
            <entry>
                <!-- 属性でkeyとvalueを指定したり、タグで指定することも出来る -->
                <key>
                    <value>b</value>
                </key>
                <value>い</value>
            </entry>
        </map>
    </property>

    <property name="props">
        <!-- Propertiesはpropsタグ -->
        <props>
            <!-- 1つのプロパティはpropタグであらわす 
            この例では、["a" => "あいうえお", "b" => "かきくけこ"]というPropertiesを定義している -->
            <prop key="a">あいうえお</prop>
            <prop key="ka">かきくけこ</prop>
        </props>
    </property>
</bean>

とまぁこんな感じ。

[Java]Spring Framework 2.5入門「DIコンテナのメリット」

kazuki@wankuma.com (かずき) — Sun, 15 Feb 2009 11:12:00 GMT

前回：[Java]Spring Framework 2.5入門「依存性の注入」

前回までで、Spring Framework2.5のDIコンテナとしての基本的な機能は使えるようになってきました。
といっても、beanタグとpropertyタグとconstructor-argタグを使うだけですが。今回は、DIコンテナのメリットを書いてみようと思います。

一般的にDIコンテナを使ったプログラムでは、インターフェースを定義して、それを実装したクラスをDIコンテナに登録して使います。これまでのエントリでは、インターフェースは使わずに具象クラスのみ使っていました。

ということで、前回やったMyServiceとMyLogicをインターフェースを使うように変えてみます。
下記の４つを定義します。

springbean.beans.MyLogicインターフェース
springbean.beans.MyLogicImplクラス
springbean.beans.MyServiceインターフェース
springbean.beans.MyServiceImplクラス

実装は特に悩むことはなく、単純にインターフェースと実装クラスのペアをつくっていくだけです。

MyLogicインターフェース

package springbean.beans;

public interface MyLogic {
    int add(int lhs, int rhs);
}

MyLogicImplクラス

package springbean.beans;

public class MyLogicImpl implements MyLogic {
    public int add(int lhs, int rhs) {
        return lhs + rhs;
    }
}

MyServiceインターフェース

package springbean.beans;

public interface MyService {
    int execute();
}

MyServiceImplクラス

package springbean.beans;

public class MyServiceImpl implements MyService {
    // インターフェースを受け取るようにする
    private MyLogic logic;

    private int lhs;
    private int rhs;

    public int execute() {
        return logic.add(lhs, rhs);
    }

    public void setLhs(int lhs) {
        this.lhs = lhs;
    }

    public void setLogic(MyLogic logic) {
        this.logic = logic;
    }

    public void setRhs(int rhs) {
        this.rhs = rhs;
    }


}

ここで大事なのが、MyServiceImplクラスが依存するものがMyLogicインターフェースになるという部分です。MyLogicインターフェースを実装するクラスなら何でもMyServiceImplに設定することが出来るようになります。

当然application.xmlも変更が入ります。MyLogicImplとMyServiceImplを定義するように変更します。

application.xml(beansタグの内側だけ抜粋)

<bean id="myLogic" class="springbean.beans.MyLogicImpl" />

<bean id="myService" class="springbean.beans.MyServiceImpl">
    <property name="logic" ref="myLogic" />
    <property name="lhs" value="100" />
    <property name="rhs" value="200" />
</bean>

Mainは特に変更はありませんが一応mainメソッド内部だけのせておきます。

ApplicationContext ctx = new ClassPathXmlApplicationContext("application.xml");

// インターフェースに対してプログラムを書く
MyService service = (MyService) ctx.getBean("myService");
System.out.println("service#execute = " + service.execute()); // 300と表示される

これで、一般的なDIコンテナを使ったプログラムっぽい形になりました。正直、こんなめんどくさいことを何故するんだろう？と最初思いましたが、こうすることで”ユニットテストが非常にやりやすい”形になっています。

MyServiceImplクラス内には、外部のクラスに直接依存する部分は排除される形になっています。MyServiceImplクラスを動かすための要件は、MyLogicインターフェースを実装したクラスがあるということだけになります。

つまり、テストをしたければ、MyLogicインターフェースを実装したMyLogicMockみたいなクラスを作って、それを使ってテストが出来るようになります。

ということでやってみましょう。Spring Frameworkには単体テストを支援する色々な機能が組み込まれていますが、ここでは、その機能は使わずに書いてみます。

MyServiceImplが単体として満たさなければいけない要件は、以下の２つになると思います。

logicのaddメソッドにlhsフィールド, rhsフィールドの値をちゃんと渡す。
logicのaddメソッドの結果をちゃんと返す。

ということで、早速MyLogicインターフェースを実装したMockクラスを定義します。

package springbean.beans;

import static org.junit.Assert.*;

public class MyLogicMock implements MyLogic {
    public int add(int lhs, int rhs) {
        // 要件１をちゃんと満たしているか確認
        assertEquals(100, lhs);
        assertEquals(200, rhs);

        return 1000; // 固定値を返す
    }
}

このMockクラスは、引数が100と200がわたってきているか確認した後に、固定値で1000を返します。このMockクラスを使うように定義したspringbean.beans.MyServiceTest-context.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-2.5.xsd">
    <!-- ロジックはMockを使う -->
    <bean id="logic" class="springbean.beans.MyLogicMock" />
    <bean id="service" class="springbean.beans.MyServiceImpl">
        <property name="logic" ref="logic" />
        <property name="lhs" value="100" />
        <property name="rhs" value="200" />
    </bean>
</beans>

テストクラスのセットアップで、この定義ファイルを読み込んでApplicationContextを作ってserviceを取得します。
そして、取得したserviceに対してテストを実施します。

package springbean.beans;

import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import static org.junit.Assert.*;

public class MyServiceTest {

    private MyService service;

    @Before
    public void setUp() {
        // テスト用の定義ファイル読み込み
        ApplicationContext ctx = new ClassPathXmlApplicationContext(
                "springbean/beans/MyServiceTest-context.xml");
        service = (MyService) ctx.getBean("service");
    }

    @After
    public void tearDown() {
        service = null;
    }

    @Test
    public void execute() throws Exception {
        // 要件２を満たしているか確認
        assertEquals(1000, service.execute());
    }
}

といった感じにクラス間が疎結合になり、単体テストがとてもやりやすくなるのがDIコンテナのメリットの１つでもあります。

今回の例では、単純すぎてあんまりメリットは感じないですが、たとえばMyLogicがDBにアクセスするような処理だったら、Mockに簡単に差し替えることでDBに依存しないでMyServiceのテストが出来るということは大きなメリットになると思います。

ということで今回はおしまい。

[Java]Spring Framework 2.5入門「依存性の注入」

kazuki@wankuma.com (かずき) — Fri, 13 Feb 2009 13:18:00 GMT

Spring FrameworkはIoCコンテナとかDIコンテナとか言われています。
要は、今までコードの中に書いてたクラス間の依存関係をSpring側で面倒見てあげるというものです。

代償としてXMLファイルを書かなければなりません。（新機能とか色々使えばそうでもないけど）
ということで、今回は依存性の注入をしてみようと思います。

依存性の注入方法には、代表的なもので２つあります。他にもありますが、とりあえず基本的なパターンでよく使うと思われる２つに絞ります。

セッターインジェクション
コンストラクタインジェクション

名前からわかるように、各々セッターを使ってクラスのインスタンスを設定するか、コンストラクタで設定するかの違いです。
Spring的には、セッターインジェクションがオススメみたいなことが書いてありました。
（英語力が皆無なので誤読してる可能性あり）

なんでも、「理想を語るならコンストラクタインジェクションだけど、セッターインジェクションの方が色々便利だよ」と言う事らしいです。
詳しくは、Springのリファレンスを見てください。

ということで、今回はspring2bean.beans.MyServiceクラスとspring2bean.beans.MyLogicクラスを使って依存性注入をしてみようと思います。
MyServiceクラスがMyLogicクラスを使うといった形になっています。

MyServiceクラス

package spring2bean.beans;

// 左辺値と右辺値を受け取ってMyLogicのaddメソッドに渡すだけのクラス
public class MyService {
    private MyLogic logic;

    private int lhs;
    private int rhs;

    public MyService() {
    }

    // コンストラクタで初期化
    public MyService(MyLogic logic, int lhs, int rhs) {
        this.logic = logic;
        this.lhs = lhs;
        this.rhs = rhs;
    }

    public int execute() {
        return logic.add(lhs, rhs);
    }

    // セッターでも初期化可能
    public void setLogic(MyLogic logic) {
        this.logic = logic;
    }

    public void setLhs(int lhs) {
        this.lhs = lhs;
    }

    public void setRhs(int rhs) {
        this.rhs = rhs;
    }
}

MyLogicクラス

package spring2bean.beans;

public class MyLogic {
    public int add(int x, int y) {
        return x + y;
    }
}

MyServiceクラスには、コンストラクタからでもセッターからでもフィールドの値の設定が可能なつくりにしました。
このクラスを使って、コンストラクタインジェクションとセッターインジェクションの場合の定義例を以下に示します。

application.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-2.5.xsd">
    <!-- サービスから使われるロジック -->
    <bean id="myLogic" class="spring2bean.beans.MyLogic" />

    <!-- セッターインジェクション -->
    <bean id="setterService" class="spring2bean.beans.MyService">
        <!--
        propertyタグを使って、どのプロパティに何をセットするかを記述する。
        refを使って既に定義されているbeanを参照することも、valueを使って
        intやString等を直接設定することが出来る。
        -->
        <property name="logic" ref="myLogic" />
        <property name="lhs" value="100" />
        <property name="rhs" value="200" />
    </bean>

    <!-- コンストラクタインジェクション -->
    <bean id="constructorService" class="spring2bean.beans.MyService">
        <!--
        constructor-argタグを使って、何番目のコンストラクタの引数に何を設定するかを
        指定する。
        propertyタグと同じようにrefとvalueが使える。
        こっちはpropertyタグにはないtype属性があって、そこに型を指定できる。
        -->
        <constructor-arg ref="myLogic" />
        <constructor-arg type="int" value="1000" />
        <constructor-arg type="int" value="150" />
    </bean>
</beans>

簡単な説明をXML中にコメントとして追加しました。これを読み込んでサービスの処理を実行するMainを書いて動きを見てみます。うまくいけば、setterServiceのexecuteは300を返して、constructorServiceのexecuteは1150を返すはずです。

Main.java

package spring2bean;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import spring2bean.beans.MyService;

public class Main {

    public static void main(String[] args) {
        // ApplicationContext作って～
        ApplicationContext ctx = new ClassPathXmlApplicationContext("application.xml");
        
        // サービスのインスタンスを取得して～
        MyService setterService = (MyService) ctx.getBean("setterService");
        MyService constructorService = (MyService) ctx.getBean("constructorService");

        // 処理実行！
        System.out.println("setterService#execute = " + setterService.execute());
        System.out.println("constructorService#execute = " + constructorService.execute());
    }

}

実行結果は…

setterService#execute = 300
constructorService#execute = 1150

思ったとおり！

今回のを簡単にまとめると・・・
依存性の注入にはセッターインジェクションとコンストラクタインジェクションの2通りがある。
セッターインジェクションにはpropertyタグを使う。
コンストラクタインジェクションにはconstructor-argタグを使う。
ref属性で、既に定義されているbeanを参照できて、value属性で直接値を設定できる。

ということで今回はここまで。

[Java]Spring Framework入門「beanの登録」

kazuki@wankuma.com (かずき) — Fri, 13 Feb 2009 00:57:00 GMT

前回：[Java]Spring Framework 2.5入門「コンテナの作成」

前回で、application.xmlファイルを準備して、それを読み込んでApplicationContextを作ることが出来るようになりました。
今回は、このファイルにbeanを登録してみようと思います。

まず、プロジェクトの下準備をします。
NetBeansでspringbeanという名前のプロジェクトを作成し、application.xmlという名前でSpring XML 構成ファイルを作成します。

そして、Greeterというクラスをspringbean.beansパッケージに作成します。

package springbean.beans;

public class Greeter {
    public void greet() {
        System.out.println("Greeter#greet()");
    }
}

この時点のプロジェクトウィンドウの画像を以下に示します。

application.xmlにここで作成したGreeterを登録します。
Springへのクラスの登録は、beanタグを使用します。

beanタグには、以下のような属性が定義できます。

class
クラス名（パッケージ名ふくむ）
name
Springから登録されたクラスを取得するために必要な名前
scope
prototypeやsessioon, request, singletonなんかを指定します

基本的にこれくらい知ってれば、とりあえずは大丈夫です。ということで、Greeterクラスを登録します。
以下のタグをapplication.xmlのbeansタグの中に書けばOK。

<bean name="greeter" class="springbean.beans.Greeter" />

最後に、ここで定義したbeanを取り出す方法について述べます。取り出し方は、ApplicationContextのgetBeanで可能です。
beanタグのnameに指定したもので取り出すことが出来ます。

package springbean;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import springbean.beans.Greeter;

public class Main {

    public static void main(String[] args) {
        // application.xmlをもとにSpringのコンテナを作成する。
        ApplicationContext ctx = new ClassPathXmlApplicationContext("application.xml");

        // Greeterのインスタンスの取得
        Greeter g = (Greeter) ctx.getBean("greeter");
        g.greet();
    }

}

今日はここまで！