Enviar emails a través de un servidor SMTP autenticado con Java
Como ya he explicado en la introducción a este articulo, no hace mucho que tuve que realizar un programa en Java que enviara emails.
Lo primero que necesitamos para enviar emails es un servidor SMTP (Single Mail Transmision Protocol), normalmente nuestro administrador de red nos dará la dirección de este servidor, pero si no disponemos de servidor SMTP podemos bajar uno facilmete de internet.
Para la realización de este articulo he utilizado el servidor QK SMTP Server , de QKSoft. Podemos descargar una versión de evaluación de este programa pulsando en este enlace. QK SMTP Server
El siguiente paso que debemos dar es decargar e instalar el API JavaMail, que contiene el conunto de clases que nos van a permitir conectar con el servidor SMTP y enviar emails. Además necesitamos la última versión de JAF Activation.
Para descargar el API JavaMail, http://java.sun.com/products/javamail/downloads/index.html
Para descargar JAF Activation, http://java.sun.com/products/javabeans/glasgow/jaf.html
Los ficheros .zip obtenidos de las descargas anteriores continen abundante documentación y los archivos java (.jar) que necesitamos. Debemos extraer los archivos .jar y modificar nuestro CLASSPATH para incluirlos. Casi todos los IDE de Java permiten agregar referencias a los archivos .jar, y es el propio IDE quien se encarga de generar la variable CLASSPATH correcta en el momento de compilar.
Si queremos un tutorial completo sobre el API JavaMail tenemos uno en el siguiente enlace http://www.programacion.com/java/tutorial/javamail/.
El siguiente programa muestra como enviar un email contra un servidor que requiere autenticación.
El programa está compuesto por las siguientes clases:
-
JavaMailSamples, que contiene el método main y sirve como punto de entrada del programa.
-
SendAuthentication, que nos proporciona un método estático Send que es el encargado de enviar el email.
-
SMTPAuthentication, que es la clase que se encarga de proporcionar el nombre de usuario y clave de acceso al servidor SMTP.
-
ExceptionManager, que es la clase que se encarga de gestionar las posibles excepciones.
El listado de programa es el siguiente:
|
import javax.activation.*;
import javax.mail.*;
import javax.mail.internet.*;
import java.util.Properties;
public class JavaMailSamples
{
public static void main(String[] args)
{
SendAuthentication.Send();
}
}
class SendAuthentication
{
public static void Send()
{
String host = "127.0.0.1";//Suponiendo que el servidor SMTPsea la propia máquina
String from ="remitente";
String to = "destinatario";
System.out.println ("Prueba para enviar un mail..." + new java.util.Date());
Properties prop = new Properties();
prop.put( "mail.smtp.host", host);
/*Esta línea es la que indica al API que debe autenticarse*/
prop.put("mail.smtp.auth", "true");
/*Añadir esta linea si queremos ver una salida detallada del programa*/
//prop.put("mail.debug", "true");
try{
SMTPAuthentication auth = new SMTPAuthentication();
Session session = Session.getInstance(prop , auth );
Message msg = getMessage(session, from, to);
System.out.println ("Enviando ..." );
Transport.send(msg);
System.out.println ( "Mensaje enviado!");
}
catch (Exception e)
{
ExceptionManager.ManageException(e);
}
}
private static MimeMessage getMessage(Session session, String from, String to)
{
try{
MimeMessage msg = new MimeMessage(session);
msg.setText("El mail desde java. Este mensaje a utilizado autenticacion en el servidor.");
msg.addRecipient(Message.RecipientType.TO, new InternetAddress(to));
msg.setFrom(new InternetAddress(from,"JavaMail en accion"));
return msg;
}
catch (java.io.UnsupportedEncodingException ex)
{
ExceptionManager.ManageException(ex);
return null;
}
catch (MessagingException ex)
{
ExceptionManager.ManageException(ex);
return null;
}
}
}
class SMTPAuthentication extends javax.mail.Authenticator
{
public PasswordAuthentication getPasswordAuthentication()
{
String username = "nombre_de_usuario";
String password = "clave";
return new PasswordAuthentication(username, password);
}
}
class ExceptionManager
{
public static void ManageException (Exception e)
{
System.out.println ( "Se ha producido una exception");
System.out.println (e.getMessage());
e.printStackTrace(System.out);
}
} |
Ahora vamos a explicar brevemente el programa. El punto de entrada es la clase JavaMailSamples, que únicamente llama al método Send de la clase SendAuthentication. Lógicamente realizamos las importaciones necesarias para la correcta compilación del código.
El método Send de la clase SendAuthentication es quien realmente realiza todo el trabajo. El método comienza definiendo las variables que se utilizan en el proceso, remitente, destinatario, servidor SMTP ....
Creamos un objeto Properties y le añadimos dos entradas, "mail.smtp.host",con el servidor SMTP que queramos utilizar y "mail.smtp.auth" , dandole el valor true, si no añadimos esta entrada al Properties se producirá una excepción al enviar el mensaje y no se producirá la autenticación en el servidor.
A continuación creamos un objeto de la clase SMTPAuthentication, esta clase está definida a continuación de SendAuthentication. La clase hereda de javax.mail.Authenticator, que es una clase abstracta proporcionada por el API JavaMail. En dicha clase debemos implementar el método getPasswordAuthentication(), definido como abstracto en la clase base, y que devuelve un objeto de tipo PasswordAuthentication. El objeto PasswordAuthentication proporcionará al API el nombre de usuario y clave que le indicamos en el constructor. El API JavaMail ya sabe en que momento debe utilizar estos datos.
Con nuestros objetos Properties y SMTPAuthentication creamos un objeto Session a través del método estatico getInstance() de la propia clase Session.La clase Session pertenece al API y define la sesion utilizada para establecer la conexión con el servidor. Hemos aislado la formación del mensaje en el método getMessage(), que devuelve un objeto MimeMessage, tambien definido por el API, y que representa el mensaje a enviar.
Por último enviamos el mensaje a través del método estático send de la clase Transport. La clase Transport es la clase encargada de la entrega de mensajes al servidor.
La clase ExceptionManager únicamente imprime un mensaje en pantalla indicandonos que se ha producido una excepción.
Con esto hemos conseguido enviar el email.
Saludos a todos y hasta la proxima,
Devjoker.