Java Gmail

Java Gmail

En el siguiente contenido consta de dos partes:

En la primera explicare como establecer una conexión con Gmail con el protocolo smpt y bajo la capa de conexión segura(SSL).

En la segunda voy a explicar acerca de una clase(Gmail.java)  que podemos re-utilizar para el envio de correos electronicos desde nuestros proyectos en Java.

Parte 1 – Proceso básico del envío de correos electrónicos:

Lo primero vamos a explicar cual es el procedimiento básico de envíos de correos electrónicos con SMTP con Java utilizando la API de: Javax.mail , el cual el proceso básico consiste en tres partes:

  1. Establecer las propiedades de la conexión.
  2. Autenticarse y establecer una sesión.
  3. Agregando atributos del email y envio.

Como se comento vamos a ocupar javax.mail la cual sera una dependencia de nuestro código, para resolver dicha dependencia podemos ocupar maven:

 <dependency>
        <groupId>javax.mail</groupId>
        <artifactId>mail</artifactId>
        <version>1.4</version>
    </dependency>

O bien lo puedes descargar el .jar desde:
http://www.oracle.com/technetwork/java/javasebusiness/downloads/java-archive-downloads-eeplat-419426.html#javamail-1.4.7-oth-JPR

1.- Estableciendo propiedades

Lo primero que tenemos que hacer es definir las propiedades de nuestra conexión para esto ocupamos el paquete java.util.Properties donde vamos a establecer el puerto 465 y activamos la autenticación con capa SSL.

// Paso 1 estableciendo las propiedades de conexión
java.util.Properties mailServerProperties;
mailServerProperties = System.getProperties();
mailServerProperties.put("mail.smtp.host", "smtp.gmail.com");
mailServerProperties.put("mail.smtp.socketFactory.port", "465");
mailServerProperties.put("mail.smtp.socketFactory.class", "javax.net.ssl.SSLSocketFactory");
mailServerProperties.put("mail.smtp.auth", "true");
mailServerProperties.put("mail.smtp.port", "465");

 

2.- Autenticandose

Vamos a identificarnos y establecer sesión para esto ocupamos el paquete javax.mail.Session, como se ve a continuación:

javax.mail.Session getMailSession = Session.getDefaultInstance(
       mailServerProperties,
       new javax.mail.Authenticator() {
	protected PasswordAuthentication getPasswordAuthentication() {
		return new PasswordAuthentication("mi.cuenta@gmail.com", "mi password");
	}
});

3.- Enviado el correo

Enviando el correo

javax.mail.internet.MimeMessage generateMailMessage;
generateMailMessage = new MimeMessage(getMailSession);
//Estableciendo el destino (TO)
generateMailMessage.addRecipient(Message.RecipientType.TO, new InternetAddress("destino@server.com"));

//Estableciendo el destino de la copia (CC)
generateMailMessage.addRecipient(Message.RecipientType.CC, new InternetAddress("con.copia@gmail.com"));

//Estableciendo el destino de la copia oculta (BCC)
generateMailMessage.addRecipient(Message.RecipientType.BCC, new InternetAddress("bcc@hotmail.com"));

//Estableciendo el titulo del mensaje (subject)
generateMailMessage.setSubject("titulo del mensaje a enviar");

// Estableciendo el contenido del correo electronico enriquesido(HTML)
String bodyEmail = "<h1>correo desde gmail</h1><p>Enviado de forma exitosa</p>";
generateMailMessage.setContent(bodyEmail, "text/html");

//Finalmente  enviamos el correo
javax.mail.Transport.send(generateMailMessage);

Parte 2 .- Clase Gmail Una clase lista para enviar desde Gmail

Vamos a crear una clase llamada Gmail en donde le vamos a agregar lo anterior explicado a la vez que la creamos de una forma que sea muy fácil de reutilizar, veamos como quedaría:

package com.mundosica.core.Utils;

import java.util.Properties;

import javax.mail.Message;
import javax.mail.MessagingException;
import javax.mail.PasswordAuthentication;
import javax.mail.Session;
import javax.mail.internet.AddressException;
import javax.mail.internet.InternetAddress;
import javax.mail.internet.MimeMessage;

public class Gmail {
    static Properties mailServerProperties;
    static Session getMailSession;
    static MimeMessage generateMailMessage;
    static String login = "username";
    static String password = "secret";
    static String to = null;
    static String cc = null;
    static String bcc = null;
    static String subject = null;
    static String body = null;
    
