LuAuF » J2EE http://luauf.com Fri, 27 Jan 2012 01:44:47 +0000 en hourly 1 http://wordpress.org/?v=3.3.1 Tutorial por entregas de JavaServer Faces http://luauf.com/2008/07/20/tutorial-por-entregas-de-javaserver-faces/ http://luauf.com/2008/07/20/tutorial-por-entregas-de-javaserver-faces/#comments Mon, 21 Jul 2008 00:49:40 +0000 Luciano http://luauf.com/?p=529 En la página de NetBeans, más específicamente en Docs & Support, se publicará una serie de tutoriales para conocer el uso básico de JSF y crear una aplicación web utilizando NetBeans. A lo largo de los mencionados tutoriales, se desarrollará una aplicación llamada jAstrologer.

El siguiente documento: Introduction to the JavaServer Faces Framework, es el primero de una serie que demuestra los principios básicos para el uso del framework JSF (JavaServer Faces) para construir aplicaciones web en NetBeans.

Vía: Cafe Lojano

]]> http://luauf.com/2008/07/20/tutorial-por-entregas-de-javaserver-faces/feed/ 2 Fragmentos de código Java en páginas JSP http://luauf.com/2008/07/20/fragmentos-de-codigo-java-en-paginas-jsp/ http://luauf.com/2008/07/20/fragmentos-de-codigo-java-en-paginas-jsp/#comments Sun, 20 Jul 2008 16:13:48 +0000 Luciano http://luauf.com/?p=519 El código Java, en una página JSP, se indica enmarcado por los símbolos <% y %>. Estos fragmentos son los que luego, el contenedor web busca para generar los servlets utilizando el código allí escrito.

Sin embargo, hay cinco tipos diferentes de etiquetas básicas, que indican a su vez, cinco diferentes tipos de elementos JSP:

  • Scriptlets
  • Expresiones
  • Directivas
  • Declaraciones
  • Comentarios

Los scriptlets son fragmentos de código Java totalmente libre, es decir, dentro de un scriptlets  puedes escribir cualquier cosa que un compilador Java pueda entender. Se identifica delimitado por las etiquetas <% y %>.

<%
    System.out.println("Hola");
    out.println("Chau");
%>

Las expresiones representan una porción de código que tienen como resultado un String y cuyo resultado se enviará directamente al cliente. Las expresiones van enmarcadas por los símbolos <%= y %> y no deben incluir el punto y coma al final.

<H1>¡Hola! Hoy es <%= new Date() %></H1>

Las directivas controlan la forma en que el contenedor traduce y ejecuta la página JSP, se colocan entre los demarcadores <%@ y %>.

<%@ page import="java.util.*" %>

Las declaraciones se colocan entre los demarcadores <%! y %>.

<%!
    long hora = System.currentTimeMillis();
    Date fecha = new Date();
    int i = 0;
%>

Los comentarios se colocan entre los símbolos <%-- y --%>. Éstos no son traducidos por el compilador, ni enviados al cliente en el HTML resultante.

<%-- Este comentario
no aparece en el HTML devuelto al cliente  --%>

Leido en Orientación a objetos con Java y UML de Carlos Fontela.

]]> http://luauf.com/2008/07/20/fragmentos-de-codigo-java-en-paginas-jsp/feed/ 1 Servlets, NetBeans y AJAX http://luauf.com/2008/05/24/servlets-netbeans-y-ajax/ http://luauf.com/2008/05/24/servlets-netbeans-y-ajax/#comments Sat, 24 May 2008 22:33:20 +0000 Luciano http://luauf.com/?p=318 Este artículo es la continuación del ejemplo iniciado con Introducción a Java Servlets con NetBeans. El objetivo es modificar el proyecto realizado, para que los datos que se envían al Servlet se hagan por medio del objeto XMLHttpRequest y que mediante DOM accedamos y modifiquemos algunas partes de nuestro documento actual. En resumen, el objetivo es incorporar AJAX a nuestro proyecto. Por lo tanto, también recomiendo leer una Introducción teórica a AJAX, ya que en este artículo me enfocaré exclusivamente en el código.

Sobre el proyecto inicial de Introducción a Java Servlets con NetBeans, realizaremos las siguientes modificaciones:

  • Del lado del cliente:
    • En el formulario de envío de datos se quitará el botón submit y se agregará un nuevo botón, que en su evento onclick ejecutará una función Javascript.
    • Se agregará una función Javascript, que instanciará el objeto XMLHttpRequest, enviará los datos al servidor y procesará la respuesta del Servlet.
  • Del lado del servidor:
    • Se modificará el código de la respuesta enviada por el Servlet, antes enviaba todo un documento HTML (<HTML><HEAD>.... </HEAD><BODY>...</BODY></HTML>). Ahora solo enviará un fragmento de código HTML, pues el mismo, procesado por el cliente, se insertará en la página HTML existente, pues con el objeto XMLHttpRequest el cliente se evita cargar de nuevo la página (uno de los principales objetivos de AJAX)

Haciendo efectivos los cambios mencionados, el cliente queda así:

<html>
    <head>
        <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
        <title>Hello World</title>
    </head>

    <script>
    function Enviar() {

        var obj = false;

        if (window.XMLHttpRequest) {
            //Cuidado aqui, el objeto XMLHttpRequest no esta disponible en versiones previas a IE7
            obj = new XMLHttpRequest();
        } else {
            return false;
        }
        obj.onreadystatechange = function () {
            if ( obj.readyState == 4 && (obj.status == 200 || window.location.href.indexOf ("http")==- 1)) {
                document.getElementById("Respuesta_Hello").innerHTML = obj.responseText;
            } else {
                //procesando...
            }   
        };
        obj.open("GET", "Servlet_Hola?nombre=" + document.getElementById("nombre").value , true);
        obj.send(null);

        return (true);
    }
    </script>

    <body>

        <form action="Servlet_Hola" method="GET">
        Ingrese su nombre: <input type="text" name="nombre" value="" size="45" id="nombre" />
        <input type="button" value="Enviar (con Ajax)" onclick="Enviar();" name="enviarAjax">
        </form>

        <div id="Respuesta_Hello">
            <!-- Este DIV contendra la respuesta enviada por el Servlet -->
        </div>

    </body>

</html>

Por el lado del servidor, el método processRequest del Servlet queda así:

protected void processRequest(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
    response.setContentType("text/html;charset=UTF-8");
    PrintWriter out = response.getWriter();
    try {
        out.println("<strong>Hola " + request.getParameter("nombre") + "<strong>");
    } finally {
        out.close();
    }
}

Lo ejecutamos, de la misma forma que antes ejecutabamos nuestro proyecto desde NetBeans y probamos tener el comportamiento deseado:

]]> http://luauf.com/2008/05/24/servlets-netbeans-y-ajax/feed/ 6 Introducción a Java Servlets con NetBeans http://luauf.com/2008/05/21/introduccion-a-java-servlets-con-netbeans/ http://luauf.com/2008/05/21/introduccion-a-java-servlets-con-netbeans/#comments Thu, 22 May 2008 02:37:51 +0000 Luciano http://luauf.com/?p=305 Los Servlets son una de las tecnologías más importantes de Java. Esta publicación, es un simple ejemplo de construcción de un clásico Hola Mundo en una aplicación web J2EE.

Para este ejemplo, habremos de utilizar:

En mi caso, utilizaré NetBeans 6.1 con Apache-Tomcat 6.1, particularmente en su paquete Web & Java EE, que incorpora lo servidores de aplicaciones Java GlassFish y Apache Tomcat.

  • Iniciamos NetBeans y seleccionamos File \ New Project...
  • Se abre un diálogo que nos solicita el tipo de proyecto, seleccionamos Web Application

  • En el siguiente paso, nos solicita el nombre del proyecto (Project Name), en nuestro caso ingresamos Servlet_HelloWorld

  • El siguiente paso, nos solicita el servidor de aplicaciones (contenedor de Servlets a utilizar). Así, del combo Server, seleccionamos Tomcat (según la versión que yo tengo instalada, Tomcat 6.0.16)

  • Finalmente, nos permite seleccionar el o los frameworks a utilizar (Spring, Struts, JSF, etc). No seleccionamos nada pues, por ahora, para este ejempo, no vale la pena.
  • NetBeans crea por su cuenta el proyecto, una estructura de directorios, y dentro de la carpeta Web Pages un arhivo index.jsp, que será el punto de partida de nuestra aplicación. Si bien es de extensión JSP, por ahora no escribiremos código JSP, sinó simplemente un formulario HTML. En este formulario HTML definiremos en el atributo action el nombre del servlet que se ejecutará al enviar (submit) el formulario.

<form action="Servlet_Hola" method="POST">
            Ingrese su nombre: <input type="text" name="nombre" value="" size="45" />
            <input type="submit" value="Enviar" name="enviar" />
</form>

  • Luego, desde el explorador de proyectos, luego de hacer clic derecho en la carpeta Source Packages, seleccionamos New \ Servlet...

  • Aquí, se abre un diálogo que nos solicita nombre y paquete del servlet.
    • En nombre, hay que ingresar el mismo nombre del atributo action del formulario creado anteriormente, pues este será el servlet que recibirá los datos enviados por el formulario HTML. En nuestro caso, según indicamos en el form: Servlet_Hola.
    • En paquete se puede ingresar el nombre que se quiera, ahora no es de importancia.

  • Dados el nombre del servlet y el paquete, hacemos clic sobre Finish.
  • Finalizado esto, automáticamente crea una clase con el nombre de servlet dado (Servlet_Hola para nosotros), que hereda de HttpServlet. Además redefine (override) algunos métodos (doGet, doPost, getServletInfo) y los rellena con un poco de código. Además, crea un método processRequest (invocado desde los métodos doGet y doPost) para procesar los formularios que llegan por los métodos GET y POST.
  • Nosotros, en este ejemplo, nos limitaremos completar con unas pocas líneas (pues la mayoría la completó automáticamente el NetBeans) el método processRequest para que cree una página HTML que será la respuesta del formulario enviado:

package com.luauf.servlet;

import java.io.*;

import javax.servlet.*;
import javax.servlet.http.*;

public class Servlet_Hola extends HttpServlet {
   
    /**
    * Processes requests for both HTTP <code>GET</code> and <code>POST</code> methods.
    * @param request servlet request
    * @param response servlet response
    */
    protected void processRequest(HttpServletRequest request, HttpServletResponse response)
    throws ServletException, IOException {
        response.setContentType("text/html;charset=UTF-8");
        PrintWriter out = response.getWriter();
        try {
            /*
            TODO output your page here
            */
            out.println("<html>");
            out.println("<head>");
            out.println("<title>Servlet Servlet_Hola</title>"); 
            out.println("</head>");
            out.println("<body>");
            out.println("<p>");
            out.println("Hola <strong>" + request.getParameter("nombre").toString() + "<strong>");
            out.println("</p>");
            out.println("</body>");
            out.println("</html>");
           
        } finally {
            out.close();
        }
    }

    // <editor-fold defaultstate="collapsed" desc="HttpServlet methods. Click on the + sign on the left to edit the code.">
    /**
    * Handles the HTTP <code>GET</code> method.
    * @param request servlet request
    * @param response servlet response
    */
    protected void doGet(HttpServletRequest request, HttpServletResponse response)
    throws ServletException, IOException {
        processRequest(request, response);
    }

    /**
    * Handles the HTTP <code>POST</code> method.
    * @param request servlet request
    * @param response servlet response
    */
    protected void doPost(HttpServletRequest request, HttpServletResponse response)
    throws ServletException, IOException {
        processRequest(request, response);
    }

