POO

Abril - Mayo 2003

El API
JavaMail

Arturo Rodríguez Álamo

Rosa Rodríguez Herrero

Departamento de Informática y Automática

Universidad de Salamanca
Información de los autores:
Arturo Rodríguez Álamo
Estudiante de Ingeniería Técnica en Informática de Sistemas
Facultad de Ciencias – Universidad de Salamanca
tururodr@hotmail.com
Rosa Rodríguez Herrero
Estudiante de Ingeniería Técnica en Informática de Sistemas
Facultad de Ciencias – Universidad de Salamanca
rositarodr@hotmail.com

Este documento puede ser libremente distribuido.

© 2003 Departamento de Informática y Automática - Universidad de Salamanca.
Resumen
En este documento se pretende dar a conocer el funcionamiento del API JavaMail.
La primera parte de este documento se dedica a introducir en qué consiste JavaMail, así como a
dar a conocer los protocolos para la transferencia de mensajes y el funcionamiento de un
sistema de correo electrónico.
En la segunda parte se estudian detenidamente cada una de las clases que utiliza JavaMail.
En el tercer apartado se explica como implementar un sistema de correo electrónico: el envío y
la recepción de mensajes, archivos adjuntos, etc.
Finalmente, se incluye en el documento un ejemplo práctico.

Java Mail i
Tabla de Contenidos

1. Introducción al API JavaMail Página 1

1.1 ¿Qué es? Página 1
1.2 Funcionamiento de un sistema de correo electrónico Página 1
1.3 Protocolos relacionados Página 2
2. Clases que componen el API JavaMail Página 2
2.1 session Página 2
2.2 message Página 3
2.2.1 Estructura de un mensaje Página 4
2.2.2 Tipos de clase de mensaje Página 4
2.3 address Página 5
2.4 authenticator Página 6
2.5 transport Página 7
2.6 store Página 7
2.7 folder Página 8
3. Utilización de JavaMail Página 8
3.1 Envío de mensajes Página 8
3.2 Lectura de mensajes Página 8
3.3 Reenvío Página 9
3.4 Borrar un mensaje Página 10
3.5 Archivos adjuntos Página 11
3.6 Búsqueda de mensajes Página 11
4. Ejemplo práctico: Un cliente de correo Página 13
5. Conclusiones Página 16
6. Referencias Página 17

ii Java Mail
Índice de figuras
Figura 1: Servidor de e-mails y su cliente. Página 1

Figura 2: Funcionamiento de los sistemas de correo electrónico. Página 2

Figura 3: Estructura de un mensaje simple. Página 4

Figura 4: Estructura de un mensaje Multipart. Página 5

Figura 5: La capa del API JavaMail Página 17

Java Mail iii

1. Introducción al API JavaMail
El correo electrónico es una de las funciones más importantes que proporciona Internet. El API
JavaMail ofrece la posibilidad de desarrollar clientes de correo electrónico y aplicaciones de
Java compatibles con el correo.

1.1 ¿Qué es?

El API JavaMail es un paquete opcional para leer, componer y enviar mensajes electrónicos. Se
usa este paquete para crear programas similares a Eudora y Microsoft Outlook, por
ejemplo. Su propósito principal es leer y escribir e-mails e interaccionar con los
programas que se encargan del envío de estos mensajes usando el lenguaje de
programación Java.

Figura 1: Servidor de e-mails y su cliente

JavaMail está formada por un conjunto de clases abstractas que modelan las partes de un
sistema de correo electrónico. Estas clases son:
- session: define una sesión de correo básica.
- message: representa un mensaje de correo electrónico.
- address: indica la dirección a la que se va a enviar el mensaje
- authenticator: se utiliza para proteger accesos a recursos mediante un nombre de
usuario y una contraseña
- transport: representa un protocolo de transporte específico
- store: representa una base de datos de mensajes que es mantenida por un servidor de
correos electrónicos y agrupada por el usuario.
- folder: proporciona un método para recuperar los mensajes.

1.2 Funcionamiento de un sistema de correo electrónico

Los sistemas de correo electrónico están formados por dos componentes principales: un
cliente de correo, o agente del usuario (UA) y un servidor de correo, o agente de
transferencia de mensajes (MTA).

