martes, 17 de agosto de 2010

Stateless VS Stateful

En este ejemplo voy a demostrar la diferencia entre Stateful Beans y Stateless Beans.
Para este ejemplo estoy usando Ubuntu version 10.04, Netbeans 3.0 y Glassfish V3.
Primeramente creamos una aplicacion Java EE, desde Netbeans

Para mi caso la voy a llamar SessionProject

Seleccionamos Glassfish como servidor y marcamos la casilla de creacion de un cliente para probar nuestra aplicación.



Una vez hecho esto, creamos un EJB Session Bean llamado StatefulBean, Este bean es Remoto de tipo Stateful en el paquete com.ejb.stateful

Ahora tenemos crear los métodos, para esto usamos Netbeans y dentro de StatefulBean damos click con el botón derecho seleccionamos InsertCode y luego AddBusinessMethod y creamos un método llamado incremetar, que devuelve un Integer



Una vez acabado esto nos quedará el siguiente código:
Para la Interface

package com.ejb.stateful;

import javax.ejb.Remote;

@Remote
public interface StatefulBeanRemote {

Integer incrementar();

}

ParaStatefulBean:

package com.ejb.stateful;

import javax.ejb.Stateful;

@Stateful
public class StatefulBean implements StatefulBeanRemote {
private Integer valor=0;
public Integer incrementar() {
return ++valor;
}

}


Ahora vamos a crear el Stateless.
Una vez hecho esto, creamos un EJB Session Bean llamado StatelessBean, Este bean es Remoto de tipo Stateless en el paquete com.ejb.stateless

Ahora tenemos crear los métodos, para esto usamos Netbeans y dentro de StatefulBean damos click con el botón derecho seleccionamos InsertCode y luego AddBusinessMethod y creamos un método llamado incremetar, que devuelve un Integer


Una vez acabado esto nos quedará el siguiente código:
Para la Interface


package com.ejb.stateless;

import javax.ejb.Remote;

@Remote
public interface StatelessBeanRemote {

Integer incrementar();
}



Para StatelessBean

package com.ejb.stateless;

import javax.ejb.Stateless;

@Stateless
public class StatelessBean implements StatelessBeanRemote {
private Integer valor=0;
public Integer incrementar() {
return ++valor;
}
}


Hecho esto, vamos a cambiar las propiedades del proyecto para ejecutar el cliente.Para esto damos botón derecho sobre el proyecto principal(SessionProject) y seleccionamos properties. Luego seleccionamos Run y en el Client Module seleccionamos SessionProject-app-client.


Una vez configurado, abrimos la clase main de SessionProject-app-client
damos boton derecho sobre el método main y seleccionamos InsertCode y luego "Call Enterprise Bean". Luego de esto seleccionamos SessionProject-ejb y en Reference Name colocamos statefulbean1. Los mismos pasos seguimos para statefulbean2, statelessbean1,statelessbean2



Con esto se nos genera el siguiente código:
@EJB(name = "statefulbean1")
private static StatefulBeanRemote statefulbean1;
@EJB(name = "statefulbean2")
private static StatefulBeanRemote statefulbean2;
@EJB(name = "statelessbean1")
private static StatelessBeanRemote statelessbean1;
@EJB(name = "statelessbean2")
private static StatelessBeanRemote statelessbean2;


Luego agregamos el siguiente código en el método main:
System.err.println("Variable Stateful1");
System.err.println(statefulbean1.incrementar());
System.err.println(statefulbean1.incrementar());
System.err.println(statefulbean1.incrementar());

System.err.println("Variable Stateful2");
System.err.println(statefulbean2.incrementar());
System.err.println(statefulbean2.incrementar());
System.err.println(statefulbean2.incrementar());

System.err.println("Variable Stateless1");
System.err.println(statelessbean1.incrementar());
System.err.println(statelessbean1.incrementar());
System.err.println(statelessbean1.incrementar());

System.err.println("Variable Stateless2");
System.err.println(statelessbean2.incrementar());
System.err.println(statelessbean2.incrementar());
System.err.println(statelessbean2.incrementar());


Con lo que el código final nos quedará como:
package sessionproject;

import com.ejb.stateful.StatefulBean;
import com.ejb.stateful.StatefulBeanRemote;
import com.ejb.stateless.StatelessBean;
import com.ejb.stateless.StatelessBeanRemote;
import javax.ejb.EJB;

public class Main {


@EJB(name = "statefulbean1")
private static StatefulBeanRemote statefulbean1;
@EJB(name = "statefulbean2")
private static StatefulBeanRemote statefulbean2;
@EJB(name = "statelessbean1")
private static StatelessBeanRemote statelessbean1;
@EJB(name = "statelessbean2")
private static StatelessBeanRemote statelessbean2;

public static void main(String[] args) {
System.err.println("Variable Stateful1");
System.err.println(statefulbean1.incrementar());
System.err.println(statefulbean1.incrementar());
System.err.println(statefulbean1.incrementar());

System.err.println("Variable Stateful2");
System.err.println(statefulbean2.incrementar());
System.err.println(statefulbean2.incrementar());
System.err.println(statefulbean2.incrementar());

System.err.println("Variable Stateless1");
System.err.println(statelessbean1.incrementar());
System.err.println(statelessbean1.incrementar());
System.err.println(statelessbean1.incrementar());

System.err.println("Variable Stateless2");
System.err.println(statelessbean2.incrementar());
System.err.println(statelessbean2.incrementar());
System.err.println(statelessbean2.incrementar());
}
}


Si ejecutamos el proyecto principal(SessionProject)
En la consola tenemos la siguiente salida:

Variable Stateful1
1

2
3
Variable Stateful2
1
2
3
Variable Stateless1
1
2
3
Variable Stateless2
4
5
6

La idea es que los cambios a stateless afectará a todas las instancias creadas de stateless. Mientras que en stateful, las instancias son independientes y no se ven afectadas.

jueves, 12 de agosto de 2010

Usando Servlets Asíncronos con Servlet 3.0

Para este ejemplo estoy usando Ubuntu 10.04, Netbeans 9 y Glassfish V3



En este ejemplo voy a demostrar el uso de Servlets asíncronos.
El uso de este tipo de servlets es para ejecutar funciones callback, es decir para evitar que el código se ejecute de una manera secuencial como se lo hace con los servlets tradicionales.

Primero creamos un nuevo proyecto WEB

Luego creamos una clase llamada ClaseAsincrona, con el siguiente código:
package com.ejemplo;

import javax.servlet.AsyncContext;

public class ClaseAsincrona implements Runnable{

AsyncContext ctx;

public ClaseAsincrona(AsyncContext ctx) {
this.ctx = ctx;
}

public void run() {
try {
Thread.sleep(60000);
System.out.println("Se ejecutara luego de 1 minuto");
} catch (Exception ex) {
ex.printStackTrace();
}
ctx.complete();
}
}


Luego creamos un servlet con el siguiente código:

package com.ejemplo.servlet;

import com.ejemplo.ClaseAsincrona;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.concurrent.ScheduledThreadPoolExecutor;
import javax.servlet.AsyncContext;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;


@WebServlet(name = "Servlet1", urlPatterns = {"/Servlet1"},asyncSupported=true)
public class Servlet1 extends HttpServlet {

protected void processRequest(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
AsyncContext aCtx = request.startAsync(request, response);
ScheduledThreadPoolExecutor executor = new ScheduledThreadPoolExecutor(10);
executor.execute(new ClaseAsincrona(aCtx));

PrintWriter out = response.getWriter();
try {

out.println("<html>");
out.println("<head>");
out.println("<title>Ejemplo de Servlet Asincrónico</title>");
out.println("</head>");
out.println("<body>");
out.println("<h1>Aqui ejecutamos cualquier proceso y en 1 minuto revise su log de Glassfish"+"</h1 >");
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.">
@Override
protected void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
processRequest(request, response);
}

@Override
protected void doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
processRequest(request, response);
}

}


Finalmente ejecutamos el servlet y tendremos la siguiente salida:

y si luego de un minuto revisamos el log de Glassfish.

Upload de archivos con javax.servlet.http.Part con Servlet 3.0

Para este ejemplo estoy usando Ubuntu 10.04, Netbeans 9 y Glassfish V3
Para hacer un upload de archivo ya no es necesario usar librerias externas como common file-upload de Apache ya que desde la versión 3 de Servlets ya contamos con funcionalidad que nos permite hacer upload de archivos:

Primeramente creamos un proyecto web.Luego creamos archivo de texto con cualquier contenido en cualquier lugar de nuestro disco duro, para mi caso el archivo se llama archivo.txt. El archivo tiene el siguiente contenido:

Esta es una prueba de un archivo que se encuentra en disco

Luego creamos un servlet de la siguiente manera

/*
* To change this template, choose Tools | Templates
* and open the template in the editor.
*/
package com.ejemplo;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import javax.servlet.RequestDispatcher;
import javax.servlet.ServletException;
import javax.servlet.annotation.MultipartConfig;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.Part;

/**
*
* @author santiago
*/
@WebServlet(name = "Upload", urlPatterns = {"/Upload"})
@MultipartConfig(location = "/tmp")
public class Upload extends HttpServlet {

/**
* Processes requests for both HTTP <code>GET</code> and <code>POST</code> methods.
* @param request servlet request
* @param response servlet response
* @throws ServletException if a servlet-specific error occurs
* @throws IOException if an I/O error occurs
*/
protected void processRequest(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
response.setContentType("text/html;charset=UTF-8");
PrintWriter out = response.getWriter();
try {
Part p = request.getPart("desc");
BufferedReader r = new BufferedReader(new InputStreamReader(p.getInputStream()));
String desc = r.readLine();
request.setAttribute("desc", desc);
p.write("browser.txt");
p = request.getPart("data");
p.write("DATAFILE");
RequestDispatcher rd = request.getRequestDispatcher("mensaje.jsp");
rd.forward(request, response);
} finally {
out.close();
}
}

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

@Override
protected void doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
processRequest(request, response);
}
}

Quiero destacar el uso de la anotación:
@MultipartConfig(location = "/tmp") que es usada para especificar en que lugar de nuestro disco duro guardaremos la información.

Ahora creamos una pagina JSP que en el action del formulario(que es multipart) llamará al Servlet antes creado:

<%@page contentType="text/html" pageEncoding="UTF-8"%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
"http://www.w3.org/TR/html4/loose.dtd">

<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>JSP Page</title>
</head>
<body>
<form name="form1" action="Upload" enctype="multipart/form-data" method="post">
Description:<input type="text" name="desc"/>
File:<input type="file" name="data"/>
<input type="submit" value="Click"/>
</form>
</body>
</html>


Luego creamos una pagina para indicar que se subio el archivo, llamada mensaje.jsp, con el siguiente código
<%@page contentType="text/html" pageEncoding="UTF-8"%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
"http://www.w3.org/TR/html4/loose.dtd">

<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>JSP Page</title>
</head>
<body>
<h1>Archivos Subidos y creados</h1>
</body>
</html>

Si ejecutamos la página JSP, ingresamos algo en la caja de texto y subimos un archivo:


Vemos que se nos han creado dos archivos uno con el contenido del archivo que subimos y otro archivo con lo que escribimos en la caja de texto


Uso de objetos implicitos con EL

Para este ejemplo estoy usando Ubuntu version 10.04, Netbeans 6.9 y Glassfish V3
En este post voy a publicar como usar los objetos implícitos con EL(Expression Language).

Para esto primero crearemos un servlet que pondra algunos valores en el scope y luego hara un dispatcher a una página JSP donde mostraremos la información por medio de EL.

protected void processRequest(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
response.setContentType("text/html;charset=UTF-8");
PrintWriter out = response.getWriter();
try {
request.setAttribute("variableRequest", "var request");
request.getSession().setAttribute("variableSesion", "var sesion");
this.getServletContext().setAttribute("variableAplicacion", "var aplicacion");
Cookie c=new Cookie("variableCookie","var Cookie");
response.addCookie(c);
RequestDispatcher rd = request.getRequestDispatcher("VerVariables.jsp?"
+ "parametro=var+parametro");
rd.forward(request, response);
} finally {
out.close();
}


También vamos a agregar una variable de contexto en web.xml
<context-param>
<param-name>mensaje</param-name>
<param-value>Este es un mensaje de Init</param-value>
</context-param>


Finalmente vamos a crear una pagina JSP donde mostraremos las diferentes variables ingresadas:
<%@page contentType="text/html" pageEncoding="UTF-8"%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
"http://www.w3.org/TR/html4/loose.dtd">
<%@taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c"%>
<c:set var="variableLocal" value="Soy una variable local" scope="page"/>
<c:set var="variableRequest2" value="Soy una variable request" scope="request"/>
<c:set var="variableSesion2" value="Soy una variable sesion" scope="session"/>
<c:set var="variableAplicacion2" value="Soy una variable aplicación" scope="application"/>



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

</head>
<body>
<table border="1">
<tr><td>
Page Context</td><td>${pageContext.request.requestURI}
</td></tr>
<tr><td>
Page Scope</td><td>${pageScope.variableLocal}</td></tr>
<tr><td>
Request Scope</td><td>${requestScope['variableRequest']}
</td></tr>
<tr><td>
Request Scope2</td><td>${requestScope['variableRequest2']}
</td></tr>
<tr><td>
Session Scope</td><td>${sessionScope['variableSesion']}
</td></tr>
<tr><td>
Session Scope2</td><td>${sessionScope['variableSesion2']}
</td></tr>
<tr><td>
Application Scope</td><td>${applicationScope['variableAplicacion']}
</td></tr>
<tr><td>
Application Scope2</td><td>${applicationScope['variableAplicacion2']}
</td></tr>
<tr><td>
Param</td><td>${param['parametro']}
</td></tr>
<tr><td>
ParamValues</td><td>
<c:forEach var='parameter' items='${paramValues}'>
<c:out value='${parameter.key}'/> =
<c:forEach var='value' items='${parameter.value}'>
<c:out value='${value}' escapeXml="false"/>
</c:forEach>
</c:forEach>
</td></tr>
<tr><td>
<tr><td>
ParamValues2</td><td>
<c:forEach var='parameter' items='${param}'>
${parameter.key}:
${parameter.value}
</c:forEach>
</td></tr>
<tr><td>
Header</td><td>${header.Host}
</td></tr>
<tr><td>
Header Values</td><td>
<c:forEach var="head" items="${headerValues}">
<c:out value="${head.key}" /> =
<c:forEach var="val" items="${head.value}">
<c:out escapeXml="false" value="${val}" />
</c:forEach>
</c:forEach>
</td></tr>
<tr><td>
Header Values2</td><td>
<c:forEach var="httpHeaderValues" items="${header}">
${httpHeaderValues.key}:
${httpHeaderValues.value}
</c:forEach>
</td></tr>
<tr><td>
Cookie</td><td>${cookie.variableCookie.value}
</td></tr>
<tr><td>
Init</td><td>${initParam['mensaje']}
</td></tr>
</table>
</body>
</html>


Si ejecutamos el servlet, tendremos la siguiente salida:


y si actualizamos la página tendremos el valor de la cookie.

miércoles, 11 de agosto de 2010

Ejemplo completo con JSTL(core,xml, function,sql,format)

Para este ejemplo estoy utilizando Ubuntu 10.04 y Netbeans version 9
Primeramente creamos un nuevo proyecto web en Netbeans, lo llamaremos JSTL .

Además utilizaremos el servidor Glassfish V3 y damos click en Finish

Una vez hecho esto damos boton derecho sobre el proyecto y seleccionamos properties

Luego la opción Libraries y damos click en Add Library. Ahi seleccionamos JSTL 1.1 y luego damos click en Add Library y OK. Esto es para dar el soporte de JSTL a nuestro proyecto.

Ahora tenemos que crear una base de datos en Derby para conectar nuestra aplicacion JSTL a una base de datos
Seleccionamos Services, luego Databases.

Luego sobre JavaDB, seleccionamos Create Database
Le damos el nombre ejemplo, con el user usuario1 y la clave usuario1 y damos click en ok
Luego seleccionamos la conexion, nos conectamos.
abrimos APP y damos botón derecho sobre tables y seleccionamos CREATE TABLE.
Entonces creamos una tabla llamada Clientes.
Con los campos Id de tipo Integer, Nombre del tipo varchar(20) y Direccion del tipo varchar(20)





Con esto tenemos creada una base de datos, con la que vamos a interactuar cuando usemos JSTL con SQL


Luego de esto abrimos index.jsp , que tendrá enlaces a pagainas y Servlets con funcionalidades de JSTL.

En index.jsp vamos a colocar el siguiente codigo:
- Una referencia a JSTL
- Declaración de varaibles
- Visualización de esas variables

Todo esto corresponde al siguiente código:
<%@page contentType="text/html" pageEncoding="UTF-8"%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
"http://www.w3.org/TR/html4/loose.dtd">
<%@taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c"%>
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>JSP Page</title>
</head>
<body>
<c:set var="opcion1" value="Mapa"/>
<c:set var="opcion2" value="Funciones.jsp"/>
<c:set var="opcion3" value="Formatos"/>
<c:set var="opcion4" value="SQL.jsp"/>
<c:set var="opcion5" value="XML.jsp"/>
<c:out value="Seleccione una opción:"/><br/>
<a href='<c:url value="${opcion1}"/>'>${opcion1}</a><br/>
<a href='<c:url value="${opcion2}"/>'>${opcion2}</a><br/>
<a href='<c:url value="${opcion3}"/>'>${opcion3}</a><br/>
<a href='<c:url value="${opcion4}"/>'>${opcion4}</a><br/>
<a href='<c:url value="${opcion5}"/>'>${opcion5}</a><br/>
</body>
</html>


Una vez hecho esto, tenemos que crear el sisguiente paquete:com.ejemplo
Este paquete contendrá dos servlets
Mapa.java: Este servlet crea un mapa simple, coloca valores y luego usando un dispatcher, los envia a otra página, acontinuación coloco el método processRequest:

protected void processRequest(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
response.setContentType("text/html;charset=UTF-8");
PrintWriter out = response.getWriter();
try {
List<Map<String,String>> listadoPersonas=new ArrayList<Map<String,String>>();
for(int i=0;i<10;i++){
Map<String, String> persona=new HashMap<String,String>();
persona.put("id", String.valueOf(i));
persona.put("nombre", "persona"+i);
persona.put("direccion", "direccion"+i);
listadoPersonas.add(persona);
}
RequestDispatcher rd = request.getRequestDispatcher("VerMapa.jsp");
request.setAttribute("personas", listadoPersonas);
rd.forward(request, response);
} finally {
out.close();
}
}

Tambien creamos otro servlet dentro del mismo paquete que se llamará Formatos.java

Este servlet, no permite colocar una fecha en el request y un numero a los que se les aplicará un formato:

protected void processRequest(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
response.setContentType("text/html;charset=UTF-8");
PrintWriter out = response.getWriter();
try {
Double valor=100000d/3d;
Date fecha= new Date();
RequestDispatcher rd = request.getRequestDispatcher("VerFormatos.jsp");
request.setAttribute("numero", valor);
request.setAttribute("fecha", fecha);
rd.forward(request, response);
} finally {
out.close();
}
}

También vamos a crear un archivo de propiedades llamado app.properties, que se encontrará junto al directorio com, de nuestro código fuente, el archivo de propiedades debe tener el siguiente contenido:
ejemplo1=prueba1
ejemplo2=prueba2
ejemplo3=prueba3


Hecho esto vamos a crear una página para ver el mapa que la llamaremos VerMapa.jsp
Esta pagina hace una llamada a JSTL y relaiza una iteración, creando una tabla de HTML:
<%@page contentType="text/html" pageEncoding="UTF-8"%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
"http://www.w3.org/TR/html4/loose.dtd">
<%@taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c"%>
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>JSP Page</title>
</head>
<body>
<table border="1">
<tr>
<td>ID</td>
<td>NOMBRE</td>
<td>DIRECCION</td>
</tr>
<c:forEach var="persona" items="${personas}">

<tr
<c:choose>
<c:when test="${persona.id mod 2==0}"> bgColor="#FF0000"</c:when>
<c:when test="${persona.id mod 3==0}"> bgColor="#00FF00"</c:when>
<c:otherwise> bgColor="#0000FF"</c:otherwise>
</c:choose>
>
<td>${persona.id}</td>
<td>${persona.nombre}</td>
<td>${persona.direccion}</td>
</tr>
</c:forEach>
</table>
</body>
</html>


Ahora vamos a crear una tabla llamada VerFormatos.jsp
Esta tabla coloca un locale y aplica un formato a la fecha y numero colocados en el Servlet, además carga la información del archivo de propiedades llamado app que se encuentra junto al directorio com de nuestros paquetes

<%@page contentType="text/html" pageEncoding="UTF-8"%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
"http://www.w3.org/TR/html4/loose.dtd">
<%@taglib uri="http://java.sun.com/jsp/jstl/fmt" prefix="fmt"%>
<%@taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c"%>

<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>JSP Page</title>
</head>
<body>
<fmt:formatDate pattern="dd/MM/yyyy" value="${fecha}"/><br/>
<fmt:setLocale value="es_EC"/>
${numero}<br/>
<fmt:formatNumber pattern="###,###.###" value="${numero}"/><br/>
<fmt:bundle basename="app">
<fmt:message key='ejemplo1'/><br/>
<fmt:message key='ejemplo2'/><br/>
<fmt:message key='ejemplo3'/><br/>
</fmt:bundle>

</body>
</html>


Ahora vamos a crear la página llamada Funciones .jsp, esta página tiene las siguientes características:
- Carga una referencia al jslt encargado de usar funciones
- Usa ciertas funciones en una variable

El código es el siguiente:

<%@page contentType="text/html" pageEncoding="UTF-8"%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
"http://www.w3.org/TR/html4/loose.dtd">
<%@taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c"%>
<%@taglib uri="http://java.sun.com/jsp/jstl/functions" prefix="fn"%>
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>JSP Page</title>
</head>
<body>
<c:set var="cadena" value="Esta es una prueba"/>

Replace:${fn:replace(cadena,"a","A")}<br/>
Split: <c:forEach var="num" items="${fn:split(cadena, ' ')}">
<c:out value="${num}"/><br/>
</c:forEach>

Starts With:<c:if test="${fn:startsWith(cadena,'Esta es')}">
Puede ser: Esta es una cadena
</c:if>
</body>
</html>


Ahora tenemos que crear un archivo xml, llamado información.xml a la altura de index.jsp, este archivo tiene el siguiente contenido:
<?xml version="1.0" ?>
<libros>
<libro>
<titulo>Triangulos</titulo>
<autor>Pitagoras</autor>
</libro>
<libro>
<titulo>Java</titulo>
<autor>Alex</autor>
</libro>
<libro>
<titulo>Objective C</titulo>
<autor>Martinez</autor>
</libro>
</libros>


Luego de esto, tenemos que crear una página llamada XML.jsp, que se encargará de mostrarnos la informacion del archivo XML
<%@page contentType="text/html" pageEncoding="UTF-8"%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
"http://www.w3.org/TR/html4/loose.dtd">
<%@taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
<%@taglib uri="http://java.sun.com/jsp/jstl/xml" prefix="x" %>
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>JSP Page</title>
</head>
<body>
<c:import url="informacion.xml" var="archivo" />
<x:parse xml="${archivo}" var="doc" />
<br/>
<x:forEach var="i"
select="$doc/libros/libro">
<x:out select="$i/titulo" />
<br>
<x:out select="$i/autor" />
<br>

</x:forEach>
</body>
</html>



Ahora vamos a crear una pagina llamada SQL.jsp
Este código hace una conexion directa a la base de datos junto con un insert y una consulta que es devuelta a pantalla

El código es el siguiente:

<%@page contentType="text/html" pageEncoding="UTF-8"%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
"http://www.w3.org/TR/html4/loose.dtd">
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
<%@ taglib uri="http://java.sun.com/jsp/jstl/sql" prefix="sql" %>
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>JSP Page</title>
</head>
<body>
<c:set var="nombre" value="otro"/>

<sql:setDataSource
var="ds"
driver="org.apache.derby.jdbc.ClientDriver"
url="jdbc:derby://localhost:1527/ejemplo"
user="usuario1"
password="usuario1"
/>

<sql:transaction dataSource="${ds}">
<sql:update var="actualizar">
INSERT INTO APP.CLIENTES VALUES (5,'${nombre}','direccion1')

</sql:update>

<sql:query var="clientes">
SELECT * FROM APP.CLIENTES
</sql:query>
</sql:transaction>


<table border=1>
<c:forEach var="row" items="${clientes.rows}">
<tr>
<td><c:out value="${row.id}"/></td>
<td><c:out value="${row.nombre}"/></td>
<td><c:out value="${row.direccion}"/></td>
</tr>
</c:forEach>
</table>
</body>
</html>

Nota: El uso de JSTL para conectarnos a una Base de Datos no es recomendado, es mejor tratar de utilizar un patrón MVC.

Si ejecutamos la aplicacón tenemos:

Mapa:
Funciones:

Formatos:

Sql:
XML:

Maven, Http Headers & Jetty

Para este ejemplo estoy utilizando Ubuntu 10.04 LTS y Maven version 2.2.1

La idea de este ejemplo es crear una aplicación web por medio de maven y ejecutarla en un servidor Jetty.





Ejecutamos el siguiente comando de maven

mvn archetype:create -DgroupId=com.ejemplo.app -DartifactId=AplicacionWeb -DarchetypeArtifactId=maven-archetype-webapp


Luego modificamos pom.xml de acuerdo a la siguiente estructura
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.ejemplo.app</groupId>
<artifactId>AplicacionWeb</artifactId>
<packaging>war</packaging>
<version>1.0-SNAPSHOT</version>
<name>AplicacionWeb Maven Webapp</name>
<url>http://maven.apache.org</url>
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>3.8.1</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>servlet-api</artifactId>
<version>2.5</version>
<scope>provided</scope>
</dependency>
</dependencies>
<build>
<finalName>AplicacionWeb</finalName>
<plugins>
<plugin>
<artifactId>maven-compiler-plugin</artifactId>
<configuration>
<source>1.5</source>
<target>1.5</target>
</configuration>
</plugin>
<plugin>
<groupId>org.mortbay.jetty</groupId>
<artifactId>maven-jetty-plugin</artifactId>
</plugin>

</plugins>
</build>
</project>
Luego modificamos index.jsp que se encuentra en la ruta:<RUTA>/AplicacionWeb/src/main/webapp y colocamos el siguiente codigo:

<html>
<body>
<jsp:forward page="pagina1.jsp"/>
</body>
</html>


Despues de esto, creamos una página JSP llamada pagina1.jsp en <RUTA>/AplicacionWeb/src/main/webapp, con el siguiente código:
<%@page contentType="text/html" pageEncoding="UTF-8"%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
"http://www.w3.org/TR/html4/loose.dtd">

<html>
<head>
<title>Pagina1</title>
</head>
<body>
<form name="form1" action="ServletInformacion" method="POST">
Ingresar un valor:<input type="text" name="valor1"/>
<input type="submit" value="Enviar">
</form>
</body>
</html>

Luego de esto, creamos el directorio de fuentes. Para esto vamos al directorio <RUTA>/AplicacionWeb/ y ejecutamos el comando:
mkdir -p src/main/java/com/ejemplo/servlets

y luego entramos a ese directorio, con el comando cd src/main/java/com/ejemplo/servlets

En este directorio, creamos un servlet llamado ServletInformacion.java

package com.ejemplo.servlets;

import java.io.*;
import java.util.Enumeration;
import javax.servlet.*;
import javax.servlet.http.*;

public class ServletInformacion extends HttpServlet {
protected void doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
response.setContentType("text/html;charset=UTF-8");
PrintWriter out = response.getWriter();
try {
out.println("<html>");
out.println("<head>");
out.println("<title>Servlet Headers</title>");
out.println("</head>");
out.println("<body>");
out.println("<h1>Servlet Headers at " + request.getContextPath() + "</h1>");
Enumeration listado = request.getHeaderNames();
out.println("REQUEST");
while (listado.hasMoreElements()) {
String nombre = (String) listado.nextElement();
out.println("<li>" + nombre + ":" + request.getHeader(nombre) + "</li>");
}
out.println("</body>");
out.println("</html>");
} finally {
out.close();
}
}

}


Luego agregamos la informacion del mapeo del Servlet en <RUTA>/AplicacionWeb/src/main/webapp/WEB-INF/web.xml, con lo que web.xml nos queda de la siguiente manera:
<!DOCTYPE web-app PUBLIC
"-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
"http://java.sun.com/dtd/web-app_2_3.dtd" >

<web-app>
<display-name>Archetype Created Web Application</display-name>
<servlet>
<servlet-name>ServletInformacion</servlet-name>
<servlet-class>com.ejemplo.servlets.ServletInformacion</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>ServletInformacion</servlet-name>
<url-pattern>/ServletInformacion</url-pattern>
</servlet-mapping>>
</web-app>

Finalmente ejecutamos
mvn clean install
mvn jetty:run

y entramos a:http://localhost:8080/AplicacionWeb/




Damos click en Enviar