Recevoir des e-mails à l'aide de l'API Gmail en Java

introduction

J'ai essayé d'utiliser l'API de Gmail en Java, mais même si je la recherchais sur Google, j'étais triste que seuls Stack Overflow et des articles en anglais sur le site officiel de Google soient sortis, j'ai donc dû écrire un article en japonais. pensée.

Chose que tu veux faire

Je souhaite obtenir le corps et les fichiers joints du courrier reçu sur Gmail à l'aide de Java.

supposition

--Utilisez Eclipse.

Courriel que vous souhaitez recevoir

Ceci est un exemple d'e-mail à recevoir cette fois. 19.png J'ai joint une image d'un pingouin Linux dans le fichier joint.

Importer la bibliothèque

Tout d'abord, pour préparer l'utilisation de l'API Gmail, récupérez la bibliothèque d'API Gmail à partir de l'URL suivante. Gmail API Client Library for Java ; https://developers.google.com/api-client-library/java/apis/gmail/v1

Ceux qui utilisent MAVEN et GRADLE peuvent installer la bibliothèque en suivant les instructions sur le lien. Si vous ne pouvez pas utiliser une telle commodité pour diverses raisons, téléchargez-le sous forme de zip et incluez tous les fichiers jar à l'intérieur.

Paramètres d'authentification

Faites les deux choses suivantes.

Créer un projet

Accédez à l'URL suivante et créez un projet. Gestion des ressources; https://console.developers.google.com/cloud-resource-manager __1. Cliquez sur "Créer un projet" __ 13.png

__2. Donnez un nom de projet approprié et cliquez sur "Créer" __ 14.png

__3. Un projet sera créé après un certain temps __ Attendons un instant 15.png

Activer l'API Gmail

Accédez à la bibliothèque d'API de Google à partir de l'URL suivante et activez l'API Gmail. Bibliothèque d'API; https://console.developers.google.com/apis/library 6.png

Préparer le client OAuth 2.0

Accédez à l'URL suivante pour créer un client OAuth 2.0. Credentials; https://console.developers.google.com/apis/credentials

__1. Cliquez sur Créer des informations d'identification __ 7.png

__2. Sélectionnez l'ID client OAuth __ 8.png

__3. Sélectionnez "Autre", donnez-lui un nom et cliquez sur "Créer" __ 9.png

__4. Achèvement __ 11.png

__5. Téléchargez la clé privée pour une utilisation ultérieure __ Tout va bien, mais sauvegardons-le sous "client_secret.json". 12.png

__6. Créez un écran de consentement OAuth de manière appropriée __ 10.png

Écrivons Java

Le flux de traitement est à peu près le suivant, nous allons donc procéder dans l'ordre.

  1. Authentification
  2. Obtenez l'ID du message
  3. Recevoir du courrier
  4. Décodage corporel
  5. Téléchargez les fichiers joints

Authentification

En fonction de la clé privée obtenue précédemment, effectuez un travail d'authentification pour obtenir un jeton pour l'utilisation de l'API et un jeton d'actualisation pour réémettre le jeton.

__1. Placez la clé privée "client_secret.json" précédemment obtenue dans le projet __ 16.png

__2. J'obtiens les informations nécessaires à l'authentification, comme le jeton d'actualisation basé sur la clé privée, mais je crée un dossier dans le projet pour l'enregistrer __ Pour le moment, nommez-le "informations d'identification". 17.png

__3. Enfin codage __ Obtenez un jeton pour utiliser l'API et un jeton d'actualisation pour réémettre le jeton en fonction de la clé privée

//Traitement Json
JsonFactory JSON_FACTORY = JacksonFactory.getDefaultInstance();
//portée
List<String> SCOPES = Collections.singletonList(GmailScopes.GMAIL_READONLY);
//Clé privée
String CLIENT_SECRET_DIR = "client_secret.json";
//Dossier de stockage pour les fichiers de configuration autour de l'authentification
String CREDENTIALS_FOLDER = "credentials";
//Communication HTTP
NetHttpTransport HTTP_TRANSPORT = GoogleNetHttpTransport.newTrustedTransport();

//Authentification
//Lire la clé privée
FileInputStream in = new FileInputStream(new File(CLIENT_SECRET_DIR));
InputStreamReader reader = new InputStreamReader(in);
GoogleClientSecrets clientSecrets = GoogleClientSecrets.load(JSON_FACTORY, reader);
//Paramètres d'authentification
GoogleAuthorizationCodeFlow flow = new GoogleAuthorizationCodeFlow.Builder(HTTP_TRANSPORT, JSON_FACTORY,
        clientSecrets, SCOPES)
                .setDataStoreFactory(new FileDataStoreFactory(new java.io.File(CREDENTIALS_FOLDER)))
                .setAccessType("offline").build();
//Authentifier
Credential credential = new AuthorizationCodeInstalledApp(flow, new LocalServerReceiver()).authorize("user");

Tout d'abord, explication des constantes

--_ JSON_FACTORY__: objet de traitement JSON. Les données renvoyées par l'API sont au format JSON. --__ CHAMP D'APPLICATION__: Dans quelle mesure Gmail doit-il être autorisé à l'aide de l'API? Il devrait y avoir toutes les constantes dans la classe GmailScopes, alors choisissez celle qui convient et utilisez-la. Si vous sélectionnez GMAIL_READONLY, vous devriez pouvoir faire tout ce que vous voulez faire cette fois, alors sélectionnons-le. --__ CLIENT_SECRET_DIR__: chemin du fichier de clé privée. Cette fois, j'ai mis le nom "client_secret.json" directement en dessous, donc "client_secret.json" est OK. --__ CREDENTIALS_FOLDER__: Le chemin du dossier pour enregistrer les fichiers autour de l'authentification obtenue à l'aide de la clé privée. Définissez le dossier créé ci-dessus. --__ HTTP_TRANSPORT__: objet pour la communication HTTP.

Ensuite, explication du traitement

//Lire la clé privée
FileInputStream in = new FileInputStream(new File(CLIENT_SECRET_DIR));
InputStreamReader reader = new InputStreamReader(in);
GoogleClientSecrets clientSecrets = GoogleClientSecrets.load(JSON_FACTORY, reader);

La clé privée "client_secret.json" directement en dessous est lue

GoogleAuthorizationCodeFlow flow = new GoogleAuthorizationCodeFlow.Builder(HTTP_TRANSPORT, JSON_FACTORY, clientSecrets, SCOPES)
    .setDataStoreFactory(new FileDataStoreFactory(new java.io.File(CREDENTIALS_FOLDER)))
    .setAccessType("offline").build();

J'ai mis le paramètre pour lancer l'authentification.

--nouveau argument GoogleAuthorizationCodeFlow.Builder --__ Objet de communication HTTP : HTTP_TRANSPORT -- Objet de traitement JSON : JSON_FACTORY -- clé privée : clientSecrets -- Scope : SCOPES (celui réglé à LIRE UNIQUEMENT) --SetDataStoreFactory, argument -- Destination de sortie des fichiers autour de l'authentification obtenue à l'aide de la clé privée __ --setAccessType argument -- Accès hors ligne __ (pas celui auquel les humains accèdent sur le navigateur), utilisez donc "hors ligne"

//Authentifier
Credential credential = new AuthorizationCodeInstalledApp(flow, new LocalServerReceiver()).authorize("user");

Effectuez en fait la communication HTTP, lancez la clé privée, obtenez le jeton ou le jeton d'accès et enregistrez-le dans le dossier spécifié. Lorsque vous l'exécutez, vous devriez voir certains fichiers dans le dossier comme indiqué ci-dessous. 18.png

Obtenir l'identifiant du message

