E-mail verzenden met Java

Ik probeer een e-mail te sturen met Java:

import java.util.*;
import javax.mail.*;
import javax.mail.internet.*;
import javax.activation.*;
public class SendEmail {
   public static void main(String [] args) {
      // Recipient's email ID needs to be mentioned.
      String to = "[email protected]";
      // Sender's email ID needs to be mentioned
      String from = "[email protected]";
      // Assuming you are sending email from localhost
      String host = "localhost";
      // Get system properties
      Properties properties = System.getProperties();
      // Setup mail server
      properties.setProperty("mail.smtp.host", host);
      // 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.send(message);
         System.out.println("Sent message successfully....");
      }catch (MessagingException mex) {
         mex.printStackTrace();
      }
   }
}

Ik krijg de foutmelding:

javax.mail.MessagingException: Could not connect to SMTP host: localhost, port: 25;
  nested exception is:java.net.ConnectException: Connection refused: connect
        at com.sun.mail.smtp.SMTPTransport.openServer(SMTPTransport.java:1706)
        at com.sun.mail.smtp.SMTPTransport.protocolConnect(SMTPTransport.java:525)

Werkt deze code om e-mail te verzenden?


Antwoord 1, Autoriteit 100%

De volgende code werkt erg goed met Google SMTP-server. U moet uw Google-gebruikersnaam en wachtwoord leveren.

import com.sun.mail.smtp.SMTPTransport;
import java.security.Security;
import java.util.Date;
import java.util.Properties;
import javax.mail.Message;
import javax.mail.MessagingException;
import javax.mail.Session;
import javax.mail.internet.AddressException;
import javax.mail.internet.InternetAddress;
import javax.mail.internet.MimeMessage;
/**
 *
 * @author doraemon
 */
public class GoogleMail {
    private GoogleMail() {
    }
    /**
     * Send email using GMail SMTP server.
     *
     * @param username GMail username
     * @param password GMail password
     * @param recipientEmail TO recipient
     * @param title title of the message
     * @param message message to be sent
     * @throws AddressException if the email address parse failed
     * @throws MessagingException if the connection is dead or not in the connected state or if the message is not a MimeMessage
     */
    public static void Send(final String username, final String password, String recipientEmail, String title, String message) throws AddressException, MessagingException {
        GoogleMail.Send(username, password, recipientEmail, "", title, message);
    }
    /**
     * Send email using GMail SMTP server.
     *
     * @param username GMail username
     * @param password GMail password
     * @param recipientEmail TO recipient
     * @param ccEmail CC recipient. Can be empty if there is no CC recipient
     * @param title title of the message
     * @param message message to be sent
     * @throws AddressException if the email address parse failed
     * @throws MessagingException if the connection is dead or not in the connected state or if the message is not a MimeMessage
     */
    public static void Send(final String username, final String password, String recipientEmail, String ccEmail, String title, String message) throws AddressException, MessagingException {
        Security.addProvider(new com.sun.net.ssl.internal.ssl.Provider());
        final String SSL_FACTORY = "javax.net.ssl.SSLSocketFactory";
        // Get a Properties object
        Properties props = System.getProperties();
        props.setProperty("mail.smtps.host", "smtp.gmail.com");
        props.setProperty("mail.smtp.socketFactory.class", SSL_FACTORY);
        props.setProperty("mail.smtp.socketFactory.fallback", "false");
        props.setProperty("mail.smtp.port", "465");
        props.setProperty("mail.smtp.socketFactory.port", "465");
        props.setProperty("mail.smtps.auth", "true");
        /*
        If set to false, the QUIT command is sent and the connection is immediately closed. If set 
        to true (the default), causes the transport to wait for the response to the QUIT command.
        ref :   http://java.sun.com/products/javamail/javadocs/com/sun/mail/smtp/package-summary.html
                http://forum.java.sun.com/thread.jspa?threadID=5205249
                smtpsend.java - demo program from javamail
        */
        props.put("mail.smtps.quitwait", "false");
        Session session = Session.getInstance(props, null);
        // -- Create a new message --
        final MimeMessage msg = new MimeMessage(session);
        // -- Set the FROM and TO fields --
        msg.setFrom(new InternetAddress(username + "@gmail.com"));
        msg.setRecipients(Message.RecipientType.TO, InternetAddress.parse(recipientEmail, false));
        if (ccEmail.length() > 0) {
            msg.setRecipients(Message.RecipientType.CC, InternetAddress.parse(ccEmail, false));
        }
        msg.setSubject(title);
        msg.setText(message, "utf-8");
        msg.setSentDate(new Date());
        SMTPTransport t = (SMTPTransport)session.getTransport("smtps");
        t.connect("smtp.gmail.com", username, password);
        t.sendMessage(msg, msg.getAllRecipients());      
        t.close();
    }
}

