La API de java nos provee de dos clases para manejar fechas: Date y Calendar, ambas en el paquete java.util. Calendar ofrece más opciones y Date está en desuso.
Crear un objeto Calendar:
Calendar cal=Calendar.getInstance();
Esto nos crea un objeto Calendar con los datos del sistema. Para obtener los ditintos campos utilizamos el método get(int field) que nos devuelve un entero. La clase Calendar posee atributos estáticos que representan los distintos campos de una fecha:
cal.get(Calendar.DATE):devuelve el día
cal.get(Calendar.MONTH):devuelve el mes
cal.get(Calendar.YEAR):devuelve el año
Modificar un objeto Calendar:
Para ello recurrimos al método set(int field). Al igual que con get(int fiel) le pasamos como parámetro el campo que queremos modificar. Si lo que queremos es sumar una cantidad a uno de los campos podemos recurrir al método roll(int field,int cantidad), por ejemplo:
cal.roll(Calendar.DATE, -5): resta 5 días.
cal.roll(Calendar.MONTH, 5): suma 5 meses.
Formatear fechas:
Para formatear fechas podemos recurrir a la clase SimpleDateFormat del paquete java.text. El siguiente ejemplo nos muestra cómo usar dicha clase para darle formato a una fecha:
SimpleDateFormat formater=new SimpleDateFormat();
formater.applyPattern("dd/MM/yy");
String fechaFormateada=formater.format(cal.getTime());
¡¡Ojo!!:
La clase Calendar le asigna el valor 0 al mes de enero y no 1, esto hay que tenerlo en cuenta a la hora de manejar fechas
viernes, 30 de enero de 2009
martes, 27 de enero de 2009
Instalacion del plugin SVN en Eclipse
¿QUÉ ES SVN?
SVN es un sistema de control de versiones que nos permite tener un historial de los distintos cambios que hacemos sobre nuestro código y, por tanto, mantener guardado en un lugar centralizado las distintas versiones de nuestros proyectos.
INSTALACIÓN DEL CLIENTE SVN EN ECLIPSE
SVN es un sistema de control de versiones que nos permite tener un historial de los distintos cambios que hacemos sobre nuestro código y, por tanto, mantener guardado en un lugar centralizado las distintas versiones de nuestros proyectos.
INSTALACIÓN DEL CLIENTE SVN EN ECLIPSE
- Vamos a Help->Software Updates->Add Site...
- Introducimos la dirección http://subclipse.tigris.org/update_1.4.x
- Le damos a instalar
- Abrimos la vista de SVN: Window->Show View y escribimos SVN
- En el panel SVN Repositories: Menú contextual->New->Repository Location...
- Introducimos la URL del repositorio y aceptamos
- En la vista Project Explorer: Menú contextual->New->Project
- En el nuevo diálogo elejimos SVN->Checkout Projects from SVN
- En el siguiente diálogo seleccionamos el repositorio del que queremos descargar
- Elejimos el proyecto y aceptamos
- En el siguiente diálogo elejimos el nombre para el proyecto
- En la vista Project Explorer seleccionamos el proyecto: Menú contextual->Team->Share Project...
- En el siguiente diálogo seleccionamos el sistema de versiones SVN.
- Seleccionamos el repositorio
- En el siguiente diálogo seleccionamos el nombre para el proyecto y aceptamos
- Una vez creado nos vamos al proyecto: Menú contextual->Team->Commit...
- Sobre el proyecto: Menú contextual->Team->Disconnect...
- Seguimos los pasos para subir un proyecto
viernes, 23 de enero de 2009
Limpiar la caché del servidor
Cuando estamos realizando muchos cambios en nuestro código, es aconsejable limpiar la caché del servidor de manera eventual porque puede que no esté actualizando dichos cambios y nos lleve a situaciones en las que nuestra aplición no se ejecute como se podría esperar.
jueves, 22 de enero de 2009
Filtros
¿QUÉ SON LOS FILTROS?
Los filtros son clases que nos permiten realizar ciertas operaciones sobre una petición (HttpServletRequest) antes de ser entregada al servlet destino y de la misma manera nos permite realizar ciertas operaciones sobre la respuesta (HttpServletResponse) de un servlet antes de ser entregada al cliente. La siguiente figura nos muestra dicho proceso:
Hay que tener en cuenta que:
Los filtros nos pueden permitir verificar los datos que el usuario envía a la aplicación, darle un formato determinado a esos datos, desviar la petición a otro servlet para que la procese antes de enviar la información al servlet destino, darle formato a la respuesta que envía el servlet, modificar convenientemente la respuesta de un servlet (por ejemplo una imagen, un fichero pdf, etc), etc. Hay dos importantes ventajas que nos ofrecen los filtros:
Los filtros son clases que nos permiten realizar ciertas operaciones sobre una petición (HttpServletRequest) antes de ser entregada al servlet destino y de la misma manera nos permite realizar ciertas operaciones sobre la respuesta (HttpServletResponse) de un servlet antes de ser entregada al cliente. La siguiente figura nos muestra dicho proceso:
Hay que tener en cuenta que:
- Podemos tener más de un filtro para procesar la petición dispuestos en cadena
- Un mismo filtro puede atender las peticiones de más de un servlet
- Un filtro puede procesar únicamente la petición o únicamente la respuesta
Los filtros nos pueden permitir verificar los datos que el usuario envía a la aplicación, darle un formato determinado a esos datos, desviar la petición a otro servlet para que la procese antes de enviar la información al servlet destino, darle formato a la respuesta que envía el servlet, modificar convenientemente la respuesta de un servlet (por ejemplo una imagen, un fichero pdf, etc), etc. Hay dos importantes ventajas que nos ofrecen los filtros:
- Descarga al servlet de realizar ciertas tareas relacionadas con la petición y la respuesta
- Si está adecuadamente diseñado, nos permite reutilizar ese filtro en distintas aplicaciones
- Creamos una clase que implemente la interfaz javax.servlet.Filter
- Implementamos sus métodos
- Damos de alta el filtro en el fichero web.xml
miércoles, 21 de enero de 2009
Uso de Listeners
¿QUÉ ES UN LISTENER?
Un Listener (o escuchador) es una clase que implementa la interfaz Listener y que nos permite realizar ciertas acciones ante un evento determinado. Los eventos que atiende un escuchador son:
¿QUÉ ACCIONES PODRÍAMOS REALIZAR ANTE ESTOS EVENTOS?
Los escuchadores nos permiten inicializar las varibles de aplicación comunes a todos los usuarios (ServletContextListener), inicializar variables de sesión para un usuario (HttpSessionListener), hacer comprobaciones sobre los datos que el usuario envía a la aplicación (ServletRequestListener) o cualquier otra acción que necesitemos.
¿CÓMO SE CREA UN LISTENER?
Un Listener (o escuchador) es una clase que implementa la interfaz Listener y que nos permite realizar ciertas acciones ante un evento determinado. Los eventos que atiende un escuchador son:
- Cuando se inicia la aplicación (se crea el objetos ServletContext) y cuando se termina
- Cuando se inicia una sesión (se crea un objeto HttpSession) y cuando se cierra
- Cuando se realiza una petición (se crea un objeto HttpServletRequest) y cuando se destruye
¿QUÉ ACCIONES PODRÍAMOS REALIZAR ANTE ESTOS EVENTOS?
Los escuchadores nos permiten inicializar las varibles de aplicación comunes a todos los usuarios (ServletContextListener), inicializar variables de sesión para un usuario (HttpSessionListener), hacer comprobaciones sobre los datos que el usuario envía a la aplicación (ServletRequestListener) o cualquier otra acción que necesitemos.
¿CÓMO SE CREA UN LISTENER?
- Creamos una clase que implemente la interfaz Listener
- Implementamos sus métodos
- Lo damos de alta en el fichero web.xml
Esctructura de directorios de una aplicación web
Una aplicación web desarrollada en java tiene una estructura similar a la siguiente:
aplicacion/
.../archivo.html
.../archivo.jsp
.../img/archivo.png
.../css/archivo.css
.../html/otro.html
.../jsps/otro.jsp
-------------------------------------------------------
Las carpetas y documentos anteriores conforman el contenido accesible desde el navegador
-------------------------------------------------------
.../WEB-INF/web.xml(Archivo de despliegue de la aplicaión)
.../WEB-INF/classes/es.cea...(Aquí van las clases de nuestra aplicación)
.../WEB-INF/lib/libreria.jar(Aquí van las librería necesarias para la aplicación)
aplicacion/
.../archivo.html
.../archivo.jsp
.../img/archivo.png
.../css/archivo.css
.../html/otro.html
.../jsps/otro.jsp
-------------------------------------------------------
Las carpetas y documentos anteriores conforman el contenido accesible desde el navegador
-------------------------------------------------------
.../WEB-INF/web.xml(Archivo de despliegue de la aplicaión)
.../WEB-INF/classes/es.cea...(Aquí van las clases de nuestra aplicación)
.../WEB-INF/lib/libreria.jar(Aquí van las librería necesarias para la aplicación)
Colecciones de objetos
Java nos provee de distintos tipos de estructuras para almacenar colecciones de objetas y poder operar sobre dichas colecciones. Entre los más importantes nos encontramos con las listas (List), los mapas (Map) y los conjuntos (Set). Los conjuntos se diferencian de los otros dos en que no pueden tener elementos duplicados (aquí entra en juego la sobreescritura del método equals() para determinar la duplicidad de los objetos).
En los servlets podemos usar el método println(variable_estructura) para imprimir todos los objetos que contiene la estructura (aquí interviene la sobreescritura del método toString() de los objetos almacenados). La forma en que se imprimen es entre corchetes y separados por comas los distintos objetos:
[objeto1,objeto2,...,objetoN]
En los servlets podemos usar el método println(variable_estructura) para imprimir todos los objetos que contiene la estructura (aquí interviene la sobreescritura del método toString() de los objetos almacenados). La forma en que se imprimen es entre corchetes y separados por comas los distintos objetos:
[objeto1,objeto2,...,objetoN]
martes, 20 de enero de 2009
Introducción a las sesiones en los Servlets
Para poder obtener un objeto HttpSession recurrimos al método getSession() del objeto HttpServletRequest. De este modo podemos crear variables de sesión mediante el método setAttribute(clave,valor) del objeto HttpSession y acceder a esas variables con el método getAttribute(clave). El método getAttribute(clave) devuelve un objeto de tipo Object así que es necesario hacer casting al tipo adecuado cuando recuperamos la variable. Ejemplo:
HttpServletRequest req;
req.getSession().setAttribute("nombre","raul"); //Declaramos la variable de sesión
String nombre=(String)req.getSession().getAttribute("nombre"); //Recuperamos la variable
HttpServletRequest req;
req.getSession().setAttribute("nombre","raul"); //Declaramos la variable de sesión
String nombre=(String)req.getSession().getAttribute("nombre"); //Recuperamos la variable
Atajos de teclado en Eclipse I
Eclipse nos provee de una serie de atajos de teclado que facilita nuestro trabajo
- Ctrl+1 sobre un elemento del código (variable, método, atributo, clase,...) nos ofrece sugerencias sobre él.
- Escribir syso y después teclear Ctrl+Espacio nos genera la instrucción System.out.println
- Si pulsamos Ctrl+click sobre cualquier elemento del código nos permite navegar por el código como si de una página web se tratase. Por ejemplo, si hacemos esta operación sobre una variable de tipo Persona declarada en una clase Agenda nos llevaría al código de la clase Persona. Con Alt+flecha izquierda volvemos al código donde ejecutamos Ctrl+click.
- Si estamos tecleando código y pulsamos Ctrl+Espacio nos aparece el diálogo de sugerencia de código para poder autocompletar.
Sobreescritura de métotos desde Eclipse
Eclipse nos provee de las opciones necesarias para sobreescribir o implementar ciertos métodos. Siguiendo con la línea de la anterior entrada, podemos sobreescribir los métodos toString() y equals(Object) de la siguiente manera:
- Elegimos la opción Source->Override/Implements Methods...
- En el diálogo que nos aparece elegimos los métodos que queremos sobreescribir
- Nos aparece el código de los métodos elegidos y sólo queda implementar el código
- Elegimos la opción Source->Generate hashCode() and equals()...
- En el diálogo elegimos los atributos que servirán de criterio para la igualdad
- Se genera en nuestra clase los métodos correspondientes y su código.
- Generate Getters and Setters...
- Generate Constructor using Fields...
Sobreescritura de métotos heredados de Object
Todas las clases en Java (incluidas las que creamos nosotros) heredan implícitamente de la clase Object. De esta clase heredamos los siguientes métodos:
paquete.Clase@direccion
En el caso de las clases de envoltorio este método está sobreescrito para que muestre una cadena con el valor primitivo que encapsula. En nuestras clases podemos sobreescribirlo para que muestre el valor de los atributos que nos interese mostrar en vez de recurrir a métodos getVariable() y tener que transformar la salida en un String. En este ejemplo lo vemos:
public class Persona{
private String nombre;
private Integer edad;
public Persona(String n,Integer e){
nombre=n;
edad=e;
}
@Override
public String toString(){
return "NOMBRE: "+nombre+"\nEDAD: "+edad;
}
public static void main(String[] args){
Persona p1=new Persona("Pepe",new Integer(30));
System.out.println(p1);
}
}
La salida de la anterior clase nos daría como resultado:
NOMBRE: Pepe
EDAD: 30
En el caso de las colecciones de objetos, esto nos permitiría recorrer la colección e imprimir el valor de las variables con sólo llamar a nuestro método toString() sobreescrito.
El otro método que nos puede interesar sobreescribir es el método equals(Object). Este método compara dos objetos y nos devulve true o false en caso de que sean iguales o no. Según como esté implemetado el método en cada clase, los criterios de igualdad variarán. Nos puede interesar en las clases que creamos determinar los criterios a tener en cuenta para establecer esa igualdad sobreescribiendo el método equals(Object). Siguiendo con el ejemplo anterior:
public class Persona{
private String nombre;
private Integer edad;
public Persona(String n,Integer e){
nombre=n;
edad=e;
}
@Override
public String toString(){
return "NOMBRE: "+nombre+"\nEDAD: "+edad;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Person other = (Person) obj;
if (nombre == null) {
if (other.nombre != null)
return false;
} else if (!nombre.equals(other.nombre))
return false;
return true;
}
public static void main(String[] args){
Persona p1=new Persona("Pepe",new Integer(30));
Persona p2=new Persona("Pepe",new Integer(25));
boolean igual=p1.equals(p2);
System.out.println(p1);
System.out.println(p2);
System.out.println("\nEs igual: "+igual);
}
}
El ejemplo anterior nos devolverá que la variable igual es true ya que el criterio de igualdad que hemos definido es el atributo nombre:
NOMBRE: Pepe
EDAD: 30
NOMBRE: Pepe
EDAD: 25
Es igual: true
- toString()
- equals(Object)
- hashCode()
- finalize()
- clone()
paquete.Clase@direccion
En el caso de las clases de envoltorio este método está sobreescrito para que muestre una cadena con el valor primitivo que encapsula. En nuestras clases podemos sobreescribirlo para que muestre el valor de los atributos que nos interese mostrar en vez de recurrir a métodos getVariable() y tener que transformar la salida en un String. En este ejemplo lo vemos:
public class Persona{
private String nombre;
private Integer edad;
public Persona(String n,Integer e){
nombre=n;
edad=e;
}
@Override
public String toString(){
return "NOMBRE: "+nombre+"\nEDAD: "+edad;
}
public static void main(String[] args){
Persona p1=new Persona("Pepe",new Integer(30));
System.out.println(p1);
}
}
La salida de la anterior clase nos daría como resultado:
NOMBRE: Pepe
EDAD: 30
En el caso de las colecciones de objetos, esto nos permitiría recorrer la colección e imprimir el valor de las variables con sólo llamar a nuestro método toString() sobreescrito.
El otro método que nos puede interesar sobreescribir es el método equals(Object). Este método compara dos objetos y nos devulve true o false en caso de que sean iguales o no. Según como esté implemetado el método en cada clase, los criterios de igualdad variarán. Nos puede interesar en las clases que creamos determinar los criterios a tener en cuenta para establecer esa igualdad sobreescribiendo el método equals(Object). Siguiendo con el ejemplo anterior:
public class Persona{
private String nombre;
private Integer edad;
public Persona(String n,Integer e){
nombre=n;
edad=e;
}
@Override
public String toString(){
return "NOMBRE: "+nombre+"\nEDAD: "+edad;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Person other = (Person) obj;
if (nombre == null) {
if (other.nombre != null)
return false;
} else if (!nombre.equals(other.nombre))
return false;
return true;
}
public static void main(String[] args){
Persona p1=new Persona("Pepe",new Integer(30));
Persona p2=new Persona("Pepe",new Integer(25));
boolean igual=p1.equals(p2);
System.out.println(p1);
System.out.println(p2);
System.out.println("\nEs igual: "+igual);
}
}
El ejemplo anterior nos devolverá que la variable igual es true ya que el criterio de igualdad que hemos definido es el atributo nombre:
NOMBRE: Pepe
EDAD: 30
NOMBRE: Pepe
EDAD: 25
Es igual: true
sábado, 17 de enero de 2009
Imprimir variables en JSP
JSP nos permite incrustar código java en cualquier parte dentro de un documento con etiquetas HTML. Para ello debemos encerrar dicho código entre las etiquetas <% %>. Si queremos imprimir el valor de una variable en un punto determinado los hacemos de la siguiente manera:
<%=variable%>
Pero hay una restricción a ello, la variable debe ser un String. Si queremos imprimir el valor de una variable de tipo primitivo debemos primero hacer boxing-encapsular el valor dentro de su clase envoltorio correspondiente- y después usar el método toString() para convertirlo en una cadena.
¡¡Truquito!!
Para ahorrarnos los pasos anteriores podemos sumarle a la variable el valor de una cadena vacía ya que el resultado de esta operación devuelve un String:
<%=variable+""%>
<%=variable%>
Pero hay una restricción a ello, la variable debe ser un String. Si queremos imprimir el valor de una variable de tipo primitivo debemos primero hacer boxing-encapsular el valor dentro de su clase envoltorio correspondiente- y después usar el método toString() para convertirlo en una cadena.
¡¡Truquito!!
Para ahorrarnos los pasos anteriores podemos sumarle a la variable el valor de una cadena vacía ya que el resultado de esta operación devuelve un String:
<%=variable+""%>
viernes, 16 de enero de 2009
Introducción a los Servlets
Un servlet no es más que una clase java capaz de procesar peticiones http por parte de un cliente. Para crear un servlet seguimos los siguientes pasos:
1- En Eclipse, dentro de nuestra aplicación web, en JavaResources: src creamos un nuevo paquete y le damos el nombre que queramos p.e. es.cea
2- Dentro de ese paquete creamos nuestra clase Servlet p.e. Saludo
3- Esa clase debe heredar de HttpServlet y sobreescribir los métodos doGet() y doPost(). Estos métdos se encargan de realizar las operaciones necesarias como respuesta a la solicitud.
¡¡Truquito!!
Cuando heredamos una clase o implementamos una interfaz, podemos ahorrarnos escribir el código de los miembros que queremos sobreescribir de la siguiente manera.
- Abrimos el menú contextual dentro del cuerpo de la declaración de la clase
- Elegimos la opción Source->Override/Implements Methods
- Nos sale un cuadro de diálogo con todos los métodos disponibles
- Marcamos los que queremos implementar y aceptamos
- Ahora aparce en nuestra clase el código con los métodos.
4- Editamos el fichero web.xml de nuestra aplicación y damos de alta nuestra clase en Tomcat.
1- En Eclipse, dentro de nuestra aplicación web, en JavaResources: src creamos un nuevo paquete y le damos el nombre que queramos p.e. es.cea
2- Dentro de ese paquete creamos nuestra clase Servlet p.e. Saludo
3- Esa clase debe heredar de HttpServlet y sobreescribir los métodos doGet() y doPost(). Estos métdos se encargan de realizar las operaciones necesarias como respuesta a la solicitud.
¡¡Truquito!!
Cuando heredamos una clase o implementamos una interfaz, podemos ahorrarnos escribir el código de los miembros que queremos sobreescribir de la siguiente manera.
- Abrimos el menú contextual dentro del cuerpo de la declaración de la clase
- Elegimos la opción Source->Override/Implements Methods
- Nos sale un cuadro de diálogo con todos los métodos disponibles
- Marcamos los que queremos implementar y aceptamos
- Ahora aparce en nuestra clase el código con los métodos.
4- Editamos el fichero web.xml de nuestra aplicación y damos de alta nuestra clase en Tomcat.
jueves, 15 de enero de 2009
Procesar peticiones en JSP
CREAR PROYECTO DE TRABAJO
Para la clase de hoy se creará un nuevo proyecto en Eclipse:
1- Crear un nuevo proyecto web dinámico llamado cea01.
2- Creamos dentro de WebContent el fichero bienvenida.jsp
3- Desplegamos el fichero en Tomcat
4- Accedemos a la URL http://localhost:8090/cea01/bienvenida.jsp para comprobarlo.
TEORIA: OBJETOS IMPLÍCITOS EN JSP Y SERVLETS
Los objetos mostrados en la anterior tabla son implícitos ya que no es necesario instanciarlos, la máquina virtual se encarga de ello, y así podemos hacer un uso directo de sus métodos y atributos. Cada uno de esos objetos se utilizan dentro de un contexto:
A) EVENTO
Un evento es toda acción que el usuario realiza sobre nuestra página y que genera URL más sus parámetros (si los hay), es decir, pulsar sobre un botón, un enlace, escribir directamente una URL, enviar un formulario,etc. Los eventos son manejados en JSP mediante el objeto request. El esquema siguiente muestra dicho proceso:
De esta manera, cada vez que se genera un evento, se crea un nuevo objeto request que se encarga de procesar dicho evento y que se destruye en el momento que procesa los datos que recibe. Para procesar los datos tenemos dos métodos:
-String getParameter(String parámetro): nos devuelve el valor del parámetro indicado
-String getRequestURL(): nos devuelve la URL que recibe los parámetros(el fichero)
Para entender estos dos métodos hay que tener en cuenta que el formato de petición de una URL con parámetros es: url_destino?parametro1=valor1¶metro2=valor2&... Por ejemplo:
bienvenida.jsp?nombre=raul&edad=27. Usando los dos métodos mencionados obtendríamos:
getParameter(“nombre”) devuelve “raul”
getParameter(“edad”) devuelve “27”
getRequestURL() devuelve “bienvenida.jsp”
B) SESIÓN
Este contexto se produce desde que un usuario accede a nuestra aplicación hasta que la abandona. Las sesiones son procesadas en JSP mediante el objeto session. Por tanto, se creará un nuevo objeto session por cada usuario que acceda a la aplicación y se destruirá dicho objeto cuando el usuario abandone la aplicación. Con respecto a esto hay que tener en cuenta que si un usuario accede a una aplicación desde dos navegadores distintos se crean dos sesiones ya que el usuario de nuestra aplicación es el programa navegador y no la persona que lo utiliza. En resumen, el objeto session nos permite encapsular aquellos recursos que podamos necesitar durante la sesión. Para ello tenemos los siguientes métodos:
-void setAttribute(String clave,String valor): definimos un parámetro y su valor
-String getAttribute(String clave): obtenemos el valor de un parámetro
C) APLICACIÓN
Este contexto se produce por la propia aplicación en sí y se mantiene mientras la aplicación se ejecute en el servidor. Por tanto, sólo hay un objeto application por cada aplicación. Este objeto encapsula todos los recursos necesarios durante la ejecución de nuestro programa.
EN RESUMEN:
- Los recursos comunes a todos los usuarios son manejados por application
- Los recursos comunes a un usuario durante su sesión son manejados por session
- Los recursos propios de un evento son manejados por request
- Sólo hay un objeto application por cada aplicación
- Hay un objeto session por cada usuario de la aplicación
- Se genera un objeto request por cada evento
Para la clase de hoy se creará un nuevo proyecto en Eclipse:
1- Crear un nuevo proyecto web dinámico llamado cea01.
2- Creamos dentro de WebContent el fichero bienvenida.jsp
3- Desplegamos el fichero en Tomcat
4- Accedemos a la URL http://localhost:8090/cea01/bienvenida.jsp para comprobarlo.
TEORIA: OBJETOS IMPLÍCITOS EN JSP Y SERVLETS
Los objetos mostrados en la anterior tabla son implícitos ya que no es necesario instanciarlos, la máquina virtual se encarga de ello, y así podemos hacer un uso directo de sus métodos y atributos. Cada uno de esos objetos se utilizan dentro de un contexto:
A) EVENTO
Un evento es toda acción que el usuario realiza sobre nuestra página y que genera URL más sus parámetros (si los hay), es decir, pulsar sobre un botón, un enlace, escribir directamente una URL, enviar un formulario,etc. Los eventos son manejados en JSP mediante el objeto request. El esquema siguiente muestra dicho proceso:
De esta manera, cada vez que se genera un evento, se crea un nuevo objeto request que se encarga de procesar dicho evento y que se destruye en el momento que procesa los datos que recibe. Para procesar los datos tenemos dos métodos:
-String getParameter(String parámetro): nos devuelve el valor del parámetro indicado
-String getRequestURL(): nos devuelve la URL que recibe los parámetros(el fichero)
Para entender estos dos métodos hay que tener en cuenta que el formato de petición de una URL con parámetros es: url_destino?parametro1=valor1¶metro2=valor2&... Por ejemplo:
bienvenida.jsp?nombre=raul&edad=27. Usando los dos métodos mencionados obtendríamos:
getParameter(“nombre”) devuelve “raul”
getParameter(“edad”) devuelve “27”
getRequestURL() devuelve “bienvenida.jsp”
B) SESIÓN
Este contexto se produce desde que un usuario accede a nuestra aplicación hasta que la abandona. Las sesiones son procesadas en JSP mediante el objeto session. Por tanto, se creará un nuevo objeto session por cada usuario que acceda a la aplicación y se destruirá dicho objeto cuando el usuario abandone la aplicación. Con respecto a esto hay que tener en cuenta que si un usuario accede a una aplicación desde dos navegadores distintos se crean dos sesiones ya que el usuario de nuestra aplicación es el programa navegador y no la persona que lo utiliza. En resumen, el objeto session nos permite encapsular aquellos recursos que podamos necesitar durante la sesión. Para ello tenemos los siguientes métodos:
-void setAttribute(String clave,String valor): definimos un parámetro y su valor
-String getAttribute(String clave): obtenemos el valor de un parámetro
C) APLICACIÓN
Este contexto se produce por la propia aplicación en sí y se mantiene mientras la aplicación se ejecute en el servidor. Por tanto, sólo hay un objeto application por cada aplicación. Este objeto encapsula todos los recursos necesarios durante la ejecución de nuestro programa.
EN RESUMEN:
- Los recursos comunes a todos los usuarios son manejados por application
- Los recursos comunes a un usuario durante su sesión son manejados por session
- Los recursos propios de un evento son manejados por request
- Sólo hay un objeto application por cada aplicación
- Hay un objeto session por cada usuario de la aplicación
- Se genera un objeto request por cada evento
miércoles, 14 de enero de 2009
Instalación de herramintas
1- Creación del presente blog desde blogger.com. La direccion del blog es
raultinoco-cea2.blogspot.com.
2- Crear una cuenta en del.icio.us para gestionar marcadores y hacer seguimiento de los distintos enlaces que visitamos cuando investigamos a cerca de un tema. La cueanta creada es ul2mac.
3- Crear un sistema de subversión en code.google.com para poder subir el código de los ejercicios propuestos. Para ello sólo es necesario tener una cuenta con gmail. El sistema de subversión creado es raultinoco-cea2.
4- Instalación de Apache Tomcat 6.0: para ello se ha creado una carpeta servers dentro de la carpeta JAVA y en su interior se ha descomprimido la estructura de ficheros de Tomcat. Posteriormente se ha creado el usuario "tomcat" con el "manager" editando el fichero tomcat-users.xml de la carpeta conf en el directorio de Tomcat y se ha añadido la variable de entorno JAVA_HOME con la URI de la carpeta donde se encuentra Tomcat.
5- Instalación del IDE eclipse. Para ello se siguieron los siguientes pasos:
a) Descomprimir en la carpeta JAVA el fichero con la estructura de directorios de dicho IDE.
b) Crear la carpeta C:\workspace.
c) La primera vez que abrimos eclipse asignamos la carpeta anterior como carpeta de trabajo
por defecto y activamos la casilla para que no vuelva a preguntar el espacio de trabajo.
6- Agregar en Eclipse el servidor web Apache Tomcat. Para ello se siguieron los siguientes pasos:
a) Abrir eclipse.
b) Agregar la vista de servidores: Window->Show View->Servers.
c) Dentro de la pestaña Servers que ahora nos aperece abrir el menú contextual y seleccionar:
New->Server.
d) En el nuevo cuadro de diálogo elegir Apache->Tomcat v6.0 Server y pulsar siguiente.
e) En el nuevo cuadro de diáogo indicar la ruta donde se encuntra Tomcat, en nuestro caso
está en C:\...\JAVA\servers\apache-tomcat-6.0.18.
f) Cambiar el JRE con el que trabajamos por JDK. Para ellos pulsamos sobre Installed JREs,
en el nuevo diálo pulsamos sobre Add, en el nuevo diálogo elegimos Standard VM y
pulsamos siguiente, seleccionamos la ruta del JDK: C:\Archivos de Programas\Java\jdk-xx,
le damos a aceptar y seleccionamos el JDK como JRE por defecto.
g) Ya nos aparece en la vista Servers nuestro Tomcat. Para iniciarlo abrimos el menú
contextual sobre él y pulsamos Start.
7- Instalación del plagin JBoss en eclipse. Para ello descomprimimos el fichero. Nos aparecen dos carpetas: plugins y features. El contenido de plugins lo copiamos al directorio plugins de eclipse y el contenido de featrues lo copiamos dentro del directorio features de eclipse. Arrancamos eclipse y comprobamos en Window->Show View->Other que nos aparece JBoss.
8- Crear el proyecto holaMundo en eclipse y desplegarlo en Tomcat. Para ello:
a) Pulsamos sobre File->New->Dynamic Web Project.
b) En el diálogo le damos el nombre holaMundo y en la sección Target Runtime
seleccionamos Apache v6.0 Tomcat. Pulsamos siguiente.
c) En el siguiente diálogo dejamos los valores por defecto y pulsamos sobre finalizar
d) En la vista Project Explorer de la ventana principal desplegamos el árbol de directorios de
nuestro proyecto y sobre la carpeta WebContent abrimos el menú contextual y elegimos
New->JSP. En el cuadro de diálogo le damos el nombre index y aceptamos.
e) Se nos abre el fichero e introducimos el código JSP.
f) Para desplegar nuestro proyecto abrimos el menú contextual sobre el servidor Tomcat y
seleccionamos Add and Remove Projects. En el nuevo diálogo elegimos el proyecto que
hemos creado lo añadimos y aceptamos.
g) Para ver el proyecto abrimos el explorador he introducimos la ruta siguiente:
http://localhost:8080/holaMundo/index.jsp?nombre=loquesea.
raultinoco-cea2.blogspot.com.
2- Crear una cuenta en del.icio.us para gestionar marcadores y hacer seguimiento de los distintos enlaces que visitamos cuando investigamos a cerca de un tema. La cueanta creada es ul2mac.
3- Crear un sistema de subversión en code.google.com para poder subir el código de los ejercicios propuestos. Para ello sólo es necesario tener una cuenta con gmail. El sistema de subversión creado es raultinoco-cea2.
4- Instalación de Apache Tomcat 6.0: para ello se ha creado una carpeta servers dentro de la carpeta JAVA y en su interior se ha descomprimido la estructura de ficheros de Tomcat. Posteriormente se ha creado el usuario "tomcat" con el "manager" editando el fichero tomcat-users.xml de la carpeta conf en el directorio de Tomcat y se ha añadido la variable de entorno JAVA_HOME con la URI de la carpeta donde se encuentra Tomcat.
5- Instalación del IDE eclipse. Para ello se siguieron los siguientes pasos:
a) Descomprimir en la carpeta JAVA el fichero con la estructura de directorios de dicho IDE.
b) Crear la carpeta C:\workspace.
c) La primera vez que abrimos eclipse asignamos la carpeta anterior como carpeta de trabajo
por defecto y activamos la casilla para que no vuelva a preguntar el espacio de trabajo.
6- Agregar en Eclipse el servidor web Apache Tomcat. Para ello se siguieron los siguientes pasos:
a) Abrir eclipse.
b) Agregar la vista de servidores: Window->Show View->Servers.
c) Dentro de la pestaña Servers que ahora nos aperece abrir el menú contextual y seleccionar:
New->Server.
d) En el nuevo cuadro de diálogo elegir Apache->Tomcat v6.0 Server y pulsar siguiente.
e) En el nuevo cuadro de diáogo indicar la ruta donde se encuntra Tomcat, en nuestro caso
está en C:\...\JAVA\servers\apache-tomcat-6.0.18.
f) Cambiar el JRE con el que trabajamos por JDK. Para ellos pulsamos sobre Installed JREs,
en el nuevo diálo pulsamos sobre Add, en el nuevo diálogo elegimos Standard VM y
pulsamos siguiente, seleccionamos la ruta del JDK: C:\Archivos de Programas\Java\jdk-xx,
le damos a aceptar y seleccionamos el JDK como JRE por defecto.
g) Ya nos aparece en la vista Servers nuestro Tomcat. Para iniciarlo abrimos el menú
contextual sobre él y pulsamos Start.
7- Instalación del plagin JBoss en eclipse. Para ello descomprimimos el fichero. Nos aparecen dos carpetas: plugins y features. El contenido de plugins lo copiamos al directorio plugins de eclipse y el contenido de featrues lo copiamos dentro del directorio features de eclipse. Arrancamos eclipse y comprobamos en Window->Show View->Other que nos aparece JBoss.
8- Crear el proyecto holaMundo en eclipse y desplegarlo en Tomcat. Para ello:
a) Pulsamos sobre File->New->Dynamic Web Project.
b) En el diálogo le damos el nombre holaMundo y en la sección Target Runtime
seleccionamos Apache v6.0 Tomcat. Pulsamos siguiente.
c) En el siguiente diálogo dejamos los valores por defecto y pulsamos sobre finalizar
d) En la vista Project Explorer de la ventana principal desplegamos el árbol de directorios de
nuestro proyecto y sobre la carpeta WebContent abrimos el menú contextual y elegimos
New->JSP. En el cuadro de diálogo le damos el nombre index y aceptamos.
e) Se nos abre el fichero e introducimos el código JSP.
f) Para desplegar nuestro proyecto abrimos el menú contextual sobre el servidor Tomcat y
seleccionamos Add and Remove Projects. En el nuevo diálogo elegimos el proyecto que
hemos creado lo añadimos y aceptamos.
g) Para ver el proyecto abrimos el explorador he introducimos la ruta siguiente:
http://localhost:8080/holaMundo/index.jsp?nombre=loquesea.
Suscribirse a:
Entradas (Atom)