J'utilise une API appelée liste de messages. messages est une API pour obtenir, envoyer et manipuler du courrier, et list obtient littéralement une liste des messages reçus. Comme il ne s'agit que d'une liste, vous ne pouvez obtenir que l'ID de message et l'ID de fil, et vous ne pouvez pas voir le texte. Utilisez entrer des messages pour obtenir le texte et des données détaillées. Pour le moment, l'explication du site officiel est la suivante (américain)

Users.messages: list ; https://developers.google.com/gmail/api/v1/reference/users/messages/list

Il est pratique à lire car il contient les informations requises pour lancer l'API, la portée requise, la définition du JSON renvoyé et un exemple de code dans différentes langues. C'est américain.

Pour le moment, créez un objet pour le service Gmail, exécutez la liste des messages sur cet objet et placez les données renvoyées dans la liste.

//Créer un service Gmail
//Nom de l'application
String APPLICATION_NAME = "Test1";
//Accéder à Gmail
Gmail service = new Gmail.Builder(HTTP_TRANSPORT, JSON_FACTORY, credential).setApplicationName(APPLICATION_NAME).build();

//Recevoir du courrier
//Utilisateur
String USER = "me";
//Recevez tous les e-mails(Seul l'ID de message est inclus)
ListMessagesResponse messagesResponse = service.users().messages().list(USER).execute();
List<Message> messageList = messagesResponse.getMessages();

Description des constantes

--__ APPLICATION_NAME__: nom à donner à l'objet de service Gmail que vous créez. Approprié.

Description du traitement

//Créer un service Gmail
//Nom de l'application
String APPLICATION_NAME = "Test1";
//Accéder à Gmail
Gmail service = new Gmail.Builder(HTTP_TRANSPORT, JSON_FACTORY, credential).setApplicationName(APPLICATION_NAME).build();

Je crée un objet pour le service Gmail.

--Nouvel argument Gmail.Builder --__ Objet de communication HTTP _: HTTP_TRANSPORT -- Objet de traitement JSON : JSON_FACTORY -- Identifiants __: identifiant


//Recevoir du courrier
//Utilisateur
String USER = "me";
//Recevez tous les e-mails(Seul l'ID de message est inclus)
ListMessagesResponse messagesResponse = service.users().messages().list(USER).execute();
List<Message> messageList = messagesResponse.getMessages();

Je lance une liste de messages et stocke les résultats dans une liste. L'argument concerne uniquement l'utilisateur. Je veux voir mon courrier, alors mettez simplement «moi» dedans. Cela créera une liste JSON qui contient uniquement l'ID de message et l'ID de fil, comme indiqué ci-dessous.

{
    "id": "1635e36ac0cf27ce",
    "threadId": "1635e36ac0cf27ce"
}

Recevoir du courrier

Obtenez en outre des données détaillées telles que l'objet et le corps de l'ID de message pour affiner les e-mails cibles.

//Explorez toutes les données d'e-mail pour trouver l'e-mail cible
Message targetMessage = null;
for (Message message : messageList) {
    //Obtenez toutes les données de messagerie
    Message fullMessage = service.users().messages().get(USER, message.getId()).execute();
    //Afficher l'en-tête
    for (MessagePartHeader header : fullMessage.getPayload().getHeaders()) {
        //Le nom est le sujet dans l'en-tête(matière)Obtenez l'ID de message du message dont la valeur est "test mail"
        if (header.getName().equals("Subject") && header.getValue().equals("E-mail test")) {
            targetMessage = fullMessage;
        }
    }
}

Pour faire une excuse d'abord, la façon d'écrire ce code n'est pas très bonne, il vaut mieux diviser ce processus en méthodes et en faire une méthode qui retourne lorsque le courrier cible est trouvé, et je le ferais certainement Je le ferai donc. Cette fois, en tant qu'exemple de code à publier sur le net, je voulais écrire tout le traitement dans la même méthode, alors j'ai fait cela.

Mis à part les excuses, ce que je fais, c'est utiliser l'ID de message de la liste des messages récupérés et utiliser l'API get des messages dans l'API Gmail pour obtenir des données plus détaillées telles que l'objet et le corps. Je suis. Nous recherchons un email avec le sujet "Test Email" afin de retrouver l'email cible dans les données acquises.

Description de la variable

--__ Message targetMessage__: Variable de stockage du courrier cible

Description du traitement

//Obtenez toutes les données de messagerie
Message fullMessage = service.users().messages().get(USER, message.getId()).execute();

Pour le moment, l'explication officielle de get for messages est la suivante Users.messages : get; https://developers.google.com/gmail/api/v1/reference/users/messages/get

Si vous mettez l'utilisateur et l'ID de message dans l'argument et que vous le lancez, des informations de courrier plus détaillées seront renvoyées.

{
    "historyId": "212543",
    "id": "1635e36ac0cf27ce",
    "internalDate": "1526294031000",
    "labelIds": [
        "IMPORTANT",
        "Label_8",
        "SENT"
    ],
    "payload": {
        "body": {
            "size": 0
        },
        "filename": "",
        "headers": [
            {
                "name": "MIME-Version",
                "value": "1.0"
            },
            {
                "name": "Received",
                "value": "by 10.179.15.206 with HTTP; Mon, 14 May 2018 03:33:51 -0700 (PDT)"
            },
            {
                "name": "Date",
                "value": "Mon, 14 May 2018 19:33:51 +0900"
            },
            {
                "name": "Delivered-To",
                "value": "[email protected]"
            },
            {
                "name": "Message-ID",
                "value": "<CAJsBAS7wAJm+gaUETbUzR1fyshn=zgu4mb5sexdKAv7+jHbmCA@mail.gmail.com>"
            },
            {
                "name": "Subject",
                "value": "E-mail test"
            },
            {
                "name": "From",
                "value": "Fuga Hoge <[email protected]>"
            },
            {
                "name": "To",
                "value": "[email protected]"
            },
            {
                "name": "Content-Type",
                "value": "multipart/mixed; boundary=\"0000000000009360f1056c2805b7\""
            }
        ],
        "mimeType": "multipart/mixed",
        "partId": "",
        "parts": [
            {
                "body": {
                    "size": 0
                },
                "filename": "",
                "headers": [
                    {
                        "name": "Content-Type",
                        "value": "multipart/alternative; boundary=\"0000000000009360ec056c2805b5\""
                    }
                ],
                "mimeType": "multipart/alternative",
                "partId": "0",
                "parts": [
                    {
                        "body": {
                            "data": "5pys5paH44G744Gr44KD44KJ44KJDQo=",
                            "size": 23
                        },
                        "filename": "",
                        "headers": [
                            {
                                "name": "Content-Type",
                                "value": "text/plain; charset=\"UTF-8\""
                            },
                            {
                                "name": "Content-Transfer-Encoding",
                                "value": "base64"
                            }
                        ],
                        "mimeType": "text/plain",
                        "partId": "0.0"
                    },
                    {
                        "body": {
                            "data": "PGRpdiBkaXI9Imx0ciI-5pys5paH44G744Gr44KD44KJ44KJPGJyPjwvZGl2Pg0K",
                            "size": 48
                        },
                        "filename": "",
                        "headers": [
                            {
                                "name": "Content-Type",
                                "value": "text/html; charset=\"UTF-8\""
                            },
                            {
                                "name": "Content-Transfer-Encoding",
                                "value": "base64"
                            }
                        ],
                        "mimeType": "text/html",
                        "partId": "0.1"
                    }
                ]
            },
            {
                "body": {
                    "attachmentId": "ANGjdJ_kQ0lQ3VjL86PDW2-qlN7bEQf-PLcRtzgFKvkg49Mi7KGwxlS8G2sn0LcOqdjM3D9CkVyVhmu1xbdDrxJC-GaaU7cBTUr4KUbwtENCONY9p0WW0stx8QuCEF5fnC2ZkKBFjOTxLqH3QJn88RGz-1IaE8l2wdexLgCP7MhYRNVx5Q0UCuvykLJO2WU3_uyJZWyZoVz5SxJz7_kXtLLv7X58p24HE3UU3Bxi3WIp5wpznsg1Z5GOmkYNTe29f7ag52B7L0p5SS_hIeGd73WqkgkH_Hma7Qmn0fPgd6wu_HUT8sqITt96CTfrl0M",
                    "size": 124626
                },
                "filename": "linux.png ",
                "headers": [
                    {
                        "name": "Content-Type",
                        "value": "image/png; name=\"linux.png\""
                    },
                    {
                        "name": "Content-Disposition",
                        "value": "attachment; filename=\"linux.png\""
                    },
                    {
                        "name": "Content-Transfer-Encoding",
                        "value": "base64"
                    },
                    {
                        "name": "X-Attachment-Id",
                        "value": "f_jh6421y31"
                    }
                ],
                "mimeType": "image/png",
                "partId": "1"
            }
        ]
    },
    "sizeEstimate": 171687,
    "snippet": "Corps Honyara",
    "threadId": "1635e36ac0cf27ce"
}