Update op 11 december 2015

Gebruikersnaam + wachtwoord is niet langer een aanbevolen oplossing. Dit komt door

Ik heb dit geprobeerd en Gmail heeft de e-mail verzonden die als gebruikersnaam in deze code is gebruikt en
e-mail waarin staat dat we onlangs een inlogpoging op uw Google hebben geblokkeerd
Account, en stuurde me naar deze ondersteuningspagina:
support.google.com/accounts/answer/6010255 dus het lijkt erop dat het werkt,
het e-mailaccount dat wordt gebruikt om te verzenden, moet hun eigen e-mail verminderen
beveiliging

Google heeft Gmail API uitgebracht – https://developers.google.com/gmail /api/?hl=nl. We moeten de oAuth2-methode gebruiken in plaats van gebruikersnaam + wachtwoord.

Hier is het codefragment om met de Gmail API te werken.

GoogleMail.java

import com.google.api.client.util.Base64;
import com.google.api.services.gmail.Gmail;
import com.google.api.services.gmail.model.Message;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.util.Properties;
import javax.mail.MessagingException;
import javax.mail.Session;
import javax.mail.internet.InternetAddress;
import javax.mail.internet.MimeMessage;
/**
 *
 * @author doraemon
 */
public class GoogleMail {
    private GoogleMail() {
    }
    private static MimeMessage createEmail(String to, String cc, String from, String subject, String bodyText) throws MessagingException {
        Properties props = new Properties();
        Session session = Session.getDefaultInstance(props, null);
        MimeMessage email = new MimeMessage(session);
        InternetAddress tAddress = new InternetAddress(to);
        InternetAddress cAddress = cc.isEmpty() ? null : new InternetAddress(cc);
        InternetAddress fAddress = new InternetAddress(from);
        email.setFrom(fAddress);
        if (cAddress != null) {
            email.addRecipient(javax.mail.Message.RecipientType.CC, cAddress);
        }
        email.addRecipient(javax.mail.Message.RecipientType.TO, tAddress);
        email.setSubject(subject);
        email.setText(bodyText);
        return email;
    }
    private static Message createMessageWithEmail(MimeMessage email) throws MessagingException, IOException {
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        email.writeTo(baos);
        String encodedEmail = Base64.encodeBase64URLSafeString(baos.toByteArray());
        Message message = new Message();
        message.setRaw(encodedEmail);
        return message;
    }
    public static void Send(Gmail service, String recipientEmail, String ccEmail, String fromEmail, String title, String message) throws IOException, MessagingException {
        Message m = createMessageWithEmail(createEmail(recipientEmail, ccEmail, fromEmail, title, message));
        service.users().messages().send("me", m).execute();
    }
}

Hier is het codefragment om een geautoriseerde Gmail-service te bouwen via oAuth2.

Utils.java

import com.google.api.client.auth.oauth2.Credential;
import com.google.api.client.extensions.jetty.auth.oauth2.LocalServerReceiver;
import com.google.api.client.googleapis.auth.oauth2.GoogleAuthorizationCodeFlow;
import com.google.api.client.googleapis.auth.oauth2.GoogleClientSecrets;
import com.google.api.client.googleapis.javanet.GoogleNetHttpTransport;
import com.google.api.client.http.HttpTransport;
import com.google.api.client.json.gson.GsonFactory;
import com.google.api.client.util.store.FileDataStoreFactory;
import com.google.api.services.gmail.Gmail;
import com.google.api.services.gmail.GmailScopes;
import com.google.api.services.oauth2.Oauth2;
import com.google.api.services.oauth2.model.Userinfoplus;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.security.GeneralSecurityException;
import java.util.HashSet;
import java.util.Set;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.yccheok.jstock.engine.Pair;
/**
 *
 * @author yccheok
 */
