Aunque trabajo como programador informático, no suelo poner muchas entradas de esa temática. Sin embargo, en el nuevo aire
que le he dado al blog, quiero que este tipo de entradas, puedan llegar a ser algo más habituales.
Empecemos.
Lo primero es explicar qué es la tecnología JNLP. Dentro de unos días la explicaré mejor.
Sin hacer referencia a aburridas y largas explicaciones en inglés, JNLP es simple y llanamente un tecnología de JAVA que nos
permite ejecutar de forma on-line una aplicación de escritorio.
Es decir, centralizamos el recurso (un archivo .jar) en el servidor y con una página web que haga referencia a un archivo
JNLP (en el fondo, un archivo XML), podemos iniciar el programita desde cualquier parte, con la ventaja de que en caso de
tener que actualizar el programa, Java Web Start se encarga de comprobar y hacer la actualización pertinente si fuese
necesario.
En una linea : JNLP es un acceso directo desde una página web a un programa remoto.
Aún así, para quien quiera más información:
wikipedia/jnlpDicho esto, vamos al mehollo.
No voy a poner código inncesario que con un poco de google puedes encontrar por mil sitios. Simplemente me voy a limitar a
explicar lo que hay que hacer y poner el código que crea conveniente.
Ejemplo 1:
Queremos arrancar on-line una aplicacion estática (siempre es la misma)
1- Creamos una aplicación web, y en el index.jsp ponemos un enlace al archivo .jnlp:
<center>
<a href="recursos/miArchivo.jnlp">
<img src="recursos/imagenes/reloj.gif">
</a>
</center>
2- Lógicamente creamos el archivo jnlp.
3- Si la aplicación hace uso de recursos locales del ordenador, bases de datos, etc. habrá que firmarla (cómo se firma, lo explicaré en otra entrada en unos días, intentaré enlazarla desde aquí).
Naturalmente, una aplicación puede tener librerias, es decir, varios .jar más a parte del principal. Habrá que firmarlos todos.
Cuidado con las dobles firmas. Algunas librerías vienen firmadas de origen. Deberéis entrar en el .jar (al fin y al cabo, no son más que archivos comprimidos) y borrar del META-INF las referencias a archivos .DSA, .RSA y .SF que no sean de tu firma
Y ya está. ¿Fácil no?
Ejemplo 2:
Complicamos la cosa un poco.
Imaginemos que queremos arrancar una aplicación que nos mostrará un texto que hemos escrito en la página web.
Realmente esto es una chorrada, pero si el texto "dinamico" fuese una clave generada a partir de un usuario y contraseña para validar el inicio de la aplicación... la cosa va cogiendo color.
A lo que vamos:
1- Creamos una aplicación web.
1.1- En el index.jsp ponemos algo como esto:
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=windows-1252">
<title>JSP Page</title>
</head>
<body>
<center>
<form name="Generador" action="GeneradorJNLP" method="POST">
<div style="
border-style:solid;
border-width:1px;
width:200px;
height:80px;">
<center>
<br>
<input type="text" name="valor" style="width:180px"/><br>
<a href="#" onclick="Generador.submit();">Iniciar</a>
</center>
</div>
</form>
</center>
</body>
</html>
Contiene un input para recoger el texto y un enlace que realiza un submit() del formulario.
2.2 Creamos en la aplicación web un servlet, en mi caso llamada "GeneradorJNLP" que es donde apunta el action del formulario
Del servlet lo que nos interesa es:
protected void processRequest(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
PrintWriter out = response.getWriter();
String valor = (String) request.getParameter("valor");
String jnlp = getJnlp(valor);
try {
response.setContentType("application/x-java-jnlp-file");
out.print(jnlp);
} finally {
out.close();
}
}
}
Recogemos el valor del input anterior con :
(String) request.getParameter("valor");
Mediante
response.setContentType("application/x-java-jnlp-file");
le decimos que vamos a mandar un documento de tipo JNLP para que el navegador lo interprete correctamente.
En getJnlp(valor) :
public String getJnlp(String valor) {
return "<?xml version=\"1.0\" encoding=\"UTF-8\"?> \n" +
"<jnlp codebase="">
(...)
"<application-desc main-class=\"inicio.Main\"> \n" +
" <argument>" + valor + "</argument> \n" +
"</application-desc>";
}
Fijaros que aunque en todos los sitios con informacion sobre JNLP ponen en esa linea href="nombreDelJNLP", yo no lo he puesto.
La explicación es fácil.
No queremos generar un archivo de forma física, por lo que no podemos tampoco poner un href ya que no existe una dirección que linkar.
Al poner href le obligamos a JNLP a que el aunque en el archivo que nos descarguemos ponga misa, ejecute el archivo jnlp que hay en el servidor. Así se evitan posibles manipulaciones locales.
En nuestro caso, podemos prescindir de esto.
Por otra parte, el valor lo hemos incluído como un argumento en la etiqueta de jnlp que indica cual es la clase principal (donde se encuentra el método public static void main(String args[]) )
Este argumento, luego podrá ser recuperado en el programa accedidiendo a la posición 0 del vector args[]. Y una vez recuperado, ya lo podremos tratar.
3.Naturalmente, y como en el ejemplo anterior, firmar todos los recursos .jar que sean necesarios.
Bueno, aquí la cosa se ha complicado un poco con relación al ejemplo 1, pero aún así, ¿sigue siendo fácil no?
Quizá se me ha pasado alguna parte, o quizá algo podría estar mejor explicado, no lo sé. Si mal no recuerdo, es la primera vez que posteo un tema relacionado con programación.
Así que todas las correcciones en cuanto a sintaxis, explicación, ejemplos, código, u otras cosas, las aceptaré y tendré muy en cuenta.
Naturalmente como siempre, espero vuestros comentarios.
(Actualización: podéis ver la segunda parte,
aquí)