C'est assez long comme ça.

//Afficher l'en-tête
for (MessagePartHeader header : fullMessage.getPayload().getHeaders()) {
    //Le nom est le sujet dans l'en-tête(matière)Obtenez l'ID de message du message dont la valeur est "test mail"
    if (header.getName().equals("Subject") && header.getValue().equals("E-mail test")) {
        targetMessage = fullMessage;
    }
}

Il y a des données avec la clé «Subject» dans l'en-tête de la charge utile JSON acquise, et c'est le sujet. Je recherche quelqu'un dont le sujet est "test mail".

Décodage corporel

Certains des JSON récupérés ont une clé "snippet" et une valeur comme celle-ci, "Body Honyara", mais il s'agit d'un extrait au lieu du corps, et lorsque la liste des e-mails est affichée D'ailleurs, c'est différent car ce sont les données de celui qui affiche un peu le texte pour renseigner le contenu. Le corps de cet e-mail de test étant court, il contient le texte intégral, mais en gros, il vaut mieux penser que le texte intégral n'est pas inclus.

20.png _Ceci est un extrait de code _

Le texte réel est plus profond dans les parties de la charge utile et est encodé en Base64, il doit donc être décodé en UTF8, etc. pour être lisible.

//Acquisition de texte
//Acquisition de texte(Base64)
String bodyBase64 = targetMessage.getPayload().getParts().get(0).getParts().get(0).getBody().get("data").toString();
//Décoder à partir de Base64(chaîne d'octets)
byte[] bodyBytes = Base64.decodeBase64(bodyBase64);
//Convertir une chaîne d'octets en chaîne
String body = new String(bodyBytes, "UTF-8");

Description du traitement

//Acquisition de texte(Base64)
String bodyBase64 = targetMessage.getPayload().getParts().get(0).getParts().get(0).getBody().get("data").toString();

Comme vous pouvez le voir, le texte est dans une position profonde incompréhensible. Voir le JSON brut ci-dessus pour voir pourquoi cela s'est produit. Puisque la classe de retour de la méthode get est de type Object, j'ai réussi à obtenir les données au format attendu en faisant toString (). Au fait, il est encodé en BASE64.

//Décoder à partir de Base64(chaîne d'octets)
byte[] bodyBytes = Base64.decodeBase64(bodyBase64);

Conversion de la chaîne d'octets BASE64 en UTF8 pour le moment. Je veux que tu deviennes un String bientôt.

//Convertir une chaîne d'octets en chaîne
String body = new String(bodyBytes, "UTF-8");

Maintenant, c'est enfin une chaîne. Voici le texte.

Télécharger les fichiers joints

Enfin, téléchargez le fichier joint.

