Como usar Beans en JSP

En nuestro articulo de hoy trataremos sobre el uso de beans dentro de nuestras páginas jsp, este material está incluido dentro de nuestro Máster en desarrollo de aplicaciones web empresariales con Java EE.

Los famosos java beans que se utilizan en JavaEE, se pueden utilizar en jsp, las principales características son:

• Los JavaBeans son objetos Java que cumplen ciertas características en cuanto a su diseño.

• Se utilizan para reducir al máximo el código Java insertado en una página JSP. En lugar de meterlo directamente en el fichero JSP se mete en un objeto y éste se llama desde el JSP.

• Permite separar la lógica de ejecución (en el JavaBean) de la presentación (en el servlet generado)

Se encapsula el código Java en un objeto (JavaBean) y se instancia y usa con el JSP.
-Si se usa un JavaBean en una página habrá que definir la clase correspondiente, creando los métodos set y get para los atributos definidos

• Dentro del servlet generado se puede llamar a métodos de un JavaBean que se encarguen de realizar ciertas operaciones y el servlet muestra el resultado de las mismas

• Ventaja del traslado de la lógica a un JavaBean
– Separación de interfaz de la implementación

Ejemplo
1.- Clase beans
public class LenguajeBean {

private String nombre;
private String lenguaje;
public LenguajeBean() {}

public void setNombre(String nombre) {

this.nombre=nombre;
}

public String getNombre(){

return nombre;
}

public void setLenguaje(String lenguaje){

this.lenguaje=lenguaje;
}

public String getLenguaje() {

return lenguaje;
}

public String getcomentariosLenguaje (){

if (lenguaje.equals(“Java”)){
return “El rey de los lenguaje Orientados a objetos”;
}
else if (lenguaje.equals(“C++”)){
return “Demasiado complejo”;

} else if (lenguaje.equals(“Perl”)){
return “OK si te gusta el códigoincomprensible”;
}else {
return “Lo siento, no conozco ellenguaje ” + lenguaje ;
}
}

}

2.- pagina html con un form y que solicita una pagina jsp.

beans jsp

3.- ejecutamos el jsp con el beans

beans jsp real




Mini tutorial JavaMail – Leer correos con JavaMail (Parte III)

Suponemos que ya te has bajado JavaMail y JAF. Ahora que sabemos como enviar un correo sencillo con JavaMail, vamos a ver cómo leer un correo.

Leer un correo tonto de texto con JavaMail es bastante sencillo, pero si nuestro programa hace eso a piñón fijo, no podremos leer cualquier correo que nos llegue.

La estructura real de un correo, con adjuntos y posibilidad de visualizarlo en texto plano o html es algo compleja, pero debemos tratarla para poder leer cualquier correo.

En este tutorial haremos un ejemplo de lectura de correo con JavaMail, teniendo en cuenta todo esto, pero sin complicarnos demasiado la vida. Lo justo para ver cómo leer correos conJavaMail y empezar a entender la estructura de estos correos complejos.

El comprender estos correos complejos nos ayudará, más adelante, a construir y enviar con JavaMail correos que van más allá de un simple texto.

Servidor de gmail

En el ejemplo, usaré una cuenta de gmail para conectarme con ella y obtener los correos del buzón inbox (carpeta de entrada). Si usas otro servidor de correo, deberás cambiar los parámetros de configuración de acuerdo a tu servidor.

La configuración de gmail para leer los correos es la siguiente

  • Tener POP habilitado. Entra en tu cuenta de gmail y arriba a la derecha pincha “configuración”. En la nueva pantalla pincha “Reenvio y correo POP”. Asegúrate de que pone “POP habilitado” o marca la opción “Habilitar POP para todos los mensajes que se reciban a partir de ahora”. Si no lo haces, no podrás acceder desde JavaMail a tus mensajes.
  • Servidor de correo al que conectarse pop.gmail.com
  • Puerto de conexión 995
  • Conexión SSL
  • Deshabilitar TLS
  • Usuario -la dirección de correo, usaré ejemplo@gmail.com– y password válidos de gmail.