public class Utils {
    /** Global instance of the JSON factory. */
    private static final GsonFactory JSON_FACTORY = GsonFactory.getDefaultInstance();
    /** Global instance of the HTTP transport. */
    private static HttpTransport httpTransport;
    private static final Log log = LogFactory.getLog(Utils.class);
    static {
        try {
            // initialize the transport
            httpTransport = GoogleNetHttpTransport.newTrustedTransport();
        } catch (IOException ex) {
            log.error(null, ex);
        } catch (GeneralSecurityException ex) {
            log.error(null, ex);
        }
    }
    private static File getGmailDataDirectory() {
        return new File(org.yccheok.jstock.gui.Utils.getUserDataDirectory() + "authentication" + File.separator + "gmail");
    }
    /**
     * Send a request to the UserInfo API to retrieve the user's information.
     *
     * @param credentials OAuth 2.0 credentials to authorize the request.
     * @return User's information.
     * @throws java.io.IOException
     */
    public static Userinfoplus getUserInfo(Credential credentials) throws IOException
    {
        Oauth2 userInfoService =
            new Oauth2.Builder(httpTransport, JSON_FACTORY, credentials).setApplicationName("JStock").build();
        Userinfoplus userInfo  = userInfoService.userinfo().get().execute();
        return userInfo;
    }
    public static String loadEmail(File dataStoreDirectory)  {
        File file = new File(dataStoreDirectory, "email");
        try {
            return new String(Files.readAllBytes(Paths.get(file.toURI())), "UTF-8");
        } catch (IOException ex) {
            log.error(null, ex);
            return null;
        }
    }
    public static boolean saveEmail(File dataStoreDirectory, String email) {
        File file = new File(dataStoreDirectory, "email");
        try {
            //If the constructor throws an exception, the finally block will NOT execute
            BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(file), "UTF-8"));
            try {
                writer.write(email);
            } finally {
                writer.close();
            }
            return true;
        } catch (IOException ex){
            log.error(null, ex);
            return false;
        }
    }
    public static void logoutGmail() {
        File credential = new File(getGmailDataDirectory(), "StoredCredential");
        File email = new File(getGmailDataDirectory(), "email");
        credential.delete();
        email.delete();
    }
    public static Pair<Pair<Credential, String>, Boolean> authorizeGmail() throws Exception {
        // Ask for only the permissions you need. Asking for more permissions will
        // reduce the number of users who finish the process for giving you access
        // to their accounts. It will also increase the amount of effort you will
        // have to spend explaining to users what you are doing with their data.
        // Here we are listing all of the available scopes. You should remove scopes
        // that you are not actually using.
        Set<String> scopes = new HashSet<>();
        // We would like to display what email this credential associated to.
        scopes.add("email");
        scopes.add(GmailScopes.GMAIL_SEND);
        // load client secrets
        GoogleClientSecrets clientSecrets = GoogleClientSecrets.load(Utils.JSON_FACTORY,
            new InputStreamReader(Utils.class.getResourceAsStream("/assets/authentication/gmail/client_secrets.json")));
        return authorize(clientSecrets, scopes, getGmailDataDirectory());
    }
    /** Authorizes the installed application to access user's protected data.
     * @return 
     * @throws java.lang.Exception */
    private static Pair<Pair<Credential, String>, Boolean> authorize(GoogleClientSecrets clientSecrets, Set<String> scopes, File dataStoreDirectory) throws Exception {
        // Set up authorization code flow.
        GoogleAuthorizationCodeFlow flow = new GoogleAuthorizationCodeFlow.Builder(
            httpTransport, JSON_FACTORY, clientSecrets, scopes)
            .setDataStoreFactory(new FileDataStoreFactory(dataStoreDirectory))
            .build();
        // authorize
        return new MyAuthorizationCodeInstalledApp(flow, new LocalServerReceiver()).authorize("user");
    }
    public static Gmail getGmail(Credential credential) {
        Gmail service = new Gmail.Builder(httpTransport, JSON_FACTORY, credential).setApplicationName("JStock").build();
        return service;        
    }
}

Om een gebruiksvriendelijke manier van oAuth2-authenticatie te bieden, heb ik JavaFX gebruikt om het volgende invoervenster weer te geven

De sleutel om de gebruiksvriendelijke oAuth2-dialoog weer te geven is te vinden in MyAuthorizationCodeInstalledApp.javaen SimpleSwingBrowser.java


