¿Cómo puedo enviar un correo electrónico mediante la aplicación Java usando GMail, Yahoo o Hotmail?

Question

¿Es posible enviar un correo electrónico desde mi aplicación Java utilizando una cuenta de GMail? Configuré el servidor de correo de mi empresa con la aplicación Java para enviar correos electrónicos, pero eso no va a reducirlo cuando distribuyo la aplicación. Las respuestas con cualquiera de usar Hotmail, Yahoo o GMail son aceptables.

Answer 1

Primero descarga el JavaMail API y asegúrese de que los archivos jar relevantes estén en su classpath.

Este es un ejemplo de trabajo completo con GMail.

import java.util.*; 
import javax.mail.*; 
import javax.mail.internet.*; 

public class Main { 

    private static String USER_NAME = "*****"; // GMail user name (just the part before "@gmail.com") 
    private static String PASSWORD = "********"; // GMail password 
    private static String RECIPIENT = "lizard.bill@myschool.edu"; 

    public static void main(String[] args) { 
     String from = USER_NAME; 
     String pass = PASSWORD; 
     String[] to = { RECIPIENT }; // list of recipient email addresses 
     String subject = "Java send mail example"; 
     String body = "Welcome to JavaMail!"; 

     sendFromGMail(from, pass, to, subject, body); 
    } 

    private static void sendFromGMail(String from, String pass, String[] to, String subject, String body) { 
     Properties props = System.getProperties(); 
     String host = "smtp.gmail.com"; 
     props.put("mail.smtp.starttls.enable", "true"); 
     props.put("mail.smtp.host", host); 
     props.put("mail.smtp.user", from); 
     props.put("mail.smtp.password", pass); 
     props.put("mail.smtp.port", "587"); 
     props.put("mail.smtp.auth", "true"); 

     Session session = Session.getDefaultInstance(props); 
     MimeMessage message = new MimeMessage(session); 

     try { 
      message.setFrom(new InternetAddress(from)); 
      InternetAddress[] toAddress = new InternetAddress[to.length]; 

      // To get the array of addresses 
      for(int i = 0; i < to.length; i++) { 
       toAddress[i] = new InternetAddress(to[i]); 
      } 

      for(int i = 0; i < toAddress.length; i++) { 
       message.addRecipient(Message.RecipientType.TO, toAddress[i]); 
      } 

      message.setSubject(subject); 
      message.setText(body); 
      Transport transport = session.getTransport("smtp"); 
      transport.connect(host, from, pass); 
      transport.sendMessage(message, message.getAllRecipients()); 
      transport.close(); 
     } 
     catch (AddressException ae) { 
      ae.printStackTrace(); 
     } 
     catch (MessagingException me) { 
      me.printStackTrace(); 
     } 
    } 
} 

Naturalmente, usted querrá hacer más en los bloques de catch imprimir el seguimiento de la pila como lo hice en el código de ejemplo anterior. (Eliminar los bloques catch para ver qué método llama a las excepciones de la API JavaMail tiro así que mejor puede ver cómo manejar adecuadamente.)

---

Gracias a @jodonnel y todos los demás que respondió. Le estoy dando una recompensa porque su respuesta me llevó aproximadamente el 95% del camino a una respuesta completa.

Answer 2

Una ruta fácil sería tener la cuenta de Gmail configurada/habilitada para el acceso POP3. Esto le permitiría enviar a través de SMTP normal a través de los servidores de Gmail.

Entonces usted acaba de enviar a través smtp.gmail.com (en el puerto 587)

Answer 3

Algo como esto (suena como sólo tiene que cambiar su servidor SMTP):

String host = "smtp.gmail.com"; 
String from = "user name"; 
Properties props = System.getProperties(); 
props.put("mail.smtp.host", host); 
props.put("mail.smtp.user", from); 
props.put("mail.smtp.password", "asdfgh"); 
props.put("mail.smtp.port", "587"); // 587 is the port number of yahoo mail 
props.put("mail.smtp.auth", "true"); 

Session session = Session.getDefaultInstance(props, null); 
MimeMessage message = new MimeMessage(session); 
message.setFrom(new InternetAddress(from)); 

