Module jdk.scripting.nashorn
Package jdk.nashorn.api.scripting

## Class NashornScriptEngineFactory

- java.lang.Object
- - jdk.nashorn.api.scripting.NashornScriptEngineFactory

All Implemented Interfaces:
  ScriptEngineFactory

    public final class NashornScriptEngineFactory
    extends Object
    implements ScriptEngineFactory

JSR-223 compliant script engine factory for Nashorn. The engine answers for:

- names `"nashorn"`, `"Nashorn"`, `"js"`, `"JS"`, `"JavaScript"`, `"javascript"`, `"ECMAScript"`, and `"ecmascript"`;
- MIME types `"application/javascript"`, `"application/ecmascript"`, `"text/javascript"`, and `"text/ecmascript"`;
- as well as for the extension `"js"`.

Programs executing in engines created using `getScriptEngine(String[])` will have the passed arguments accessible as a global variable named `"arguments"`.

Since:
  1.8u40

### Constructor Summary

Constructors
Constructor and Description
`NashornScriptEngineFactory()`

### Method Summary

All Methods Instance Methods Concrete Methods
`String` `getEngineName()` Returns the full name of the `ScriptEngine`.
`String` `getEngineVersion()` Returns the version of the `ScriptEngine`.
`List<String>` `getExtensions()` Returns an immutable list of filename extensions, which generally identify scripts written in the language supported by this `ScriptEngine`.
`String` `getLanguageName()` Returns the name of the scripting language supported by this `ScriptEngine`.
`String` `getLanguageVersion()` Returns the version of the scripting language supported by this `ScriptEngine`.
`String` `getMethodCallSyntax(String obj, String method, String... args)` Returns a String which can be used to invoke a method of a Java object using the syntax of the supported scripting language.
`List<String>` `getMimeTypes()` Returns an immutable list of mimetypes, associated with scripts that can be executed by the engine.
`List<String>` `getNames()` Returns an immutable list of short names for the `ScriptEngine`, which may be used to identify the `ScriptEngine` by the `ScriptEngineManager`.
`String` `getOutputStatement(String toDisplay)` Returns a String that can be used as a statement to display the specified String using the syntax of the supported scripting language.
`Object` `getParameter(String key)` Returns the value of an attribute whose meaning may be implementation-specific.
`String` `getProgram(String... statements)` Returns a valid scripting language executable program with given statements.
`ScriptEngine` `getScriptEngine()` Returns an instance of the `ScriptEngine` associated with this `ScriptEngineFactory`.
`ScriptEngine` `getScriptEngine(ClassLoader appLoader)` Create a new Script engine initialized with the given class loader.
`ScriptEngine` `getScriptEngine(String... args)` Create a new Script engine initialized with the given arguments.
`ScriptEngine` `getScriptEngine(String[] args, ClassLoader appLoader)` Create a new Script engine initialized with the given arguments and the given class loader.
`ScriptEngine` `getScriptEngine(String[] args, ClassLoader appLoader, ClassFilter classFilter)` Create a new Script engine initialized with the given arguments, class loader and class filter.
`ScriptEngine` `getScriptEngine(ClassFilter classFilter)` Create a new Script engine initialized with the given class filter.

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

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

### Constructor Detail

#### NashornScriptEngineFactory

    public NashornScriptEngineFactory()

### Method Detail

#### getEngineName

    public String getEngineName()

Description copied from interface: `javax.script.ScriptEngineFactory`
Returns the full name of the `ScriptEngine`. For instance an implementation based on the Mozilla Rhino Javascript engine might return Rhino Mozilla Javascript Engine.

Specified by:
  `getEngineName` in interface `ScriptEngineFactory`
Returns:
  The name of the engine implementation.

#### getEngineVersion

    public String getEngineVersion()

Description copied from interface: `javax.script.ScriptEngineFactory`
Returns the version of the `ScriptEngine`.

Specified by:
  `getEngineVersion` in interface `ScriptEngineFactory`
Returns:
  The `ScriptEngine` implementation version.

#### getExtensions

    public List<String> getExtensions()

Description copied from interface: `javax.script.ScriptEngineFactory`
Returns an immutable list of filename extensions, which generally identify scripts written in the language supported by this `ScriptEngine`. The array is used by the `ScriptEngineManager` to implement its `getEngineByExtension` method.