Antwoord 2, autoriteit 49%

De volgende code werkte voor mij.

import java.io.UnsupportedEncodingException;
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 SendMail {
    public static void main(String[] args) {
        final String username = "[email protected]";
        final String password = "yourpassword";
        Properties props = new Properties();
        props.put("mail.smtp.starttls.enable", "true");
        props.put("mail.smtp.auth", "true");
        props.put("mail.smtp.host", "smtp.gmail.com");
        props.put("mail.smtp.port", "587");
        Session session = Session.getInstance(props,
          new javax.mail.Authenticator() {
            protected PasswordAuthentication getPasswordAuthentication() {
                return new PasswordAuthentication(username, password);
            }
          });
        try {
            Message message = new MimeMessage(session);
            message.setFrom(new InternetAddress("[email protected]"));
            message.setRecipients(Message.RecipientType.TO,
                InternetAddress.parse("[email protected]"));
            message.setSubject("Testing Subject");
            message.setText("Dear Mail Crawler,"
                + "\n\n No spam to my email, please!");
            Transport.send(message);
            System.out.println("Done");
        } catch (MessagingException e) {
            throw new RuntimeException(e);
        }
    }
}

Antwoord 3, autoriteit 17%

import java.util.Date;
import java.util.Properties;
import javax.mail.Message;
import javax.mail.PasswordAuthentication;
import javax.mail.Session;
import javax.mail.Transport;
import javax.mail.internet.InternetAddress;
import javax.mail.internet.MimeMessage;
public class SendEmail extends Object{
public static void main(String [] args)
{
    try{
        Properties props = new Properties();
        props.put("mail.smtp.host", "smtp.mail.yahoo.com"); // for gmail use smtp.gmail.com
        props.put("mail.smtp.auth", "true");
        props.put("mail.debug", "true"); 
        props.put("mail.smtp.starttls.enable", "true");
        props.put("mail.smtp.port", "465");
        props.put("mail.smtp.socketFactory.port", "465");
        props.put("mail.smtp.socketFactory.class", "javax.net.ssl.SSLSocketFactory");
        props.put("mail.smtp.socketFactory.fallback", "false");
        Session mailSession = Session.getInstance(props, new javax.mail.Authenticator() {
            protected PasswordAuthentication getPasswordAuthentication() {
                return new PasswordAuthentication("[email protected]", "password");
            }
        });
        mailSession.setDebug(true); // Enable the debug mode
        Message msg = new MimeMessage( mailSession );
        //--[ Set the FROM, TO, DATE and SUBJECT fields
        msg.setFrom( new InternetAddress( "[email protected]" ) );
        msg.setRecipients( Message.RecipientType.TO,InternetAddress.parse("[email protected]") );
        msg.setSentDate( new Date());
        msg.setSubject( "Hello World!" );
        //--[ Create the body of the mail
        msg.setText( "Hello from my first e-mail sent with JavaMail" );
        //--[ Ask the Transport class to send our mail message
        Transport.send( msg );
    }catch(Exception E){
        System.out.println( "Oops something has gone pearshaped!");
        System.out.println( E );
    }
}
}

Vereiste jar-bestanden

Klik hier – Externe potten toevoegen


Antwoord 4, autoriteit 11%

Het korte antwoord – Nee.

Het lange antwoord – nee, aangezien de code afhankelijk is van de aanwezigheid van een SMTP-server die op de lokale computer draait en luistert op poort 25. De SMTP-server (technisch gezien de MTA of Mail Transfer Agent) is verantwoordelijk voor de communicatie met de Mail User Agent (MUA, in dit geval het Java-proces) om uitgaande e-mails te ontvangen.

Nu zijn MTA’s doorgaans verantwoordelijk voor het ontvangen van e-mails van gebruikers voor een bepaald domein. Voor het domein gmail.com zouden het dus de Google-mailservers zijn die verantwoordelijk zijn voor het verifiëren van e-mailgebruikersagenten en dus voor het overbrengen van e-mails naar inboxen op de GMail-servers. Ik weet niet zeker of GMail open mail relay-servers vertrouwt, maar het is zeker geen gemakkelijke taak om namens Google authenticatie uit te voeren en vervolgens mail door te sturen naar de GMail-servers.