//Obtenir les fichiers joints
//Explorer la partie de la charge utile
for (MessagePart part : targetMessage.getPayload().getParts()) {
    String fileName = part.getFilename();
    //Le nom du fichier est nul ou""Sinon, il s'agit d'un fichier joint, alors téléchargez-le.
    if (fileName != null && fileName.length() > 0) {
        //Télécharger un fichier(Base64)
        MessagePartBody attachPart = service.users().messages().attachments()
                .get(USER, targetMessage.getId(), part.getBody().getAttachmentId()).execute();
        //Décoder à partir de Base64
        byte[] fileByteArray = Base64.decodeBase64(attachPart.getData());
        //Enregistrer dans le système
        FileOutputStream fileOutFile = new FileOutputStream(fileName);
        fileOutFile.write(fileByteArray);
        fileOutFile.close();
    }
}

Pour les pièces jointes, utilisez l'API Gmail message.attachments.get. Pour le moment, l'explication du site officiel est la suivante. Avec l'ID de pièce jointe et l'ID de message, vous pouvez obtenir le fichier joint encodé en BASE64.

Users.messages.attachments: get ; https://developers.google.com/gmail/api/v1/reference/users/messages/attachments/get

Description du traitement

//Obtenir les fichiers joints
//Explorer la partie de la charge utile
for (MessagePart part : targetMessage.getPayload().getParts()) {
    String fileName = part.getFilename();
    //Le nom du fichier est nul ou""Sinon, il s'agit d'un fichier joint, alors téléchargez-le.
    if (fileName != null && fileName.length() > 0) {
        //réduction
    }
}

Le nom de fichier et l'ID de pièce jointe sont stockés dans les parties de la charge utile. Cependant, il y a aussi un texte, etc. dans la même hiérarchie, auquel cas le fileName doit être "" etc., évitez-les et obtenez l'ID de la pièce jointe.

//Obtenir les fichiers joints
//Explorer la partie de la charge utile
if (fileName != null && fileName.length() > 0) {
    //Télécharger un fichier(Base64)
    MessagePartBody attachPart = service.users().messages().attachments().get(USER, targetMessage.getId(), part.getBody().getAttachmentId()).execute();
    //Décoder à partir de Base64
    byte[] fileByteArray = Base64.decodeBase64(attachPart.getData());
    //Enregistrer dans le système
    FileOutputStream fileOutFile = new FileOutputStream(fileName);
    fileOutFile.write(fileByteArray);
    fileOutFile.close();
}

Maintenant que vous disposez de l'ID de pièce jointe, utilisez-le pour obtenir les pièces jointes à l'aide de message.attachments.get dans l'API Gmail. Le fichier joint acquis étant encodé en BASE64, il est décodé en une chaîne d'octets. Enregistrez ensuite la dernière chaîne d'octets décodée dans un fichier. Lorsque vous l'exécutez, le fichier joint doit être téléchargé directement sous le projet comme indiqué ci-dessous. 21.png

à la fin

Si vous connectez tout le code écrit ici, cela ressemble à ce qui suit.

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.security.GeneralSecurityException;
import java.util.Collections;
import java.util.List;

import com.google.api.client.auth.oauth2.Credential;
import com.google.api.client.extensions.java6.auth.oauth2.AuthorizationCodeInstalledApp;
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.javanet.NetHttpTransport;
import com.google.api.client.json.JsonFactory;
import com.google.api.client.json.jackson2.JacksonFactory;
import com.google.api.client.repackaged.org.apache.commons.codec.binary.Base64;
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.gmail.model.ListMessagesResponse;
import com.google.api.services.gmail.model.Message;
import com.google.api.services.gmail.model.MessagePart;
import com.google.api.services.gmail.model.MessagePartBody;
import com.google.api.services.gmail.model.MessagePartHeader;

