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