Overview | Package | Class | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## org.springframework.scripting.groovy
Class GroovyScriptFactory

    java.lang.Object
      org.springframework.scripting.groovy.GroovyScriptFactory

All Implemented Interfaces:
  BeanClassLoaderAware, BeanFactoryAware, ScriptFactory

    public class GroovyScriptFactory

extends Object
implements ScriptFactory, BeanFactoryAware, BeanClassLoaderAware

`ScriptFactory` implementation for a Groovy script.

Typically used in combination with a `ScriptFactoryPostProcessor`; see the latter's javadoc} for a configuration example.

Since:
  2.0
Author:
  Juergen Hoeller, Rob Harrop, Rod Johnson
See Also:
  `GroovyClassLoader`, `ScriptFactoryPostProcessor`

Constructor Summary
`GroovyScriptFactory(String scriptSourceLocator)` Create a new GroovyScriptFactory for the given script source.
`GroovyScriptFactory(String scriptSourceLocator, GroovyObjectCustomizer groovyObjectCustomizer)` Create a new GroovyScriptFactory for the given script source, specifying a strategy interface that can create a custom MetaClass to supply missing methods and otherwise change the behavior of the object.

Method Summary
`protected Object` | `executeScript(ScriptSource scriptSource, Class scriptClass)` Instantiate the given Groovy script class and run it if necessary.
`groovy.lang.GroovyClassLoader` | `getGroovyClassLoader()` Return the GroovyClassLoader used by this script factory.
`Object` | `getScriptedObject(ScriptSource scriptSource, Class[] actualInterfaces)` Loads and parses the Groovy script via the GroovyClassLoader.
`Class` | `getScriptedObjectType(ScriptSource scriptSource)` Determine the type of the scripted Java object.
`Class[]` | `getScriptInterfaces()` Groovy scripts determine their interfaces themselves, hence we don't need to explicitly expose interfaces here.
`String` | `getScriptSourceLocator()` Return a locator that points to the source of the script.
`boolean` | `requiresConfigInterface()` Groovy scripts do not need a config interface, since they expose their setters as public methods.
`boolean` | `requiresScriptedObjectRefresh(ScriptSource scriptSource)` Determine whether a refresh is required (e.g.
`void` | `setBeanClassLoader(ClassLoader classLoader)` Callback that supplies the bean `class loader` to a bean instance.
`void` | `setBeanFactory(BeanFactory beanFactory)` Callback that supplies the owning factory to a bean instance.
`String` | `toString()`

Methods inherited from class java.lang.Object
`clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait`

Constructor Detail

### GroovyScriptFactory

    public GroovyScriptFactory(String scriptSourceLocator)

  Create a new GroovyScriptFactory for the given script source.

  We don't need to specify script interfaces here, since a Groovy script defines its Java interfaces itself.

  Parameters:
    `scriptSourceLocator` - a locator that points to the source of the script. Interpreted by the post-processor that actually creates the script.

### GroovyScriptFactory

    public GroovyScriptFactory(String scriptSourceLocator,
                               GroovyObjectCustomizer groovyObjectCustomizer)

  Create a new GroovyScriptFactory for the given script source, specifying a strategy interface that can create a custom MetaClass to supply missing methods and otherwise change the behavior of the object.

  We don't need to specify script interfaces here, since a Groovy script defines its Java interfaces itself.

  Parameters:
    `scriptSourceLocator` - a locator that points to the source of the script. Interpreted by the post-processor that actually creates the script.
    `groovyObjectCustomizer` - a customizer that can set a custom metaclass or make other changes to the GroovyObject created by this factory (may be `null`)

Method Detail

### setBeanFactory

    public void setBeanFactory(BeanFactory beanFactory)
                        throws BeansException

  Description copied from interface: `BeanFactoryAware`
  Callback that supplies the owning factory to a bean instance.

  Invoked after the population of normal bean properties but before an initialization callback such as `InitializingBean.afterPropertiesSet()` or a custom init-method.

  Specified by:
    `setBeanFactory` in interface `BeanFactoryAware`
  Parameters:
    `beanFactory` - owning BeanFactory (never `null`). The bean can immediately call methods on the factory.
  Throws:
    `BeansException` - in case of initialization errors
  See Also:
    `BeanInitializationException`

### setBeanClassLoader

    public void setBeanClassLoader(ClassLoader classLoader)

  Description copied from interface: `BeanClassLoaderAware`
  Callback that supplies the bean `class loader` to a bean instance.

  Invoked after the population of normal bean properties but before an initialization callback such as `InitializingBean's` `InitializingBean.afterPropertiesSet()` method or a custom init-method.

  Specified by:
    `setBeanClassLoader` in interface `BeanClassLoaderAware`
  Parameters:
    `classLoader` - the owning class loader; may be `null` in which case a default `ClassLoader` must be used, for example the `ClassLoader` obtained via `ClassUtils.getDefaultClassLoader()`

### getGroovyClassLoader

    public groovy.lang.GroovyClassLoader getGroovyClassLoader()

  Return the GroovyClassLoader used by this script factory.

### getScriptSourceLocator

    public String getScriptSourceLocator()

  Description copied from interface: `ScriptFactory`
  Return a locator that points to the source of the script. Interpreted by the post-processor that actually creates the script.

  Typical supported locators are Spring resource locations (such as "file:C:/myScript.bsh" or "classpath:myPackage/myScript.bsh") and inline scripts ("inline:myScriptText...").

  Specified by:
    `getScriptSourceLocator` in interface `ScriptFactory`
  Returns:
    the script source locator
  See Also:
    `ScriptFactoryPostProcessor.convertToScriptSource(java.lang.String, java.lang.String, org.springframework.core.io.ResourceLoader)`, `ResourceLoader`

### getScriptInterfaces

    public Class[] getScriptInterfaces()

  Groovy scripts determine their interfaces themselves, hence we don't need to explicitly expose interfaces here.

  Specified by:
    `getScriptInterfaces` in interface `ScriptFactory`
  Returns:
    `null` always

### requiresConfigInterface

    public boolean requiresConfigInterface()

  Groovy scripts do not need a config interface, since they expose their setters as public methods.

  Specified by:
    `requiresConfigInterface` in interface `ScriptFactory`
  Returns:
    whether the script requires a generated config interface
  See Also:
    `ScriptFactory.getScriptInterfaces()`

### getScriptedObject

    public Object getScriptedObject(ScriptSource scriptSource,
                                    Class[] actualInterfaces)
                             throws IOException,
                                    ScriptCompilationException

  Loads and parses the Groovy script via the GroovyClassLoader.

  Specified by:
    `getScriptedObject` in interface `ScriptFactory`
  Parameters:
    `scriptSource` - the actual ScriptSource to retrieve the script source text from (never `null`)
    `actualInterfaces` - the actual interfaces to expose, including script interfaces as well as a generated config interface (if applicable; may be `null`)
  Returns:
    the scripted Java object
  Throws:
    `IOException` - if script retrieval failed
    `ScriptCompilationException` - if script compilation failed
  See Also:
    `GroovyClassLoader`

### getScriptedObjectType

    public Class getScriptedObjectType(ScriptSource scriptSource)
                                throws IOException,
                                       ScriptCompilationException

  Description copied from interface: `ScriptFactory`
  Determine the type of the scripted Java object.

  Implementations are encouraged to cache script metadata such as a generated script class. Note that this method may be invoked concurrently and must be implemented in a thread-safe fashion.

  Specified by:
    `getScriptedObjectType` in interface `ScriptFactory`
  Parameters:
    `scriptSource` - the actual ScriptSource to retrieve the script source text from (never `null`)
  Returns:
    the type of the scripted Java object, or `null` if none could be determined
  Throws:
    `IOException` - if script retrieval failed
    `ScriptCompilationException` - if script compilation failed

### requiresScriptedObjectRefresh

    public boolean requiresScriptedObjectRefresh(ScriptSource scriptSource)

  Description copied from interface: `ScriptFactory`
  Determine whether a refresh is required (e.g. through ScriptSource's `isModified()` method).

  Specified by:
    `requiresScriptedObjectRefresh` in interface `ScriptFactory`
  Parameters:
    `scriptSource` - the actual ScriptSource to retrieve the script source text from (never `null`)
  Returns:
    whether a fresh `ScriptFactory.getScriptedObject(org.springframework.scripting.ScriptSource, java.lang.Class[])` call is required
  See Also:
    `ScriptSource.isModified()`

### executeScript

    protected Object executeScript(ScriptSource scriptSource,
                                   Class scriptClass)
                            throws ScriptCompilationException

  Instantiate the given Groovy script class and run it if necessary.

  Parameters:
    `scriptSource` - the source for the underlying script
    `scriptClass` - the Groovy script class
  Returns:
    the result object (either an instance of the script class or the result of running the script instance)
  Throws:
    `ScriptCompilationException` - in case of instantiation failure

### toString

    public String toString()

  Overrides:
    `toString` in class `Object`

Overview | Package | Class | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD