(Quick Reference)

16 GrailsとSpring - Reference Documentation

Authors: Graeme Rocher, Peter Ledbrook, Marc Palmer, Jeff Brown, Luke Daley, Burt Beckwith

Version: 2.4.0.M1

Translated by: T.Yamamoto, Japanese Grails Doc Translating Team. Special thanks to NTT Software.
【注意】このドキュメントの内容はスナップショットバージョンを元に*意訳*されているため、一部現行バージョンでは未対応の機能もあります。

16.1Grailsの土台

16.2追加ビーンを定義する

16.3ビーンDSLでSpringランタイム

16.4ビーンビルダーDSLの解説

16.5プロパティプレースホルダ設定

16.6プロパティオーバーライド設定

16 GrailsとSpring

This section is for advanced users and those who are interested in how Grails integrates with and builds on the Spring Framework It is also useful for plugin developers considering doing runtime configuration Grails.

このセクションでは、Grailsが Spring Framework とどのように統合され、構築されるかに興味がある上級者向けの内容を扱います。この内容はプラグイン開発者にとっても、Grails実行時の構成を検討する上で有用な情報です。

16.1 Grailsの土台

Grails is actually a Spring MVC application in disguise. Spring MVC is the Spring framework's built-in MVC web application framework. Although Spring MVC suffers from some of the same difficulties as frameworks like Struts in terms of its ease of use, it is superbly designed and architected and was, for Grails, the perfect framework to build another framework on top of.

Grailsは、実はGrailsという皮を被ったSpring MVCアプリケーションです。 Spring MVCはSpring frameworkに含まれているMVCウェブアプリケーションフレームワークです。 Spring MVCはStrutsのようなフレームワークと同様に、使いやすさの面においては多少難があるため悩まされますが、その上に他のフレームワークを構築するには申し分ないフレームワークであり、Grailsにとってはすばらしい設計とアーキテクチャであるといえます。

Grails leverages Spring MVC in the following areas:

GrailsはSpring MVCを次の領域で活用しています:

Basic controller logic - Grails subclasses Spring's DispatcherServlet and uses it to delegate to Grails controllers

基本的なコントローラのロジック - GrailsのサーブレットはSpringのDispatcherServletのサブクラスであり、それを用いてGrailsのコントローラにディスパッチを行います

Data Binding and Validation - Grails' validation and data binding capabilities are built on those provided by Spring

データバインディングとバリデーション - Grailsのバリデーションとデータバインディングの機能は、Springで提供されているものを用いています

Runtime configuration - Grails' entire runtime convention based system is wired together by a Spring ApplicationContext

ランタイム設定 - Grailsランタイム全体の規約に基づくシステムはSpringのApplicationContextと結びついています

Transactions - Grails uses Spring's transaction management in GORM

トランザクション - GrailsはSpringのトランザクション管理をGORMで利用しています

In other words Grails has Spring embedded running all the way through it.

言い換えれば、Grailsはすべての機能を組み込まれたSpringを介して実行しているということになります。

The Grails ApplicationContext

Grailsアプリケーションコンテキスト

Spring developers are often keen to understand how the Grails ApplicationContext instance is constructed. The basics of it are as follows.

Spring開発者は、どのようにGrailsのApplicationContextインスタンスが組み立てられるのか理解したい、と熱心に望んでいます。基本的には次のようになります:

Grails constructs a parent ApplicationContext from the web-app/WEB-INF/applicationContext.xml file. This ApplicationContext configures the api:org.codehaus.groovy.grails.commons.GrailsApplication instance and the api:org.codehaus.groovy.grails.plugins.GrailsPluginManager.

Grailsがweb-app/WEB-INF/applicationContext.xmlファイルから親となるApplicationContextを組み立てます。このApplicationContextはGrailsApplicationインスタンスとGrailsPluginManagerを設定します。

Using this ApplicationContext as a parent Grails' analyses the conventions with the GrailsApplication instance and constructs a child ApplicationContext that is used as the root ApplicationContext of the web application

この親となるApplicationContextを用いて、GrailsApplicationインスタンスと共にGrailsの規約を解析し、Webアプリケーションのルートとして利用される子ApplicationContextを組み立てます。

Configured Spring Beans

構成されたSpringビーン

