Mini tutorial JavaMail – Enviar correos con adjuntos en JavaMail (Parte IV) Vamos con nuestra última parte de este mini tutorial de JavaMail. Suponemos que ya te has bajado JavaMail y JAF, además de que has leído -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 envío 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 Session y Transport para la conexión con gmail y envio del mensaje. MimeMessage, MimeMultiPart y MimeBodyPart Para construir el mensaje. 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”, “[email protected]”); 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 javaTambié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 claseFileDataSource, 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(“[email protected]”)); // Se rellenan los destinatarios message.addRecipient(Message.RecipientType.TO, new InternetAddress(“[email protected]”)); // 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(“[email protected]”,”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. Si te ha gustado este post compártelo!!, muchas gracias.

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é

[email protected]–

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 nombrevalor. 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.SSLSocketFact ory” ); 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”,”[email protected]”,”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