Als je de Veelgestelde vragen over JavaMail over het gebruik van JavaMail om toegang te krijgen tot GMail, zult u merken dat de hostnaam en de poort naar de GMail-servers verwijzen, en zeker niet naar localhost. Als u van plan bent uw lokale machine te gebruiken, moet u ofwel relaying ofwel forwarding uitvoeren.

U zult waarschijnlijk het SMTP-protocol grondig moeten begrijpen als u iets wilt bereiken als het op SMTP aankomt. U kunt beginnen met het Wikipedia-artikel over SMTP, maar voor verdere vooruitgang is programmeren tegen een SMTP-server.


Antwoord 5, autoriteit 6%

Je hebt een SMTP-server nodig voor het verzenden van e-mails. Er zijn servers die je lokaal op je eigen pc kunt installeren, of je kunt gebruik maken van een van de vele online servers. Een van de meer bekende servers is die van Google:

Ik heb zojuist de toegestane Google SMTP-configuratiesgetest met de eerste voorbeeld van Simple Java Mail:

   final Email email = EmailBuilder.startingBlank()
        .from("lollypop", "[email protected]")
        .to("C.Cane", "[email protected]")
        .withPlainText("We should meet up!")
        .withHTMLText("<b>We should meet up!</b>")
        .withSubject("hey");
    // starting 5.0.0 do the following using the MailerBuilder instead...
    new Mailer("smtp.gmail.com", 25, "your user", "your password", TransportStrategy.SMTP_TLS).sendMail(email);
    new Mailer("smtp.gmail.com", 587, "your user", "your password", TransportStrategy.SMTP_TLS).sendMail(email);
    new Mailer("smtp.gmail.com", 465, "your user", "your password", TransportStrategy.SMTP_SSL).sendMail(email);

Let op de verschillende poorten en transportstrategieën (die alle benodigde eigenschappen voor u afhandelen).

Vreemd genoeg vereist Google ook TLS op poort 25, hoewel de instructies van Google anders zeggen.


Antwoord 6, autoriteit 4%

Het is alweer een tijdje geleden dat dit gepost is. Maar vanaf 13 november 2012 kan ik verifiëren dat poort 465 nog steeds werkt.

Raadpleeg het antwoord van GaryM op dit forum.
Ik hoop dat dit nog een paar mensen helpt.

/*
* Created on Feb 21, 2005
*
*/
import java.security.Security;
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.InternetAddress;
import javax.mail.internet.MimeMessage;
public class GoogleTest {
    private static final String SMTP_HOST_NAME = "smtp.gmail.com";
    private static final String SMTP_PORT = "465";
    private static final String emailMsgTxt = "Test Message Contents";
    private static final String emailSubjectTxt = "A test from gmail";
    private static final String emailFromAddress = "";
    private static final String SSL_FACTORY = "javax.net.ssl.SSLSocketFactory";
    private static final String[] sendTo = { "" };
    public static void main(String args[]) throws Exception {
        Security.addProvider(new com.sun.net.ssl.internal.ssl.Provider());
        new GoogleTest().sendSSLMessage(sendTo, emailSubjectTxt,
            emailMsgTxt, emailFromAddress);
        System.out.println("Sucessfully mail to All Users");
    }
    public void sendSSLMessage(String recipients[], String subject,
                               String message, String from) throws MessagingException {
        boolean debug = true;
        Properties props = new Properties();
        props.put("mail.smtp.host", SMTP_HOST_NAME);
        props.put("mail.smtp.auth", "true");
        props.put("mail.debug", "true");
        props.put("mail.smtp.port", SMTP_PORT);
        props.put("mail.smtp.socketFactory.port", SMTP_PORT);
        props.put("mail.smtp.socketFactory.class", SSL_FACTORY);
        props.put("mail.smtp.socketFactory.fallback", "false");
        Session session = Session.getDefaultInstance(props,
            new javax.mail.Authenticator() {
                protected PasswordAuthentication getPasswordAuthentication() {
                    return new PasswordAuthentication("xxxxxx", "xxxxxx");
            }
        });
        session.setDebug(debug);
        Message msg = new MimeMessage(session);
        InternetAddress addressFrom = new InternetAddress(from);
        msg.setFrom(addressFrom);
        InternetAddress[] addressTo = new InternetAddress[recipients.length];
        for (int i = 0; i < recipients.length; i++) {
            addressTo[i] = new InternetAddress(recipients);
        }
        msg.setRecipients(Message.RecipientType.TO, addressTo);
        // Setting the Subject and Content Type
        msg.setSubject(subject);
        msg.setContent(message, "text/plain");
        Transport.send(msg);
    }
}

