Nos creamos nuestra prueba.jsp y en el form le ponemos la ruta del servlet.
prueba.jsp

RecogeForm.java

Para que una prueba unitaria sea buena se deben cumplir los siguientes requisitos:
Se recomienda seguirlos o de lo contrario las pruebas pierden parte de su función.Pero no es obligatorio.
Supongamos que tenemos una clase existente Ventana y queremos añadirle funcionalidad para que muestre un borde alrededor. Podemos crear una subclase VentanaConBorde que herede de Ventana.
Hasta aquí todo bien, pero supongamos que surge la necesidad de crear una ventana que muestre un pequeño botón de ayuda con un signo de interrogación (?) en su parte superior. Entonces tenemos las siguientes opciones:
Problema: No cubre la necesidad de tener ventanas con bordes y botón de ayuda a la vez.
Problema: No tenemos una ventana con botón de ayuda y sin borde.
Problema: Con este ejemplo tendríamos cuatro clases: Ventana, VentanaConBorde, VentanaConBotonDeAyuda y VentanaConBordeYBotonDeAyuda; con tres funcionalidades tendríamos ocho clases y con cuatro, ¡dieciséis!
El patrón Decorator soluciona este problema de una manera mucho más sencilla y extensible.
Se crea a partir de Ventana la subclase abstracta VentanaDecorator y, heredando de ella, BordeDecorator y BotonDeAyudaDecorator. VentanaDecorator encapsula el comportamiento de Ventana y utiliza composición recursiva para que sea posible añadir tantas "capas" de Decorators como se desee. Podemos crear tantos Decorators como queramos heredando de VentanaDecoratorEjemplo:
abstract class Componente
{
abstract public void Operacion();
}
class ComponenteConcreto extends Componente
{
public void Operacion()
{
System.out.println("ConcreteComponent.Operation()");
}
}
abstract class Decorator extends Componente
{
protected Componente componente;
public void SetComponente(Componente component)
{
this.componente = component;
}
public void Operacion()
{
if (componente != null) componente.Operacion();
}
}
class DecoradorConcretoA extends Decorator
{
private String estadoAgregado;
public void Operacion()
{
super.Operacion();
estadoAgregado = "Nuevo estado";
System.out.println("DecoradorConcretoA.Operacion()");
}
}
class DecoradorConcretoB extends Decorator
{
public void Operacion()
{
super.Operacion();
AgregarComportamiento();
System.out.println("DecoradorConcretoB.Operacion()");
}
void AgregarComportamiento()
{
System.out.println("comportamiento añadido B");
}
}
public class Cliente
{
public static void main(String[] args)
{
ComponenteConcreto c = new ComponenteConcreto();
DecoradorConcretoA d1 = new DecoradorConcretoA();
DecoradorConcretoB d2 = new DecoradorConcretoB();
d1.SetComponente(c);
d2.SetComponente(d1);
d2.Operacion();
}
}
Las etiquetas JSP son poderosas y encapsulan tareas que serían difíciles o llevarián mucho tiempo de programar.Los lenguajes de script que tenemos disponibles dependen del motor JSP que estemos usando. Con la implementación JSP de Sun, debemos usar el lenguaje Java como lenguaje de script, pero otros motores de JSP de terceras partes podrían incluir soporte para otros lenguajes.
Las etiquetas JSP tienen diferentes categorías:
Comentarios: <%-- mi comentario --%>
Declaraciones: se utiliza para declarar variables de tipos simples,objetos y métodos. .Ejemplo: <%! int contador = 0; %>. La sintaxis es puro Java y se continua con la vieja regla de "declarar antes de usar".
Expresiones: al procesar la página la salida es el valor de la expresión delimitada por <%= %>, por ejemplo podemos insertar la expresión dentro de una línea HTML típica
& ltp>La cuenta es: <%=contador%> <p>El cuadrado de la cuenta es: <%=cuadrado( contador )%> <%-- Llamada a método --%>
Scriptlets: un conjunto de instrucciones Java. Formato: <% scriptlet %>. Ejemplo:
<%! int base = 5, altura = 7 ; %> <% base * altura / 2.0; new java.util.Date(); %> <BR> Hola HTML <% System.out.println( "de regreso a scriplets" ); base + altura; %>
Directivas: su sintaxis general es <%@ directiva {atributo ="valor"} %> dónde la directiva debe tener al menos un atributo:
Directivas page: en función del atributo utilizado sirven para la configuración general: importar clases, definir tipo MIME, etc.
<%@ page import="paquete.clase" %> <%@ page contentType="tipo MIME" %>
Para contentType los valores por defecto son contentType="text/html; charset=iso-8859-1".
Algunos atributos:
import="package.*,clase.class" Sirve para importar paquetes y clases.
session="true|false" Por defecto es true. Indica si mantiene atributos de sesión para la página.
isThreadSafe="true|false" Por defecto es true. Si es true cada petición corre en un hilo y por tanto el procesador maneja las peticiones de forma asíncrona ("simultáneamente"). Con false se gestionan las peticiones en un hilo (una por una).
info="text" Información de la página a la que se puede acceder a través del método Servlet.getServletInfo()
errorPage="pagina_error". Página que manejará las excepciones.
isErrorPage="true|false". Indica si es una página que manejará errores.
Ejemplos:
<%@ page import=”com.myco.*” buffer=”26k” errorPage=”/oops.jsp”%>
Para reenviar una excepción a una página tiene: <%@ page errorPage="07_errorPage.jsp"%> En la página de error (07_errorPage.jsp) tenemos una forma de capturar el error por medio del objeto implícito "exception":
<%@ page isErrorPage="true" %>
<html>
<head><title>Ejemplo de errorPage
<body>
<h1>Se ha producido un error
<p>Error: <%= exception %>
Esta página capta las excepciones. No capta los errores debidos a fallos de enlace (URL).
Directivas include: se inserta un fichero en el lugar de la directiva. Matiz: se inserta el fichero, no su valor o resultado. Utiles, entre otras cosas, para insertar código HTML o JSP que se repite. La URL debe ser relativa. Ejemplo:
<%@ include file="cabecera.html" %>
Directivas Taglib: indica la referencia a la librería de etiquetas definidas por el programador (etiquetas personalizadas). El motor JSP utiliza esta librería para saber como interpretar las etiquetas personalizadas de la página JSP.Ejemplo:
<%@ taglib uri="URI_de_librería" prefix="prefijo_de_etiquetas" %>
URI es el descriptor único de la librería. No tiene valor por defecto. Si no se especifica aparece una excepción. El prefijo es el prefijo en la expresión prefijo:etiqueta, que sirve para definir la etiqueta personalizada. Cuando el motor de JSP se encuentra en la página con la expresión prefijo_de_etiquetas:etiqueta, entonces se dirige a la librería señalada en URI para interpretar la etiqueta. Las etiquetas personalizadas son importantes en el manejo de JSP.
Acciones: realizan una tarea en el momento en que se solicita la página. Sirven para acceder a beans, etc. La acción de inclusión, a diferencia de la directiva de inclusión, implica la sustitución por el valor o resultado del archivo en el momento de la petición. Ejemplo:
<jsp:include page="también una URL relativa" flush="true"/>
Otra acción es jsp:forward, que tiene el mismo comportamiento que javax.servlet.RequestDispatcher. Su sintaxis admite (o no) parámetros. La ejecución de la página invocante se detiene para resolver el forward. Sintaxis:
<jsp:forward page="también una URL relativa">
<jsp:param name="nombre_parametro" value="valor" />
Para entender el funcionamiento básico de JBoss Seam debes familiarizarte con dos conceptos: Contexto y Componente.
Un componente es un objeto con estado (normalmente stateful session beans). Una instancia de un componente vive en un contexto y se le asigna un nombre en dicho contexto.
Para asociar la instancia de un componente al nombre de dicho componente en un contexto Seam proporciona el mecanismo de Bijection
Bijection = Injection + Outjection
El mecanismo de injection permite a un componente A obtener de un contexto una referencia a una
instancia de un componente B, haciendo que el contenedor de aplicaciones ”inyecte” el componente B en una variable del componente A.
El mecanismo de outjection permite que un componente B esté disponible en un contexto para poder ser inyectado en un componente A.
Es decir, mediante outjection se toma una instancia de un componente y se deposita en un contexto
y mediante injection se toma una instancia de un componente de un contexto y se asocia a una
variable de otro componente.
A diferencia del mecanismo de Injection, el mecanismo de Bijection es:
Se puede entender por una conversación en Seam algo muy parecido de lo que hacemos cuando conversamos entre personas.
Existe un lugar (AplicationContext), un tiempo (SessionContext) y después una serie de objetos implicados en la conversación. Entre los objetos implicados en la conversación se encuentra el usuario, que participa a través de eventos, de tipo:
Lanzamos la tarea seam-gen>setup para configurar la información del archivo seam-gen/build.properties:
Nos irá saliendo una ventanitas que tendremos que meter la siguiente información:
Ya tenemos creado las propiedades de nuesta proyecto nuevo
Lanzamos la tarea seam-gen>new-project para generar el proyecto nuevo en el workspace indicado anteriormente y lo abrimos con eclipse.File>new project>java project>create project from existing source>seleccionamos nuestro proyecto en el workspace y le ponemos de nombre al proyecto.
Localizamos el archivo de ant:build.xml de nuestro nuevo proyecto y lo arrastramos a la ventanita de Ant, y a continuación lanzamos la tarea deploy.
Arrancamos nuestro jboss a través de la ventanita servers de nuestro eclipse. Seleccionamos y click en start y cuando acabe de arrancar la aplicación podemos verla en el navegador en la dirección: http://localhost:8080/nombre proyecto dandole al deploy del Ant de nuestro proyecto o al explode(esto esta explicado la diferencia en otro apartado)
Para crearnos las clases(entidades) utilizamos new-entity del archivo build.xml de seam-gen y se nos aparecera 3 ventanitas :
Enlas clase que se crean se ven los import de las etiquetas del api de persistencia. Así como un validador de HIbernate: org.hibernate.validator.Length .