Package org.springframework.beans.factory.groovy

# Class GroovyBeanDefinitionReader

java.lang.Object
org.springframework.beans.factory.support.AbstractBeanDefinitionReader
org.springframework.beans.factory.groovy.GroovyBeanDefinitionReader

All Implemented Interfaces:
  `groovy.lang.GroovyObject`, `BeanDefinitionReader`, `org.springframework.core.env.EnvironmentCapable`

public class GroovyBeanDefinitionReader extends AbstractBeanDefinitionReader implements groovy.lang.GroovyObject
A Groovy-based reader for Spring bean definitions: like a Groovy builder, but more of a DSL for Spring configuration.

This bean definition reader also understands XML bean definition files, allowing for seamless mixing and matching with Groovy bean definition files.

Typically applied to a `DefaultListableBeanFactory` or a `org.springframework.context.support.GenericApplicationContext`, but can be used against any `BeanDefinitionRegistry` implementation.

### Example Syntax

     import org.hibernate.SessionFactory
     import org.apache.commons.dbcp.BasicDataSource

     def reader = new GroovyBeanDefinitionReader(myApplicationContext)
     reader.beans {
         dataSource(BasicDataSource) {                  // <--- invokeMethod
             driverClassName = "org.hsqldb.jdbcDriver"
             url = "jdbc:hsqldb:mem:grailsDB"
             username = "sa"                            // <-- setProperty
             password = ""
             settings = [mynew:"setting"]
         }
         sessionFactory(SessionFactory) {
             dataSource = dataSource                    // <-- getProperty for retrieving references
         }
         myService(MyService) {
             nestedBean = { AnotherBean bean ->         // <-- setProperty with closure for nested bean
                 dataSource = dataSource
             }
         }
     }

You can also load resources containing beans defined in a Groovy script using either the `AbstractBeanDefinitionReader.loadBeanDefinitions(Resource...)` or `AbstractBeanDefinitionReader.loadBeanDefinitions(String...)` method, with a script looking similar to the following.

     import org.hibernate.SessionFactory
     import org.apache.commons.dbcp.BasicDataSource

     beans {
         dataSource(BasicDataSource) {
             driverClassName = "org.hsqldb.jdbcDriver"
             url = "jdbc:hsqldb:mem:grailsDB"
             username = "sa"
             password = ""
             settings = [mynew:"setting"]
         }
         sessionFactory(SessionFactory) {
             dataSource = dataSource
         }
         myService(MyService) {
             nestedBean = { AnotherBean bean ->
                 dataSource = dataSource
             }
         }
     }

Since:
  4.0
Author:
  Jeff Brown, Graeme Rocher, Juergen Hoeller, Sam Brannen
See Also:
  - `BeanDefinitionRegistry`
  - `DefaultListableBeanFactory`
  - `org.springframework.context.support.GenericApplicationContext`
  - `org.springframework.context.support.GenericGroovyApplicationContext`

## Field Summary

### Fields inherited from class org.springframework.beans.factory.support.AbstractBeanDefinitionReader

`logger`

## Constructor Summary

Constructors
Constructor
Description
`GroovyBeanDefinitionReader(BeanDefinitionRegistry registry)`
Create a new `GroovyBeanDefinitionReader` for the given `BeanDefinitionRegistry`.
`GroovyBeanDefinitionReader(XmlBeanDefinitionReader xmlBeanDefinitionReader)`
Create a new `GroovyBeanDefinitionReader` based on the given `XmlBeanDefinitionReader`, loading bean definitions into its `BeanDefinitionRegistry` and delegating Groovy DSL loading to it.

## Method Summary

Modifier and Type
Method
Description
`protected void`
`applyPropertyToBeanDefinition(String name, Object value)`
`GenericBeanDefinition`
`bean(Class<?> type)`
Define an inner bean definition.
`AbstractBeanDefinition`
`bean(Class<?> type, Object... args)`
Define an inner bean definition.
`GroovyBeanDefinitionReader`
`beans(groovy.lang.Closure<?> closure)`
Defines a set of beans for the given block or closure.
`groovy.lang.Binding`
`getBinding()`
Return a specified binding for Groovy variables, if any.
`groovy.lang.MetaClass`
`getMetaClass()`
`Object`
`getProperty(String name)`
This method overrides property retrieval in the scope of the `GroovyBeanDefinitionReader`.
`void`
`importBeans(String resourcePattern)`
Import Spring bean definitions from either XML or Groovy sources into the current bean builder instance.
`protected GroovyBeanDefinitionReader`
`invokeBeanDefiningClosure(groovy.lang.Closure<?> callable)`
When a method argument is only a closure it is a set of bean definitions.
`Object`
`invokeMethod(String name, Object arg)`
This method overrides method invocation to create beans for each method name that takes a class argument.
`int`
`loadBeanDefinitions(org.springframework.core.io.Resource resource)`
Load bean definitions from the specified Groovy script or XML file.
`int`
`loadBeanDefinitions(org.springframework.core.io.support.EncodedResource encodedResource)`
Load bean definitions from the specified Groovy script or XML file.
`protected List<Object>`
`resolveConstructorArguments(Object[] args, int start, int end)`
`void`
`setBinding(groovy.lang.Binding binding)`
Set the binding, i.e.
`void`
`setMetaClass(groovy.lang.MetaClass metaClass)`
`void`
`setProperty(String name, Object value)`
This method overrides property setting in the scope of the `GroovyBeanDefinitionReader` to set properties on the current bean definition.
`void`
`xmlns(Map<String,String> definition)`
Define a Spring XML namespace definition to use.

### Methods inherited from class org.springframework.beans.factory.support.AbstractBeanDefinitionReader