Antwoord 7, Autoriteit 3%

De volgende code werkt erg goed. Probeer dit als een Java-applicatie met Javamail-1.4.5.jar

import javax.mail.*;
import javax.mail.internet.*;
import java.util.*;
public class MailSender
{
    final String senderEmailID = "[email protected]";
    final String senderPassword = "typesenderpassword";
    final String emailSMTPserver = "smtp.gmail.com";
    final String emailServerPort = "465";
    String receiverEmailID = null;
    static String emailSubject = "Test Mail";
    static String emailBody = ":)";
    public MailSender(
            String receiverEmailID,
            String emailSubject,
            String emailBody
    ) {
        this.receiverEmailID=receiverEmailID;
        this.emailSubject=emailSubject;
        this.emailBody=emailBody;
        Properties props = new Properties();
        props.put("mail.smtp.user",senderEmailID);
        props.put("mail.smtp.host", emailSMTPserver);
        props.put("mail.smtp.port", emailServerPort);
        props.put("mail.smtp.starttls.enable", "true");
        props.put("mail.smtp.auth", "true");
        props.put("mail.smtp.socketFactory.port", emailServerPort);
        props.put("mail.smtp.socketFactory.class","javax.net.ssl.SSLSocketFactory");
        props.put("mail.smtp.socketFactory.fallback", "false");
        SecurityManager security = System.getSecurityManager();
        try {
            Authenticator auth = new SMTPAuthenticator();
            Session session = Session.getInstance(props, auth);
            MimeMessage msg = new MimeMessage(session);
            msg.setText(emailBody);
            msg.setSubject(emailSubject);
            msg.setFrom(new InternetAddress(senderEmailID));
            msg.addRecipient(Message.RecipientType.TO,
                    new InternetAddress(receiverEmailID));
            Transport.send(msg);
            System.out.println("Message send Successfully:)");
        }
        catch (Exception mex)
        {
            mex.printStackTrace();
        }
    }
    public class SMTPAuthenticator extends javax.mail.Authenticator
    {
        public PasswordAuthentication getPasswordAuthentication()
        {
            return new PasswordAuthentication(senderEmailID, senderPassword);
        }
    }
    public static void main(String[] args)
    {
        MailSender mailSender=new
            MailSender("[email protected]",emailSubject,emailBody);
    }
}

Antwoord 8, autoriteit 2%

Is deze code geschikt om e-mail te verzenden?

Nou, nee, niet zonder enkele onderdelen te veranderen, aangezien je een foutmelding krijgt. U probeert momenteel e-mail te verzenden via een SMTP-server die draait op localhost, maar u gebruikt er geen, vandaar de ConnectException.

Ervan uitgaande dat de code in orde is (ik heb het niet echt gecontroleerd), moet je ofwel een lokale SMTP-server gebruiken, of een (externe) server gebruiken (van je ISP).

Wat betreft de code, u kunt voorbeelden vinden in het JavaMail-downloadpakket zoals vermeld in de Veelgestelde vragen:

Waar kan ik een voorbeeld vinden
programma’s die laten zien hoe te gebruiken
JavaMail?

V: Waar kan ik een voorbeeld vinden?
programma’s die laten zien hoe te gebruiken
JavaMail?
A: Er zijn veel voorbeelden:
programma’s die zijn opgenomen in de JavaMail
downloadpakket
, inclusief simple
opdrachtregelprogramma’s die illustreren:
verschillende aspecten van de JavaMail API, a
Swing-gebaseerde GUI-applicatie, een eenvoudige
servlet-gebaseerde applicatie, en a
complete webapplicatie met JSP
pagina’s en een tagbibliotheek.


Antwoord 9, autoriteit 2%

Probeer dit eens. het werkt goed voor mij. Zorg ervoor dat u vóór het verzenden van e-mail de toegang voor minder veilige app in uw Gmail-account moet geven. Ga dus naar de volgende link en probeer het uit met deze Java-code.
Gmail activeren voor minder veilige app

U moet het javax.mail.jar-bestand en het activatie.jar-bestand naar uw project importeren.

Dit is de volledige code voor het verzenden van e-mail in java