public class Test {
    public static void main(String[] args) throws IOException, GeneralSecurityException {
        //Traitement Json
        JsonFactory JSON_FACTORY = JacksonFactory.getDefaultInstance();
        //portée
        List<String> SCOPES = Collections.singletonList(GmailScopes.GMAIL_READONLY);
        //Clé privée
        String CLIENT_SECRET_DIR = "client_secret.json";
        //Dossier de stockage pour les fichiers de configuration autour de l'authentification
        String CREDENTIALS_FOLDER = "credentials";
        //Communication HTTP
        NetHttpTransport HTTP_TRANSPORT = GoogleNetHttpTransport.newTrustedTransport();

        //Authentification
        //Lire la clé privée
        FileInputStream in = new FileInputStream(new File(CLIENT_SECRET_DIR));
        InputStreamReader reader = new InputStreamReader(in);
        GoogleClientSecrets clientSecrets = GoogleClientSecrets.load(JSON_FACTORY, reader);
        //Paramètres d'authentification
        GoogleAuthorizationCodeFlow flow = new GoogleAuthorizationCodeFlow.Builder(HTTP_TRANSPORT, JSON_FACTORY,
                clientSecrets, SCOPES)
                        .setDataStoreFactory(new FileDataStoreFactory(new java.io.File(CREDENTIALS_FOLDER)))
                        .setAccessType("offline").build();
        //Authentifier
        Credential credential = new AuthorizationCodeInstalledApp(flow, new LocalServerReceiver()).authorize("user");

        //Créer un service Gmail
        //Nom de l'application
        String APPLICATION_NAME = "Test1";
        //Accéder à Gmail
        Gmail service = new Gmail.Builder(HTTP_TRANSPORT, JSON_FACTORY, credential).setApplicationName(APPLICATION_NAME)
                .build();

        //Recevoir du courrier
        //Utilisateur
        String USER = "me";
        //Recevez tous les e-mails(Seul l'identifiant de messagerie est inclus)
        ListMessagesResponse messagesResponse = service.users().messages().list(USER).execute();
        List<Message> messageList = messagesResponse.getMessages();

        //Explorez toutes les données d'e-mail pour trouver l'e-mail cible
        Message targetMessage = null;
        for (Message message : messageList) {
            //Obtenez toutes les données de messagerie
            Message fullMessage = service.users().messages().get(USER, message.getId()).execute();
            //Afficher l'en-tête
            for (MessagePartHeader header : fullMessage.getPayload().getHeaders()) {
                //Le nom est le sujet dans l'en-tête(matière)Obtenez l'ID de messagerie du message dont la valeur est "test mail"
                if (header.getName().equals("Subject") && header.getValue().equals("E-mail test")) {
                    targetMessage = fullMessage;
                }
            }
        }

        //Acquisition de texte
        //Acquisition de texte(Base64)
        String bodyBase64 = targetMessage.getPayload().getParts().get(0).getParts().get(0).getBody().get("data").toString();
        //Décoder à partir de Base64(chaîne d'octets)
        byte[] bodyBytes = Base64.decodeBase64(bodyBase64);
        //Convertir une chaîne d'octets en chaîne
        String body = new String(bodyBytes, "UTF-8");
        //Sortie standard de texte
        System.out.println(body);

        //Obtenir les fichiers joints
        //Explorer la partie de la charge utile
        for (MessagePart part : targetMessage.getPayload().getParts()) {
            String fileName = part.getFilename();
            //Le nom du fichier est nul ou""Sinon, il s'agit d'un fichier joint, alors téléchargez-le.
            if (fileName != null && fileName.length() > 0) {
                //Télécharger un fichier(Base64)
                MessagePartBody attachPart = service.users().messages().attachments()
                        .get(USER, targetMessage.getId(), part.getBody().getAttachmentId()).execute();
                //Décoder à partir de Base64
                byte[] fileByteArray = Base64.decodeBase64(attachPart.getData());
                //Enregistrer dans le système
                FileOutputStream fileOutFile = new FileOutputStream(fileName);
                fileOutFile.write(fileByteArray);
                fileOutFile.close();
            }
        }
    }
}

Avec cela, vous pourrez récupérer automatiquement les e-mails Gmail et vous serez peut-être heureux de pouvoir automatiser les tâches qui l'accompagnent. L'API Gmail expliquée attentivement ici est également l'URL suivante, et bien que la langue officielle soit américaine, elle explique comment l'utiliser, donc si vous la lisez, vous pouvez tout faire.

