in

Compatibilidad con JNLP en la tecnología de complemento Java ™ de próxima generación (introducida en la actualización 10 de Java SE 6)

Introducción

La tecnología Java Plug-In de próxima generación (en adelante, el «Java Plug-In») proporciona soporte para iniciar subprogramas directamente desde archivos JNLP. Anteriormente, solo Java Web Start utilizaba archivos JNLP con el fin de iniciar aplicaciones Java. Ahora los subprogramas de Java se pueden describir utilizando el mismo metadescriptor.

Esta nueva funcionalidad ofrece muchos beneficios:

  • Acceso a extensiones JNLP en applets. Se han escrito poderosas extensiones JNLP para aplicaciones Java Web Start, como el Enlace de Java a la API OpenGL 3D, los gráfico de escena Para el JavaFX tiempo de ejecución, y el sistema de visualización planetario y extraplanetario Java World Wind de la NASA. Ahora es trivial utilizar estas extensiones de los subprogramas. (Ha habido soluciones para utilizar algunas de estas extensiones antes, pero estas soluciones siempre han tenido restricciones severas).
  • Acceso a las API de JNLP. Las aplicaciones Java Web Start de espacio aislado tienen acceso a las API de JNLP para obtener acceso controlado por el usuario al almacenamiento persistente (el PersistenceService), partes descargadas con pereza (el DownloadService), el sistema de archivos local (el FileOpenService y FileSaveService), y otra funcionalidad útil. Ahora toda esta funcionalidad está disponible de forma transparente para los desarrolladores de subprogramas.
  • Descarga automática, selección de versión y más. Sobre la base de la arquitectura del nuevo complemento de Java, los subprogramas lanzados a través de JNLP pueden utilizar todas las funciones previamente disponibles para las aplicaciones de Java Web Start, como la selección de versión de JRE, la descarga automática de una versión particular de JRE, pasando argumentos de línea de comandos y propiedades del sistema a la JVM, y mucho más.
  • Unificación del despliegue de Java. La compatibilidad con JNLP en el complemento Java unifica los mecanismos de implementación del contenido Java dentro y fuera del navegador web, lo que simplifica el proceso de toma de decisiones para el desarrollador. Los programas escritos con un modelo de componentes se pueden implementar trivialmente como un elemento en una página web, como una aplicación independiente o ambos.

Este documento destaca las ligeras diferencias semánticas al utilizar JNLP para describir los subprogramas de Java en el navegador y proporciona ejemplos de implementación de subprogramas simple y avanzada a través de JNLP.

Uso

Para iniciar un subprograma desde un archivo JNLP, utilice el jnlp_href parámetro en el <applet> etiqueta:

  
    <applet width="300" height="300" code="com.mycompany.MyApplet">
      <param id="jnlp_href" value="http://www.oracle.com/java/technologies/my_applet.jnlp">
   </applet>
my_applet.jnlp
    <?xml version="1.0" encoding="UTF-8"?>
   <jnlp href="http://www.oracle.com/java/technologies/my_applet.jnlp">
     <information>
       <title>My Applet</title>
       <vendor>My Company, Inc.</vendor>
       <offline-allowed />
     </information>
     <resources>
       <j2se version="1.4+"
href="http://bit.ly/xyGWeN" />
       <jar href="my_applet.jar" main="true" />
       <extension id="SomeExtension"
  href="http://some.server.com/some_extension.jnlp" />
     </resources>
     <applet-desc 
         id="My Applet"
         main-class="com.mycompany.MyApplet"
         width="300"
         height="300">
     </applet-desc>
   </jnlp>

Los desarrolladores que han utilizado Java Web Start ya estarán familiarizados con el formato de archivo JNLP. Para los desarrolladores nuevos en JNLP, se especifica en JSR-56, y se describe en el contexto de aplicaciones en el Guía para desarrolladores de Java Web Start.

Semántica

los <applet> La etiqueta y el archivo JNLP tienen mecanismos superpuestos para especificar ciertos parámetros. Estos conflictos se resuelven de la siguiente manera:

Manejo de base de código

Especificación

En un archivo JNLP, la base de código es un parámetro opcional para el <jnlp> etiqueta. Se utiliza tanto para localizar los recursos descritos en ese archivo JNLP como para encontrar el archivo JNLP en sí. Por razones técnicas, Java Web Start no puede actualizar el contenido del archivo JNLP desde el servidor a menos que se especifique una base de código absoluta.

En el complemento de Java, el navegador siempre proporciona una base de código, ya sea porque se especificó explícitamente o porque se obtuvo implícitamente de la ubicación del documento HTML. Esto permite utilizar URL relativas en archivos JNLP, lo cual es muy útil para mover un árbol completo de contenido de un servidor a otro.

Los archivos JNLP hacen referencia a otros archivos JNLP en una estructura de árbol. El archivo JNLP raíz para un subprograma JNLP es referenciado por un <applet> etiqueta. El código base de la etiqueta del subprograma ayuda a definir la ubicación del archivo JNLP raíz.

Las reglas para el cálculo de la base de código son las siguientes:

  • Si se especifica una base de código absoluta en el archivo JNLP, se utiliza. Esto es necesario por motivos de compatibilidad con versiones anteriores.
  • Si no se especifica la base de código JNLP, se utiliza el directorio que contiene el archivo JNLP.
  • De lo contrario, combine la base de código de JNLP en el directorio que contiene el archivo JNLP.

En términos simples de Java, esto se puede expresar como

URL new_codebase = new URL(current_jnlp_dir, current_jnlp_codebase);