import javax.mail.*;
import javax.mail.internet.*;
import java.util.*;
public class SendEmail {
    final String senderEmail = "your email address";
    final String senderPassword = "your password";
    final String emailSMTPserver = "smtp.gmail.com";
    final String emailServerPort = "587";
    String receiverEmail = null;
    String emailSubject = null;
    String emailBody = null;
    public SendEmail(String receiverEmail, String Subject, String message) {
        this.receiverEmail = receiverEmail;
        this.emailSubject = Subject;
        this.emailBody = message;
        Properties props = new Properties();
        props.put("mail.smtp.user", senderEmail);
        props.put("mail.smtp.host", emailSMTPserver);
        props.put("mail.smtp.port", emailServerPort);
        props.put("mail.smtp.starttls.enable", "true");
        props.put("mail.smtp.auth", "true");
        props.put("mail.smtp.socketFactory.port", emailServerPort);
        props.put("mail.smtp.socketFactory.class", "javax.net.ssl.SSLSocketFactory");
        SecurityManager security = System.getSecurityManager();
        try {
            Authenticator auth = new SMTPAuthenticator();
            Session session = Session.getInstance(props, auth);
            Message msg = new MimeMessage(session);
            msg.setText(emailBody);
            msg.setSubject(emailSubject);
            msg.setFrom(new InternetAddress(senderEmail));
            msg.addRecipient(Message.RecipientType.TO,
                    new InternetAddress(receiverEmail));
            Transport.send(msg);
            System.out.println("send successfully");
        } catch (Exception ex) {
            System.err.println("Error occurred while sending.!");
        }
    }
    private class SMTPAuthenticator extends javax.mail.Authenticator {
        public PasswordAuthentication getPasswordAuthentication() {
            return new PasswordAuthentication(senderEmail, senderPassword);
        }
    }
    public static void main(String[] args) {
        SendEmail send = new SendEmail("receiver email address", "subject", "message");
    }
}

Antwoord 10, Autoriteit 2%