    public static void config(String... namesAndValues) {
        if (namesAndValues.length % 2 == 1) {
            throw new IllegalArgumentException("The number of arguments must be pair.");
        }
        String nameConfig = null, valueConfig = null;
        for (int i = 0; i < namesAndValues.length - 1; i += 2) {
            nameConfig = namesAndValues[i].trim().toLowerCase();
            valueConfig = namesAndValues[i +1];
            switch    (nameConfig) {
                case "username":
                case "login":
                    Gmail.login = valueConfig;
                    break;
                case "password":
                case "pass":
                    Gmail.password = valueConfig;
                    break;
                case "to":
                    Gmail.to = valueConfig;
                    break;
                case "cc":
                    Gmail.cc = valueConfig;
                    break;
                case "bcc":
                    Gmail.bcc = valueConfig;
                    break;
                case "title":
                case "subject":
                    Gmail.subject = valueConfig;
                    break;
                case "msg":
                case "body":
                    Gmail.body = valueConfig;
            }
        }
    }
    public static Boolean send(String... namesAndValues) {
        Gmail.config(namesAndValues);
        try {
            return Gmail.send();
        } catch (MessagingException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return false;
    }
    public static Boolean send() throws AddressException, MessagingException {
        Boolean success = false;
        // step 1 set connection properties
        mailServerProperties = System.getProperties();
        mailServerProperties.put("mail.smtp.host", "smtp.gmail.com");
        mailServerProperties.put("mail.smtp.socketFactory.port", "465");
        mailServerProperties.put("mail.smtp.socketFactory.class", "javax.net.ssl.SSLSocketFactory");
        mailServerProperties.put("mail.smtp.auth", "true");
        mailServerProperties.put("mail.smtp.port", "465");
        // step 2 Authentication
        if (Gmail.login == null || Gmail.password == null) {
                return success;
        }
        Session getMailSession = Session.getDefaultInstance(mailServerProperties,new javax.mail.Authenticator() {
            @Override
            protected PasswordAuthentication getPasswordAuthentication() {
            return new PasswordAuthentication(Gmail.login, Gmail.password);
            }
        });

        // step 3 sending Email
        generateMailMessage = new MimeMessage(getMailSession);
        if (Gmail.to != null) {
            generateMailMessage.addRecipient(Message.RecipientType.TO, new InternetAddress(Gmail.to));
        }
        if (Gmail.cc != null) {
            generateMailMessage.addRecipient(Message.RecipientType.CC, new InternetAddress(Gmail.cc));
        }
        if (Gmail.bcc != null) {
            generateMailMessage.addRecipient(Message.RecipientType.BCC, new InternetAddress(Gmail.bcc));
        }
        if (Gmail.subject == null) {
            Gmail.subject = "subject gmail object";
        }
        generateMailMessage.setSubject(Gmail.subject);
        if (Gmail.body == null) {
            Gmail.body = "<h1>body gmail object</h1><p>it's a simple test</p>";
        }
        generateMailMessage.setContent(Gmail.body, "text/html");
        javax.mail.Transport.send(generateMailMessage);
        return success;
    }

}

Test Haciendo una prueba

Haciendo una prueba con Junit, dejo dos ejemplos de como utilizar la clase Gmail:

import org.junit.Test;
public class GmailTest {

    @Test
    public void testSendDirecto() {
        Gmail.send(
                "login", "some.user@gmail.com",
                "password", "secret",
                "to", "edw_inkisidor@hotmail.com",
                "cc", "chanerec@gmail.com",
                "bcc", "eymard@gmail.com",
                "subject", "prueba de email",
                "body", "<h1>Esto es una prueba de envio de correos</h1><p>exitosa!!</p>"
        );
    }
    
    @Test
    public void testConfigYSend() {
        //Esto quizas en el archivo de configuracion
        Gmail.config(
                "username", "some.user@gmail.com", //alias de login
                "pass", "**secret**", //alias de password
                "to", "edw_inkisidor@hotmail.com",
                "cc", "chanerec@gmail.com",
                "bcc", "eymard@gmail.com"
        );
        //esto en donde se envia el correo previamente ya configurado los parametros
        Gmail.send(
                "title", "prueba de email",//alias de subject
                "msg", "<h1>Esto es una prueba de envio de correos</h1><p>exitosa!!</p>"
        );
    }
}

Código en github

Este código forma parte de un conjunto de clases que hemos desarrollado en mundosica.com, del cual extraje esta parte y lo dejo en github para quien lo guste usar:

Visitar proyecto

Fitorec

Me gusta la programación, me fascina el software libre, mis lenguajes preferidos son PHP, JavaScript, Python y Bash (aunque me gusta programar en casi cualquier lenguaje), en sistemas operativos me gusta GNU/Linux.

Más Entradas - Website

Sígueme:
TwitterGoogle PlusYouTubeDelicious

Sin Comentarios

Puedes ser el primero en comentar.

Deja un comentario

Por favor, introduzca su nombre. Please enter an valid email address. Por favor, introduzca un mensaje.