Clases implicadas en la lectura de un correo

Para leer los correos necesitamos básicamente las siguientes clases de JavaMail:

  • Session, que representa de alguna forma la conexión con gmail.
  • Store y Folder, que representan el almacén del servidor con los ocrreos y la carpeta dentro de ese almacén donde el servidor guarda los correos que queremos leer.
  • Message, los mensajes que leeremos.

Establecer la Session

Para obtener la sesión con gmail necesitamos tener una instancia de la clase Session con la configuración adecuada. Esta instancia se obtiene llamando al métodoSession.getDefaultInstance(). El parámetro para este método es una clase java.util.Properties de java estándar.

Como mencionamos anteriormente, Properties es una clase java que nos permite guardar datos de tipo texto asignándoles un nombre. Sería algo parecido a esto

Properties p = new Properties();
p.setProperty(“un nombre”, “un valor”);
p.setProperty(“PI”, “3.1416”);

Para obtener una instancia correctamente configurada de Session, en la clase Properties que le pasemos deben estar fijadas determinadas parejas nombre-valor. Tienes una lista de todas las posibles propiedades que JavaMail tiene en cuenta en la API. Vamos a ver las concretas para la conexión con pop.gmail.com

Properties prop = new Properties();

// Deshabilitamos TLS
prop.setProperty(“mail.pop3.starttls.enable”, “false”);

// Hay que usar SSL
prop.setProperty(“mail.pop3.socketFactory.class”,”javax.net.ssl.SSLSocketFactory” );
prop.setProperty(“mail.pop3.socketFactory.fallback”, “false”);

// Puerto 995 para conectarse.
prop.setProperty(“mail.pop3.port”,”995″);
prop.setProperty(“mail.pop3.socketFactory.port”, “995”);

Con mail.pop3.starttls.enable a false deshabilitamos TLS.

Para usar SSL debemos decirle a JMail como obtener un socket SSL, para ellos fijamos mail.pop3.socketFactory.class al nombre de clase que nos proporciona java estándar para obtener sockets SSL, es decir, javax.net.ssl.SSLSocketFactory.

Lo de mail.pop3.socketFactory.fallback es opcional. Si no lo fijamos, si falla el socket SSL JavaMail intentará con un socket normal. Puesto que es inútil -gmail sólo admite SSL-, ponemos esta propiedad a false para indicarle a JavaMail que no lo intente con sockets normales.

Falta indicar el puerto 995 tanto para JavaMail como para la clase que crea sockets SSL, por ello fijamos con este valor dos propiedades distintas: mail.pop3.port ymail.pop3.socketFactory.port

Con todo esto inicializado, ya podemos obtener nuestra instancia de Session

Session sesion = Session.getInstance(prop);
sesion.setDebug(true);

Lo de setDebug(true) es sólo para obtener más información en la pantalla de lo que se está haciendo. Cuando nuestro programa funcione correctamente, podemos quitar esta línea.

Obtener el Store y el Folder de Inbox

Una vez que tenemos nuestro Session, tenemos que obtener la carpeta de correo entrante de nuestro servidor de correo. Para ello ponemos las siguientes líneas de código

Store store = sesion.getStore(“pop3”);
store.connect(“pop.gmail.com”,”ejemplo@gmail.com”,”la password “);
Folder folder = store.getFolder(“INBOX”);
folder.open(Folder.READ_ONLY);

A partir de Session obtenemos el almacen de correos Store con getStore(), indicando el protocolo “pop3” con nuestro servidor de correo.

Con el Store establecemos la conexión con el servidor de correo, indicando nombre de host -pop.gmail.com-, usuario (la dirección de correo) y password. Para ello usamos el métodoconnect().

Finalmente, al Store le pedimos la carpeta Inbox con getFolder(“INBOX”). Este Folder hay que abrirlo, en principio para sólo lectura.