InternetAddress[] to_address = new InternetAddress[to.length]; 
int i = 0; 
// To get the array of addresses 
while (to[i] != null) { 
    to_address[i] = new InternetAddress(to[i]); 
    i++; 
} 
System.out.println(Message.RecipientType.TO); 
i = 0; 
while (to_address[i] != null) { 

    message.addRecipient(Message.RecipientType.TO, to_address[i]); 
    i++; 
} 
message.setSubject("sending in a group"); 
message.setText("Welcome to JavaMail"); 
// alternately, to send HTML mail: 
// message.setContent("<p>Welcome to JavaMail</p>", "text/html"); 
Transport transport = session.getTransport("smtp"); 
transport.connect("smtp.mail.yahoo.co.in", "user name", "asdfgh"); 
transport.sendMessage(message, message.getAllRecipients()); 
transport.close(); 

Answer 4

A pesar de que esta pregunta se cerró, me gustaría publicar una solución de venta libre, pero ahora usando Simple Java Mail (Open Source JavaMail envoltorio SMTP):

final Email email = new Email(); 

String host = "smtp.gmail.com"; 
Integer port = 587; 
String from = "username"; 
String pass = "password"; 
String[] to = {"to@gmail.com"}; 

email.setFromAddress("", from); 
email.setSubject("sending in a group"); 
for(int i=0; i < to.length; i++) { 
    email.addRecipient("", to[i], RecipientType.TO); 
} 
email.setText("Welcome to JavaMail"); 

new Mailer(host, port, from, pass).sendMail(email); 
// you could also still use your mail session instead 
new Mailer(session).sendMail(email); 

Answer 5

Esto es lo que hago cuando quiero enviar correo electrónico con archivo adjunto, funciona bien. :)

public class NewClass { 

    public static void main(String[] args) { 
     try { 
      Properties props = System.getProperties(); 
      props.put("mail.smtp.starttls.enable", "true"); 
      props.put("mail.smtp.host", "smtp.gmail.com"); 
      props.put("mail.smtp.auth", "true"); 
      props.put("mail.smtp.port", "465"); // smtp port 
      Authenticator auth = new Authenticator() { 

       @Override 
       protected PasswordAuthentication getPasswordAuthentication() { 
        return new PasswordAuthentication("username-gmail", "password-gmail"); 
       } 
      }; 
      Session session = Session.getDefaultInstance(props, auth); 
      MimeMessage msg = new MimeMessage(session); 
      msg.setFrom(new InternetAddress("username-gmail@gmail.com")); 
      msg.setSubject("Try attachment gmail"); 
      msg.setRecipient(RecipientType.TO, new InternetAddress("username-gmail@gmail.com")); 
      //add atleast simple body 
      MimeBodyPart body = new MimeBodyPart(); 
      body.setText("Try attachment"); 
      //do attachment 
      MimeBodyPart attachMent = new MimeBodyPart(); 
      FileDataSource dataSource = new FileDataSource(new File("file-sent.txt")); 
      attachMent.setDataHandler(new DataHandler(dataSource)); 
      attachMent.setFileName("file-sent.txt"); 
      attachMent.setDisposition(MimeBodyPart.ATTACHMENT); 
      Multipart multipart = new MimeMultipart(); 
      multipart.addBodyPart(body); 
      multipart.addBodyPart(attachMent); 
      msg.setContent(multipart); 
      Transport.send(msg); 
     } catch (AddressException ex) { 
      Logger.getLogger(NewClass.class.getName()).log(Level.SEVERE, null, ex); 
     } catch (MessagingException ex) { 
      Logger.getLogger(NewClass.class.getName()).log(Level.SEVERE, null, ex); 
     } 
    } 

} 

Answer 6

Otras personas tienen buenas respuestas arriba, pero quería añadir una nota sobre mi experiencia aquí. Descubrí que al usar Gmail como un servidor SMTP de salida para mi aplicación web, Gmail solo me permite enviar aproximadamente 10 mensajes antes de responder con una respuesta antispam que tengo que pasar manualmente para volver a habilitar el acceso SMTP. Los correos electrónicos que estaba enviando no eran spam, pero eran correos electrónicos de "bienvenida" cuando los usuarios se registraron en mi sistema. Entonces, YMMV y yo no dependeríamos de Gmail para una aplicación web de producción. Si envía un correo electrónico en nombre de un usuario, como una aplicación de escritorio instalada (donde el usuario ingresa sus propias credenciales de Gmail), puede estar bien.

Además, si usted está utilizando la primavera, he aquí una configuración de trabajo a utilizar Gmail para SMTP saliente:

<bean id="mailSender" class="org.springframework.mail.javamail.JavaMailSenderImpl"> 
    <property name="defaultEncoding" value="UTF-8"/> 
    <property name="host" value="smtp.gmail.com"/> 
    <property name="port" value="465"/> 
    <property name="username" value="${mail.username}"/> 
    <property name="password" value="${mail.password}"/> 
    <property name="javaMailProperties"> 
     <value> 
      mail.debug=true 
      mail.smtp.auth=true 
      mail.smtp.socketFactory.class=java.net.SocketFactory 
      mail.smtp.socketFactory.fallback=false 
     </value> 
    </property> 
</bean> 

Answer 7

//set CLASSPATH=%CLASSPATH%;activation.jar;mail.jar 
import javax.mail.*; 
import javax.mail.internet.*; 
import java.util.*; 

public class Mail 
{ 
    String d_email = "iamdvr@gmail.com", 
      d_password = "****", 
      d_host = "smtp.gmail.com", 
      d_port = "465", 
      m_to = "iamdvr@yahoo.com", 
      m_subject = "Testing", 
      m_text = "Hey, this is the testing email using smtp.gmail.com."; 
    public static void main(String[] args) 
    { 
     String[] to={"XXX@yahoo.com"}; 
     String[] cc={"XXX@yahoo.com"}; 
     String[] bcc={"XXX@yahoo.com"}; 
     //This is for google 
     Mail.sendMail("venkatesh@dfdf.com", "password", "smtp.gmail.com", 
         "465", "true", "true", 
         true, "javax.net.ssl.SSLSocketFactory", "false", 
         to, cc, bcc, 
         "hi baba don't send virus mails..", 
         "This is my style...of reply..If u send virus mails.."); 
    } 

    public synchronized static boolean sendMail(
     String userName, String passWord, String host, 
     String port, String starttls, String auth, 
     boolean debug, String socketFactoryClass, String fallback, 
     String[] to, String[] cc, String[] bcc, 
     String subject, String text) 
    { 
     Properties props = new Properties(); 
     //Properties props=System.getProperties(); 
     props.put("mail.smtp.user", userName); 
     props.put("mail.smtp.host", host); 
     if(!"".equals(port)) 
      props.put("mail.smtp.port", port); 
     if(!"".equals(starttls)) 
      props.put("mail.smtp.starttls.enable",starttls); 
     props.put("mail.smtp.auth", auth); 
     if(debug) { 
      props.put("mail.smtp.debug", "true"); 
     } else { 
      props.put("mail.smtp.debug", "false");   
     } 
     if(!"".equals(port)) 
      props.put("mail.smtp.socketFactory.port", port); 
     if(!"".equals(socketFactoryClass)) 
      props.put("mail.smtp.socketFactory.class",socketFactoryClass); 
     if(!"".equals(fallback)) 
      props.put("mail.smtp.socketFactory.fallback", fallback); 

     try 
     { 
      Session session = Session.getDefaultInstance(props, null); 
      session.setDebug(debug); 
      MimeMessage msg = new MimeMessage(session); 
      msg.setText(text); 
      msg.setSubject(subject); 
      msg.setFrom(new InternetAddress("p_sambasivarao@sutyam.com")); 
      for(int i=0;i<to.length;i++) { 
       msg.addRecipient(Message.RecipientType.TO, 
           new InternetAddress(to[i])); 
      } 
      for(int i=0;i<cc.length;i++) { 
       msg.addRecipient(Message.RecipientType.CC, 
           new InternetAddress(cc[i])); 
      } 
      for(int i=0;i<bcc.length;i++) { 
       msg.addRecipient(Message.RecipientType.BCC, 
           new InternetAddress(bcc[i])); 
      } 
      msg.saveChanges(); 
      Transport transport = session.getTransport("smtp"); 
      transport.connect(host, userName, passWord); 
      transport.sendMessage(msg, msg.getAllRecipients()); 
      transport.close(); 
      return true; 
     } 
     catch (Exception mex) 
     { 
      mex.printStackTrace(); 
      return false; 
     } 
    } 

} 

Answer 8

Mi código completo como a continuación está funcionando bien:

package ripon.java.mail; 
import java.util.*; 
import javax.mail.*; 
import javax.mail.internet.*; 