Most of Grails' configuration happens at runtime. Each plugin may configure Spring beans that are registered in the ApplicationContext. For a reference as to which beans are configured, refer to the reference guide which describes each of the Grails plugins and which beans they configure.

Grailsの設定のほとんどは実行時に行われます。各pluginはApplicationContextに登録されているSpringビーンを構成することができます。構成されるビーンの詳細については各プラグインのリファレンスガイドを参照してください。

16.2 追加ビーンを定義する

Using the Spring Bean DSL

SpringビーンDSLの使用

You can easily register new (or override existing) beans by configuring them in grails-app/conf/spring/resources.groovy which uses the Grails Spring DSL. Beans are defined inside a beans property (a Closure):

Grails Spring DSLを使い、grails-app/conf/spring/resources.groovyに設定することで、簡単に新しいビーンが登録(または上書き)できます。ビーンはbeansプロパティ(クロージャ)の内部に設定します。

beans = {
    // beans here
}

As a simple example you can configure a bean with the following syntax:

簡単な例として、以下のようなシンタックスでビーンを設定できます。

import my.company.MyBeanImplbeans = {
    myBean(MyBeanImpl) {
        someProperty = 42
        otherProperty = "blue"
    }
}

Once configured, the bean can be auto-wired into Grails artifacts and other classes that support dependency injection (for example BootStrap.groovy and integration tests) by declaring a public field whose name is your bean's name (in this case myBean):

一度設定をすれば、パブリックフィールドをビーンの名前(この場合はmyBean)で宣言することで、Grailsのアーティファクトや、他の依存性の注入がサポートされているクラス(例えば、BootStrap.groovyやインテグレーションテスト)にビーンが自動注入されます。

class ExampleController {     def myBean
     …
}

Using the DSL has the advantage that you can mix bean declarations and logic, for example based on the environment:

DSLを使用することで、ビーンの定義にロジックを混ぜることができる利点があります。例えば環境を基にビーンを定義する場合です。

import grails.util.Environment
import my.company.mock.MockImpl
import my.company.MyBeanImplbeans = {
    switch(Environment.current) {
        case Environment.PRODUCTION:
            myBean(MyBeanImpl) {
                someProperty = 42
                otherProperty = "blue"
            }
            break
        case Environment.DEVELOPMENT:
            myBean(MockImpl) {
                someProperty = 42
                otherProperty = "blue"
            }
            break
    }
}

The GrailsApplication object can be accessed with the application variable and can be used to access the Grails configuration (amongst other things):

GrailsApplicationオブジェクトはapplication変数で参照でき、Grailsの設定などにアクセスできます。

import grails.util.Environment
import my.company.mock.MockImpl
import my.company.MyBeanImplbeans = {
    if (application.config.my.company.mockService) {
        myBean(MockImpl) {
            someProperty = 42
            otherProperty = "blue"
        }
    } else {
        myBean(MyBeanImpl) {
            someProperty = 42
            otherProperty = "blue"
        }
    }
}

If you define a bean in resources.groovy with the same name as one previously registered by Grails or an installed plugin, your bean will replace the previous registration. This is a convenient way to customize behavior without resorting to editing plugin code or other approaches that would affect maintainability.

もし、Grailsやインストールしたプラグインによって登録された名前のビーンをresources.groovyに定義した場合は、既存で登録されいているビーンが自分で登録したビーンに置き換えられます。これは、既存の振る舞いをカスタマイズする便利な方法です。既存のプラグインのコードを変更することなく、またメンテンナンスに影響を与えることもありません。

Using XML

XMLの使用

Beans can also be configured using a grails-app/conf/spring/resources.xml. In earlier versions of Grails this file was automatically generated for you by the run-app script, but the DSL in resources.groovy is the preferred approach now so it isn't automatically generated now. But it is still supported - you just need to create it yourself.

ビーンはgrails-app/conf/spring/resources.xmlを使用して定義することもできます。このXMLファイルは、以前のGrailsのバージョンではrun-appを実行したタイミングで自動的に生成されていました。しかし、現在はresources.groovyでDSLを使用した方法が推奨のため、このXMLファイルが自動的に生成されることはありません。自動的に生成はされませんが、まだサポートはされています。もし使用したい場合は、手動でこのファイルを作成します。

This file is typical Spring XML file and the Spring documentation has an excellent reference on how to configure Spring beans.