-1-
El API JavaMail

Los agentes de usuario permiten a los usuarios redactar y enviar mensajes de correo
electrónico y recuperarlos de los agentes de transferencia de mensajes. Ejemplos de agentes de
usuario son, por ejemplo Eudora y Outlook.

Los agentes de transferencia de mensajes son los que almacenan y reenvían el correo
electrónico de los agentes de usuario y admiten el intercambio de correo por una red o grupo de
redes, como por ejemplo los programas que actúan de servidor de correo electrónico como
Sendmail y Exchange.

Figura 2: Funcionamiento de los sistemas de correo electrónico

Para que los agentes de usuarios se puedan comunicar con los agentes de
transferencia de mensajes son necesarios una serie de protocolos, que se describen
brevemente en el siguiente punto.

1.3 Protocolos relacionados

Los protocolos que se utilizan con el API JavaMail son básicamente cuatro: SMTP, POP, IMAP
y MIME, aunque también se utiliza, por ejemplo, NNTP.

· SMTP

El protocolo Simple Mail Transfer Protocol (SMTP) define el mecanismo para enviar e-
mail. En el contexto del API JavaMail, un programa basado en JavaMail comunicará con
el servidor SMTP del proveedor de servicios que dejará el mensaje en el servidor SMTP
del receptor para que sea recogido por los usuarios.

· POP

Post Office Protocol; está actualmente en la versión 3. POP es el mecanismo que la

mayoría de la gente usa en Internet para conseguir su correo. Define el soporte de un sólo
buzón por cada usuario. POP no soporta, como habitualmente se cree, la capacidad de ver

-2-
 A. Rodríguez y R. Rodríguez

cuántos mensajes de correo nuevos tiene un usuario. Estas capacidades se construyen en

programas como Eudora o Microsoft Outlook.

· IMAP

IMAP (Internet Message Access Protocol) es un protocolo más avanzado para recibir
mensajes y está actualmente en la versión 4. Para usar el IMAP, el servidor de correo
debe soportar este protocolo. Si el servidor de correo soporta IMAP, el programa basado
en JavaMail puede aprovecharse de los usuarios que tienen carpetas múltiples en el
servidor y estas carpetas se pueden compartir por varios usuarios

· MIME

Este protocolo (Multi-purpose Internet Mail Extensions) se ha desarrollado para poder

transmitir mensajes multimedia a través de las redes IP. Es, por tanto, una ampliación de
e-mail para la transmisión de información multimedia, que convierte en texto cualquier
clase de información y que la regenera al formato original en el destino.

· NNTP

El NNTP (Networks News Transport Protocol) se basa el servicio de news. Es un

protocolo basado en el modelo cliente/servidor que define el formato, la sintaxis y el
contenido de una conversación entre dos computadoras, donde "conversación" quiere
decir intercambio de grupos de noticias. NNTP fue diseñado de tal manera que los
artículos de noticias son guardados en una Base de Datos Central, permitiendo al usuario
seleccionar los que le interesan, indexarlos, etc.

2. Clases que componen el API JavaMail

Esencialmente, para manejar el API JavaMail hay que entender cómo usar las siete clases que la
componen.

2.1 session

La clase session define una sesión de correo básica. El objeto session utiliza un objeto
java.util.Properties para obtener información, como el servidor de correo, el nombre de
usuario, la contraseña, y otra información que puede compartirse a lo largo de toda la
aplicación.

El constructor para la clase session es privado. Es posible obtener una sola sesión por
defecto que puede ser compartida con el método getDefaultInstance():

-3-
El API JavaMail

Properties props = new Properties();

// se rellena props con la información deseada.
Session session = Session.getDefaultInstance(props, null);

O se puede crear una única sesión con getInstance():

Properties props = new Properties();
// se rellena props con la información deseada.
Session session = Session.getInstance(props, null);
En ambos casos el argumento null es un objeto Authenticator que se verá más adelante.

En la mayoría de los casos, es suficiente usar la sesión compartida, incluso si se trabaja con
una sesión de correo para múltiples buzones de usuario. Se podrá añadir una combinación de
nombre de usuario y contraseña en un paso posterior en el proceso de comunicación.

2.2 message

Una vez que se tiene el objeto session, se puede crear un mensaje para enviar. Esto puede
hacerse con un objeto message.