public class SendEmail 
{ 
public static void main(String [] args) 
{  
    // Sender's email ID needs to be mentioned 
    String from = "test@gmail.com"; 
    String pass ="test123"; 
    // Recipient's email ID needs to be mentioned. 
    String to = "ripon420@yahoo.com"; 

    String host = "smtp.gmail.com"; 

    // Get system properties 
    Properties properties = System.getProperties(); 
    // Setup mail server 
    properties.put("mail.smtp.starttls.enable", "true"); 
    properties.put("mail.smtp.host", host); 
    properties.put("mail.smtp.user", from); 
    properties.put("mail.smtp.password", pass); 
    properties.put("mail.smtp.port", "587"); 
    properties.put("mail.smtp.auth", "true"); 

    // Get the default Session object. 
    Session session = Session.getDefaultInstance(properties); 

    try{ 
     // Create a default MimeMessage object. 
     MimeMessage message = new MimeMessage(session); 

     // Set From: header field of the header. 
     message.setFrom(new InternetAddress(from)); 

     // Set To: header field of the header. 
     message.addRecipient(Message.RecipientType.TO, 
           new InternetAddress(to)); 

     // Set Subject: header field 
     message.setSubject("This is the Subject Line!"); 

     // Now set the actual message 
     message.setText("This is actual message"); 

     // Send message 
     Transport transport = session.getTransport("smtp"); 
     transport.connect(host, from, pass); 
     transport.sendMessage(message, message.getAllRecipients()); 
     transport.close(); 
     System.out.println("Sent message successfully...."); 
    }catch (MessagingException mex) { 
     mex.printStackTrace(); 
    } 
} 
} 

Answer 9

Las soluciones de código publicadas pueden causar problemas cuando necesite configurar varias sesiones SMTP en cualquier lugar dentro de la misma JVM.

El FAQ JavaMail recomienda el uso de

Session.getInstance(properties); 

en lugar de

Session.getDefaultInstance(properties); 

porque el getDefault sólo usará las propiedades dada la primera vez que se invoca. Todos los usos posteriores de la instancia predeterminada ignorarán los cambios de propiedad.

Ver http://www.oracle.com/technetwork/java/faq-135477.html#getdefaultinstance

Answer 10

Hola probar este código ....

package my.test.service; 

import java.util.Properties; 

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

public class Sample { 
    public static void main(String args[]) { 
     final String SMTP_HOST = "smtp.gmail.com"; 
     final String SMTP_PORT = "587"; 
     final String GMAIL_USERNAME = "xxxxxxxxxx@gmail.com"; 
     final String GMAIL_PASSWORD = "xxxxxxxxxx"; 

     System.out.println("Process Started"); 

     Properties prop = System.getProperties(); 
     prop.setProperty("mail.smtp.starttls.enable", "true"); 
     prop.setProperty("mail.smtp.host", SMTP_HOST); 
     prop.setProperty("mail.smtp.user", GMAIL_USERNAME); 
     prop.setProperty("mail.smtp.password", GMAIL_PASSWORD); 
     prop.setProperty("mail.smtp.port", SMTP_PORT); 
     prop.setProperty("mail.smtp.auth", "true"); 
     System.out.println("Props : " + prop); 

     Session session = Session.getInstance(prop, new Authenticator() { 
      protected PasswordAuthentication getPasswordAuthentication() { 
       return new PasswordAuthentication(GMAIL_USERNAME, 
         GMAIL_PASSWORD); 
      } 
     }); 

     System.out.println("Got Session : " + session); 

     MimeMessage message = new MimeMessage(session); 
     try { 
      System.out.println("before sending"); 
      message.setFrom(new InternetAddress(GMAIL_USERNAME)); 
      message.addRecipients(Message.RecipientType.TO, 
        InternetAddress.parse(GMAIL_USERNAME)); 
      message.setSubject("My First Email Attempt from Java"); 
      message.setText("Hi, This mail came from Java Application."); 
      message.setRecipients(Message.RecipientType.TO, 
        InternetAddress.parse(GMAIL_USERNAME)); 
      Transport transport = session.getTransport("smtp"); 
      System.out.println("Got Transport" + transport); 
      transport.connect(SMTP_HOST, GMAIL_USERNAME, GMAIL_PASSWORD); 
      transport.sendMessage(message, message.getAllRecipients()); 
      System.out.println("message Object : " + message); 
      System.out.println("Email Sent Successfully"); 
     } catch (AddressException e) { 
      // TODO Auto-generated catch block 
      e.printStackTrace(); 
     } catch (MessagingException e) { 
      // TODO Auto-generated catch block 
      e.printStackTrace(); 
     } 
    } 
} 

Answer 11

El mínimo requerido:

import java.util.Properties; 

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

public class MessageSender { 