Specified by:
  `getExtensions` in interface `ScriptEngineFactory`
Returns:
  The list of extensions.

#### getLanguageName

    public String getLanguageName()

Description copied from interface: `javax.script.ScriptEngineFactory`
Returns the name of the scripting language supported by this `ScriptEngine`.

Specified by:
  `getLanguageName` in interface `ScriptEngineFactory`
Returns:
  The name of the supported language.

#### getLanguageVersion

    public String getLanguageVersion()

Description copied from interface: `javax.script.ScriptEngineFactory`
Returns the version of the scripting language supported by this `ScriptEngine`.

Specified by:
  `getLanguageVersion` in interface `ScriptEngineFactory`
Returns:
  The version of the supported language.

#### getMethodCallSyntax

    public String getMethodCallSyntax(String obj,
                                      String method,
                                      String... args)

Description copied from interface: `javax.script.ScriptEngineFactory`
Returns a String which can be used to invoke a method of a Java object using the syntax of the supported scripting language. For instance, an implementation for a Javascript engine might be;

     public String getMethodCallSyntax(String obj,
                                       String m, String... args) {
          String ret = obj;
          ret += "." + m + "(";
          for (int i = 0; i < args.length; i++) {
              ret += args[i];
              if (i < args.length - 1) {
                  ret += ",";
              }
          }
          ret += ")";
          return ret;
     }

Specified by:
  `getMethodCallSyntax` in interface `ScriptEngineFactory`
Parameters:
  `obj` - The name representing the object whose method is to be invoked. The name is the one used to create bindings using the `put` method of `ScriptEngine`, the `put` method of an `ENGINE_SCOPE` `Bindings`,or the `setAttribute` method of `ScriptContext`. The identifier used in scripts may be a decorated form of the specified one.
  `method` - The name of the method to invoke.
  `args` - names of the arguments in the method call.
Returns:
  The String used to invoke the method in the syntax of the scripting language.

#### getMimeTypes

    public List<String> getMimeTypes()

Description copied from interface: `javax.script.ScriptEngineFactory`
Returns an immutable list of mimetypes, associated with scripts that can be executed by the engine. The list is used by the `ScriptEngineManager` class to implement its `getEngineByMimetype` method.

Specified by:
  `getMimeTypes` in interface `ScriptEngineFactory`
Returns:
  The list of mime types.

#### getNames

    public List<String> getNames()

Description copied from interface: `javax.script.ScriptEngineFactory`
Returns an immutable list of short names for the `ScriptEngine`, which may be used to identify the `ScriptEngine` by the `ScriptEngineManager`. For instance, an implementation based on the Mozilla Rhino Javascript engine might return list containing {"javascript", "rhino"}.

Specified by:
  `getNames` in interface `ScriptEngineFactory`
Returns:
  an immutable list of short names

#### getOutputStatement

    public String getOutputStatement(String toDisplay)

Description copied from interface: `javax.script.ScriptEngineFactory`
Returns a String that can be used as a statement to display the specified String using the syntax of the supported scripting language. For instance, the implementation for a Perl engine might be;

     public String getOutputStatement(String toDisplay) {
          return "print(" + toDisplay + ")";
     }

Specified by:
  `getOutputStatement` in interface `ScriptEngineFactory`
Parameters:
  `toDisplay` - The String to be displayed by the returned statement.
Returns:
  The string used to display the String in the syntax of the scripting language.

#### getParameter

    public Object getParameter(String key)

Description copied from interface: `javax.script.ScriptEngineFactory`
Returns the value of an attribute whose meaning may be implementation-specific. Keys for which the value is defined in all implementations are:

- ScriptEngine.ENGINE
- ScriptEngine.ENGINE_VERSION
- ScriptEngine.LANGUAGE
- ScriptEngine.LANGUAGE_VERSION
- ScriptEngine.NAME

The values for these keys are the Strings returned by `getEngineName`, `getEngineVersion`, `getLanguageName`, `getLanguageVersion` for the first four keys respectively. For NAME, one of the Strings returned by `getNames` is returned.
A reserved key, `THREADING`, whose value describes the behavior of the engine with respect to concurrent execution of scripts and maintenance of state is also defined. These values for the `THREADING` key are:

- `null` - The engine implementation is not thread safe, and cannot be used to execute scripts concurrently on multiple threads.
- `"MULTITHREADED"` - The engine implementation is internally thread-safe and scripts may execute concurrently although effects of script execution on one thread may be visible to scripts on other threads.
- `"THREAD-ISOLATED"` - The implementation satisfies the requirements of "MULTITHREADED", and also, the engine maintains independent values for symbols in scripts executing on different threads.
- `"STATELESS"` - The implementation satisfies the requirements of
- `"THREAD-ISOLATED"`. In addition, script executions do not alter the mappings in the `Bindings` which is the engine scope of the `ScriptEngine`. In particular, the keys in the `Bindings` and their associated values are the same before and after the execution of the script.

Implementations may define implementation-specific keys.

Specified by:
  `getParameter` in interface `ScriptEngineFactory`
Parameters:
  `key` - The name of the parameter
Returns:
  The value for the given parameter. Returns `null` if no value is assigned to the key.

#### getProgram

    public String getProgram(String... statements)

Description copied from interface: `javax.script.ScriptEngineFactory`
Returns a valid scripting language executable program with given statements. For instance an implementation for a PHP engine might be:

     public String getProgram(String... statements) {
          String retval = "<?\n";
          int len = statements.length;
          for (int i = 0; i < len; i++) {
              retval += statements[i] + ";\n";
          }
          return retval += "?>";
     }

Specified by:
  `getProgram` in interface `ScriptEngineFactory`
Parameters:
  `statements` - The statements to be executed. May be return values of calls to the `getMethodCallSyntax` and `getOutputStatement` methods.
Returns:
  The Program

#### getScriptEngine

    public ScriptEngine getScriptEngine()

Description copied from interface: `javax.script.ScriptEngineFactory`
Returns an instance of the `ScriptEngine` associated with this `ScriptEngineFactory`. A new ScriptEngine is generally returned, but implementations may pool, share or reuse engines.

Specified by:
  `getScriptEngine` in interface `ScriptEngineFactory`
Returns:
  A new `ScriptEngine` instance.

#### getScriptEngine

    public ScriptEngine getScriptEngine(ClassLoader appLoader)

Create a new Script engine initialized with the given class loader.

Parameters:
  `appLoader` - class loader to be used as script "app" class loader.
Returns:
  newly created script engine.
Throws:
  `SecurityException` - if the security manager's `checkPermission` denies `RuntimePermission("nashorn.setConfig")`

#### getScriptEngine

    public ScriptEngine getScriptEngine(ClassFilter classFilter)

Create a new Script engine initialized with the given class filter.

Parameters:
  `classFilter` - class filter to use.
Returns:
  newly created script engine.
Throws:
  `NullPointerException` - if `classFilter` is `null`
  `SecurityException` - if the security manager's `checkPermission` denies `RuntimePermission("nashorn.setConfig")`

#### getScriptEngine

    public ScriptEngine getScriptEngine(String... args)

Create a new Script engine initialized with the given arguments.

Parameters:
  `args` - arguments array passed to script engine.
Returns:
  newly created script engine.
Throws:
  `NullPointerException` - if `args` is `null`
  `SecurityException` - if the security manager's `checkPermission` denies `RuntimePermission("nashorn.setConfig")`

#### getScriptEngine

    public ScriptEngine getScriptEngine(String[] args,
                                        ClassLoader appLoader)

Create a new Script engine initialized with the given arguments and the given class loader.

Parameters:
  `args` - arguments array passed to script engine.
  `appLoader` - class loader to be used as script "app" class loader.
Returns:
  newly created script engine.
Throws:
  `NullPointerException` - if `args` is `null`
  `SecurityException` - if the security manager's `checkPermission` denies `RuntimePermission("nashorn.setConfig")`

#### getScriptEngine

    public ScriptEngine getScriptEngine(String[] args,
                                        ClassLoader appLoader,
                                        ClassFilter classFilter)

Create a new Script engine initialized with the given arguments, class loader and class filter.

Parameters:
  `args` - arguments array passed to script engine.
  `appLoader` - class loader to be used as script "app" class loader.
  `classFilter` - class filter to use.
Returns:
  newly created script engine.
Throws:
  `NullPointerException` - if `args` or `classFilter` is `null`
  `SecurityException` - if the security manager's `checkPermission` denies `RuntimePermission("nashorn.setConfig")`