2.2.1 Estructura de un mensaje:

La clase message define un conjunto de atributos y un contenido para un mensaje de correo

electrónico. Los atributos serán parejas de nombre-valor que especifican la información de la
dirección y definen la estructura del contenido del mensaje, es decir, su tipo de contenido. Los
mensajes pueden contener un único objeto que represente al contenido o, indirectamente, varios
objetos. En cualquier caso, el contenido es manejado con un objeto DataHandler que
proporciona una interfaz consistente para los datos, independientemente de su formato.
- Mensajes simples: van a tener un único objeto que representa al contenido, Éste será
manejado con un DataHandler. La estructura queda del siguiente modo:

Figura 3 – Estructura de un mensaje simple.

-4-
 A. Rodríguez y R. Rodríguez

- Mensajes Multipart: son los mensajes que contienen varios objetos que representan el
contenido. El objeto DataHandler va a contener un objeto Multipart, que a su vez,
contiene objetos BodyPart. La estructura de un objeto BodyPart es similar a la de
un objeto simple ya que ambos implementan la parte que se corresponde con la interfaz
del mensajes:

Figura 4 – Estructura de un mensaje Multipart

2.2.2 Tipos de clases de mensaje

Dependiendo de las aplicaciones que se creen se utilizará uno de estos mensajes:

- Si se tiene una aplicación y el proveedor permite trabajar con mensajes que soportan el
estilo MIME, cosa que es bastante frecuente se puede implementar un mensaje con la
clase: javax.mail.internet.MimeMessage.

o Un MimeMessage es un mensaje que entiende los tipos MIME. Las cabeceras

de mensajes están restringidas a caracteres US-ASCII, aunque en ciertos
campos de cabecera se pueden codificar caracteres no ASCII.

o Para crearlo, se lo pasamos el objeto session al constructor de MimeMessage:

MimeMessage message = new MimeMessage(session);

o El mecanismo para configurar el contenido es el método setContent(), con

argumentos para el contenido y el tipo:

-5-
El API JavaMail

message.setContent("Hello", "text/plain");

Sin embargo, si se trabaja con un MimeMessage y el mensaje es texto, es

posible usar su método setText() que sólo requiere el contenido real,
dejando por defecto el tipo a text/plain: message.setText("Hello");

o Para seleccionar el asunto del mensaje, se utiliza el método setSubject():

message.setSubject("First");
- Si la aplicación va a interaccionar con una que no soporta mensajes MimeMessage, el
mensaje debe ser implementado con una subclase.

2.3 address

Una vez que se ha definido una sesión y se ha creado un mensaje con contenido, hay que poner
dirección al e-mail con un objeto address de la clase:
javax.mail.internet.InternetAddress.

Para crear una dirección con sólo la dirección e-mail, se le pasa al constructor:
Address address = new InternetAddress("rector@usal.es ");

Si se pretende que aparezca el nombre junto a la dirección e-mail, también al constructor:

Address address = new InternetAddress("rector@usal.es ", "Battaner");

Es necesario crear objetos address para los campos from y to del mensaje. Una vez que
se han definido las direcciones, se conectan al mensaje de una de estas dos formas.

- Para identificar al que lo envía, se usa el método setFrom():

message.setFrom(address)
Si el mensaje necesita varias direcciones from, se utiliza el método addFrom():
Address address[] = ...;
message.addFrom(address);
- Para identificar a los receptores del mensaje, se utiliza el método addRecipient().
Este método requiere un tipo predefinido de mensaje junto a la dirección:
message.addRecipient(type, address)

Los tres tipos predefinidos de direcciones son: Message.RecipientType.TO,

Message.RecipientType.CC y Message.RecipientType.BCC. Así, si se desea enviar
una copia de un mensaje a una persona, se hará de la siguiente manera:
Address toAddress = new InternetAddress("rector@usal.es");
Address ccAddress = new InternetAddress("vice-rector@usal.es");
message.addRecipient(Message.RecipientType.TO, toAddress);
message.addRecipient(Message.RecipientType.CC, ccAddress);

-6-
 A. Rodríguez y R. Rodríguez

El API JavaMail no proporciona mecanismos para chequear la validez de una dirección e-