API Reference ; https://developers.google.com/gmail/api/v1/reference/

En tant qu'impression personnelle en utilisant l'API Gmail, il était difficile de rechercher la charge utile et les parties lors de l'obtention du sujet et du corps, donc la classe Message a fait de son mieux et avait beaucoup de champs. Je suis heureux que vous puissiez les rejoindre automatiquement.

Recommended Posts

Recevoir des e-mails à l'aide de l'API Gmail en Java
Obtenez des données Youtube en Python à l'aide de l'API Youtube Data
Obtenir l'URL de l'image à l'aide de l'API Flickr en Python
Obtenez des données LEAD à l'aide de l'API REST de Marketo en Python
Créez Gmail en Python sans utiliser l'API
Obtenez des données Amazon à l'aide de Keep API # 1 Obtenez des données
J'ai essayé d'utiliser l'API de reconnaissance vocale docomo et l'API Google Speech en Java
Fonctionnement de la souris à l'aide de l'API Windows en Python
Essayez d'utiliser l'API Wunderlist en Python
Obtenir l'équilibre Suica en Python (en utilisant libpafe)
Tweet à l'aide de l'API Twitter en Python
Obtenez les données de l'API Google Fit en Python
Golang api obtenir
Pièces jointes par e-mail à l'aide de votre compte gmail avec python.
[Python] Obtenez tous les commentaires à l'aide de Youtube Data Api
Essayez d'utiliser l'API BitFlyer Ligntning en Python
Obtenir la liste des objets Google Cloud Storage en Java
Appel de l'API CloudWatch (utilisation dans le plugin Blackbird AWS)
Jugons les émotions à l'aide de l'API Emotion en Python
Comment obtenir des données d'article à l'aide de l'API Qiita
Obtenez l'objet et le corps de Gmail avec Python et l'API Gmail
Pour envoyer automatiquement des e-mails avec des pièces jointes à l'aide de l'API Gmail en Python
Essayez d'utiliser l'API ChatWork et l'API Qiita en Python
Essayez d'utiliser l'API DropBox Core avec Python
[Rails] Comment obtenir des informations de localisation à l'aide de l'API de géolocalisation
Obtenir le nom de fichier dans un dossier à l'aide de glob
Importez un fichier JPG à l'aide de l'API Google Drive en Python
Paramètres initiaux lors de l'utilisation de l'API foursquare avec python
[Python] Obtenez des données insight à l'aide de l'API Google My Business
Envoyez et recevez Gmail via l'API Gmail en utilisant Python
Essayez de supprimer des tweets en masse à l'aide de l'API de Twitter
OpenVINO utilisant l'API Python d'Inference Engine dans un environnement PC
Recevoir des e-mails de Gmail et étiqueter avec Python3
Utiliser l'API de recherche de la Bibliothèque du Parlement national en Python
Recevez des tweets avec des mots-clés arbitraires à l'aide de l'API Streaming de Twitter
Modèle de façade en Java
Modèle de poids mouche en Java
Modèle d'observateur en Java
Autorisations Linux sur Java
Utiliser DataFrame en Java
Modèle d'itérateur en Java
API Evernote en Python
Modèle de décorateur en Java
Obtenir la date en Python
Brouillon de Gmail en Python
API C en Python 3
Modèle de prototype en Java
Envoyer Gmail en Python
Modèle de proxy en Java
Obtenez votre fréquence cardiaque à partir de l'API fitbit en Python!
Obtenez des champs de chat en direct YouTube en temps réel avec l'API
Prédire le sexe à partir du nom à l'aide de l'API Gender et de Pykakasi en Python
Autoriser l'exécution rapide des scripts Python dans Cloud Run à l'aide du répondeur
Obtenez le nom du produit et le prix le plus bas à l'aide de l'API Amazon Product Advertising
Obtenez la météo en utilisant l'API et laissez Raspberry Pi parler!
Appelez l'API github en python pour obtenir des informations sur la demande d'extraction