Comment envoyer un e-mail à l'aide de Gmail API et Java
J'ai un Service Web déployé sur Openshift. Actuellement ce que je suis en développement est un type de l'envoi d'un e-mail automatique à un certain point, à l'aide de mon compte Gmail.
J'ai donc été me documenter pour deux ou trois jours et j'en ai conclu que j'ai deux options:
1) à l'Aide de JavaMail de la bibliothèque.
2) à l'Aide de Gmail API.
Pour la première option Que j'ai utilisé est les classes suivantes:
public class EmailSenderService {
private final Properties properties = new Properties();
private String password = "*******";
private Session session;
private void init() {
//ssl
properties.put("mail.smtp.host", "smtp.gmail.com");
properties.put("mail.smtp.socketFactory.port", "465");
properties.put("mail.smtp.socketFactory.class",
"javax.net.ssl.SSLSocketFactory");
properties.put("mail.smtp.auth", "true");
properties.put("mail.smtp.port", "465");
session = Session.getDefaultInstance(properties,
new javax.mail.Authenticator() {
protected PasswordAuthentication getPasswordAuthentication() {
return new PasswordAuthentication("eu***@gmail.com",password);
}
});
}
public void sendEmail(){
init();
//ssl
try {
Message message = new MimeMessage(session);
message.setFrom(new InternetAddress("eu***@gmail.com"));
message.setRecipients(Message.RecipientType.TO,
InternetAddress.parse("c***[email protected]"));
message.setSubject("Testing Subject");
message.setText("Dear Mail Crawler," +
"\n\n No spam to my email, please!");
Transport t = session.getTransport("smtp");
t.connect("smtp.gmail.com", "eu***@gmail.com", password);
t.sendMessage(message, message.getAllRecipients());
System.out.println("Done");
} catch (MessagingException e) {
e.printStackTrace();
}
}
}
Et de les appeler à l'aide de ceci:
EmailSenderService ess = new EmailSenderService();
ess.sendEmail();
2) La deuxième option que j'utilise est la suivante:
public class EmailSenderGmailApi {
/*
* Atributos
*/
//Check https://developers.google.com/gmail/api/auth/scopes for all available scopes
private static final String SCOPE = "https://www.googleapis.com/auth/gmail.compose";
private static final String APP_NAME = "eu***l";
//Email address of the user, or "me" can be used to represent the currently authorized user.
private static final String USER = "eu***@gmail.com";
//Path to the client_secret.json file downloaded from the Developer Console
private static final String CLIENT_SECRET_PATH = "../app-root/data/eu***.json";
private static GoogleClientSecrets clientSecrets;
/*
* Metodos
*/
public static Gmail init() throws IOException{
System.out.println("***Working Directory = " + System.getProperty("user.dir"));
HttpTransport httpTransport = new NetHttpTransport();
JsonFactory jsonFactory = new JacksonFactory();
clientSecrets = GoogleClientSecrets.load(jsonFactory, new FileReader(CLIENT_SECRET_PATH));
//Allow user to authorize via url.
GoogleAuthorizationCodeFlow flow = new GoogleAuthorizationCodeFlow.Builder(
httpTransport, jsonFactory, clientSecrets, Arrays.asList(SCOPE))
.setAccessType("online")
.setApprovalPrompt("auto").build();
String code = "***";
//Generate Credential using retrieved code.
GoogleTokenResponse response = flow.newTokenRequest(code)
.setRedirectUri(GoogleOAuthConstants.OOB_REDIRECT_URI).execute();
GoogleCredential credential = new GoogleCredential()
.setFromTokenResponse(response);
//Create a new authorized Gmail API client
return new Gmail.Builder(httpTransport, jsonFactory, credential)
.setApplicationName(APP_NAME).build();
}
/**
* Create a MimeMessage using the parameters provided.
*
* @param to Email address of the receiver.
* @param from Email address of the sender, the mailbox account.
* @param subject Subject of the email.
* @param bodyText Body text of the email.
* @return MimeMessage to be used to send email.
* @throws MessagingException
*/
public static MimeMessage createEmail(String to, String from, String subject,
String bodyText) throws MessagingException {
System.out.println("***Empezando a enviar email...");
Properties props = new Properties();
Session session = Session.getDefaultInstance(props, null);
MimeMessage email = new MimeMessage(session);
InternetAddress tAddress = new InternetAddress(to);
InternetAddress fAddress = new InternetAddress(from);
email.setFrom(new InternetAddress(from));
email.addRecipient(javax.mail.Message.RecipientType.TO,
new InternetAddress(to));
email.setSubject(subject);
email.setText(bodyText);
return email;
}
/**
* Create a Message from an email
*
* @param email Email to be set to raw of message
* @return Message containing base64 encoded email.
* @throws IOException
* @throws MessagingException
*/
public static Message createMessageWithEmail(MimeMessage email)
throws MessagingException, IOException {
ByteArrayOutputStream bytes = new ByteArrayOutputStream();
email.writeTo(bytes);
String encodedEmail = Base64.encodeBase64URLSafeString(bytes.toByteArray());
Message message = new Message();
message.setRaw(encodedEmail);
return message;
}
/**
* Send an email from the user's mailbox to its recipient.
*
* @param service Authorized Gmail API instance.
* @param userId User's email address. The special value "me"
* can be used to indicate the authenticated user.
* @param email Email to be sent.
* @throws MessagingException
* @throws IOException
*/
public static void sendMessage(Gmail service, String userId, MimeMessage email)
throws MessagingException, IOException {
Message message = createMessageWithEmail(email);
message = service.users().messages().send(userId, message).execute();
System.out.println("Message id: " + message.getId());
System.out.println(message.toPrettyString());
}
}
La première option, lors de l'appel, le message qui est affiché dans La COnsole est le suivant:
javax.mail.AuthenticationFailedException
at javax.mail.Service.connect(Service.java:306)
at javax.mail.Service.connect(Service.java:156)
at main.java.model.EmailSenderService.sendEmail(EmailSenderService.java:86)
at main.java.model.AccessManager.renewPassStepOne(AccessManager.java:234)
at main.java.webService.UsuarioService.renewPassStepOne(UsuarioService.java:192)
at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:57)
at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
at java.lang.reflect.Method.invoke(Method.java:606)
at com.sun.jersey.spi.container.JavaMethodInvokerFactory$1.invoke(JavaMethodInvokerFactory.java:60)
at com.sun.jersey.server.impl.model.method.dispatch.AbstractResourceMethodDispatchProvider$TypeOutInvoker._dispatch(AbstractResourceMethodDispatchProvider.java:185)
at com.sun.jersey.server.impl.model.method.dispatch.ResourceJavaMethodDispatcher.dispatch(ResourceJavaMethodDispatcher.java:75)
at com.sun.jersey.server.impl.uri.rules.HttpMethodRule.accept(HttpMethodRule.java:302)
...
J'ai essayé de le résoudre par moi-même, à la recherche avec google, stackoverflow... Mais tous les changements que j'ai introduire, le même message que je reçois.
Dans l'option 2, je ne sais pas comment l'utiliser. Je suis en train d'essayer quelque chose comme ça:
MimeMessage msg = EmailSenderGmailApi.createEmail("ca***@gmail.com", "eu***@gmail.com", "test", "holaaaaa");
EmailSenderGmailApi.sendMessage(
EmailSenderGmailApi.init(),
"cap***@gmail.com",
msg);
De toute façon, pour être honnête, j'ai étudié beaucoup de Java Mail, j'espère que quelqu'un peut me donner un coup de main la résolution de toute erreur je l'aurais fait.
Par rapport à Gmail Api, sur la documentation officielle, je n'ai pas été en mesure de comprendre comment envoyer un email. Ni il n'y a pas beaucoup de documentation sur internet.
Quelqu'un pourrait me prêter un coup de main?
OriginalL'auteur russellhoff | 2014-10-19
Vous devez vous connecter pour publier un commentaire.
L'Gmail API publique docs avoir un guide sur l'envoi d'e-mail et il a même l'exemple de code java:
https://developers.google.com/gmail/api/guides/sending
Votre code ci-dessus ne semble pas si loin. J'aimerais tout d'abord assurez-vous que vous avez obtenu Oauth2 le droit de travailler en faisant quelque chose de simple comme étiquettes.list() et si cela fonctionne alors de passer à quelque chose de plus compliqué, comme l'envoi d'un email. (Vous avez la bonne idée de construire, de transformer en une chaîne de caractères, base64url encodage et ensuite l'envoyer.) Quel est exactement le problème que vous obtenez tout en essayant de l'envoyer avec Gmail API? Obtenu quelques sortie d'erreur ou manque quelque chose dans votre code?
Ah ok. Devrait être assez standard avec d'autres Api Google telles que l'agenda, drive, et Plus susceptibles de commencer/démarrages rapides pour preuve, il doit travailler pour Gmail avec des substitutions appropriées. Je vais ajouter quelques balises pour, nous l'espérons aider à obtenir le plus les yeux sur elle.
OriginalL'auteur Eric D
Si vous utilisez Java Mail API dans votre openshift application,
Puis ajouter de nouvelles bibliothèques dans l'application, vous devez ajouter son maven-configuration dans le pom.xml fichier. Ou en d'autres termes, vous devez ajouter la dépendance à l'pom.xml fichier.
c'est la dépendance de messagerie 1.4.7
Il suffit d'ajouter ce code dans le pom.xml fichier
De même, pour les autres intégrations, ne pas oublier d'ajouter les dépendances.
Vous pouvez effectuer une recherche dans google :
"maven de la dépendance ________"
OriginalL'auteur Parth Pithadia
Commencer par la fixation de ces les erreurs courantes dans vos JavaMail code.
Voir ce JavaMail entrée de la FAQ de l'envoi de mail via Gmail.
Voir ce JavaMail entrée de la FAQ pour savoir comment déboguer des problèmes avec JavaMail.
Voir ce JavaMail page wiki sur l'utilisation de OAuth2.
OriginalL'auteur Bill Shannon