mail.

2.4 authenticator

El API JavaMail puede aprovecharse de un authenticator para proteger accesos a recursos

mediante un nombre de usuario y una contraseña. El authenticator JavaMail se encuentra
en el paquete javax.mail.

Para usar el authenticator se debe registrar con la sesión cuando se crea. Luego, el
authenticator será notificado cuando sea necesaria una autentificación. En ese momento, se
mostrará una ventana o se leerá el nombre del usuario y su contraseña de un fichero (si no está
encriptado no es seguro). Finalmente, se devuelve un objeto PasswordAuthentication del
método getPasswordAuthentication() al llamador.
Properties props = new Properties();
// rellenar props con la información necesaria.
Authenticator auth = new MyAuthenticator();
Session session = Session.getDefaultInstance(props, auth);

2.5 transport

La parte final del envío de un mensaje es usar la clase transport. Esta clase establece el
lenguaje específico del protocolo para enviar mensajes.

Se puede usar la versión por defecto de la clase sólo llamando al método estático send():
Transport.send(message);

Otra opción es obtener un ejemplar específico desde la sesión para el protocolo, pasándole
el nombre de usuario y la contraseña (en blanco si no son necesarias), enviar el mensaje, y
cerrar la conexión:
message.saveChanges();
Transport transport = session.getTransport("smtp");
transport.connect(host, username, password);
transport.sendMessage(message, message.getAllRecipients());
transport.close();

Esta última forma es mejor cuando es necesario enviar varios mensajes, porque mantendrá
activa la conexión entre mensajes. El mecanismo básico send() hace una conexión separada al
servidor para cada llamada a método.

-7-
El API JavaMail

2.6 store

La clase store modela una base de datos de mensajes y su protocolo de acceso para obtener
estos mensajes. Después de obtener la sesión, se conecta a una clase store, probablemente
con un nombre de usuario y una contraseña y se le indica qué protocolo utilizar:

Store store = session.getStore("imap");

Store store = session.getStore("pop3");
store.connect(host, username, password);

2.7 folder

Después de conectar al store, se debe obtener un folder, que debe estar abierto antes de
poder leer los mensajes que hay en su interior:

Folder folder = store.getFolder("INBOX");

folder.open(Folder.READ_ONLY);
Message message[] = folder.getMessages();
/* Esta operación no lee todos los mensajes del servidor, sólo
cuando realmente se necesita obtener una parte del mensaje, el
contenido es recuperado*/

Una vez que se recuperan los mensajes, se puede obtener sus contenidos con
getContent() o escribirlos en una cadena con writeTo() cuya salida también incluye las
cabeceras.
System.out.println(((MimeMessage)message).getContent());

Después de haber leído el e-mail, se cierra la conexión:

folder.close(aBoolean);
store.close();

El valor booleano pasado al método close() significa si se actualiza o no la carpeta

eliminando los mensajes borrados.

3. Utilización del API JavaMail

3.1 Envío de mensajes

Enviar un mensaje de e-mail implica obtener una sesión, crear y rellenar un mensaje y enviarlo.
Se puede especificar el servidor SMTP configurando la propiedad mail.smtp.host del
objeto Properties cuando se obtiene la sesión:

String host = ...;

-8-
 A. Rodríguez y R. Rodríguez

String from = ...;

String to = ...;
Properties props = System.getProperties();
// Se indica el protocolo del servidor
props.put("mail.smtp.host", host);
// Obtención de la sesión
Session session = Session.getDefaultInstance(props, null);
// Definición del mensaje: a quién va dirigido y su contenido
MimeMessage message = new MimeMessage(session);
message.setFrom(new InternetAddress(from));
message.addRecipient(Message.RecipientType.TO,
new InternetAddress(to));
message.setSubject("Hola JavaMail");
message.setText("Bienvenido al API JavaMail");
// Finalmente, se envía el mensaje
Transport.send(message);

3.2 Lectura de mensajes

Para leer mensajes, se debe obtener una sesión, conectarse con el store apropiado para el
buzón, abrir la carpeta apropiada, y obtener los mensajes. No se debe olvidar cerrar la conexión
cuando se haya terminado.
String host = ...;
String username = ...;
String password = ...;
Properties props = new Properties();
// se obtiene la sesión
Session session = Session.getDefaultInstance(props, null);
// conexión con el buzón en el que se almacenan los mensajes
Store store = session.getStore("pop3");
store.connect(host, username, password);
// se indica la carpeta en la que se van a almacenar los mensajes
Folder folder = store.getFolder("INBOX");
folder.open(Folder.READ_ONLY);
// se obtienen los mensajes
Message message[] = folder.getMessages();
for (int i=0, n=message.length; i<n; i++)
{
System.out.println(i + ": " + message[i].getFrom()[0]
+ "\t" + message[i].getSubject());

-9-
El API JavaMail

}
// se cierra la conexión
folder.close(false);
store.close();

El bloque de código anterior sólo muestra de quién viene el mensaje y el asunto. Para
mostrar el mensaje completo, se le preguntará al usuario si quiere verlo después de haya visto
los campos anteriores.

BufferedReader reader = new BufferedReader (

new InputStreamReader(System.in));
// se obtiene el directorio
Message message[] = folder.getMessages();
for (int i=0, n=message.length; i<n; i++)
{
System.out.println(i + ": " + message[i].getFrom()[0]
+ "\t" + message[i].getSubject());
System.out.println("Quiere leer el mensaje? " +
"[SI para leer / NO para salir]");
String line = reader.readLine();
if ("SI".equals(line))
message[i].writeTo(System.out);
else if ("NO".equals(line))
break;
}

3.3 Reenvío

No existe una llamada para reenviar un mensaje, sino que se va a construir el mensaje a reenviar
trabajando con cada una de las partes que componen un mensaje.

Un mensaje puede estar compuesto por varias partes. Cada una de ellas es un BodyPart.
Las distintas partes del cuerpo de un mensaje se combinan en un objeto Multipart. Para
reenviar un mensaje, se crea una parte para el texto de un mensaje y una segunda parte para el
mensaje a reenviar. Ambas partes se combinan en un objeto Multipart. Para terminar se
añade el objeto al mensaje creado para reenviar, se le pone una dirección y se envía como si se
tratara de un mensaje normal.

// Creación del mensaje a reenviar.

Message forward = new MimeMessage(session);
// A continuación se rellena la cabecera
forward.setSubject("Fwd: " + message.getSubject());

- 10 -
 A. Rodríguez y R. Rodríguez

forward.setFrom(new InternetAddress(from));
forward.addRecipient(Message.RecipientType.TO,
new InternetAddress(to));
// Se crea la parte del mensaje correspondiente al texto
BodyPart messageBodyPart = new MimeBodyPart();
messageBodyPart.setText(
"Te reenvío el mensaje original:\n\n");
// Se crea un objeto Multipart
Multipart multipart = new MimeMultipart();
multipart.addBodyPart(messageBodyPart);
// Se crea la parte en la que se incluirá el mensaje inicial
messageBodyPart = new MimeBodyPart();
messageBodyPart.setDataHandler(message.getDataHandler());
// Se añade esta parte al objeto Multipart
multipart.addBodyPart(messageBodyPart);
// Finalmente se asocia el objeto Multipart con el mensaje
forward.setContent(multipart);
// Y se envía.
Transport.send(forward);

3.4 Borrar un mensaje

Borrar mensajes implica trabajar con las banderas asociadas con los mensajes. Para borrar
mensajes se deben seguir los siguientes pasos:
- Primero se debe abrir la carpeta en modo READ_WRITE:
folder.open(Folder.READ_WRITE);
- Después se selecciona la bandera DELETED del mensaje:
message.setFlag(Flags.Flag.DELETED, true);
- Luego, cuando se haya procesado todos los mensajes, se cierras la carpeta, pasando un valor
true para purgar todos los mensajes borrados:
folder.close(true);

3.5 Archivos adjuntos

Los archivos adjuntos son ficheros asociados a un mensaje de correo electrónico que
normalmente son mantenidos fuera del mensaje. JavaMail permite adjuntar recursos a los
mensajes y enviarlos.

Para enviar un mensaje que tenga un archivo adjunto se construye un mensaje completo,
con la dirección, y el contenido, que será un objeto Multipart. A continuación se añade una

- 11 -
El API JavaMail

