Googles Gmail gehört zu den beliebtesten und am häufigsten verwendeten E-Mail-Diensten. Google Mail bietet neben dem Senden und Empfangen von E-Mails eine Reihe von Funktionen, z. B. Kalender, Chats usw. In bestimmten Fällen müssen Sie möglicherweise eine Verbindung zu Google Mail herstellen und Kontakte programmgesteuert aus Ihren Anwendungen importieren. Um dies zu erreichen, zeigt dieser Artikel, wie Sie Gmail-Kontakte mit Java importieren. Außerdem erfahren Sie, wie Sie auf Kontakte in einer bestimmten E-Mail-Gruppe zugreifen.
Java-API zum Importieren von Gmail-Kontakten
Aspose.Email for Java ist eine leistungsstarke API zum Erstellen von E-Mail-Client-Anwendungen. Darüber hinaus unterstützt es die Arbeit mit Google Mail, z. B. den Zugriff auf Kontakte, Kalender, Termine usw. Wir werden diese API verwenden, um auf Kontakte aus Google Mail-Konten zuzugreifen und diese zu importieren. Sie können die API entweder herunterladen oder sie mit den folgenden Maven-Konfigurationen installieren.
Repository:
<repository>
<id>AsposeJavaAPI</id>
<name>Aspose Java API</name>
<url>http://repository.aspose.com/repo/</url>
</repository>
Abhängigkeit:
<dependency>
<groupId>com.aspose</groupId>
<artifactId>aspose-email</artifactId>
<version>22.2</version>
<classifier>jdk16</classifier>
</dependency>
Importieren Sie Kontakte aus Google Mail in Java
Bevor Sie beginnen, müssen Sie ein Projekt in der Google Developer Console erstellen, mit dem Sie den Code ausführen können. Um eine zu erstellen, können Sie dieser Anleitung folgen.
Erstellen Sie nun eine Hilfsklasse namens GoogleOAuthHelper, die sich um die Authentifizierung eines Gmail-Kontos kümmert. Erstellen Sie außerdem eine Klasse namens OAuthUser, um Benutzerinformationen zu speichern. Das Folgende ist die vollständige Implementierung beider Klassen.
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>
* Entwicklerkonsole https://console.developers.google.com/projectselector/apis/credentials?pli=1
* Dokumentation 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) {
// ignorieren
}
return result.toString();
}
}
Importieren Sie Kontakte aus einem Gmail-Konto
Im Folgenden sind die Schritte zum Importieren von Kontakten aus einem Gmail-Konto in Java aufgeführt.
- Erstellen Sie ein Objekt der OAuthUser-Klasse und initialisieren Sie es mit E-Mail, Client-ID und Client-Secret.
- Erstellen Sie zwei String-Objekte zum Speichern des Autorisierungscodes und des Codeverifizierers.
- Rufen Sie das Aktualisierungstoken und das Zugriffstoken ab.
- Rufen Sie mithilfe der Methode GmailClient.getInstance(String, String) eine Instanz der GmailClient-Klasse in ein IGmailClient-Objekt ab.
- Kontakte mit der Methode IGmailClient.getAllContacts() in ein Array einlesen.
- Durchschleifen Sie das Array, um auf jeden Kontakt zuzugreifen.
Das folgende Codebeispiel zeigt, wie Gmail-Kontakte aus einem Konto in Java importiert werden.
OAuthUser user = new OAuthUser();
// Legen Sie clientId, clientSecret und E-Mail fest
user.clientId = "<<clientID>>";
user.clientSecret = "<<clientSecret>>";
user.email = "<<email>>";
// Sie müssen den AuthorizationCode manuell mit der generierten AuthorizationCodeUrl abrufen
// Berechtigungscode festlegen
String authorizationCode = "<<authCode>>";
// Kopieren Sie Code Verifier aus der Ausgabe des vorherigen Schritts
// codeVerifier festlegen
String codeVerifier = "<<codeVerifier>>";
// Holen Sie sich das Aktualisierungstoken
String refreshToken = GoogleOAuthHelper.getAccessTokenByAuthCode(authorizationCode, codeVerifier, user);
user.refreshToken = refreshToken;
// Zugriffstoken erhalten
String accessToken = GoogleOAuthHelper.getAccessTokenByRefreshToken(user);
// Verwenden Sie das Zugriffstoken in der 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));
Gmail-Kontakte aus einer Gruppe importieren
Sie können auch auf Kontakte aus einer bestimmten E-Mail-Gruppe in Google Mail zugreifen, indem Sie die folgenden Schritte ausführen.
- Befolgen Sie die im vorherigen Abschnitt erwähnten Schritte, um den IGmailClient zu initialisieren.
- Rufen Sie IGmailClient.getAllGroups() auf, um Gruppen in ein ContactGroupCollection-Objekt zu bekommen.
- Filtern Sie die erforderliche(n) Gruppe(n) basierend auf dem Titel.
- Greifen Sie mit der Methode IGmailClient.getContactsFromGroup(String) auf Kontakte aus einer Gruppe zu.
- Durchschleifen Sie das Array, um auf jeden Kontakt zuzugreifen.
Das folgende Codebeispiel zeigt, wie Kontakte aus einer bestimmten Gmail-Gruppe in Java importiert werden.
OAuthUser user = new OAuthUser();
// Legen Sie clientId, clientSecret und E-Mail fest
user.clientId = "<<clientID>>";
user.clientSecret = "<<clientSecret>>";
user.email = "<<email>>";
// Sie müssen den AuthorizationCode manuell mit der generierten AuthorizationCodeUrl abrufen
// Berechtigungscode festlegen
String authorizationCode = "<<authCode>>";
// Kopieren Sie Code Verifier aus der Ausgabe des vorherigen Schritts
// codeVerifier festlegen
String codeVerifier = "<<codeVerifier>>";
// Holen Sie sich das Aktualisierungstoken
String refreshToken = GoogleOAuthHelper.getAccessTokenByAuthCode(authorizationCode, codeVerifier, user);
user.refreshToken = refreshToken;
// Zugriffstoken erhalten
String accessToken = GoogleOAuthHelper.getAccessTokenByRefreshToken(user);
// Verwenden Sie das Zugriffstoken in der API
IGmailClient client = GmailClient.getInstance(accessToken, user.email);
// Rufen Sie Kontakte aus einer bestimmten Gruppe ab
ContactGroupCollection groups = client.getAllGroups();
GoogleContactGroup group = null;
for (GoogleContactGroup g : groups) {
if ("TestGroup".equals(g.getTitle())) {
group = g;
}
}
// Rufen Sie Kontakte aus der Gruppe ab
if (group != null) {
Contact[] contacts2 = client.getContactsFromGroup(group.getId());
for (Contact con : contacts2)
System.out.println(con.getDisplayName() + "," + con.getEmailAddresses().get_Item(0).toString());
}
Holen Sie sich eine kostenlose API-Lizenz
Sie können eine kostenlose temporäre Lizenz erhalten, um Aspose.Email für Java ohne Evaluierungseinschränkungen zu verwenden.
Fazit
In diesem Artikel haben Sie gelernt, wie Sie Gmail-Kontakte programmgesteuert aus einem Konto in Java importieren. Außerdem haben Sie gesehen, wie Sie in Google Mail auf Kontakte aus einer bestimmten E-Mail-Gruppe zugreifen. Abgesehen davon können Sie die Dokumentation durchsuchen, um mehr über Aspose.Email für Java zu erfahren. Außerdem können Sie Ihre Fragen über unser Forum stellen.