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 | Description
    --- | ---
    `NashornScriptEngineFactory​()` |

  - ### Method Summary

    All Methods Instance Methods Concrete Methods
    Modifier and Type | Method | Description
    --- | --- | ---
    `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: `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: `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: `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: `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: `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: `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: `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: `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: `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: `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: `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: `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")`