このXMLファイルは、典型的なSpringのXMLファイルです。このXMLファイルで、どのようにSpringビーンの設定をするかは、Springのドキュメンテーションに素晴らしい記述があります。

The myBean bean that we configured using the DSL would be configured with this syntax in the XML file:

さきほどDSLで定義したmyBeanは、XMLファイルでは以下のように定義できます。

<bean id="myBean" class="my.company.MyBeanImpl">
    <property name="someProperty" value="42" />
    <property name="otherProperty" value="blue" />
</bean>

Like the other bean it can be auto-wired into any class that supports dependency injection:

これは、他のビーンと同じように、依存性の注入がサポートされているクラスで、ビーンが自動注入されます。

class ExampleController {     def myBean
}

Referencing Existing Beans

既存ビーンの参照

Beans declared in resources.groovy or resources.xml can reference other beans by convention. For example if you had a BookService class its Spring bean name would be bookService, so your bean would reference it like this in the DSL:

resources.groovy、またはresources.xmlに定義したビーンは、規約によって登録された他のビーンを参照できます。例えば、BookServiceクラスがあったとすると、Springのビーンの名前はbookServiceになります。これを、DSL内で参照するには以下のようにします。

beans = {
    myBean(MyBeanImpl) {
        someProperty = 42
        otherProperty = "blue"
        bookService = ref("bookService")
    }
}

or like this in XML:

XMLを使用した場合は以下のようになります。

<bean id="myBean" class="my.company.MyBeanImpl">
    <property name="someProperty" value="42" />
    <property name="otherProperty" value="blue" />
    <property name="bookService" ref="bookService" />
</bean>

The bean needs a public setter for the bean reference (and also the two simple properties), which in Groovy would be defined like this:

このビーンには参照するビーン(とシンプルな2つのプロパティ)を設定するパブリックなセッターが必要です。 Groovyでは以下のように定義できます。

package my.companyclass MyBeanImpl {
    Integer someProperty
    String otherProperty
    BookService bookService // or just "def bookService"
}

or in Java like this:

Javaの場合は以下のようになります。

package my.company;class MyBeanImpl {
    private BookService bookService;
    private Integer someProperty;
    private String otherProperty;
    public void setBookService(BookService theBookService) {
        this.bookService = theBookService;
    }
    public void setSomeProperty(Integer someProperty) {
        this.someProperty = someProperty;
    }
    public void setOtherProperty(String otherProperty) {
        this.otherProperty = otherProperty;
    }
}

Using ref (in XML or the DSL) is very powerful since it configures a runtime reference, so the referenced bean doesn't have to exist yet. As long as it's in place when the final application context configuration occurs, everything will be resolved correctly.

refは実行時の参照を設定するため非常に強力です。これは定義時に参照するビーンが存在している必要がありません。最終的にアプリケーションコンテキストの設定が完了した時点で、そのビーンが存在していれば正しく参照が解決されます。

For a full reference of the available beans see the plugin reference in the reference guide.

参照が可能なビーンの情報は、リファレンス内のプラグインの章を参照してください。

16.3 ビーンDSLでSpringランタイム

This Bean builder in Grails aims to provide a simplified way of wiring together dependencies that uses Spring at its core.

ビーンビルダーの目的は、Grails内でSpringの依存関係を容易に構築するための手段を提供することです。

In addition, Spring's regular way of configuration (via XML and annotations) is static and difficult to modify and configure at runtime, other than programmatic XML creation which is both error prone and verbose. Grails' api:grails.spring.BeanBuilder changes all that by making it possible to programmatically wire together components at runtime, allowing you to adapt the logic based on system properties or environment variables.

通常のSpringの設定方法(XMLやアノテーションを使用した方法)は、静的に設定を行い、実行時にこれらを変更することは容易ではありません。また、XMLを使用した設定方法は設定ミスを起こしやすく、設定が冗長になりがちです。 Grailsのapi:grails.spring.BeanBuilderは、実行時にコンポーネントの構築が行えるようにし、システムプロパティや環境変数を使用したロジックも使用可能にすることで、これらの問題を解決します。

This enables the code to adapt to its environment and avoids unnecessary duplication of code (having different Spring configs for test, development and production environments)

これにより環境毎に実行するコードを切り替え、不要な重複コードを取り除くことも可能になります(テスト環境と、開発環境/本番環境で異なるSpringの設定を持つといったように)。

