Gmail di Google è tra i servizi di posta elettronica più popolari e comunemente utilizzati. Gmail offre una gamma di funzioni oltre all’invio e alla ricezione di e-mail, come calendari, chat e così via. In alcuni casi, potrebbe essere necessario connetterti a Gmail e importare i contatti in modo programmatico dalle tue applicazioni. Per raggiungere questo obiettivo, questo articolo mostra come importare i contatti di Gmail utilizzando Java. Inoltre, tratteremo come accedere ai contatti in un gruppo di posta elettronica specifico.
API Java per importare contatti Gmail
Aspose.Email per Java è una potente API per creare applicazioni client di posta elettronica. Inoltre, supporta il lavoro con Gmail come l’accesso a contatti, calendari, appuntamenti, ecc. Utilizzeremo questa API per accedere e importare i contatti dagli account Gmail. Puoi scaricare l’API o installarla utilizzando le seguenti configurazioni Maven.
Archivio:
<repository>
<id>AsposeJavaAPI</id>
<name>Aspose Java API</name>
<url>http://repository.aspose.com/repo/</url>
</repository>
Dipendenza:
<dependency>
<groupId>com.aspose</groupId>
<artifactId>aspose-email</artifactId>
<version>22.2</version>
<classifier>jdk16</classifier>
</dependency>
Importa contatti da Gmail in Java
Prima di iniziare, devi creare un progetto sulla Google Developer Console, che ti consentirà di eseguire il codice. Per crearne uno, puoi seguire questa guida.
Ora crea una classe helper denominata GoogleOAuthHelper per occuparsi dell’autenticazione di un account Gmail. Creare inoltre una classe denominata OAuthUser per memorizzare le informazioni sull’utente. Quella che segue è l’implementazione completa di entrambe le classi.
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 per gli sviluppatori https://console.developers.google.com/projectselector/apis/credentials?pli=1
* Documentazione 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) {
// ignorare
}
return result.toString();
}
}
Importa contatti da un account Gmail
Di seguito sono riportati i passaggi per importare i contatti da un account Gmail in Java.
- Crea un oggetto della classe OAuthUser e inizializzalo con e-mail, ID client e segreto client.
- Crea due oggetti stringa per memorizzare il codice di autorizzazione e il verificatore di codice.
- Ottieni token di aggiornamento e token di accesso.
- Ottieni un’istanza della classe GmailClient in un oggetto IGmailClient utilizzando il metodo GmailClient.getInstance(String, String).
- Leggi i contatti in un array usando il metodo IGmailClient.getAllContacts().
- Passa attraverso l’array per accedere a ciascun contatto.
L’esempio di codice seguente mostra come importare i contatti Gmail da un account in Java.
OAuthUser user = new OAuthUser();
// Imposta clientId, clientSecret ed e-mail
user.clientId = "<<clientID>>";
user.clientSecret = "<<clientSecret>>";
user.email = "<<email>>";
// Devi recuperare AuthorizationCode manualmente con AuthorizationCodeUrl generato
// Imposta il codice di autorizzazione
String authorizationCode = "<<authCode>>";
// Copia Code Verifier dall'output del passaggio precedente
// Imposta codeVerifier
String codeVerifier = "<<codeVerifier>>";
// Ottieni il token di aggiornamento
String refreshToken = GoogleOAuthHelper.getAccessTokenByAuthCode(authorizationCode, codeVerifier, user);
user.refreshToken = refreshToken;
// Ottieni token di accesso
String accessToken = GoogleOAuthHelper.getAccessTokenByRefreshToken(user);
// Usa il token di accesso nell'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));
Importa contatti Gmail da un gruppo
Puoi anche accedere ai contatti da un gruppo di posta elettronica specifico in Gmail seguendo i passaggi seguenti.
- Segui i passaggi indicati nella sezione precedente per inizializzare IGmailClient.
- Chiama IGmailClient.getAllGroups() per ottenere i gruppi in un oggetto ContactGroupCollection.
- Filtra i gruppi richiesti in base al titolo.
- Accedi ai contatti da un gruppo utilizzando il metodo IGmailClient.getContactsFromGroup(String).
- Passa attraverso l’array per accedere a ciascun contatto.
L’esempio di codice seguente mostra come importare i contatti da un gruppo Gmail specifico in Java.
OAuthUser user = new OAuthUser();
// Imposta clientId, clientSecret ed e-mail
user.clientId = "<<clientID>>";
user.clientSecret = "<<clientSecret>>";
user.email = "<<email>>";
// Devi recuperare AuthorizationCode manualmente con AuthorizationCodeUrl generato
// Imposta il codice di autorizzazione
String authorizationCode = "<<authCode>>";
// Copia Code Verifier dall'output del passaggio precedente
// Imposta codeVerifier
String codeVerifier = "<<codeVerifier>>";
// Ottieni il token di aggiornamento
String refreshToken = GoogleOAuthHelper.getAccessTokenByAuthCode(authorizationCode, codeVerifier, user);
user.refreshToken = refreshToken;
// Ottieni token di accesso
String accessToken = GoogleOAuthHelper.getAccessTokenByRefreshToken(user);
// Usa il token di accesso nell'API
IGmailClient client = GmailClient.getInstance(accessToken, user.email);
// Recupera i contatti da un gruppo specifico
ContactGroupCollection groups = client.getAllGroups();
GoogleContactGroup group = null;
for (GoogleContactGroup g : groups) {
if ("TestGroup".equals(g.getTitle())) {
group = g;
}
}
// Recupera i contatti dal gruppo
if (group != null) {
Contact[] contacts2 = client.getContactsFromGroup(group.getId());
for (Contact con : contacts2)
System.out.println(con.getDisplayName() + "," + con.getEmailAddresses().get_Item(0).toString());
}
Ottieni una licenza API gratuita
Puoi ottenere una licenza temporanea gratuita per utilizzare Aspose.Email per Java senza limitazioni di valutazione.
Conclusione
In questo articolo, hai imparato come importare i contatti Gmail da un account in modo programmatico in Java. Inoltre, hai visto come accedere ai contatti da un particolare gruppo di posta elettronica in Gmail. A parte questo, puoi esplorare la documentazione per saperne di più su Aspose.Email per Java. Inoltre, puoi porre le tue domande tramite il nostro forum.