parte para el texto del mensaje, que estará contenida en un objeto BodyPart y finalmente se crea
otra parte en la que el DataHandler para dicha parte será el archivo adjunto.

Si el archivo adjunto es un fichero, la fuente de datos es FileDataSource y si es una

URL es URLDataSource. Con estas fuentes se obtiene un DataSource que debe ser adjuntado
a la parte creada para el archivo adjunto con la función setDataHandler.

Para terminar hay que darle un nombre a este archivo que se ha adjuntado con la función
setFileName

// Definición del mensaje

Message message = new MimeMessage(session);
message.setFrom(new InternetAddress(from));
message.addRecipient(Message.RecipientType.TO,
new InternetAddress(to));
message.setSubject("Archivo adjunto");
// Se crea la parte para el contenido del mensaje y se rellena
BodyPart messageBodyPart = new MimeBodyPart();
messageBodyPart.setText("Te adjunto el archivo");
// Se crea el objeto Multipart y se le añade el contenido
Multipart multipart = new MimeMultipart();
multipart.addBodyPart(messageBodyPart);
// Se adjunta el archivo
messageBodyPart = new MimeBodyPart();
DataSource source = new FileDataSource(filename);
messageBodyPart.setDataHandler(new DataHandler(source));
messageBodyPart.setFileName(filename);
multipart.addBodyPart(messageBodyPart);
// Se incluye en el objeto Multipart y se envía
message.setContent(multipart);
Transport.send(message);
Enviar un mensaje con un archivo adjunto es sencillo; sin embargo, obtenerlo no lo es ya que
los mensajes de tipo MIME no conocen los archivos adjuntos. Por ello, es preciso procesar cada
una de las partes del objeto Multipart para obtener el contenido principal. Las partes
marcadas con una disposición de Part.ATTACHMENT son claramente archivos adjuntos, pero
éstos también pueden venir sin disposición o con una disposición de Part.INLINE. Cuando la
disposición es Part.ATTACHMENT o Part.INLINE, se graba el contenido de esa parte del
mensaje que tendrá el nombre del fichero original y su contenido:
Multipart mp = (Multipart)message.getContent();
for (int i=0, n=multipart.getCount(); i<n; i++)

- 12 -
 A. Rodríguez y R. Rodríguez

{
Part part = multipart.getBodyPart(i));

String disp = part.getDisposition();

