I have a Web Service deployed on Openshift. Currently what I'm developing is a kind of sending an automated email at a certain point, using my Gmail account.
So I have been documenting myself for two or three days and I've concluded that I've two options:
1) Using JavaMail library. 2) Using Gmail API.
For the first option What I've used is the following classes:
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();
}
}
}
And calling them using this:
EmailSenderService ess = new EmailSenderService();
ess.sendEmail();
2) The second option I'm using is the following:
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());
}
}
The first option, when calling to it, the message which is shown in Openshift COnsole is the following:
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)
...
I've been trying to fix it by myself, looking at google, stackoverflow... But every change I introduce, the same message I get.
In option 2, I don't know how to use it. I'm trying something like that:
MimeMessage msg = EmailSenderGmailApi.createEmail("ca***@gmail.com", "eu***@gmail.com", "test", "holaaaaa");
EmailSenderGmailApi.sendMessage(
EmailSenderGmailApi.init(),
"cap***@gmail.com",
msg);
Anyway, to be honest I have investigated a lot of Java Mail, I hope someone can give me a hand solving any error I would have.
In relation to Gmail Api, on official documentation I haven't been able to figure out how to send an email. Neither there isn't so much documentation over the internet.
Could somebody lend me a hand?
The Gmail API public docs have a guide on sending email and it even has java sample code:
https://developers.google.com/gmail/api/guides/sending
Your code above doesn't seem that far off though. I'd first make sure you got Oauth2 working right by doing something simple like labels.list() and if that works then move on to something more complicated like sending an email. (You have the right idea constructing, turning into a string, base64url encoding and then sending it though.) What is the exact problem you're getting whist trying to send it with the Gmail API? Got some error output or missing something in your code?