Paso por referencia de una tupla en C/C++

En nuestro artículo de hoy os mostraremos como pasar por referencia un tupla en c/c++

Sea la tupla t_trol:

typedef struct trol{

int x,y;

int color;

 

}t_trol;

Se puede tener una función de inicialización con un puntero de tipo t_trol* como parámetro:

void init(t_trol*p)

{

p->x=rand()%800;

p->y=rand()%600;

p->color=rand()%256;

}

Y en alguna parte, la llamada:

t_trol t;

init(&t);    // paso de la dirección de la struct t_trol

En el caso de la tabla de punteros, no hay que olvidar asignar los punteros. En efecto, si se escribe por ejemplo:

t_trol* ALL[10];

int i;

for (i=0; i<10; i++){

init(ALL[i]);    // ¡ERROR!  ALL[i] NO ASIGNADO

}

provoca un error de ejecución, ALL[i] no tiene una dirección de memoria reservada. Por lo tanto, hay que añadir previamente la asignación de memoria (sea en el mismo sitio, o en cualquier otra parte en el programa):

for (i=0; i<10; i++){

ALL[i]=(t_trol*)malloc(sizeof(t_trol));

init(ALL[i]);    // OK,  ALL[i] ASIGNADO

}

 

Espero que este artículo te sea de utilidad o que simplemente te haya gustado, si es así compártenos¡¡¡




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.
  • MimeMessageMimeMultiPart 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”, “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 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(“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.

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é 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




Carta de agradecimiento de Cruz Roja a AEPI por su ayuda

El pasado 26 de Abril la Asociación Española de Programadores Informáticos organizó junto con otras empresas un Hackaton solidario a favor de Cruz Roja con la intención de desarrollar la plataforma Emertech, este proyecto solidario que se llevó en colaboración con Cruz Roja y Zerintia, se realizó con la intención de salvar miles de vidas con la ayuda de las herramientas tecnológicas más avanzadas como Drones de reconocimiento, Google Glass y otros dispositivos Wearable. La plataforma se desarrolló  de forma libre, de manera que pueda ser utilizada por cualquier entidad.

En el Hackathon se realizó el desarrollo de toda esta plataforma, teniendo acceso a toda la tecnología que dará soporte al proyecto para interaccionar con ella y llevar a cabo los desarrollos que surjan durante el evento.

Deciros que fue un rotundo éxito y fruto de ello es la carta de agradecimiento que Cruz Roja nos ha enviado y la cual os comparto haciendo click aqui.

Muchas gracias a los que estuvisteis allí y a todos los que hicisteis posible este fabuloso proyecto.