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.

Préparez un compte Google.

Courriel que vous souhaitez recevoir

Ceci est un exemple d'e-mail à recevoir cette fois. 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éez un projet sur votre compte Google.
Activez l'API Gmail sur votre compte Google.
Étant donné que l'API Gmail utilise OAuth 2.0 pour l'authentification, préparez un client OAuth 2.0 sur votre compte Google.

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" __

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

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

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

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 __

__2. Sélectionnez l'ID client OAuth __

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

__4. Achèvement __

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

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

Écrivons Java

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

Authentification
Obtenez l'ID du message
Recevoir du courrier
Décodage corporel
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 __

__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".

__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.

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

setApplicationName --_ Le nom du service Gmail à créer __


//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.

_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.

à 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.

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

introduction

Chose que tu veux faire

supposition

Courriel que vous souhaitez recevoir

Importer la bibliothèque

Paramètres d'authentification

Créer un projet

Activer l'API Gmail

Préparer le client OAuth 2.0

Écrivons Java

Authentification

Obtenir l'identifiant du message

Recevoir du courrier

Décodage corporel

Télécharger les fichiers joints

à la fin