Gmail de Google est l’un des services de messagerie les plus populaires et les plus couramment utilisés. Gmail fournit une gamme de fonctionnalités ainsi que l’envoi et la réception d’e-mails, tels que des calendriers, des chats, etc. Dans certains cas, vous devrez peut-être vous connecter à Gmail et importer des contacts par programmation à partir de vos applications. Pour y parvenir, cet article explique comment importer des contacts Gmail à l’aide de Java. Nous expliquerons également comment accéder aux contacts d’un groupe de messagerie spécifique.
API Java pour importer des contacts Gmail
Aspose.Email for Java est une API puissante pour créer des applications client de messagerie. De plus, il prend en charge le travail avec Gmail, tel que l’accès aux contacts, aux calendriers, aux rendez-vous, etc. Nous utiliserons cette API pour accéder et importer des contacts à partir de comptes Gmail. Vous pouvez soit télécharger l’API ou l’installer à l’aide des configurations Maven suivantes.
Repository:
<repository>
<id>AsposeJavaAPI</id>
<name>Aspose Java API</name>
<url>http://repository.aspose.com/repo/</url>
</repository>
Dependency:
<dependency>
<groupId>com.aspose</groupId>
<artifactId>aspose-email</artifactId>
<version>22.2</version>
<classifier>jdk16</classifier>
</dependency>
Importer des contacts depuis Gmail en Java
Avant de commencer, vous devez créer un projet sur la Google Developer Console, qui vous permettra d’exécuter le code. Pour en créer un, vous pouvez suivre ce guide.
Maintenant, créez une classe d’assistance nommée GoogleOAuthHelper pour prendre en charge l’authentification d’un compte Gmail. Créez également une classe nommée OAuthUser pour stocker les informations utilisateur. Ce qui suit est l’implémentation complète des deux classes.
public class OAuthUser {
String email;
String clientId;
String clientSecret;
String refreshToken;
}
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.UnsupportedEncodingException;
import java.net.HttpURLConnection;
import java.net.URL;
import java.net.URLDecoder;
import java.net.URLEncoder;
import java.nio.charset.StandardCharsets;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.HashMap;
import java.util.Map;
import java.util.UUID;
import javax.xml.bind.DatatypeConverter;
/**
* <p>
* Console développeurs https://console.developers.google.com/projectselector/apis/credentials?pli=1
* Documentation https://developers.google.com/identity/protocols/OAuth2InstalledApp
* </p>
*/
class GoogleOAuthHelper {
public static final String AUTHORIZATION_URL = "https://accounts.google.com/o/oauth2/v2/auth";
public static final String TOKEN_REQUEST_URL = "https://oauth2.googleapis.com/token";
public static final String REDIRECT_URI = "urn:ietf:wg:oauth:2.0:oob";
public static final String REDIRECT_TYPE = "code";
public static final String SCOPE = "https%3A%2F%2Fwww.googleapis.com%2Fauth%2Fcalendar" // Calendar
+ "+https%3A%2F%2Fwww.google.com%2Fm8%2Ffeeds%2F" // Contacts
+ "+https%3A%2F%2Fmail.google.com%2F"; // IMAP & SMTP
static String createCodeChalange() {
String verifierStr = UUID.randomUUID().toString() + "-" + UUID.randomUUID().toString();
System.out.println("Code Verifier: " + verifierStr);
MessageDigest digest;
try {
digest = MessageDigest.getInstance("SHA-256");
} catch (NoSuchAlgorithmException e) {
throw new IllegalAccessError(e.getMessage());
}
byte[] hash = digest.digest(verifierStr.getBytes(StandardCharsets.UTF_8));
String base64Hash = DatatypeConverter.printBase64Binary(hash);
base64Hash = base64Hash.split("=")[0];
base64Hash = base64Hash.replace('+', '-').replace('/', '_');
return base64Hash;
}
static String getAuthorizationCodeUrl(OAuthUser acc) {
return getAuthorizationCodeUrl(acc, SCOPE, REDIRECT_URI, REDIRECT_TYPE);
}
static String getAuthorizationCodeUrl(OAuthUser acc, String scope, String redirectUri, String responseType) {
System.out.println("---------------------------------------------------------");
System.out.println("------------- OAuth 2.0 AuthorizationCodeUrl -------------");
System.out.println("---------------------------------------------------------");
System.out.println("Login: " + acc.email);
String codeChallenge = createCodeChalange();
String state = urlEncode(UUID.randomUUID().toString());
String approveUrl = AUTHORIZATION_URL + "?client_id=" + acc.clientId + "&redirect_uri=" + redirectUri + "&response_type=" + responseType + "&scope=" + scope
+ "&code_challenge=" + codeChallenge + "&code_challenge_method=S256&state=" + state;
System.out.println("Approve Url: " + approveUrl);
return approveUrl;
}
static String urlEncode(String value) {
try {
return URLEncoder.encode(value, StandardCharsets.UTF_8.toString());
} catch (UnsupportedEncodingException e) {
throw new IllegalAccessError(e.getMessage());
}
}
static String urlDecode(String value) {
try {
return URLDecoder.decode(value, StandardCharsets.UTF_8.toString());
} catch (UnsupportedEncodingException e) {
throw new IllegalAccessError(e.getMessage());
}
}
static String getAccessTokenByAuthCode(String authorizationCode, String codeVerifier, OAuthUser user) {
String encodedParameters = "client_id=" + urlEncode(user.clientId) + "&client_secret=" + urlEncode(user.clientSecret) + "&code=" + urlEncode(authorizationCode)
+ "&code_verifier=" + codeVerifier + "&redirect_uri=" + urlEncode(REDIRECT_URI) + "&grant_type=authorization_code";
System.out.println("---------------------------------------------------------");
System.out.println("------------- OAuth 2.0 AccessTokenByAuthCode -------------");
System.out.println("---------------------------------------------------------");
System.out.println("Authorization code: " + authorizationCode);
String result = "";
Map<String, String> token = geToken(encodedParameters);
for (String key : token.keySet()) {
System.out.println(key + ": " + token.get(key));
if (key.equals("refresh_token")) {
result = token.get(key);
}
}
System.out.println("---------------------------------------------------------");
return result;
}
static String getAccessTokenByRefreshToken(OAuthUser user) {
String encodedParameters = "client_id=" + urlEncode(user.clientId) + "&client_secret=" + urlEncode(user.clientSecret) + "&refresh_token=" + urlEncode(user.refreshToken)
+ "&grant_type=refresh_token";
System.out.println("---------------------------------------------------------");
System.out.println("----------- OAuth 2.0 AccessTokenByRefreshToken -----------");
System.out.println("---------------------------------------------------------");
System.out.println("Login: " + user.email);
String result = "";
Map<String, String> token = geToken(encodedParameters);
for (String key : token.keySet()) {
System.out.println(key + ": " + token.get(key));
if (key.equals("access_token")) {
result = token.get(key);
}
}
System.out.println("---------------------------------------------------------");
return result;
}
static Map<String, String> geToken(String encodedParameters) {
try {
HttpURLConnection connection = (HttpURLConnection) new URL(TOKEN_REQUEST_URL).openConnection();
connection.setRequestMethod("POST");
byte[] requestData = encodedParameters.getBytes(StandardCharsets.UTF_8);
connection.setUseCaches(false);
connection.setDoInput(true);
connection.setDoOutput(true);
connection.setRequestProperty("Content-Type", "application/x-www-form-urlencoded");
connection.setRequestProperty("Content-Length", "" + requestData.length);
final OutputStream st = connection.getOutputStream();
try {
st.write(requestData, 0, requestData.length);
} finally {
st.flush();
st.close();
}
connection.connect();
if (connection.getResponseCode() >= HttpURLConnection.HTTP_BAD_REQUEST) {
throw new IllegalAccessError("Operation failed: " + connection.getResponseCode() + "/" + connection.getResponseMessage() + "\r\nDetails:\r\n{2}"
+ readInputStream(connection.getErrorStream()));
}
String responseText = readInputStream(connection.getInputStream());
Map<String, String> result = new HashMap<String, String>();
System.out.println(responseText);
String[] strs = responseText.replace("{", "").replace("}", "").replace("\"", "").replace("\r", "").replace("\n", "").split(",");
for (String sPair : strs) {
String[] pair = sPair.split(":");
String name = pair[0].trim().toLowerCase();
String value = urlDecode(pair[1].trim());
result.put(name, value);
}
return result;
} catch (IOException e) {
throw new IllegalAccessError(e.getMessage());
}
}
static String readInputStream(InputStream is) {
if (is == null)
return "";
BufferedReader reader = new BufferedReader(new InputStreamReader(is));
StringBuilder result = new StringBuilder();
String line;
try {
while ((line = reader.readLine()) != null) {
result.append(line);
}
} catch (IOException e) {
// ignorer
}
return result.toString();
}
}
Importer des contacts depuis un compte Gmail
Voici les étapes pour importer des contacts depuis un compte Gmail en Java.
- Créez un objet de la classe OAuthUser et initialisez-le avec l’e-mail, l’ID client et le secret client.
- Créez deux objets de chaîne pour stocker le code d’autorisation et le vérificateur de code.
- Obtenez un jeton d’actualisation et un jeton d’accès.
- Obtenez une instance de la classe GmailClient dans un objet IGmailClient à l’aide de la méthode GmailClient.getInstance(String, String).
- Lire les contacts dans un tableau à l’aide de la méthode IGmailClient.getAllContacts().
- Boucle dans le tableau pour accéder à chaque contact.
L’exemple de code suivant montre comment importer des contacts Gmail à partir d’un compte en Java.
OAuthUser user = new OAuthUser();
// Définissez clientId, clientSecret et email
user.clientId = "<<clientID>>";
user.clientSecret = "<<clientSecret>>";
user.email = "<<email>>";
// Vous devez récupérer AuthorizationCode manuellement avec AuthorizationCodeUrl généré
// Définir le code d'autorisation
String authorizationCode = "<<authCode>>";
// Copier le vérificateur de code à partir de la sortie de l'étape précédente
// Définir le codeVérificateur
String codeVerifier = "<<codeVerifier>>";
// Obtenir un jeton d'actualisation
String refreshToken = GoogleOAuthHelper.getAccessTokenByAuthCode(authorizationCode, codeVerifier, user);
user.refreshToken = refreshToken;
// Obtenir un jeton d'accès
String accessToken = GoogleOAuthHelper.getAccessTokenByRefreshToken(user);
// Utiliser le jeton d'accès dans l'API
IGmailClient client = GmailClient.getInstance(accessToken, user.email);
Contact[] contacts = client.getAllContacts();
for (Contact contact : contacts)
System.out.println(contact.getDisplayName() + ", " + contact.getEmailAddresses().get_Item(0));
Importer des contacts Gmail à partir d’un groupe
Vous pouvez également accéder aux contacts d’un groupe de messagerie spécifique dans Gmail en suivant les étapes ci-dessous.
- Suivez les étapes mentionnées dans la section précédente pour initialiser IGmailClient.
- Appelez IGmailClient.getAllGroups() pour obtenir des groupes dans un objet ContactGroupCollection.
- Filtrez le(s) groupe(s) requis en fonction du titre.
- Accédez aux contacts d’un groupe à l’aide de la méthode IGmailClient.getContactsFromGroup(String).
- Boucle dans le tableau pour accéder à chaque contact.
L’exemple de code suivant montre comment importer des contacts à partir d’un groupe Gmail spécifique en Java.
OAuthUser user = new OAuthUser();
// Définissez clientId, clientSecret et email
user.clientId = "<<clientID>>";
user.clientSecret = "<<clientSecret>>";
user.email = "<<email>>";
// Vous devez récupérer AuthorizationCode manuellement avec AuthorizationCodeUrl généré
// Définir le code d'autorisation
String authorizationCode = "<<authCode>>";
// Copier le vérificateur de code à partir de la sortie de l'étape précédente
// Définir le codeVérificateur
String codeVerifier = "<<codeVerifier>>";
// Obtenir un jeton d'actualisation
String refreshToken = GoogleOAuthHelper.getAccessTokenByAuthCode(authorizationCode, codeVerifier, user);
user.refreshToken = refreshToken;
// Obtenir un jeton d'accès
String accessToken = GoogleOAuthHelper.getAccessTokenByRefreshToken(user);
// Utiliser le jeton d'accès dans l'API
IGmailClient client = GmailClient.getInstance(accessToken, user.email);
// Récupérer les contacts d'un groupe spécifique
ContactGroupCollection groups = client.getAllGroups();
GoogleContactGroup group = null;
for (GoogleContactGroup g : groups) {
if ("TestGroup".equals(g.getTitle())) {
group = g;
}
}
// Récupérer les contacts du groupe
if (group != null) {
Contact[] contacts2 = client.getContactsFromGroup(group.getId());
for (Contact con : contacts2)
System.out.println(con.getDisplayName() + "," + con.getEmailAddresses().get_Item(0).toString());
}
Obtenez une licence API gratuite
Vous pouvez obtenir une licence temporaire gratuite pour utiliser Aspose.Email for Java sans limitation d’évaluation.
Conclusion
Dans cet article, vous avez appris à importer des contacts Gmail à partir d’un compte par programmation en Java. De plus, vous avez vu comment accéder aux contacts d’un groupe de messagerie particulier dans Gmail. En dehors de cela, vous pouvez explorer la documentation pour en savoir plus sur Aspose.Email for Java. Vous pouvez également poser vos questions via notre forum.