Este cálculo de base de código no es una extensión de JSR-56. JSR-56 no restringe el código base para ser absoluto, y por lo tanto mayo ser relativo.

Ejemplos de

Ejemplo 1:

 
    this JNLP's location:   http://www.sun.com/this.jnlp
    this JNLP's codebase:   http://www.foo.com/test/
    resulting codebase for
     parsing this JNLP:    http://www.foo.com/test/

Ejemplo 2:


   this JNLP's location:   http://www.sun.com/test2/this.jnlp
   this JNLP's codebase:   <none>
   resulting codebase for
     parsing this JNLP:    http://www.sun.com/test2/

Ejemplo 3:

 
   this JNLP's location:   http://www.sun.com/this.jnlp
   this JNLP's codebase:   codebasedir
   resulting codebase for
     parsing this JNLP:    http://www.sun.com/codebasedir

Ejemplo 4:

Las rutas relativas se utilizan para hacer referencia a cada JNLP anidado, como en un árbol de archivos HTML.

 
    www.sun.com/html/my_applet.html
     refers to: my_applet.jnlp
     codebase:  www.sun.com/html

     my_applet.jnlp:
       codebase not specified
       inherits "www.sun.com/html"
       references JNLP extension "jogl/jogl.jnlp"

     jogl/
       jogl.jnlp
       codebase not specified
       inherits "www.sun.com/html/jogl"
         (the directory containing jogl.jnlp)
       references gluegen-rt/gluegen-rt.jnlp

       gluegen-rt/
         gluegen-rt.jnlp
         codebase not specified
         inherits "www.sun.com/html/jogl/gluegen-rt"
           (the directory containing gluegen-rt.jnlp)

Mejores prácticas

Recomendamos:

  • Dejando la base de código vacía para el archivo JNLP principal o de extensión, permitiendo el archivo JNLP de referencia o <applet> etiqueta para especificar implícitamente la base de código.
  • Especificar una URL absoluta para el código base de cualquier archivo JNLP principal o de extensión.

<jnlp>

Argumentos de la línea de comandos

La sintaxis del archivo JNLP admite múltiples mecanismos para pasar argumentos de línea de comando a la JVM. los java-vm-args atributo del <java> se puede utilizar la etiqueta, la max-heap-size atributo de la misma etiqueta puede causar una especificación implícita de un -Xmx argumento, o una propiedad del sistema se puede especificar con el <property> etiqueta.

El nuevo Java Plug-In admite la especificación de argumentos de línea de comandos de JVM por subprograma, por lo que todas estas características del formato de archivo JNLP son compatibles, con algunas reglas y restricciones.

Un conjunto de propiedades del sistema y argumentos de línea de comandos de JVM «seguros» se define en el Sintaxis del archivo JNLP sección de la Guía para desarrolladores de Java Web Start. En el nuevo complemento de Java, de forma predeterminada, solo estos argumentos seguros de la línea de comandos se pueden especificar por subprograma.

Los argumentos de línea de comandos no seguros solo se pueden especificar por subprograma si:

  • el subprograma se inicia a través de un archivo JNLP, y
  • los argumentos de la línea de comandos se especifican en el archivo JNLP, y
  • el archivo JNLP del subprograma está firmado.

El concepto de un archivo JNLP firmado se describe en el Especificación JNLP, sección 5.4.1, «Firma de archivos JNLP».

Estas restricciones son necesarias por razones de seguridad. El requisito de que el archivo JNLP esté firmado para especificar argumentos de línea de comandos no seguros garantiza que el desarrollador original del subprograma haya seleccionado los argumentos de la línea de comandos para el subprograma.

Tenga en cuenta que los argumentos de la línea de comandos aún se pueden especificar para todos los subprogramas a través de la Configuración de tiempo de ejecución del subprograma de Java en el Panel de control de Java. Cualquier argumento de línea de comando especificado allí no está sujeto a las mismas restricciones que los argumentos de línea de comando por subprograma. En particular, argumentos no seguros como -Xdebug se puede especificar en el Panel de control de Java sin afectar la ejecución de los subprogramas. Esto es útil para depurar subprogramas durante el desarrollo. Los argumentos de la línea de comandos por subprograma se agregan a cualquier especificado a través del Panel de control de Java y no los reemplazan por completo.

Cuando se especifican argumentos de línea de comandos de JVM por subprograma, es probable que el nuevo complemento de Java necesite lanzar otra instancia de JVM para satisfacerlos. En otras palabras, es poco probable que una instancia de JVM preexistente se haya iniciado con el conjunto correcto de argumentos de línea de comandos para satisfacer la solicitud del subprograma actual. Las reglas para exactamente cuándo se lanza una nueva instancia de JVM para iniciar un subprograma determinado se dejan deliberadamente sin especificar, ya que esta funcionalidad es nueva en la versión 6u10 y es posible que deba cambiarse en versiones posteriores. A continuación, se muestra un conjunto aproximado de pautas para compartir y crear nuevas instancias de JVM:

  • Si los argumentos de la línea de comandos utilizados para iniciar una instancia de JVM preexistente son un superconjunto de los argumentos solicitados, se utilizará la instancia de JVM preexistente.
  • Si se lanza una instancia de JVM para el conjunto «predeterminado» de argumentos de línea de comandos (es decir, los especificados en el Panel de control de Java, sin argumentos por subprograma especificados), esta instancia de JVM Nunca utilizarse para iniciar cualquier subprograma que tenga incluso una línea de comandos por subprograma …

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *

1KIekk9vZrco15JNzAtBucA

Cree su propia máquina de aprendizaje profundo: lo que necesita saber

Tipos de datos de Java