`getBeanClassLoader, getBeanNameGenerator, getEnvironment, getRegistry, getResourceLoader, loadBeanDefinitions, loadBeanDefinitions, loadBeanDefinitions, loadBeanDefinitions, setBeanClassLoader, setBeanNameGenerator, setEnvironment, setResourceLoader`

### Methods inherited from class java.lang.Object

`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

## Constructor Details

### GroovyBeanDefinitionReader

public GroovyBeanDefinitionReader(BeanDefinitionRegistry registry)
Create a new `GroovyBeanDefinitionReader` for the given `BeanDefinitionRegistry`.

Parameters:
  `registry` - the `BeanDefinitionRegistry` to load bean definitions into

### GroovyBeanDefinitionReader

public GroovyBeanDefinitionReader(XmlBeanDefinitionReader xmlBeanDefinitionReader)
Create a new `GroovyBeanDefinitionReader` based on the given `XmlBeanDefinitionReader`, loading bean definitions into its `BeanDefinitionRegistry` and delegating Groovy DSL loading to it.

The supplied `XmlBeanDefinitionReader` should typically be pre-configured with XML validation disabled.

Parameters:
  `xmlBeanDefinitionReader` - the `XmlBeanDefinitionReader` to derive the registry from and to delegate Groovy DSL loading to

## Method Details

### setMetaClass

public void setMetaClass(groovy.lang.MetaClass metaClass)

Specified by:
  `setMetaClass` in interface `groovy.lang.GroovyObject`

### getMetaClass

public groovy.lang.MetaClass getMetaClass()

Specified by:
  `getMetaClass` in interface `groovy.lang.GroovyObject`

### setBinding

public void setBinding(groovy.lang.Binding binding)
Set the binding, i.e. the Groovy variables available in the scope of a `GroovyBeanDefinitionReader` closure.

### getBinding

@Nullable public groovy.lang.Binding getBinding()
Return a specified binding for Groovy variables, if any.

### loadBeanDefinitions

public int loadBeanDefinitions(org.springframework.core.io.Resource resource) throws BeanDefinitionStoreException
Load bean definitions from the specified Groovy script or XML file.

Note that `".xml"` files will be parsed as XML content; all other kinds of resources will be parsed as Groovy scripts.

Specified by:
  `loadBeanDefinitions` in interface `BeanDefinitionReader`
Parameters:
  `resource` - the resource descriptor for the Groovy script or XML file
Returns:
  the number of bean definitions found
Throws:
  `BeanDefinitionStoreException` - in case of loading or parsing errors

### loadBeanDefinitions

public int loadBeanDefinitions(org.springframework.core.io.support.EncodedResource encodedResource) throws BeanDefinitionStoreException
Load bean definitions from the specified Groovy script or XML file.

Note that `".xml"` files will be parsed as XML content; all other kinds of resources will be parsed as Groovy scripts.

Parameters:
  `encodedResource` - the resource descriptor for the Groovy script or XML file, allowing specification of an encoding to use for parsing the file
Returns:
  the number of bean definitions found
Throws:
  `BeanDefinitionStoreException` - in case of loading or parsing errors

### beans

public GroovyBeanDefinitionReader beans(groovy.lang.Closure<?> closure)
Defines a set of beans for the given block or closure.

Parameters:
  `closure` - the block or closure
Returns:
  this `GroovyBeanDefinitionReader` instance

### bean

public GenericBeanDefinition bean(Class<?> type)
Define an inner bean definition.

Parameters:
  `type` - the bean type
Returns:
  the bean definition

### bean

public AbstractBeanDefinition bean(Class<?> type, Object... args)
Define an inner bean definition.

Parameters:
  `type` - the bean type
  `args` - the constructors arguments and closure configurer
Returns:
  the bean definition

### xmlns

public void xmlns(Map<String,String> definition)
Define a Spring XML namespace definition to use.

Parameters:
  `definition` - the namespace definition

### importBeans

public void importBeans(String resourcePattern) throws IOException
Import Spring bean definitions from either XML or Groovy sources into the current bean builder instance.

Parameters:
  `resourcePattern` - the resource pattern
Throws:
  `IOException`

### invokeMethod

public Object invokeMethod(String name, Object arg)
This method overrides method invocation to create beans for each method name that takes a class argument.

Specified by:
  `invokeMethod` in interface `groovy.lang.GroovyObject`

### invokeBeanDefiningClosure

protected GroovyBeanDefinitionReader invokeBeanDefiningClosure(groovy.lang.Closure<?> callable)
When a method argument is only a closure it is a set of bean definitions.

Parameters:
  `callable` - the closure argument
Returns:
  this `GroovyBeanDefinitionReader` instance

### resolveConstructorArguments

protected List<Object> resolveConstructorArguments(Object[] args, int start, int end)

### setProperty

public void setProperty(String name, Object value)
This method overrides property setting in the scope of the `GroovyBeanDefinitionReader` to set properties on the current bean definition.

Specified by:
  `setProperty` in interface `groovy.lang.GroovyObject`

### applyPropertyToBeanDefinition

protected void applyPropertyToBeanDefinition(String name, Object value)

### getProperty

@Nullable public Object getProperty(String name)
This method overrides property retrieval in the scope of the `GroovyBeanDefinitionReader`. A property retrieval will either:

- Retrieve a variable from the bean builder's binding if it exists
- Retrieve a RuntimeBeanReference for a specific bean if it exists
- Otherwise just delegate to MetaClass.getProperty which will resolve properties from the `GroovyBeanDefinitionReader` itself

Specified by:
  `getProperty` in interface `groovy.lang.GroovyObject`