The BeanBuilder class

BeanBuilderクラス

Grails provides a api:grails.spring.BeanBuilder class that uses dynamic Groovy to construct bean definitions. The basics are as follows:

Grailsは、Groovyの動的な性質を利用してビーンを構築できるapi:grails.spring.BeanBuilderクラスを提供しています。以下のように使用します。

import org.apache.commons.dbcp.BasicDataSource
import org.codehaus.groovy.grails.orm.hibernate.ConfigurableLocalSessionFactoryBean
import org.springframework.context.ApplicationContext
import grails.spring.BeanBuilderdef bb = new BeanBuilder()
bb.beans {
    dataSource(BasicDataSource) {
        driverClassName = "org.h2.Driver"
        url = "jdbc:h2:mem:grailsDB"
        username = "sa"
        password = ""
    }
    sessionFactory(ConfigurableLocalSessionFactoryBean) {
        dataSource = ref('dataSource')
        hibernateProperties = ["hibernate.hbm2ddl.auto": "create-drop",
                               "hibernate.show_sql":     "true"]
    }
}
ApplicationContext appContext = bb.createApplicationContext()

Within plugins and the grails-app/conf/spring/resources.groovy file you don't need to create a new instance of BeanBuilder. Instead the DSL is implicitly available inside the doWithSpring and beans blocks respectively.

pluginsとgrails-app/conf/spring/resources.groovyファイルではBeanBuilderのインスタンスを新たに作成する必要はありません。これらは、暗黙的にぞれぞれdoWithSpring、beansブロック内でDSLが使用可能です。

This example shows how you would configure Hibernate with a data source with the BeanBuilder class.

この例では、BeanBuilderクラスを使用して、データソースとHibernateの設定を行なっています。

Each method call (in this case dataSource and sessionFactory calls) maps to the name of the bean in Spring. The first argument to the method is the bean's class, whilst the last argument is a block. Within the body of the block you can set properties on the bean using standard Groovy syntax.

それぞれのメソッド呼び出しは(この例ではdataSourceとsessionFactory)、Springのビーン名にマッピングされます。そして、1つ目のメソッドの引数にはビーンのクラスを指定し、2つ目の引数にはブロックを指定します。このブロックの内部では、一般的なGroovyのシンタックスを使用してBeanのプロパティを設定することが可能です。

Bean references are resolved automatically using the name of the bean. This can be seen in the example above with the way the sessionFactory bean resolves the dataSource reference.

ビーンの参照は、ビーンの名前によって自動的に解決されます。上記の例はではsessionFactoryビーンで、dataSourceへの参照を解決しています。

Certain special properties related to bean management can also be set by the builder, as seen in the following code:

以下のように、ビーン管理に関連した特殊なプロパティをビルダー内で設定することもできます。

sessionFactory(ConfigurableLocalSessionFactoryBean) { bean ->
    // Autowiring behaviour. The other option is 'byType'. [autowire]
    bean.autowire = 'byName'
    // Sets the initialisation method to 'init'. [init-method]
    bean.initMethod = 'init'
    // Sets the destruction method to 'destroy'. [destroy-method]
    bean.destroyMethod = 'destroy'
    // Sets the scope of the bean. [scope]
    bean.scope = 'request'
    dataSource = ref('dataSource')
    hibernateProperties = ["hibernate.hbm2ddl.auto": "create-drop",
                           "hibernate.show_sql":     "true"]
}

The strings in square brackets are the names of the equivalent bean attributes in Spring's XML definition.

角括弧内の文字列は、XMLでSpringの設定を行う場合のbeanの属性です。

Using BeanBuilder with Spring MVC

Spring MVCでBeanBuilderを使用する

Include the grails-spring-<version>.jar file in your classpath to use BeanBuilder in a regular Spring MVC application. Then add the following <context-param> values to your /WEB-INF/web.xml file:

通常のSpring MVCアプリケーションでBeanBuilderを使用するには、クラスパスにgrails-spring-<version>.jarを追加します。そしてWEB-INF/web.xmlファイルに<context-param>の値を追加します。

<context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>/WEB-INF/applicationContext.groovy</param-value>
</context-param><context-param>
    <param-name>contextClass</param-name>
    <param-value>
      org.codehaus.groovy.grails.commons.spring.GrailsWebApplicationContext
    </param-value>
