Ejemplos java y C/linux

Tutoriales

Enlaces

Licencia

Creative Commons License
Esta obra está bajo una licencia de Creative Commons.
Para reconocer la autoría debes poner el enlace http://www.chuidiang.com

Enviar correos con adjuntos en JavaMail

Suponemos que ya te has bajado JavaMail y JAF, además de que has leido -o sabes- cómo enviar un correo simple con JavaMail.

Ahora que ya sabemos recibir correos con JavaMail y hemos visto más o menos la estructura que tiene un correo compuesto, vamos a enviar nuestro propio correo compuesto: un texto con una imagen adjunta.

Para el ejemplo usaremos una cuenta de gmail. Aunque mencionaré aquí como conectarse, puedes ver aquí los detalles de la conexión con gmail para el envio de correos.

Habíamos visto que un correo compuesto tiene más o menos una estructura de árbol. Cada nodo del árbol tiene como datos una clase MultiPart. Las hojas del árbol son las que contienen la información del correo, es decir, el texto, la imagen, etc.

Vamos a ello.

Clases implicadas

Las clases que necesitamos para enviar un correo con adjuntos con JavaMail son

Obtención de Session

Como mencionamos en el envio de un correo sencillo, necesitamos obtener una instancia de Session y para ello necesitamos previamente rellenar una variable Properties.

Properties props = new Properties();
props.put("mail.smtp.host", "smtp.gmail.com");
props.setProperty("mail.smtp.starttls.enable", "true");
props.setProperty("mail.smtp.port","587");
props.setProperty("mail.smtp.user", "chuidiang@gmail.com");
props.setProperty("mail.smtp.auth", "true");

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

Los detalles de estos valores que hemos rellenado puedes verlos en el enlace anterior.

Con esto ya tenemos instanciada la clase Session. Vamos ahora a construir el mensaje

Construir un correo de texto con un adjunto

Lo primero vamos a construir las dos partes del mensaje. El texto y la imagen. Para ello, instanciamos dos clases MimeBodyPart y las rellenamos con los datos.

Empezamos con la de texto, que es más sencilla

BodyPart texto = new MimeBodyPart();
texto.setText("Texto del mensaje");

Ya está. Al usar el método setText() sin parámetros, ya se está configurando todo para que sea un texto plano -text/plain en MIME type-.

El adjunto con la imagen también es sencillo. Supongamos que tenemos la imagen en un fichero D:\futbol.gif -por supuesto, de una extensión conocida por java-

También debemos crear un MimeBodyPart, pero esta vez llamamos al método setContent(). A este método hay que pasarle un DataHandler, que es una clase capaz de manejar los datos que vayan en esta parte. Para instanciar ese DataHandler debemos darle una fuente de datos. La fuente, puesto que tenemos la imagen en fichero, puede ser una clase FileDataSource, capaz de leer un fichero con datos y saber de qué tipo es (imagen, audio, etc). En resumen, el código sería este

BodyPart adjunto = new MimeBodyPart();
adjunto.setDataHandler(new DataHandler(new FileDataSource("d:/futbol.gif")));
adjunto.setFileName("futbol.gif");

La llamada a setFileName() es opcional. Haciéndola le daremos al receptor del correo posibilidad de saber el nombre del fichero de imagen. Si no lo ponemos, no pasa nada.

Juntar el texto y la imagen adjunta

Ahora debemos juntar estas dos partes en una única parte compuesta.

Para ello, instanciamos una clase MimeMultiPart y le añadimos ambos cachos. La clase MimeMultiPart no es más que una parte más de un correo, pero que está a su vez compuesta de otras partes -el texto y la imagen en nuestro caso-. Podemos ir añadiendo aquí todas las imagenes y otros ficheros que queramos.

MimeMultipart multiParte = new MimeMultipart();

multiParte.addBodyPart(texto);
multiParte.addBodyPart(adjunto);

Ya está. Ahora sólo nos falta el mensaje en sí, algo a lo que podamos dar un destinatario de correo, un asunto -subject-, etc.

Construir el mensaje de correo

El mensaje a construir es simplemente una instancia de MimeMessage. Al instanciarlo debemos pasarle el objeto Session que obtuvimos anteriormente. También debemos rellenar los campos de destinatario y demás. Y finalmente también debemos rellenar el contenido, metiendo nuestro MimeMultipart anterior.

Los detalles de los campos subject, to y from puedes verlos en el envío de un mensaje sencillo con JavaMail.

El código quedaría así

MimeMessage message = new MimeMessage(session);

// Se rellena el From
message.setFrom(new InternetAddress("yo@yo.com"));

// Se rellenan los destinatarios
message.addRecipient(Message.RecipientType.TO, new InternetAddress("chuidiang@gmail.com"));

// Se rellena el subject
message.setSubject("Hola");

// Se mete el texto y la foto adjunta.
message.setContent(multiParte);

Ya tenemos compuesto el total del correo. Ahora sólo queda enviarlo

Enviar el correo

Ya lo vimos en el ejemplo sencillo de envio de correo con JavaMail. Sólo tenemos que hacer lo siguiente.

Transport t = session.getTransport("smtp");
t.connect("chuidiang@gmail.com","la password");
t.sendMessage(message,message.getAllRecipients());
t.close();

Simplemente obtenemos una instancia de Transport, que es la clase encargada del envio del correo.

Realizamos la conexión dando usuario -correo de gmail de la cuenta que estemos usando- y la clave.

Enviamos el mensaje con sendMessage(). Ojo, no uses el método send() a secas, porque ese no tiene en cuenta los parámetros de conexión.

En EnviarMailComplejo.java tienes todo esto en un pequeño programita de prueba.

Estadísticas y comentarios

Numero de visitas desde el 4 Feb 2007: