Envoyer un email en utilisant java
J'essaye d'envoyer un email en 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();
}
}
}
Je reçois l'erreur:
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)
Ce code fonctionnera-t-il pour envoyer un courrier électronique?
Le code suivant fonctionne très bien avec le serveur SMTP de Google. Vous devez fournir votre nom d'utilisateur et votre mot de passe Google.
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();
}
}
Mise à jour du 11 décembre 2015
Nom d'utilisateur + mot de passe n'est plus une solution recommandée. Cela est dû à
J'ai essayé ceci et Gmail a envoyé à l'e-mail utilisé comme nom d'utilisateur dans ce code un e-mail indiquant que nous avions récemment bloqué une tentative de connexion à votre compte Google et m'avait dirigé vers cette page d'assistance: support.google.com/accounts/answer/6010255. il cherche donc à le faire fonctionner, le compte de messagerie étant utilisé pour envoyer des besoins afin de réduire leur propre sécurité
Google avait publié l'API Gmail - https://developers.google.com/gmail/api/?hl=fr . Nous devrions utiliser la méthode oAuth2, au lieu de nom d'utilisateur + mot de passe.
Voici l'extrait de code permettant d'utiliser l'API Gmail.
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();
}
}
Pour créer un service Gmail autorisé via oAuth2, voici l'extrait de code.
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;
}
}
Pour fournir un moyen convivial d'authentification oAuth2, j'ai utilisé JavaFX pour afficher la boîte de dialogue de saisie suivante.
La clé pour afficher la boîte de dialogue conviviale oAuth2 se trouve dans MyAuthorizationCodeInstalledApp.Java et SimpleSwingBrowser.Java
Le code suivant a fonctionné pour moi.
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);
}
}
}
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 );
}
}
}
Fichiers JAR requis
La réponse courte - non.
La réponse longue - non, car le code repose sur la présence d'un serveur SMTP s'exécutant sur la machine locale et à l'écoute sur le port 25. Le serveur SMTP (techniquement le MTA ou l'agent de transfert de courrier) est responsable de la communication avec l'agent de messagerie (MUA, qui est dans ce cas le processus Java,) pour recevoir des courriels sortants.
Désormais, les MTA sont généralement chargés de recevoir les courriers électroniques des utilisateurs d’un domaine particulier. Ainsi, pour le domaine gmail.com, ce sont les serveurs de messagerie Google qui sont responsables de l'authentification des agents d'utilisateurs de messagerie et donc du transfert des messages vers des boîtes de réception sur les serveurs GMail. Je ne sais pas si GMail fait confiance aux serveurs de relais de messagerie ouverts, mais ce n'est certainement pas une tâche facile d'exécuter une authentification pour le compte sur Google, puis de relayer le courrier vers les serveurs de GMail.
Si vous lisez le JavaMail FAQ sur l'utilisation de JavaMail pour accéder à GMail , vous remarquerez que le nom d'hôte et le port pointent vers les serveurs de GMail, et certainement pas vers localhost. . Si vous avez l’intention d’utiliser votre ordinateur local, vous devrez effectuer un relais ou un transfert.
Vous aurez probablement besoin de comprendre le protocole SMTP en profondeur si vous souhaitez aller quelque part en matière de SMTP. Vous pouvez commencer avec le article de Wikipedia sur SMTP , mais tout progrès ultérieur nécessitera une programmation sur un serveur SMTP.
Vous avez besoin d'un serveur SMTP pour envoyer des mails. Il existe des serveurs que vous pouvez installer localement sur votre propre ordinateur ou vous pouvez utiliser l'un des nombreux serveurs en ligne. L'un des serveurs les plus connus est celui de Google:
Je viens de tester avec succès le autorisé configurations SMTP de Google en utilisant le premier exemple de 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);
Notez les différents ports et stratégies de transport (qui gèrent pour vous toutes les propriétés nécessaires).
Curieusement, Google a également besoin de TLS sur le port 25, même si les instructions de Google dites le contraire .
Cela fait un bon bout de temps depuis que cela a été posté. Mais à compter du 13 novembre 2012, je peux vérifier que le port 465 fonctionne toujours.
Reportez-vous à la réponse de GaryM sur ce forum . J'espère que cela aide quelques personnes de plus.
/*
* 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);
}
}
Le code suivant fonctionne très bien. Essayez ceci en tant qu'application Java avec 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);
}
}
Ce code fonctionnera-t-il pour envoyer un courrier électronique?
Eh bien, non, non sans changer certaines parties puisque vous obtenez une erreur. Vous essayez actuellement d'envoyer un courrier via un serveur SMTP s'exécutant sur localhost mais vous n'exécutez pas par conséquent le ConnectException.
En supposant que le code est correct (je n'ai pas vraiment vérifié), vous devrez soit exécuter un serveur SMTP local, soit en utiliser un (distant) (de votre fournisseur de services Internet).
En ce qui concerne le code, vous pouvez trouver des exemples dans le package de téléchargement JavaMail, comme indiqué dans le FAQ :
Où puis-je trouver quelques exemples de programmes montrant comment utiliser JavaMail?
Q: Où puis-je trouver des exemples de programmes montrant comment utiliser JavaMail?
R: De nombreux exemples de programmes sont inclus dans le package de téléchargement JavaMail , y compris de simples programmes en ligne de commande illustrant divers aspects de l'API JavaMail, une application graphique basée sur Swing, un simple servlet- application Web et une application Web complète utilisant des pages JSP et une bibliothèque de balises.
Voici la solution de travail bro. c'est garanti
1) Tout d’abord, ouvrez votre compte Gmail à partir duquel vous voulez envoyer un courrier, comme dans votre cas "" [email protected] "
2) ouvrez ce lien ci-dessous https://support.google.com/accounts/answer/6010255?hl=fr
3) Cliquez sur "Accédez à la section" Applications moins sécurisées "dans Mon compte." option
4) Puis allumez-le
5) c'est tout (:
voici mon 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");
}
}
Essayez ceci. ça marche bien pour moi. Assurez-vous qu'avant d'envoyer un courrier électronique, vous devez autoriser l'accès à une application moins sécurisée dans votre compte Gmail. Allez donc sur le lien suivant et essayez avec ce code Java.
Activer Gmail pour une application moins sécurisée
Vous devez importer le fichier javax.mail.jar et le fichier activation.jar dans votre projet.
Ceci est le code complet pour envoyer un email en 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");
}
}
Votre code fonctionne, mis à part la configuration de la connexion avec le serveur SMTP. Vous avez besoin d’un serveur de messagerie en cours d’exécution (SMTP) pour vous envoyer un courrier électronique.
Voici votre code modifié. J'ai commenté les parties inutiles et modifié la création de la session, qui nécessite donc un authentificateur. Désormais, il vous suffit de connaître le nom d'hôte SMPT_HOSTNAME, le nom d'utilisateur et le mot de passe que vous souhaitez utiliser (votre fournisseur Internet les fournit généralement).
Je le fais toujours comme ça (avec un serveur SMTP distant que je connais) car faire tourner un serveur de courrier local n’est pas si simple sous Windows (c’est apparemment assez facile sous 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();
}
}
}
En effet, 465 fonctionne et l'exception que vous obtenez est peut-être due au port 25 non ouvert SMTP. Par défaut, le numéro de port est 25. Toutefois, vous pouvez le configurer à l'aide de l'agent de messagerie disponible en source ouverte - Mercure
Pour plus de simplicité, utilisez simplement la configuration suivante et tout ira bien.
// 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");
Pour encore plus: consultez l'exemple de travail complet à partir de zéro ici
J'ai mis ma classe gmail Java de travail sur Pastebin pour votre révision, portez une attention particulière à la méthode "startSessionWithTLS" et vous pourrez peut-être ajuster JavaMail pour fournir les mêmes fonctionnalités. http://Pastebin.com/VE8Mqkqp
J'ai la même exception que toi. La raison en est que le serveur smpt n'est pas en cours d'exécution sur votre machine (car votre hôte est localhost). Si vous utilisez Windows 7, il n’a pas de serveur SMTP. vous devrez donc télécharger, installer et configurer avec le domaine et créer des comptes.J'ai utilisé hmailserver en tant que serveur smtp installé et configuré dans ma machine locale. https://www.hmailserver.com/download