Hier is de werkende oplossing bro. Het is guranteed.

  1. de eerste plaats van alle openstaande uw Gmail-account van waaruit je wilde mail te sturen, zoals bij u het geval [email protected]
  2. Deze link hieronder:

    https://support.google.com/accounts/answer/6010255 ? hl = nl

  3. Klik op “Ga naar de ‘minder veilige apps’ sectie Mijn Account.” optie
  4. Zet vervolgens op
  5. Dat is het (:

Hier is mijn code:

import javax.mail.*;
import javax.mail.internet.*;
import java.util.*;
public class SendEmail {
   final String senderEmailID = "Sender Email id";
final String senderPassword = "Sender Pass word";
final String emailSMTPserver = "smtp.gmail.com";
final String emailServerPort = "465";
String receiverEmailID = null;
static String emailSubject = "Test Mail";
static String emailBody = ":)";
public SendEmail(String receiverEmailID, String emailSubject, String emailBody)
{
this.receiverEmailID=receiverEmailID;
this.emailSubject=emailSubject;
this.emailBody=emailBody;
Properties props = new Properties();
props.put("mail.smtp.user",senderEmailID);
props.put("mail.smtp.host", emailSMTPserver);
props.put("mail.smtp.port", emailServerPort);
props.put("mail.smtp.starttls.enable", "true");
props.put("mail.smtp.auth", "true");
props.put("mail.smtp.socketFactory.port", emailServerPort);
props.put("mail.smtp.socketFactory.class","javax.net.ssl.SSLSocketFactory");
props.put("mail.smtp.socketFactory.fallback", "false");
SecurityManager security = System.getSecurityManager();
try
{
Authenticator auth = new SMTPAuthenticator();
Session session = Session.getInstance(props, auth);
MimeMessage msg = new MimeMessage(session);
msg.setText(emailBody);
msg.setSubject(emailSubject);
msg.setFrom(new InternetAddress(senderEmailID));
msg.addRecipient(Message.RecipientType.TO,
new InternetAddress(receiverEmailID));
Transport.send(msg);
System.out.println("Message send Successfully:)");
}
catch (Exception mex)
{
mex.printStackTrace();
}
}
public class SMTPAuthenticator extends javax.mail.Authenticator
{
public PasswordAuthentication getPasswordAuthentication()
{
return new PasswordAuthentication(senderEmailID, senderPassword);
}
}
    public static void main(String[] args) {
       SendEmail mailSender;
        mailSender = new SendEmail("Receiver Email id","Testing Code 2 example","Testing Code Body yess");
    }
}

Antwoord 11

Ik heb mijn werkende Gmail Java-klasse op Pastebin voor uw beoordeling geplaatst, besteedt speciale aandacht aan de methode “StartsessionWithtls” en u kunt Javamail kunnen aanpassen om dezelfde functionaliteit te bieden. http://pastebin.com/ve8mqkqp


Antwoord 12

Uw code werkt, afgezien van het instellen van de verbinding met de SMTP-server. U hebt een actieve e-mail (SMTP) -server nodig om u e-mail voor u te sturen.

Hier is uw gewijzigde code. Ik merkte op dat de onderdelen die niet nodig zijn en de sessiecreatie hebben gewijzigd, dus het duurt een authenticator. Zoek nu gewoon de SMPT_HOSTNAME, gebruikersnaam en wachtwoord die u wilt gebruiken (uw internetprovider biedt deze meestal).

Ik doe het altijd zoals deze (met behulp van een externe SMTP-server die ik ken) omdat het lopen van een lokale mailserver niet zo triviaal onder Windows is (het is blijkbaar vrij eenvoudig onder Linux).

import java.util.*;
import javax.mail.*;
import javax.mail.internet.*;
//import javax.activation.*;
public class SendEmail {
    private static String SMPT_HOSTNAME = "";
    private static String USERNAME = "";
    private static String PASSWORD = "";
    public static void main(String[] args) {
        // Recipient's email ID needs to be mentioned.
        String to = "[email protected]";
        // Sender's email ID needs to be mentioned
        String from = "[email protected]";
        // Assuming you are sending email from localhost
        // String host = "localhost";
        // Get system properties
        Properties properties = System.getProperties();
        // Setup mail server
        properties.setProperty("mail.smtp.host", SMPT_HOSTNAME);
        // Get the default Session object.
        // Session session = Session.getDefaultInstance(properties);
        // create a session with an Authenticator
        Session session = Session.getInstance(properties, new Authenticator() {
            @Override
            protected PasswordAuthentication getPasswordAuthentication() {
                return new PasswordAuthentication(USERNAME, PASSWORD);
            }
        });
        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.send(message);
            System.out.println("Sent message successfully....");
        } catch (MessagingException mex) {
            mex.printStackTrace();
        }
    }
}

Antwoord 13

Inderdaad werkt 465 en de uitzondering die u krijgt is mogelijk te wijten aan de niet-open SMTP-poort 25. Standaard is het poortnummer 25. Maar u kunt het configureren met behulp van de e-mailagent die beschikbaar is als open source – Mercury

Gebruik voor de eenvoud de volgende configuratie en het komt goed.

// Setup your mail server
props.put("mail.smtp.host", SMTP_HOST); 
props.put("mail.smtp.user",FROM_NAME);
props.put("mail.smtp.ssl.enable", "true");
props.put("mail.smtp.port", "25");
props.put("mail.debug", "true");
props.put("mail.smtp.auth", "true");
props.put("mail.smtp.starttls.enable","true");
props.put("mail.smtp.EnableSSL.enable","true");
props.setProperty("mail.smtp.socketFactory.class", "javax.net.ssl.SSLSocketFactory");  
props.setProperty("mail.smtp.socketFactory.fallback", "false");  
props.setProperty("mail.smtp.port", "465");  
props.setProperty("mail.smtp.socketFactory.port", "465");

Voor nog meer: bekijk het volledige werkvoorbeeld van de grond af hier


Antwoord 14

Ik heb dezelfde uitzondering als jij.
De reden hiervoor is dat u geen actieve smpt-server op uw machine heeft (aangezien uw host localhost is). Als u Windows 7 gebruikt, heeft deze geen SMTP-server. dus je zult moeten downloaden, installeren en configureren met domein en accounts maken. Ik gebruikte hmailserver als smtp-server geïnstalleerd en geconfigureerd op mijn lokale machine.
https://www.hmailserver.com/download


Antwoord 15

U kunt hier een complete en zeer eenvoudige Java-les vinden voor het verzenden van e-mails met een Google(gmail)-account,

E-mail verzenden met Java en Google account

Het gebruikt de volgende eigenschappen

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

Other episodes