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.
【注意】このドキュメントの内容はスナップショットバージョンを元に*意訳*されているため、一部現行バージョンでは未対応の機能もあります。
Table of Contents
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
Spring開発者は、どのようにGrailsのApplicationContext
instance is constructed. The basics of it are as follows.
ApplicationContext
インスタンスが組み立てられるのか理解したい、と熱心に望んでいます。
基本的には次のようになります:- Grails constructs a parent
ApplicationContext
from theweb-app/WEB-INF/applicationContext.xml
file. ThisApplicationContext
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 theGrailsApplication
instance and constructs a childApplicationContext
that is used as the rootApplicationContext
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
Grailsの設定のほとんどは実行時に行われます。
各pluginは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.
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 Spring DSLを使い、grails-app/conf/spring/resources.groovy
which uses the Grails Spring DSL. Beans are defined inside a beans
property (a Closure):
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
さきほどDSLで定義したmyBean
bean that we configured using the DSL would be configured with this syntax in the XML file:
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 ofBeanBuilder
. Instead the DSL is implicitly available inside thedoWithSpring
andbeans
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
通常のSpring MVCアプリケーションでBeanBuilderを使用するには、クラスパスに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:
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
もしスクリプトを使用してビーンの定義を読み込んでいる場合は、GroovyのBinding
:
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
このようにすることで、DSLファイル内からmaxSize
and productGroup
properties in your DSL files.
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
プレースホルダの値は ConfigSlurper またはJavaプロパティファイルで定義を行い、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):
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