JavaMail (parte 1): recuperando mails con POP
Fecha de creación: 01.12.2002
Revisión 1.0 (01.12.2002)
Alberto Molpeceres
al AT javahispano DOT org
| Copyright (c) 2002, Alberto Molpeceres. Este documento puede ser distribuido solo bajo los términos y condiciones de la licencia de Documentación de javaHispano v1.0 o posterior (la última versión se encuentra en /licencias/). |
|
Introducción
JavaMail es uno de esos APIs de Java tremendamente útiles pero sobre el que no hay demasiada documentación. En este serie de artículos aprenderemos a recibir y enviar emails con ella, ya tengan su contenido como texto o HTML.
En este primer artículo aprenderemos a recibir los mensajes de texto por medio del protocolo POP (Post Office Protocol), sin duda el protocolo más utilizado para recoger nuestros mensajes.
Requisitos
Para trabajar con JavaMail necesitaremos disponer de dos APIs, ambas distribuidas por SUN, en concreto:
JavaMail [1]: Obviamente necesitaremos el API de Java dedicado al correo electrónico.
Java Activation Framework (JAF) [2]: Este API es una forma de acceder a fuentes de datos estándar. JavaMail lo necesita para manipular correctamente correos electrónicos multiparte (MIME).
Como con cualquier otro programa que escribamos con Java, tendremos que hacer accesibles estas librerías para nuestra aplicación, como siempre por medio del CLASSPATH, o de alguna herramienta para construir nuestras aplicaciones como Ant [3]
[4].
Un envoltorio para la sesión: POP3Session
Para el desarrollo de las explicaciones de este artículo (y de los posteriores) crearemos un wrapper, o si lo preferís un Decorator, es decir, una clase envoltorio que simplifique el uso del API JavaMail y que podamos reutilizar en varios proyectos. Empezaremos con algo muy simple e iremos añadiéndole funcionalidad.
package org.javahispano.mailer;
import javax.mail.internet.*;
import javax.mail.*;
import java.util.*;
import javax.activation.*;
public class POP3Session {
private static int DEFAULT_PORT = 110;
private String host;
private String user;
private String password;
private int port = 110;
private boolean debug = false;
public POP3Session(String host) {
this(host, DEFAULT_PORT, null, null);
}
public POP3Session(String host, String user, String password) {
this(host, DEFAULT_PORT, user, password);
}
public POP3Session(String host, int port, String user, String password) {
this.host = host;
this.user = user;
this.password = password;
this.port = port;
}
public void setDebug(boolean value) {
debug = value;
}
}
De momento no tiene mucho secreto, vamos creo yo, como mucho decir que el puerto más habitual para los servidores de recogida de correo es, como veis en el ejemplo, el 110.
Conectándonos y desconectándonos
Obviamente, para recibir nuestros mensajes de correo electrónico, tendremos que conectarnos al servidor, y una vez recogidos todos tendremos que desconectarnos. Aquí están los métodos para ello, que requieren también de dos variables de clase para almacenar la conexión mientras realizamos el resto de acciones.
private Store store = null;
private Folder activeFolder = null;
public void connect()
throws Exception {
Session session = Session.getDefaultInstance(System.getProperties());
// Podemos usar el modo de debug si así lo queremos.
// Para ello creamos esta propiedad y la ajustamos por medio de setDebug
session.setDebug(debug);
// Recoger el buzon
store = session.getStore("pop3");
store.connect(host, user, password);
}
public void disconnect() throws Exception{
if (store != null) {
activeFolder.close(true);
store.close();
}
}
Los nuevos atributos de la clase tienen un significado relativamente sencillo de entender. Store es, por decirlo así, una cuenta de correo, es decir, un almacén donde se almacenan nuestro mensajes hasta que lo recojamos. Como hemos dicho antes, POP significa Post Office Protocol, es decir, Protocolo de la Oficina de Correos, así que si lo queréis entender así, un Store es un buzón donde están esperando vuestros mensajes hasta que los recojáis.
Folder es también sencillo. Se puede organizar dicho buzón de forma que tenga subapartados, como por ejemplo familia y publicidad (spam!). Desgraciadamente casi ningún servidor de correo entrante (POP) soporta esa funcionalidad (eso si lo hacen los nuevos IMAP), por lo que habitualmente solo dispondremos de uno, el estándar, llamado INBOX.
El método disconnect no tiene ningún secreto, el método connect lo explicaremos un poco más.
Como podéis ver, primero se consigue la Session y después nos conectamos al Store o almacén. Este proceso puede varíar, de forma que podemos hacerlo en base a las propiedades del sistema (de ahí el System.getProperties), donde pueden estar las propieades referentes al correo (como mail.smtp.host), podemos usar un Authenticator en lugar de usuario y password, y muchas otras variaciones. En este caso hemos elegido esta, por ser la más sencilla de entender por su similitud con cualquier cliente de correo. Investigad un poco más el API si neceistais algo más.
Por si acaso algún día tuvieramos que cambiar el Folder con el que estamos trabajando, pondremos un par de métodos que permitirán cambiar la carpeta activa o devolverla a la que viene por defecto.
public void activateDefaultFolder() throws Exception{
activateFolder("INBOX");
}
public void activateFolder(String folder) throws Exception{
if (activeFolder != null){
activeFolder.close(true);
}
activeFolder = store.getFolder(folder);
activeFolder.open(Folder.READ_WRITE);
}
Recogiendo nuestros mails
El siguiente paso será recoger nuestros mails, como veremos, bastante sencillo. Para hacer esto crearemos una nueva clase, que explicaremos en el siguiente punto, que encapsule cada uno de los mails que recibimos de forma que podamos acceder a su información de forma sencilla. Ahora crearemos el método que recoje los mails, devolviéndolos en forma de lista:
public List getMails() throws Exception{
if (activeFolder != null){
return POP3Mail.convertMails(activeFolder.getMessages());
}
else{
throw new Exception ("Debes tener una carpeta activa.");
}
}
Un envoltorio para los mensajes: POP3Mail
package org.javahispano.mailer;
import java.util.*;
import javax.mail.*;
import javax.mail.internet.*;
/**
* Envoltorio (wrapper, decorator, etc) para facilitarnos el manejo de mails
*
* @author Alberto Molpeceres
* @created 26. November 2002
*/
public class POP3Mail {
/** Mensaje real de JavaMail */
private Message message;
/** Remitente del mensaje */
private String from;
/** Asunto del mensaje */
private String subject;
/**
*Construye un envoltorio para un mensaje de JavaMail
*
* @param message Mensaje a envolver.
*/
protected POP3Mail(Message message) {
this.message = message;
//recoger el remitente
try {
InternetAddress fromAddress = (InternetAddress) message.getFrom()[0];
//Almacenamos la dirección del remitente de la forma:
// NOMBRE (DIRECCION)
from = fromAddress.getPersonal() + " (" +
fromAddress.getAddress() + ")";
} catch (Exception e) {
from = "Remitente no disponible";
}
//recoger el asunto del mensaje
try {
subject = message.getSubject();
} catch (Exception e) {
subject = "Asunto no disponible";
}
}
/**
* Método estático que convierte los emails del tipo de JavaMail a nuestra
clase envoltorio para facilitarnos el trabajo,.
*
* @param messages Mesnajes en la carpeta
* @return Lista con nuestros mails convertidos
*/
public static List convertMails(Message[] messages) {
List list = new ArrayList();
for (int i = 0; i < messages.length; i++) {
list.add(new POP3Mail(messages[i]));
}
return list;
}
/**
* DEvuelve el remitente o emisor del mensaje
*
* @return remitente
*/
public String getFrom() {
return from;
}
/**
* DEvuelve el asunto del mensaje
*
* @return Asunto del mensaje
*/
public String getSubject() {
return subject;
}
/**
* Devuelve el contenido del email, el texto.
Como estamos tratando solo con emails de texto, no es necesario
tener en cuenta las partes (MIME)
*
* @return el texto del email
*/
public String getContent() {
try{
return message.getContent().toString();
}
catch(Exception e){
return "Error!";
}
}
/**
* Devuleve una representación del mail como cadena de caracteres
*
* @return descripción
*/
public String toString() {
if (message != null) {
return "From: " + from + "\n\t Subject: " + subject;
} else {
return ("No hay mensaje");
}
}
/**
* Elimina un mail
*
* @exception Exception si no se puede eliminar
*/
public void delete()
throws Exception {
message.setFlag(Flags.Flag.DELETED, true);
}
}
El único método que quizás requiere un poco de atención es el de getContent. Este método es tan sencillo porque solo estamos considerando mails de texto como entrada. En artículos posteriores veremos como tratar los attachments que forman los mensajes MIME.
A probar todo.
Por último vamos aprobar que todo funciona como debería con la siguiente clase:
package org.javahispano.mailer.test;
import org.javahispano.mailer.*;
import java.util.*;
/**
* Description of the Class
*
* @author Alberto Molpeceres
* @created 26. November 2002
*/
public class GetMailTest {
/**
* Test para recibir mails.
*
* @param args La linea de comandos.
*/
public static void main(String[] args) {
if (args.length != 3) {
System.out.println(
"Uso: java org.javahispano.mailer.test.GetMailTest host usuario password"
);
System.exit(-1);
}
POP3Session pop = new POP3Session(args[0], args[1], args[2]);
// pop.setDebug(true);
try {
System.out.println("\n\n[GetMailTest] Conectando....");
pop.connect();
// pop.activateFolder("INBOX");
pop.activateDefaultFolder();
//número de mails
System.out.println("\n\n[GetMailTest] Numero de mails: " + pop.getMailCount());
//list mails
List mailList = pop.getMails();
Iterator mails = mailList.iterator();
POP3Mail mail = null;
while (mails.hasNext()) {
mail = (POP3Mail) mails.next();
System.out.println(mail);
System.out.println("Contenido: " + mail.getContent());
}
pop.disconnect();
System.out.println("[GetMailTest] Test realizado con éxito");
} catch (Exception e) {
System.out.println("[GetMailTest] No se pudo conectar: " + e.getMessage());
e.printStackTrace();
}
}
}
Clase que ejecutaremos con:
java org.javahispano.mailer.test.GetMailTest servidor usuario password
El código.
Por supuesto tenéis disponible el código de este artículo para su descarga [5].
Conclusión
Hemos visto que enviar mails con JavaMail es bastante simple. Con poco trabajo podemos construir una pequeña aplicación capaz de bajarse mails de texto de servidor de correo y procesarlos. Desgraciadamente no siempre es tan fácil esta tarea: como veremos en uno de los artículos de esta serie cuando los mails tienen attchments tendremos que trabajar un poco más para descargarlos y procesarlos.
En el próximo artículo de la serie veremos que mandar un mail de texto con JavaMail es tan simple como recibirlo.
Recursos
[1] Página oficial de JavaMail,
http://java.sun.com/products/javamail/
[2] Página oficial de JAF,
http://java.sun.com/products/javabeans/glasgow/jaf.html
[3] Página oficial de Ant,
http://jakarta.apache.org/ant/
[4] Artículos de javaHispano sobre Ant,
/articulos/seccion.jsp?seccion=7
[5]
Código del artículo
Acerca del autor
Alberto Molpeceres
Alberto es es ahora mismo desarrollador de aplicaciones en ámbito cliente/servidor para la empresa T-Systems ITS GmbH en Dresden (Alemania). Cuando no está trabajando o "metiendo caña" al resto de los integrantes de javaHispano intenta pasear con su novia, buscar la desaparecida lógica del idioma alemán o intenta disfrutar del buen ambiente de la Neustadt.
miércoles, diciembre 11, 2002 at 1:00AM