    /**
    * Returns a short description of the servlet.
    */
    public String getServletInfo() {
        return "Short description";
    }
    // </editor-fold>
}

  • Para finalizar, vamos a ejecutar el proyecto, podemos hacerlo desde el menú Run o haciendo abriendo el menú contextual del proyecto (desde el explorador de proyectos) y seleccionando Run.
  • Al ejecutar una aplicación web con NetBeans, lo primero que hace el mismo es un Deploy, algo así como distribuir la aplicación en el servidor. Por más que nuestro servidor sea local y que el NetBeans lo haga transparente para nosotros, debemos entender que el Tomcat se ejecuta cuando ejecutamos la aplicación y que además posee una estructura de directorios (distinta a nuestra estructura de carpetas del proyecto) donde almacena las aplicaciones web que corre, archivos de configuración, paquetes de clases, etc.
  • Al ejecutar el proyecto se abrirá el browser predeterminado con la página index.jsp (la que tiene el formulario):

  • Si ingresamos nuestro nombre en la caja de texto y apretamos Enviar, el formulario se envía al servlet, quien se ejecuta y nos devuelve una nueva página, con un dato, en particular, cargado dinámicamente: nuestro nombre:

Basado en el texto original publicado en Java Tips.

]]> http://luauf.com/2008/05/21/introduccion-a-java-servlets-con-netbeans/feed/ 57 Servlets vs Java Server Pages http://luauf.com/2008/05/01/servlets-vs-java-server-pages/ http://luauf.com/2008/05/01/servlets-vs-java-server-pages/#comments Thu, 01 May 2008 16:16:19 +0000 Luciano http://luauf.com/?p=224 Las primeras preguntas que me han surgido, previas a mi intrusión en J2EE fueron:

  • ¿Que es un Servlet?
  • ¿Que son las Java Server Pages (JSP)?
  • ¿Cuales son las diferencias entre ambos? ¿Son tecnologías diferentes?

En la medida que tomé un libro y empecé a leer acerca del tema, se me han empezado a aclarar las cosas. Intentaré, en forma muy concreta, contestar dichas preguntas con mis primeras impresiones acerca del tema:

JEE (Java Enterprise Edition) es una plataforma de programación para el desarrollo de aplicaciones distribuidas, más precisamente en aplicaciones Java que se ejecutan sobre un servidor de aplicaciones.

El principio básico de funcionamiento se enfoca en una relación cliente-servidor, el cliente solicita la realización de cierta acción, mientras que el servidor realiza la acción y le responde al cliente. Este esquema de petición-respuesta es la base de las vistas de nivel superior sobre redes en Java: Servlets y Java Server Pages. Sun Microsystems es responsable del desarrollo de las especificaciones para los Servlets y Java Server Pages.

Los Servlets son aplicaciones escritas completamente en Java que se guardan y ejecutan en un servidor de aplicaciones. Los servidores de aplicaciones o contenedores de aplicaciones son el motor del servicio Servlet/JSP. Existen varios contenedores de aplicaciones, un ejemplo de estos es Apache Tomcat. De hecho, la implementación de referencia de ambos estándares (Servlet/JSP) se encuentra bajo el desarrollo de Fundación de software Apache como parte del Proyecto Jakarta.

La interacción entre cliente-servlet generalmente termina en la generación y posterior envío de una respuesta codificada en HTML, XHTML, XML, u otros formatos, como pueden ser pdf, xml, zip, jpeg, gif, doc, xls, etc.

La tecnología JSP, como leí por alguna parte, es un "Servlet maquillado". En realidad es una extensión de la tecnología de los Servlets. JSP permite a los desasrrolladores de sitios web crear páginas que utilicen la funcionalidad de Java para escribir scriptlets de verdadero código Java en sus páginas (para quienes hayan visto ASP o PHP, el principio de funcionamiento es prácticamente el mismo)

Generalmente:

  • JSP se utiliza cuando la mayoría del contenido que se envía al cliente es estático y marclas, y solo una pequeña porción del código se genera dinámicamente.
  • Los Servlets se utilizan cuando una pequeña porción del cóntenido que se envía al cliente es estática y marcas.
]]> http://luauf.com/2008/05/01/servlets-vs-java-server-pages/feed/ 1