if((disp!=null)&&((disp.equals(Part.ATTACHMENT)||(disp.equals
(Part.INLINE)))
{
saveFile(part.getFileName(), part.getInputStream());
}
}
Si la disposición es null, hay que obtener el tipo de la parte de la forma apropiada:
MimeBodyPart mbp = (MimeBodyPart)part;
if (mbp.isMimeType("text/plain"))
{
...
}
else
{
...
}

3.6 Búsqueda de mensajes

JavaMail incluye un mecanismo de filtrado, que se encuentra en el paquete

javax.mail.search, con el que se pueden buscar mensajes que concuerden con una o varias
condiciones especificadas. La solicitud se realizará a la clase folder:
SearchTerm st = ...;
Message[] msgs = folder.search(st);
Hay muchas clases disponibles para construir una sentencia SearchTerm. Las más habituales
son:
- AndTerm
- OrTerm
- NotTerm
- SendDateTerm
- BodyTerm
- FromTerm/FromStringTerm, RecipientTerm/RecipientStringTerm
- SubjectTerm

- 13 -
El API JavaMail

Ejemplo: expresión lógica que busca los mensajes que bien hayan sido enviados por la dirección
de correo busqueda@javamail.es o bien que contengan la palabra “búsqueda” en el asunto
del mensaje
SearchTerm st = new OrTerm(new SubjectTerm("búsqueda"),
new FromStringTerm("busqueda@javamail.es"));
Message[] msgs = folder.search(st);

4. Ejemplo práctico: Un cliente de correo

Una vez que se han visto todas las clases que proporciona JavaMail y cómo pueden ser usadas,
por ejemplo para leer o enviar un mensaje, puede escribirse el código fuente para una pequeña
aplicación que dispone de una interfaz y que puede enviar un mensaje de correo electrónico a
una dirección específica.

El programa comienza estableciendo la dirección del host a la variable mailHost. Una vez
que éste queda identificado, se crearán los componentes que forman la GUI (Interfaz Gráfica de
Usuario) en la función IniciarComponentes.

El método SendMessage es el núcleo del procesamiento de mensajes del programa. En

este método se utilizan las clases vistas anteriormente para crear un objeto session, un objeto
message y un objeto transport.

Finalmente la clase ButtonHandler maneja los eventos que están asociados con la
interfaz del programa.

import java.atw.*;
import java.atw.event.*;
import java.util.*;
import java.mail.*;
import java.mail.event.*;
import java.mail.internet.*;
public class ClienteDeCorreo extends Frame
{
String mailHost = “javamail.com”;
Label etiqPara = new Label (“Para: “);
Label etiqDe = new Label (“De: “);
Label etiqAsunto = new Label (“Asunto: “);
Label etiqConten = new Label (“Contenido: “);
TextField destino = new TextField ();
TextField origen = new TextField ();

- 14 -
 A. Rodríguez y R. Rodríguez

TextField asunto = new TextField ();

TextField conten = new TextField ();
Button send = new Button (“Enviar Mensaje”);
public static void main (String args[])
{
ClienteDeCorreo app = new ClienteDeCorreo();
}
public ClienteDeCorreo()
{
super(“Cliente de Correo”);
crear ();
addWindowListener (new WindowEventHandler());
setSize (550, 450);
mostrar ();
}
void crear ()
{
IniciarComponentes();
send.addActionListener(new ButtonHandler());
}
void IniciarComponentes()
{
int x=10;
int y=50;
etiqPara.setBounds(x,y,50,25);
destino.setBounds(x+70,y,300,25);
etiqDe.setBounds(x,y+40,50,25);
origen.setBounds(x+70,y+40,300,25);
etiqAsunto.setBounds(x,y+80,50,25);
asunto.setBounds(x+70,y+80,300,25);
etiqConten.setBounds(x,y+120,50,25);
conten.setBounds(x+70,y+120,300,100);
send.setBounds(400, y, 100, 30);
add(etiqPara);
add(destino);
add(etiqDe);
add(origen);
add(etiqAsunto);
add(asunto);

- 15 -
El API JavaMail

add(etiqConten);
add(conten);
}
void sendMessage()
{
Properties props = new Properties();
props.put(“mail.smtp.host”, mailHost);
props.put(“mail.from”, erogen.getText());
Session session = Session.getInstance(props, null);
try
{
Message mens = new MimeMessage(sesion);
InternetAddress[] dir =
new InternetAddress(destino.getText());
mens.setRecipients(Message.RecipientType.TO, dir);
mens.setFrom(new IntenetAddress (origen.getText()));
mens.setSubject(subject.getText());
mens.setContent(content.getText(), “text/plain”);
Transport tr = sesion.getTransport(dir[0]);
tr.connect();
tr.sendMessage(mens,dir);
}
}
class ButtonHandler implements ActionListener
{
public void actionPerformed(ActionEvent ev)
{
String s = ev.getActionCommand();
if (s.equals(“Send Message”))
sendMessage();
}
}
}

4. Conclusiones
El API JavaMail ofrece una plataforma independiente para poder construir aplicaciones Java
basadas en el correo electrónico, ya sea para crear programas clientes de correo electrónico o
para permitir correo en programas como editores o navegadores.

- 16 -
 A. Rodríguez y R. Rodríguez

El API JavaMail no está diseñado para poder implementar un servidor de correo

electrónico, si bien sirve como interfaz entre los agentes de transferencia de mensajes
independientemente del protocolo que se use en la transferencia de estos mensajes. Para ello,
proporciona una importante biblioteca de clases abstractas con las que implementar estas
aplicaciones. En este documento se ha pretendido mostrar cómo usar estas clases para realizar
acciones tan frecuentes como enviar o recibir un mensaje de correo electrónico.

Figura 5: La capa del API JavaMail

5. Referencias bibliográficas
- “Java 1.2 al descubierto” de Jamie Jaworski, editorial Prentice Hall-Sams.
- Tutorial de Sun sobre JavaMail: http://java.sun.com/products/javamail
- Tutorial de Programación de JavaMail: http://programacion.com/java/tutorial/javamail

- 17 -