Obtener los mensajes

Antes de nada, que quede claro que según hayas puesto en gmail, puede que sólo obtengas los mensajes nuevos. Si vas siguiendo el ejemplo con código, envíate un mensaje a esa cuenta antes de ejecutar el programa, para asegurarte que tienes un mensaje nuevo sin leer. En mis pruebas no he podido bajarme correos que me he enviado desde mi mismo PC y con mi cliente de correo (Thunderbird), así que he tenido que entrar con el navagador en gmail y enviarme desde ahí correos a mí mismo.

Para obtener los mensajes, símplemente hay que llamar a getMessages() de la clase Folder. Esto nos devolverá un array de Message, con los mensajes nuevos.

Message [] mensajes = folder.getMessages();

Como primera medida sencilla y para ver algo, sacaremos por pantalla los campos From y Subject -asunto- del mensaje. El contenido del mensaje es más complejo y lo vemos en el siguiente apartado.

Los campos From y Subject se obtienen con los métodos getFrom() y getSubject().

El getFrom() nos devuelve un array de Address, así que debemos ir leyendolos de uno en uno. El código para escribir esta información de cada mensaje puede ser como el siguiente

for (int i=0;i<mensajes.length;i++)
{
System.out.println(“From:”+mensajes[i].getFrom()[0].toString());
System.out.println(“Subject:”+mensajes[i].getSubject());
}

Ver el contenido del mensaje

Bueno, aquí comienza el lio. Un mensje puede ser muy tonto -un simple texto- o muy complicado -un texto en formato plano y html para que elijas cual quieres ver y con ficheros adjuntos variados.

Lo primero es ver de qué tipo es. La clase Message -en realidad la interface Part que esta clase implementa- tiene el método isMimeType() para poder identificar de qué tipo es el mensaje. La primera comprobación que podemos hacer es ver si es de tipo text o multipart. El primer caso nos indica que es un texto sencillo, el segundo que es un mensaje compuesto. Podríamos comprobar también si una image o cualquier otro tipo MIME que se nos ocurra, pero lo normal es que recibamos un text o un mutipart. El código sería así

