miércoles, 1 de septiembre de 2010
Spring Framework, Hibernate y Maven en 4 pasos
Para este ejemplo estoy usando Ubuntu 10.04, Maven y una base de datos MySQL con el esquema test.
Creamos un schema en la base de datos con un tabla:
create database ejemplo;
use ejemplo;
create table producto(
id int not null,
nombre varchar(20),
valor double,
PRIMARY KEY(id));
https://cds.sun.com/is-bin/INTERSHOP.enfinity/WFS/CDS-CDS_Developer-Site/en_US/-/USD/ViewProductDetail-Start?ProductRef=7089-jta-1.0.1B-mr-class-oth-JSpec@CDS-CDS_Developer
mvn install:install-file -Dfile=jta-1_0_1B-classes.zip -DgroupId=javax.transaction -DartifactId=jta -Dversion=1.0.1B -Dpackaging=jar
Paso 1) Creación y Configuración de proyecto de Maven
Creacion de proyecto Maven
mvn archetype:create -DarchetypeGroupId=org.apache.maven.archetypes -DgroupId=com.ejemplo -DartifactId=proyecto1
Luego abrimos pom.xml y agregamos dependencias, repositories y plugins a nuestro archivo de configuracion de maven de tal manera que quede de la siguiente manera
<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/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.ejemplo</groupId>
<artifactId>proyecto1</artifactId>
<version>1.0-SNAPSHOT</version>
<packaging>jar</packaging>
<name>proyecto1</name>
<url>http://maven.apache.org</url>
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
</properties>
<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<configuration>
<source>1.5</source>
<target>1.5</target>
</configuration>
</plugin>
</plugins>
</build>
<repositories>
<repository>
<id>JBoss repository</id>
<url>http://repository.jboss.com/maven2/</url>
</repository>
<repository>
<id>Java.Net</id>
<url>http://download.java.net/maven/2/</url>
</repository>
</repositories>
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>3.8.1</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>javax.persistence</groupId>
<artifactId>persistence-api</artifactId>
<version>1.0</version>
<scope>compile</scope>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring</artifactId>
<version>2.5.6</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-core</artifactId>
<version>2.5.5</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>2.5.5</version>
</dependency>
<dependency>
<groupId>cglib</groupId>
<artifactId>cglib</artifactId>
<version>2.2</version>
</dependency>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.9</version>
</dependency>
<dependency>
<groupId>hibernate</groupId>
<artifactId>hibernate3</artifactId>
<version>3.2.3.GA</version>
</dependency>
<dependency>
<groupId>hibernate-annotations</groupId>
<artifactId>hibernate-annotations</artifactId>
<version>3.3.0.GA</version>
</dependency>
<dependency>
<groupId>hibernate-commons-annotations</groupId>
<artifactId>hibernate-commons-annotations</artifactId>
<version>3.0.0.GA</version>
</dependency>
<dependency>
<groupId>javax</groupId>
<artifactId>javaee-api</artifactId>
<version>6.0</version>
</dependency>
<dependency>
<groupId>dom4j</groupId>
<artifactId>dom4j</artifactId>
<version>1.6.1</version>
</dependency>
<dependency>
<groupId>commons-logging</groupId>
<artifactId>commons-logging</artifactId>
<version>1.1.1</version>
</dependency>
<dependency>
<groupId>commons-collections</groupId>
<artifactId>commons-collections</artifactId>
<version>3.2.1</version>
</dependency>
<dependency>
<groupId>antlr</groupId>
<artifactId>antlr</artifactId>
<version>2.7.7</version>
</dependency>
<dependency>
<groupId>log4j</groupId>
<artifactId>log4j</artifactId>
<version>1.2.12</version>
</dependency>
</dependencies>
</project>
Luego ejecutamos mvn clean install
mkdir -p src/main/java/com/ejemplo/negocio/model
mkdir -p src/main/java/com/ejemplo/negocio/util
mkdir -p src/main/java/com/ejemplo/negocio/dao
mkdir -p src/main/java/com/ejemplo/negocio/bo
mkdir -p src/main/java/com/ejemplo/negocio/dao/impl
mkdir -p src/main/java/com/ejemplo/negocio/bo/impl
mkdir -p src/main/java/resources
Paso 2)Archivos de configuración del proyecto
En este paso vamos a crear:
- Archivo de propiedades
- DataSource.xml
- Hibernate.xml
- BeanLocations.xml
En el directorio resources de main del proyecto de maven, vamos a crear un archivo de propiedades llamado database.properties, el cual tendrá informacion relacionada a la base de datos a la cual nos vamos a conectar:
jdbc.driverClassName=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/ejemplo
jdbc.username=root
jdbc.password=root
Luego creamos un archivo llamado DataSource.xml, el cual tendra información para la fuente de datos de la aplicación, en base al archivo de propiedades antes creado:
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-2.5.xsd">
<bean
class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
<property name="location">
<value>database.properties</value>
</property>
</bean>
<bean id="dataSource"
class="org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name="driverClassName" value="${jdbc.driverClassName}" />
<property name="url" value="${jdbc.url}" />
<property name="username" value="${jdbc.username}" />
<property name="password" value="${jdbc.password}" />
</bean>
</beans>
Una vez hecho esto tenemos que crear el archivo Hibernate.xml, que usará la información de DataSource para la configuración de hibernate.
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-2.5.xsd">
<bean id="sessionFactory"
class="org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean">
<property name="dataSource">
<ref bean="dataSource"/>
</property>
<property name="hibernateProperties">
<props>
<prop key="hibernate.dialect">org.hibernate.dialect.MySQLDialect</prop>
<prop key="hibernate.show_sql">true</prop>
</props>
</property>
<property name="annotatedClasses">
<list>
<value>com.ejemplo.negocio.model.Producto</value>
</list>
</property>
</bean>
</beans>
Finalmente, tenemos que crear el archivo BeanLocations.xml para indicarle a Spring como se va a conectar a la base de datos y en que paquetes estan los recursos que usará la aplicación:
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-2.5.xsd">
<!-- Database Configuration -->
<import resource="DataSource.xml"/>
<import resource="Hibernate.xml"/>
<!-- Auto scan the components -->
<context:component-scan
base-package="com.ejemplo.negocio" />
</beans>
Paso 3) Creacion de clases.
En este paso vamos a crear:
1.Mapeo a la base de datos.
2.Data Access Objects
3.Business Objects
Primeramente debemos crear una clase padre, encargada de utilizar la anotación Autowired.
Creamos el archivo SoporteHibernateDao en la ruta src/main/java/com/ejemplo/negocio/util
package com.ejemplo.negocio.util;
import org.hibernate.SessionFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.orm.hibernate3.support.HibernateDaoSupport;
public abstract class SoporteHibernateDao extends HibernateDaoSupport{
@Autowired
public void metodoSoporte(SessionFactory sessionFactory){
setSessionFactory(sessionFactory);
}
}
Luego de hecho esto, vamos a crear una clase utilitaria que nos permita recuperar los beans del contexto de hibernate, esta clase se llama SpringContext y va dentro del archivo SpringContext.java que se encontrará guardado en la ruta:src/main/java/com/ejemplo/negocio/util
package com.ejemplo.negocio.util;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class SpringContext{
private static ApplicationContext contexto;
private static SpringContext instancia;
private final static String ARCHIVO_CONF = "BeanLocations.xml";
public static SpringContext getInstance() {
if (null == instancia) {
instancia = new SpringContext();
contexto = new ClassPathXmlApplicationContext(ARCHIVO_CONF);
}
return instancia;
}
public Object getBean(String nombreBean) {
return contexto.getBean(nombreBean);
}
}
Dentro del directorio src/main/java/com/ejemplo/negocio/model, creamos un archivo con la clase llamada Producto.Esta clase se encuentra mapeada por medio de anotaciones a la tabla producto de la Base de Datos, es decir:
package com.ejmplo.negocio.model;
import java.io.Serializable;
import javax.persistence.Basic;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.NamedQueries;
import javax.persistence.NamedQuery;
import javax.persistence.Table;
@Entity
@Table(name = "producto")
@NamedQueries({
@NamedQuery(name = "Producto.findAll", query = "SELECT p FROM Producto p"),
@NamedQuery(name = "Producto.findById", query = "SELECT p FROM Producto p WHERE p.id = :id"),
@NamedQuery(name = "Producto.findByNombre", query = "SELECT p FROM Producto p WHERE p.nombre = :nombre"),
@NamedQuery(name = "Producto.findByValor", query = "SELECT p FROM Producto p WHERE p.valor = :valor")})
public class Producto implements Serializable {
private static final long serialVersionUID = 1L;
@Id
@Basic(optional = false)
@Column(name = "id")
private Integer id;
@Column(name = "nombre")
private String nombre;
@Column(name = "valor")
private Double valor;
public Producto() {
}
public Producto(Integer id, String nombre, Double valor){
this.id=id;
this.nombre=nombre;
this.valor=valor;
}
public Producto(Integer id) {
this.id = id;
}
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getNombre() {
return nombre;
}
public void setNombre(String nombre) {
this.nombre = nombre;
}
public Double getValor() {
return valor;
}
public void setValor(Double valor) {
this.valor = valor;
}
}
Una vez hecho esto, debemos crear la interface DAO, para esto creamos el archivo ProductoDao.java en src/main/java/com/ejemplo/negocio/dao, con el siguiente código:
package com.ejemplo.negocio.dao;
import com.ejemplo.negocio.model.Producto;
import java.util.List;
public interface ProductoDao{
void save(Producto producto);
void delete(Producto producto);
Producto findById(Integer id);
List<Producto> findAll();
}
Luego de creado esto, debemos implementar esta interface. Para eso creamos el archivo llamado ProductoDaoImpl.java, en la ruta src/main/java/com/ejemplo/negocio/dao/impl, con el siguiente código:
package com.ejemplo.negocio.dao.impl;
import com.ejemplo.negocio.dao.ProductoDao;
import com.ejemplo.negocio.model.Producto;
import com.ejemplo.negocio.util.SoporteHibernateDao;
import java.util.List;
import org.springframework.stereotype.Repository;
@Repository("productoDao")
public class ProductoDaoImpl extends SoporteHibernateDao implements ProductoDao{
public void save(Producto producto){
getHibernateTemplate().save(producto);
}
public void delete(Producto producto){
getHibernateTemplate().delete(producto);
}
public Producto findById(Integer id){
String[] nombreParametros={"id"};
Object[] parametros={id};
return (Producto)(getHibernateTemplate().findByNamedQueryAndNamedParam("Producto.findById",nombreParametros,parametros).get(0));
}
public List<Producto> findAll(){
return (List<Producto>)getHibernateTemplate().findByNamedQuery("Producto.findAll");
}
}
Hecho, esto tenemos que crear los Business Objects que serán los usados por nuestro cliente:
Primero, creamos el archivo ProductoBo.java en la ruta:src/main/java/com/ejemplo/negocio/bo
package com.ejemplo.negocio.bo;
import com.ejemplo.negocio.model.Producto;
import java.util.List;
public interface ProductoBo{
void guardar(Producto producto);
void eliminar(Producto producto);
Producto recuperarPorId(Integer id);
List<Producto> recuperarTodos();
}
Luego implementamos esta interface en el archivo ProductoBoImpl que se encuentra en la ruta:src/main/java/com/ejemplo/negocio/dao/impl
package com.ejemplo.negocio.bo.impl;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.List;
import com.ejemplo.negocio.bo.ProductoBo;
import com.ejemplo.negocio.dao.ProductoDao;
import com.ejemplo.negocio.model.Producto;
@Service("productoBo")
public class ProductoBoImpl implements ProductoBo{
@Autowired
ProductoDao productoDao;
public void setProductoDao(ProductoDao productoDao){
this.productoDao=productoDao;
}
public void guardar(Producto producto){
productoDao.save(producto);
}
public void eliminar(Producto producto){
productoDao.delete(producto);
}
public Producto recuperarPorId(Integer id){
return productoDao.findById(id);
}
public List<Producto> recuperarTodos(){
return productoDao.findAll();
}
}
Paso 4) Creación de cliente
Una vez creadas estas clases, podemos crear un test. Para este ejemplo voy a usar el archivo App.java que se encuentra dentro de:src/test/java/com/ejemplo
package com.ejemplo;
import com.ejemplo.negocio.bo.ProductoBo;
import com.ejemplo.negocio.model.Producto;
import com.ejemplo.negocio.util.SpringContext;
import org.apache.log4j.Logger;
import junit.framework.Test;
import junit.framework.TestCase;
import junit.framework.TestSuite;
/**
* Unit test for simple App.
*/
public class AppTest
extends TestCase
{
private static Logger logger = Logger.getLogger(AppTest.class);
public AppTest( String testName )
{
super( testName );
}
public static Test suite()
{
return new TestSuite( AppTest.class );
}
public void testApp()
{
SpringContext contexto = SpringContext.getInstance();
ProductoBo productoBo=(ProductoBo)contexto.getBean("productoBo");
Producto p=new Producto(1,"jabon",13.00);
productoBo.guardar(p);
Producto p1=productoBo.recuperarPorId(1);
System.out.println("Recuperacion individual:"+p1.getNombre());
for(Producto producto:productoBo.recuperarTodos()){
System.out.println("Recuperacion Lista:"+producto.getNombre());
}
productoBo.eliminar(p);
}
}
Finalmente ejecuto mvn clean:install desde una consola de comandos, tengo la siguiente salida:
-------------------------------------------------------
T E S T S
-------------------------------------------------------
Running com.ejemplo.AppTest
Hibernate: insert into producto (nombre, valor, id) values (?, ?, ?)
Hibernate: select producto0_.id as id0_, producto0_.nombre as nombre0_, producto0_.valor as valor0_ from producto producto0_ where producto0_.id=?
Recuperacion individual:jabon
Hibernate: select producto0_.id as id0_, producto0_.nombre as nombre0_, producto0_.valor as valor0_ from producto producto0_
Recuperacion Lista:jabon
Hibernate: select producto_.id, producto_.nombre as nombre0_, producto_.valor as valor0_ from producto producto_ where producto_.id=?
Hibernate: delete from producto where id=?
Tests run: 1, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 2.67 sec
Results :
Tests run: 1, Failures: 0, Errors: 0, Skipped: 0
[INFO] [jar:jar {execution: default-jar}]
[INFO] Building jar: /home/santiago/proyecto1/target/proyecto1-1.0-SNAPSHOT.jar
[INFO] [install:install {execution: default-install}]
[INFO] Installing /home/santiago/proyecto1/target/proyecto1-1.0-SNAPSHOT.jar to /home/santiago/.m2/repository/com/ejemplo/proyecto1/1.0-SNAPSHOT/proyecto1-1.0-SNAPSHOT.jar
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESSFUL
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 9 seconds
[INFO] Finished at: Wed Sep 01 16:45:40 ECT 2010
[INFO] Final Memory: 21M/154M
[INFO] ------------------------------------------------------------------------
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.
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.
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
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.
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:
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
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
Suscribirse a:
Entradas (Atom)