</context-param>

Then create a /WEB-INF/applicationContext.groovy file that does the rest:

あとは/WEB-INF/applicationContext.groovyファイルを作成するだけです。

import org.apache.commons.dbcp.BasicDataSourcebeans {
    dataSource(BasicDataSource) {
        driverClassName = "org.h2.Driver"
        url = "jdbc:h2:mem:grailsDB"
        username = "sa"
        password = ""
    }
}

Loading Bean Definitions from the File System

ファイルシステムからBean定義を読み込む

You can use the BeanBuilder class to load external Groovy scripts that define beans using the same path matching syntax defined here. For example:

BeanBuilderクラスを使用して外部のGroovyスクリプトを読み込むには、パスマッチングのシンタックスを使用します。以下に例を示します。

def bb = new BeanBuilder()
bb.loadBeans("classpath:*SpringBeans.groovy")def applicationContext = bb.createApplicationContext()

Here the BeanBuilder loads all Groovy files on the classpath ending with SpringBeans.groovy and parses them into bean definitions. An example script can be seen below:

このようにすることで、BeanBuilderはクラスパス内のSpringBeans.groovyという名前で終わる、全てのGroovyファイルをビーンの定義として読み込みます。スクリプトの中身は以下のように定義できます。

import org.apache.commons.dbcp.BasicDataSource
import org.codehaus.groovy.grails.orm.hibernate.ConfigurableLocalSessionFactoryBeanbeans {
    dataSource(BasicDataSource) {
        driverClassName = "org.h2.Driver"
        url = "jdbc:h2:mem:grailsDB"
        username = "sa"
        password = ""
    }
    sessionFactory(ConfigurableLocalSessionFactoryBean) {
        dataSource = dataSource
        hibernateProperties = ["hibernate.hbm2ddl.auto": "create-drop",
                               "hibernate.show_sql":     "true"]
    }
}

Adding Variables to the Binding (Context)

バインディング(コンテキスト)に変数を追加する

If you're loading beans from a script you can set the binding to use by creating a Groovy Binding:

もしスクリプトを使用してビーンの定義を読み込んでいる場合は、GroovyのBindingインスタンスを作成してバインドが行えます。

def binding = new Binding()
binding.maxSize = 10000
binding.productGroup = 'finance'def bb = new BeanBuilder()
bb.binding = binding
bb.loadBeans("classpath:*SpringBeans.groovy")
def ctx = bb.createApplicationContext()

Then you can access the maxSize and productGroup properties in your DSL files.

このようにすることで、DSLファイル内からmaxSize、productGroupプロパティにアクセスすることが可能になります。

16.4 ビーンビルダーDSLの解説

Using Constructor Arguments

コンストラクタ引数の使い方

Constructor arguments can be defined using parameters to each bean-defining method. Put them after the first argument (the Class):

コンストラクタ引数は、各ビーン定義のメソッドにパラメータを使うことで定義できます。パラメータはビーン定義の最初の引数(クラス)に続けて渡します。

bb.beans {
    exampleBean(MyExampleBean, "firstArgument", 2) {
        someProperty = [1, 2, 3]
    }
}

This configuration corresponds to a MyExampleBean with a constructor that looks like this:

この設定は、次のように定義されているMyExampleBeanのコンストラクタに対応付けされます。

MyExampleBean(String foo, int bar) {
   …
}

Configuring the BeanDefinition (Using factory methods)

ビーン定義の設定 (ファクトリメソッドの利用)

The first argument to the closure is a reference to the bean configuration instance, which you can use to configure factory methods and invoke any method on the AbstractBeanDefinition class:

クロージャに渡される最初の引数は、対象となるビーンのインスタンスへの参照であり、ファクトリメソッドの設定やAbstractBeanDefinitionクラス上のメソッドの呼び出しに用いることができます。

bb.beans {
    exampleBean(MyExampleBean) { bean ->
        bean.factoryMethod = "getInstance"
        bean.singleton = false
        someProperty = [1, 2, 3]
    }
}

As an alternative you can also use the return value of the bean defining method to configure the bean:

代わりにビーン定義のメソッドの返り値を使って設定することもできます。

bb.beans {
    def example = exampleBean(MyExampleBean) {
        someProperty = [1, 2, 3]
    }
    example.factoryMethod = "getInstance"
}

Using Factory beans

