org.springframework.scripting.jruby

## Class JRubyScriptFactory

- java.lang.Object
- - org.springframework.scripting.jruby.JRubyScriptFactory

All Implemented Interfaces:
  Aware, BeanClassLoaderAware, ScriptFactory

    public class JRubyScriptFactory
    extends Object
    implements ScriptFactory, BeanClassLoaderAware

`ScriptFactory` implementation for a JRuby 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
See Also:
  `JRubyScriptUtils`, `ScriptFactoryPostProcessor`

### Constructor Summary

Constructors
Constructor and Description
`JRubyScriptFactory(String scriptSourceLocator, Class[] scriptInterfaces)` Create a new JRubyScriptFactory for the given script source.

### Method Summary

Methods
`Object` `getScriptedObject(ScriptSource scriptSource, Class[] actualInterfaces)` Load and parse the JRuby script via JRubyScriptUtils.
`Class` `getScriptedObjectType(ScriptSource scriptSource)` Determine the type of the scripted Java object.
`Class[]` `getScriptInterfaces()` Return the business interfaces that the script is supposed to implement.
`String` `getScriptSourceLocator()` Return a locator that points to the source of the script.
`boolean` `requiresConfigInterface()` JRuby scripts do require a config interface.
`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.
`String` `toString()`

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

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

### Constructor Detail

#### JRubyScriptFactory

    public JRubyScriptFactory(String scriptSourceLocator,
                      Class[] scriptInterfaces)

Create a new JRubyScriptFactory for the given script source.

Parameters:
  `scriptSourceLocator` - a locator that points to the source of the script. Interpreted by the post-processor that actually creates the script.
  `scriptInterfaces` - the Java interfaces that the scripted object is supposed to implement

### Method Detail

#### 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()`

#### 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()

Description copied from interface: `ScriptFactory`
Return the business interfaces that the script is supposed to implement.

Can return `null` if the script itself determines its Java interfaces (such as in the case of Groovy).

Specified by:
  `getScriptInterfaces` in interface `ScriptFactory`
Returns:
  the interfaces for the script

#### requiresConfigInterface

    public boolean requiresConfigInterface()

JRuby scripts do require a config interface.

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

Load and parse the JRuby script via JRubyScriptUtils.

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:
  `JRubyScriptUtils.createJRubyObject(String, Class[], ClassLoader)`

#### 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()`

#### toString

    public String toString()

Overrides:
  `toString` in class `Object`