    public static void sendHardCoded() throws AddressException, MessagingException { 
     String to = "a@a.info"; 
     final String from = "b@gmail.com"; 

     Properties properties = new Properties(); 
     properties.put("mail.smtp.starttls.enable", "true"); 
     properties.put("mail.smtp.auth", "true"); 
     properties.put("mail.smtp.host", "smtp.gmail.com"); 
     properties.put("mail.smtp.port", "587"); 

     Session session = Session.getInstance(properties, 
       new javax.mail.Authenticator() { 
        protected PasswordAuthentication getPasswordAuthentication() { 
         return new PasswordAuthentication(from, "BeNice"); 
        } 
       }); 

     MimeMessage message = new MimeMessage(session); 
     message.setFrom(new InternetAddress(from)); 
     message.addRecipient(Message.RecipientType.TO, new InternetAddress(to)); 
     message.setSubject("Hello"); 
     message.setText("What's up?"); 

     Transport.send(message); 
    } 

} 

Answer 12

Aquí está una clase de fácil uso para el envío de mensajes de correo electrónico con Gmail. Debe tener la biblioteca JavaMailadded to your build path o simplemente usar Maven.

import java.util.Properties; 

import javax.activation.DataHandler; 
import javax.activation.DataSource; 
import javax.activation.FileDataSource; 
import javax.mail.BodyPart; 
import javax.mail.Message; 
import javax.mail.MessagingException; 
import javax.mail.Multipart; 
import javax.mail.Session; 
import javax.mail.Transport; 
import javax.mail.internet.AddressException; 
import javax.mail.internet.InternetAddress; 
import javax.mail.internet.MimeBodyPart; 
import javax.mail.internet.MimeMessage; 
import javax.mail.internet.MimeMultipart; 

public class GmailSender 
{ 
    private static String protocol = "smtp"; 

    private String username; 
    private String password; 

    private Session session; 
    private Message message; 
    private Multipart multipart; 

    public GmailSender() 
    { 
     this.multipart = new MimeMultipart(); 
    } 

    public void setSender(String username, String password) 
    { 
     this.username = username; 
     this.password = password; 

     this.session = getSession(); 
     this.message = new MimeMessage(session); 
    } 

    public void addRecipient(String recipient) throws AddressException, MessagingException 
    { 
     message.addRecipient(Message.RecipientType.TO, new InternetAddress(recipient)); 
    } 

    public void setSubject(String subject) throws MessagingException 
    { 
     message.setSubject(subject); 
    } 

    public void setBody(String body) throws MessagingException 
    { 
     BodyPart messageBodyPart = new MimeBodyPart(); 
     messageBodyPart.setText(body); 
     multipart.addBodyPart(messageBodyPart); 

     message.setContent(multipart); 
    } 

    public void send() throws MessagingException 
    { 
     Transport transport = session.getTransport(protocol); 
     transport.connect(username, password); 
     transport.sendMessage(message, message.getAllRecipients()); 

     transport.close(); 
    } 

    public void addAttachment(String filePath) throws MessagingException 
    { 
     BodyPart messageBodyPart = getFileBodyPart(filePath); 
     multipart.addBodyPart(messageBodyPart); 

     message.setContent(multipart); 
    } 

    private BodyPart getFileBodyPart(String filePath) throws MessagingException 
    { 
     BodyPart messageBodyPart = new MimeBodyPart(); 
     DataSource dataSource = new FileDataSource(filePath); 
     messageBodyPart.setDataHandler(new DataHandler(dataSource)); 
     messageBodyPart.setFileName(filePath); 

     return messageBodyPart; 
    } 

    private Session getSession() 
    { 
     Properties properties = getMailServerProperties(); 
     Session session = Session.getDefaultInstance(properties); 

     return session; 
    } 

    private Properties getMailServerProperties() 
    { 
     Properties properties = System.getProperties(); 
     properties.put("mail.smtp.starttls.enable", "true"); 
     properties.put("mail.smtp.host", protocol + ".gmail.com"); 
     properties.put("mail.smtp.user", username); 
     properties.put("mail.smtp.password", password); 
     properties.put("mail.smtp.port", "587"); 
     properties.put("mail.smtp.auth", "true"); 

     return properties; 
    } 
} 

Ejemplo de uso:

GmailSender sender = new GmailSender(); 
sender.setSender("myEmailNameWithout@gmail.com", "mypassword"); 
sender.addRecipient("recipient@somehost.com"); 
sender.setSubject("The subject"); 
sender.setBody("The body"); 
sender.addAttachment("TestFile.txt"); 
sender.send(); 

Answer 13

Si desea utilizar Outlook con Javamail API a continuación, utilizar

smtp-mail.outlook.com 

como anfitrión de código sea más completa y de trabajo Check out this answer.