ファクトリビーンの利用

Spring defines the concept of factory beans and often a bean is created not directly from a new instance of a Class, but from one of these factories. In this case the bean has no Class argument and instead you must pass the name of the factory bean to the bean defining method:

Springはファクトリビーンの概念を定義しており、ビーンはクラスの新しいインスタンスから直接作成されないことが多く、いずれかのファクトリが用いられます。この場合、ビーン定義のメソッドの引数にクラスを渡さず、代わりにファクトリビーン名を渡す必要があります。

bb.beans {    myFactory(ExampleFactoryBean) {
        someProperty = [1, 2, 3]
    }
    myBean(myFactory) {
        name = "blah"
    }
}

Another common approach is provide the name of the factory method to call on the factory bean. This can be done using Groovy's named parameter syntax:

別のアプローチとして、ファクトリビーンで呼び出すファクトリメソッドの名前を渡すことができます。これにはGroovyの名前付き引数の構文を用います。

bb.beans {    myFactory(ExampleFactoryBean) {
        someProperty = [1, 2, 3]
    }
    myBean(myFactory: "getInstance") {
        name = "blah"
    }
}

Here the getInstance method on the ExampleFactoryBean bean will be called to create the myBean bean.

この例ではExampleFactoryBeanビーン上のgetInstanceメソッドがmyBeanビーンの生成時に呼び出されます。

Creating Bean References at Runtime

ビーンへの参照を実行時に生成する

Sometimes you don't know the name of the bean to be created until runtime. In this case you can use a string interpolation to invoke a bean defining method dynamically:

生成するビーンの名前を実行時に決めたい場合があります。そういったときは、動的にビーン定義メソッドを実行するために文字列の置き換えが使えます。

def beanName = "example"
bb.beans {
    "${beanName}Bean"(MyExampleBean) {
        someProperty = [1, 2, 3]
    }
}

In this case the beanName variable defined earlier is used when invoking a bean defining method. The example has a hard-coded value but would work just as well with a name that is generated programmatically based on configuration, system properties, etc.

この場合、前もって定義されたbeanName変数を用いてビーン定義メソッドを呼び出しています。この例では値をハードコードしていますが、設定やシステムプロパティ等に基づいて生成された名前でも同様に動作します。

Furthermore, because sometimes bean names are not known until runtime you may need to reference them by name when wiring together other beans, in this case using the ref method:

さらに、そういった実行時まで名前の分からないビーンへの紐付けを、refメソッドを用いて他のビーンから名前で参照する必要が生じることがあります。

def beanName = "example"
bb.beans {    "${beanName}Bean"(MyExampleBean) {
        someProperty = [1, 2, 3]
    }
    anotherBean(AnotherBean) {
        example = ref("${beanName}Bean")
    }
}

Here the example property of AnotherBean is set using a runtime reference to the exampleBean. The ref method can also be used to refer to beans from a parent ApplicationContext that is provided in the constructor of the BeanBuilder:

この例ではexampleBeanへの実行時参照を用いてAnotherBeanのプロパティに設定しています。 BeanBuilderのコンストラクタで提供される親ApplicationContextからビーンを参照するためにも、refメソッドを使うことができます。

ApplicationContext parent = ...//
der bb = new BeanBuilder(parent)
bb.beans {
    anotherBean(AnotherBean) {
        example = ref("${beanName}Bean", true)
    }
}

Here the second parameter true specifies that the reference will look for the bean in the parent context.

ここではrefメソッドの第2引数にtrueを渡すことで、親となるコンテキストからビーンを探すことを指定しています。

Using Anonymous (Inner) Beans

匿名(内部)ビーンを使う

You can use anonymous inner beans by setting a property of the bean to a block that takes an argument that is the bean type:

ビーンの型を引数に取るブロックで、ビーンのプロパティを設定することにより匿名内部ビーンが使えます。

bb.beans {    marge(Person) {
        name = "Marge"
        husband = { Person p ->
            name = "Homer"
            age = 45
            props = [overweight: true, height: "1.8m"]
        }
        children = [bart, lisa]
    }
    bart(Person) {
        name = "Bart"
        age = 11
    }
    lisa(Person) {
        name = "Lisa"
        age = 9
    }
}

In the above example we set the marge bean's husband property to a block that creates an inner bean reference. Alternatively if you have a factory bean you can omit the type and just use the specified bean definition instead to setup the factory:

上記の例ではmergeビーンのhusbandプロパティに、内部ビーンの参照を作成したブロックを渡しています。ファクトリを持つビーンは型を省略でき、ファクトリをセットアップする代わりに指定されたビーンの定義を利用するだけで済みます。

bb.beans {    personFactory(PersonFactory)
    marge(Person) {
        name = "Marge"
        husband = { bean ->
            bean.factoryBean = "personFactory"
            bean.factoryMethod = "newInstance"
            name = "Homer"
            age = 45
            props = [overweight: true, height: "1.8m"]
        }
        children = [bart, lisa]
    }
}

Abstract Beans and Parent Bean Definitions

抽象ビーンと親ビーンの定義

To create an abstract bean definition define a bean without a Class parameter:

抽象ビーン定義を作成するには、パラメータにClassを渡さずに定義します。

class HolyGrailQuest {
    def start() { println "lets begin" }
}

class KnightOfTheRoundTable {    String name
    String leader
    HolyGrailQuest quest
    KnightOfTheRoundTable(String name) {
        this.name = name
    }
    def embarkOnQuest() {
        quest.start()
    }
}

import grails.spring.BeanBuilderdef bb = new BeanBuilder()
bb.beans {
    abstractBean {
        leader = "Lancelot"
    }
    …
}

Here we define an abstract bean that has a leader property with the value of "Lancelot". To use the abstract bean set it as the parent of the child bean:

ここでは、値に"Lancelot"が入っているleaderプロパティを持つ抽象ビーンを定義しています。子ビーンの親として抽象ビーンを使うには、次のように設定します。

bb.beans {
    …
    quest(HolyGrailQuest)    knights(KnightOfTheRoundTable, "Camelot") { bean ->
        bean.parent = abstractBean
        quest = ref('quest')
    }
}

When using a parent bean you must set the parent property of the bean before setting any other properties on the bean!

親ビーンを利用するときは、ビーン上の他のプロパティを設定する前に、ビーンのparentプロパティへ設定する必要があります。

If you want an abstract bean that has a Class specified you can do it this way:

Classを明示して抽象ビーンを利用したい場合は、次に示す方法で可能です。

import grails.spring.BeanBuilderdef bb = new BeanBuilder()
bb.beans {
    abstractBean(KnightOfTheRoundTable) { bean ->
        bean.'abstract' = true
        leader = "Lancelot"
    }
    quest(HolyGrailQuest)
    knights("Camelot") { bean ->
        bean.parent = abstractBean
        quest = quest
    }
}

In this example we create an abstract bean of type KnightOfTheRoundTable and use the bean argument to set it to abstract. Later we define a knights bean that has no Class defined, but inherits the Class from the parent bean.

この例では、ビーンのabstractプロパティを利用してKnightOfTheRoundTable型の抽象ビーンを作成しています。その後、Classの指定のないknightsビーンを定義していますが、Classは親ビーンから継承されます。

Using Spring Namespaces

Springの名前空間を使う

Since Spring 2.0, users of Spring have had easier access to key features via XML namespaces. You can use a Spring namespace in BeanBuilder by declaring it with this syntax:

Spring 2.0から、XML名前空間を経由して主要な機能へ簡単にアクセスすることができるようになりました。次の構文で宣言することにより、BeanBuilderでSpringの名前空間を使うことができます。

xmlns context:"http://www.springframework.org/schema/context"

and then invoking a method that matches the names of the Spring namespace tag and its associated attributes:

そしてSpring名前空間のタグと、それに紐付いた属性の名前に一致するメソッドを呼び出します。

context.'component-scan'('base-package': "my.company.domain")

You can do some useful things with Spring namespaces, such as looking up a JNDI resource:

JNDIリソースを解決するといったような、Spring名前空間にある有用なものを利用できます。

xmlns jee:"http://www.springframework.org/schema/jee"

jee.'jndi-lookup'(id: "dataSource", 'jndi-name': "java:comp/env/myDataSource")

This example will create a Spring bean with the identifier dataSource by performing a JNDI lookup on the given JNDI name. With Spring namespaces you also get full access to all of the powerful AOP support in Spring from BeanBuilder. For example given these two classes:

この例ではdataSourceという識別子で、与えられたJNDI名でJNDIを解決するSpringビーンを作成します。また、Spring名前空間によってBeanBuilderから強力なSpringのAOPサポートにフルアクセスできます。 2つのクラスを使って例を示します。

class Person {    int age
    String name
    void birthday() {
        ++age;
    }
}

class BirthdayCardSender {    List peopleSentCards = []
    void onBirthday(Person person) {
        peopleSentCards << person
    }
}

You can define an aspect that uses a pointcut to detect whenever the birthday() method is called:

birthday()メソッドの呼び出しを検出するポイントカットを使用して、アスペクトを次のように定義できます。

xmlns aop:"http://www.springframework.org/schema/aop"fred(Person) {
    name = "Fred"
    age = 45
}
birthdayCardSenderAspect(BirthdayCardSender)
aop {
    config("proxy-target-class": true) {
        aspect(id: "sendBirthdayCard", ref: "birthdayCardSenderAspect") {
            after method: "onBirthday",
            pointcut: "execution(void ..Person.birthday()) and this(person)"
        }
    }
}

16.5 プロパティプレースホルダ設定

Grails supports the notion of property placeholder configuration through an extended version of Spring's PropertyPlaceholderConfigurer, which is typically useful in combination with externalized configuration.

Grailsは、SpringのPropertyPlaceholderConfigurerを拡張することでプロパティプレースホルダの概念をサポートしています。特に設定の外部化と組み合わせた場合に有用です。

Settings defined in either ConfigSlurper scripts or Java properties files can be used as placeholder values for Spring configuration in grails-app/conf/spring/resources.xml and grails-app/conf/spring/resources.groovy. For example given the following entries in grails-app/conf/Config.groovy (or an externalized config):

プレースホルダの値は ConfigSlurper またはJavaプロパティファイルで定義を行い、grails-app/conf/spring/resources.xmlとgrails-app/conf/spring/resources.groovyのSpringの設定ファイル内で使用できます。例えば、grails-app/conf/Config.groovy(または外部設定)で以下の設定があるとします。

database.driver="com.mysql.jdbc.Driver"
database.dbname="mysql:mydb"

You can then specify placeholders in resources.xml as follows using the familiar ${..} syntax:

resources.xml内では、使い慣れた${..}のシンタックスを使用してプレースホルダを指定できます。

<bean id="dataSource"
      class="org.springframework.jdbc.datasource.DriverManagerDataSource">
    <property name="driverClassName">
        <value>${database.driver}</value>
    </property>
    <property name="url">
        <value>jdbc:${database.dbname}</value>
    </property>
 </bean>

To specify placeholders in resources.groovy you need to use single quotes:

resources.groovy内でプレースホルダを指定するには、シングルクォートを使用する必要があります。

dataSource(org.springframework.jdbc.datasource.DriverManagerDataSource) {
    driverClassName = '${database.driver}'
    url = 'jdbc:${database.dbname}'
}

This sets the property value to a literal string which is later resolved against the config by Spring's PropertyPlaceholderConfigurer.

このプロパティの値は、後でSpringのPropertyPlaceholderConfigurerによって文字列が置換されます。

A better option for resources.groovy is to access properties through the grailsApplication variable:

また、resources.groovyではgrailsApplicationにアクセスすることが可能です。

dataSource(org.springframework.jdbc.datasource.DriverManagerDataSource) {
    driverClassName = grailsApplication.config.database.driver
    url = "jdbc:${grailsApplication.config.database.dbname}"
}

Using this approach will keep the types as defined in your config.

これにより、設定ファイル内で定義した型をそのまま使用することができます。

16.6 プロパティオーバーライド設定

Grails supports setting of bean properties via configuration. This is often useful when used in combination with externalized configuration.

Grailsでは設定を通じてビーンのプロパティ設定が行えます。これは設定の外部化と組み合わせて使用した場合にも便利です。

You define a beans block with the names of beans and their values:

設定はbeansブロックにビーンの名前と値を定義して行います。

beans {
    bookService {
        webServiceURL = "http://www.amazon.com"
    }
}

The general format is:

この設定の一般的なフォーマットは以下になります。

[bean name].[property name] = [value]

The same configuration in a Java properties file would be:

これはJavaのプロパティファイルと同じように設定が行えます。

beans.bookService.webServiceURL=http://www.amazon.com

<< 15プラグイン

17GrailsとHibernate >>