for (int i=0;i<mensajes.length;i++)
{
if (mensajes[i].isMimeType(“text/*”)
// mensaje de texto simple
if (mensajes[i].isMimeType(“multipart/*”))
// mensaje compuesto
}

Como ves, hemos usado comodines -el asterisco- para que nos valga cualquier tipo de texto -text/plain, text/html, etc- y cualquier tipo de multipart -multipart/alternative, multipart/parallel, etc-

Sacar el contenido de texto

Si el MIME type es text/*, podemos sacar su contenido. Obviamente deberíamos ver exactamente que tipo de texto -text/plain, text/html, text/rtf, etc- para presentarlo en condiciones, pero es mucho para este tutorial. Vamos a suponer que es text/plain y podemos sacarlo y visualizarlo tal cual.

El código es muy tonto

System.out.println(mensajes[i].getContent());

Si el mensaje es de tipo text, el método getContent() nos devolverá directamente el String con el texto del mensaje. Si es text/plain, se podrá escribir directamente en pantalla o donde queramos.

Para otros tipos, como text/html o text/rtf, necesitas algo más elaborado, como un JEditorPane, para mostrar el contenido correctamente.

Obtener las partes de un multiparte.

Si el MIME type del mensaje es multipart, debemos ir extrayendo cada una de las partes que componen el mensaje compuesto. Con cada una de ellas debemos hacer un tratamiento similar, es decir, ver si es algún tipo simple -text, image, etc- o si a su vez vuelve a estar compuesto -multipart- y repetir el proceso hasta obtener las partes simples.

Si el mensaje es de tipo multipart, el método getContent() nos devolverá una clase MultiPart. Esta clase tiene métodos para saber cuántos cachos componen el mensaje y obtener cada uno de ellos. El código par esto podría ser así

if (mensajes[i].isMimeType(“multipart/*”))
{
   // Obtenemos el contenido, que es de tipo MultiPart.
Multipart multi;
multi = (Multipart)mensajes[i].getContent();

   // Extraemos cada una de las partes.
for (int j=0;j<multi.getCount();j++)
{
Part unaParte = multi.getBodyPart(j);

      // Volvemos a analizar cada parte de la MultiParte
if (unaParte.isMimeType (….))

}
}

Es decir, con getContent() del mensaje obtenemos un MultiPart.

Con getCount() de este MultiPart obtenemos de cuántas partes esta compuesto el mensaje -por ejemplo, podría ser un mensaje de texto con dos imágenes adjuntas, es decir, tres partes-.

Obtenemos cada parte con getBodyPart(). Cada una de estas partes hay que volver a analizarla.

Esto, claramente, nos invita a un método recursivo para analizar cada parte, de forma que si la parte es simple, se muestra el contenido y si es compuesta, se extraen las subpartes y se vuelve a llamar al mismo método. En el código de ejemplo del final está hecho así.

Obtener una imagen adjunta.

La idea ya debería estar clara. Vamos a ver como tratar algo que no sea text ni multipart. Como ejemplo, una imagen adjunta.

Para comprobar si una parte es una imagen, nuevamente usamos el método isMimeType().

if (unaParte.isMimeType(“image/*”))
{

}

Si no es un text ni un multipart, lo más probable es que getContent() nos devuelva un InputStream del que podemos leer los bytes que componen esa parte. En nuestro caso, los bytes de la imagen. En cualquier caso, tenemos el método getInputStream() que seguro que nos lo devuelve como un InputStream.

A partir de este InputStream es fácil leer los bytes y guardarlos, por ejemplo, en un fichero de imagen con un FileOutputStream. Tal cual leemos bytes del InputStream, los vamos escribiendo en el FileOutputStream. El método getFileName(), para el caso de imagen, posiblemente nos devuelva el nombre del fichero que tenía la imagen cuando nos la enviaron, con lo que ya tenemos que nombre darle al fichero. Aquí tienes un trozo de código para guardar la imagen en un fichero (ojo, lo mete en el raíz de la unidad D:\, cámbialo si no te gusta).

if (unaParte.isMimeType(“image/*”))
{
FileOutputStream fichero = new FileOutputStream(“d:/”+unaParte.getFileName());
InputStream imagen = bodyPart.getInputStream();
byte [] bytes = new byte[1000];
int leidos=0;
while ((leidos=imagen.read(bytes))>0)
{
fichero.write(bytes,0,leidos);
}
}

De todas formas, a mí me gusta más ver la foto, así que aquí va el código para mostrarla en un JFrame.

if (unaParte.isMimeType(“image/*”))
{
JFrame v = new JFrame();
ImageIcon icono = new ImageIcon(ImageIO.read(unaParte.getInputStream()));
JLabel l = new JLabel(icono);
v.getContentPane().add(l);
v.pack();
v.setVisible(true);
}

Como puedes ver, se comprueba si es de tipo image/*. En caso afirmativo, la clase ImageIO de java nos ayuda a construir una Image a partir de un InputStream y esta podemos meterla en un ImageIcon, que se puede meter a su vez dentro de un JLabel que podemos pintar en una ventana JFrame … ¡¡uff!!

En nuestro próximo post veremos la última parte de este mini tutorial sobre JavaMail

Espero que os haya gustado, si es así comparte¡¡

Muchas gracias




Mini tutorial JavaMail – Enviar un correo con JavaMail (Parte II)

En nuestro artículo anterior sentamos las bases para poder trabajar con JavaMail, en esta segunda parte estudiaremos como mandar un correo con JavaMail. Suponemos que ya te has bajado JavaMail y JAF. Vamos a ver cómo enviar un correo simple, un simple texto, usando JavaMail. Para el ejemplo, usaremos una cuenta de gmail como servidor de correo.

La configuración de esta cuenta (de cualquier cuenta de gmail) para el envío de correos es:

Requiere usuario y password. El usuario es la cuenta de correo, pondremos por ejemplo, ejemplo@gmail.com
Protocolo smtp
TLS si está disponible
Puerto 587, que no es el de defecto de smtp.

Clases y configuración de JavaMail para el envío de mensajes

Para este ejemplo sencillo, hay tres clases de JavaMail implicadas:

Session: De alguna forma representa la conexión con el servidor gmail de correo. Hay que obtenerla pasándole los parámetros de configuración para el servidor de correo -gmail en nuestro caso-.
Transport: Clase para el envío de mensajes. Se obtiene llamando al método getTransport() de la clase Session.
MimeMessage: El mensaje.
Creación y configuración de la clase Session de JavaMail

La clase Session representa nuestra conexión con el servidor de correo -gmail en nuestro caso-. Se obtiene con el método Session.getDefaultInstance() pasándole un parámetro:

Un Properties con las propiedades de la conexión.
Properties es una clase de java estándar java.util.Properties. Esta clase admite que guardemos en ella parejas “clave-valor”, es decir, guardamos datos -de tipo String- dándoles un nombre a cada uno para luego poder recuperarlos. Esto se hace por medio del método setProperty(), de esta manera

Properties p = new Properties();
p.setProperty(“un nombre”, “un valor”);
p.setProperty(“PI”, “3.1416”);

Las Properties que necesita Session son específicas, es decir, tienen que tener unos nombres concretos y unos posibles valores concretos. En la API una lista de algunas de ellas y también en la API tienes una lista más completa.

Veremos aquí sólo las estrictamente necesarias para conectarnos con gmail y poder enviar mensajes. El código sería este

Properties props = new Properties();

// Nombre del host de correo, es smtp.gmail.com
props.setProperty(“mail.smtp.host”, “smtp.gmail.com”);

// TLS si está disponible
props.setProperty(“mail.smtp.starttls.enable”, “true”);

// Puerto de gmail para envio de correos
props.setProperty(“mail.smtp.port”,”587″);

// Nombre del usuario
props.setProperty(“mail.smtp.user”, “ejemplo@gmail.com”);

// Si requiere o no usuario y password para conectarse.
props.setProperty(“mail.smtp.auth”, “true”);

Con esto estamos en disposición de obtener nuestra instancia de Session.

Session session = Session.getDefaultInstance(props);
session.setDebug(true);

Hemos puesto setDebug(true) para obtener más información por pantalla de lo que está sucediendo. Una vez que el programa nos funcione, podemos quitar esa línea sin problemas.

Ya tenemos nuestro objeto Session.

Construir el mensaje para enviar con JavaMail

Vamos ahora a construir un mensaje simple de texto. Para ellos instanciamos la clase MimeMessage y le ponemos varios datos.

En el constructor debemos pasarle el objeto Session que obtuvimos anteriormente

MimeMessage message = new MimeMessage(session);

Ponemos luego el FROM y el TO del mensaje, es decir, quién lo envía y a quién va dirigido. Para meter estos datos usaremos los métodos setFrom() y addRecipient() de MimeMesage. Los parámetros que admiten estos métodos son instancias de javax.mail.internet.InternetAddress. En el constructor de esta clase InternetAddress símplemente ponemos la dirección de correo -ver código más abajo-.

Para los destinatarios usaremos el método addRecipient() de MimeMessage. Esta método admite dos parámetros, una constante para indicar el tipo de destinatario y otro que es el InternetAdress mencionado. El tipo de destinatario puede ser

Message.RecipientType.TO Destinatario principal del mensaje
Message.RecipientType.CC Destinatario al que se envía copia del mensaje
Message.RecipientType.BCC Destinatario al que se envía copia, pero sin que los demás destinatarios puedan verlo.
En nuestro caso, sólo pondremos el TO y la dirección de correo.

// Quien envia el correo
message.setFrom(new InternetAddress(“ejemplo@gmail.com”));

// A quien va dirigido
message.addRecipient(Message.RecipientType.TO, new InternetAddress(“destinatario@dominio.com”));

Ahora sólo queda llenar el asunto -subject que dirían los ingleses- del mensaje y el texto. Como tenemos métodos para ello, setSubject() y setText(), no hay ningún problema.

message.setSubject(“Hola”);
message.setText(“Mensajito con Java Mail” +
“de los buenos.” +
“poque si”);

Ya tenemos construido el mensaje.

Un pequeño detalle nada más. Este mensaje es de texto y el formato que se está usando es texto “plano”, es decir, texto normalito, tal cual, sin más. Hay muchas formas de enviar texto. Se puede enviar, por ejemplo, en formato html, con lo que podríamos poner negritas, cursivas, etc.

Para enviar texto con otros formatos, debemos usar el mismo método setText(), pero con más parámetros. En concreto, podemos usar la versión de setText() que admite tres parámetros:

El texto, en formato html -o el que decidamos-
El juego de caracteres a utilizar. Por ejemplo, puede ser “ISO-8859-1”, que corresponde a nuestro juego de caracteres.
El formato a utilizar. Para un html sería “html”. No se puede poner cualquier cosa, hay que utilizar subtipos estandar de los tipos MIME (Multipurpose Internet Mail Extension). Al utilizar setText(), la primera parte de este tipo se presupone “text”. El subtipo “hmtl” es el que ponemos aquí. El siguiente código crearía el mismo mensaje, pero con texto html y algún adorno de negrita y cursiva

message.setText(
“Mensaje con Java Mail<br>” + “<b>de</b> los <i>buenos</i>.” + “poque si”,
“ISO-8859-1”,
“html”);

Enviamos el mensaje

Para enviar el mensaje usamos la clase Transport, que se obtiene de Session. El método getTransport() requiere un parámetro String con el nombre del protocolo a usar. Como el de gmail es smtp, pues ponemos smtp.

Transport t = session.getTransport(“smtp”);

Ahora debemos establecer la conexión, dando el nombre de usuario y password.

t.connect(“ejemplo@gmail.com”,”la password”);

y ahora simplemente enviamos el mensaje

t.sendMessage(message,message.getAllRecipients());

El método de enviar mensaje es sendMessage() y NO sólo send(). El método send() es estático y no tiene en cuenta la conexión, ni el usuario ni la password. Es una forma rápida de envio de mensaje para un servidor smtp que no requiera autentificación. Como no es el caso, debemos usar sendMessage().

El método sendMessage(), además del mensaje, necesita la lista de receptores del mensaje, es decir, el array de direcciones a los que va el mensaje. La forma rápida de obtener este array es llamar al método getAllRecipients() de la clase MimeMessage, justo como lo hemos hecho en el código.

Con esto se envía el mensaje. Ahora solo queda cerrar la conexión

t.close();

Finalmente, aquí tienes el programa completo que he hecho con mi cuenta de gmail para probar: EnviarMail.java.

En nuestro siguiente articulo veremos cómo recibir correos con JavaMail.

Si te ha gustado este articulo comparte¡¡

 

Muchas gracias




Mini tutorial JavaMail – Como usar JavaMail (Parte I)

En esta serie de artículos vamos a empezar a usar JavaMail. Aunque en la página de SUN ponga que es para JEE, la verdad es que esta librería nos permite enviar y recibir correos desde cualquier aplicación java.

Veremos en primer lugar qué tenemos que descargarnos, puesto que JavaMail no viene por defecto con Java y necesita, además, otra librería adicional, JAF (o JavaBeans Activation Framework).

Para nuestros ejemplos usaré la cuenta de gmail, así que la configuración que veas es para dicha cuenta. Si tienes otro servidor de correo, tendrás que mirar cómo es la configuración con tu servidor y cambiar los parámetros adecuados en la configuración de JavaMail.

¿Qué necesitamos descargarnos para usar JavaMail?

Para usar JavaMail necesitamos descargarnos la librería de JavaMail de la página de SUN. Acepta las condiciones, bájate el zip, desempaquétalo y añade los jar a eclipse que vienen a tu proyecto. JavaMail utiliza otra librería, JAF, que también debes descargarte. El activation.jar que viene ahí también debes añadirlo a tu proyecto, igual que los anteriores.

Ya tienes todo lo que necesitas para usar JavaMail.

Ejemplos con JavaMail

En nuestros próximos artículos veremos tres ejemplos sencillos con JavaMail, de más sencillo a más complejo:

  • Envío de un correo de texto sencillo con JavaMail.
  • Recepción de un correo con JavaMail.
  • Envío de un correo con ficheros adjuntos con JavaMail.

 

Muchas gracias por leernos




Como usar Maven en una aplicación Web

En nuestro articulo de hoy crearemos una aplicación Web simple con Apache Maven, la cual puede ser gestionada por IDEs tales como Eclipse o Netbeans.

Requisitos

  • Java JDK 6 o superior
  • Apache Maven 2 o superior
  • Eclipse versión JEE
Pasos a seguir:
  1. Abrimos la consola de Msdos o Limix y creamos un proyecto con Maven utilizando el arquetipo adecuadomaven-archetype-webapp
    mvn archetype:generate -DgroupId=com.sobrejava.ejemplo.web -DartifactId=ejemplo-web -DarchetypeArtifactId=maven-archetype-webapp -DinteractiveMode=false
    
    Ahora tenemos una estructura similar a la siguiente
  2. Ahora agregamos las dependencias necesarias para una aplicación Web, en este ejemplo utilizaremos java-web-6, la cual nos brinda lo necesario para poder iniciarnos en el desarrollo de ServletsJSP, etc. Para ello editamos el archivo pom.xml de la siguiente manera
    Código del archivo pom.xml
    <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.sobrejava.ejemplo.web</groupId>
      <artifactId>ejemplo-web</artifactId>
      <packaging>war</packaging>
      <version>1.0-SNAPSHOT</version>
      <name>ejemplo-web 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>
        <!-- agregamos el API para JEE6 -->
        <dependency>
            <groupId>javax</groupId>
            <artifactId>javaee-web-api</artifactId>
            <version>6.0</version>
            <scope>provided</scope>
        </dependency>
      </dependencies>
      <build>
        <finalName>ejemplo-web</finalName>
        <plugins>
          <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-compiler-plugin</artifactId>
            <configuration>
              <source>1.6</source>
              <target>1.6</target>
            </configuration>
          </plugin>
        </plugins>
      </build>
    </project>
    
  3. Editamos el archivo src/main/webapp/web.xml con el descriptor 3.0
    Código del archivo web.xml
    <web-app xmlns="http://java.sun.com/xml/ns/javaee"
              xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
              xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"
              version="3.0">
    
        <display-name>Ejemplo-Web</display-name>
    
    </web-app> 
    
    Algunos IDEs como Eclipse utilizan el descriptor para definir la versión Web de la aplicación.
  4. Finalmente para descargar las dependencias (si es necesario) y asegurarnos que todo esté bien, para ello vamos al directorio de la aplicación y usamos mvn compile

Editar Aplicación con Eclipse IDE

  1. En Eclipse (JEE versión), Seleccionamos un Workspace adecuado y vamos a Menú File -> Import -> Maven Projects -> Existing Maven Project…
  2. En la pantalla de Import Maven Projects seleccionamos el directorio donde se encuentra el proyecto ejemplo-web y seleccionamos Finish
  3. Finalmente tenemos el proyecto configurado con Eclipse WTP .
Espero que este artículo os pueda servir de ayuda en vuestra vida profesional y estad atentos a nuestros próximos artículos, gracias!!!!
www.asociacionaepi.es