Googles Gmail är bland de mest populära och vanligaste e-posttjänsterna. Gmail tillhandahåller en rad funktioner tillsammans med att bara skicka och ta emot e-postmeddelanden, som kalendrar, chattar, etc. I vissa fall kan du behöva ansluta till Gmail och importera kontakter programmatiskt från dina applikationer. För att uppnå det visar den här artikeln hur du importerar Gmail-kontakter med Java. Vi kommer också att täcka hur du kommer åt kontakter i en specifik e-postgrupp.
Java API för att importera Gmail-kontakter
Aspose.Email for Java är ett kraftfullt API för att skapa e-postklientapplikationer. Dessutom stöder det arbete med Gmail som att komma åt kontakter, kalendrar, möten, etc. Vi kommer att använda detta API för att komma åt och importera kontakter från Gmail-konton. Du kan antingen ladda ner API:et eller installera det med hjälp av följande Maven-konfigurationer.
Förvar:
<repository>
<id>AsposeJavaAPI</id>
<name>Aspose Java API</name>
<url>http://repository.aspose.com/repo/</url>
</repository>
Beroende:
<dependency>
<groupId>com.aspose</groupId>
<artifactId>aspose-email</artifactId>
<version>22.2</version>
<classifier>jdk16</classifier>
</dependency>
Importera kontakter från Gmail i Java
Innan du börjar måste du skapa ett projekt på Google Developer Console, vilket gör att du kan köra koden. För att skapa en kan du följa denna guide.
Skapa nu en hjälpklass vid namn GoogleOAuthHelper för att ta hand om autentiseringen av ett Gmail-konto. Skapa också en klass som heter OAuthUser för att lagra användarinformation. Följande är den fullständiga implementeringen av båda klasserna.
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>
* Utvecklarkonsol 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) {
// ignorera
}
return result.toString();
}
}
Importera kontakter från ett Gmail-konto
Följande är stegen för att importera kontakter från ett Gmail-konto i Java.
- Skapa ett objekt av OAuthUser-klassen och initiera det med e-post, klient-ID och klienthemlighet.
- Skapa två strängobjekt för att lagra auktoriseringskod och kodverifierare.
- Få uppdateringstoken och åtkomsttoken.
- Hämta en instans av GmailClient-klassen till ett IGmailClient-objekt med metoden GmailClient.getInstance(String, String).
- Läs kontakter i en array med IGmailClient.getAllContacts()-metoden.
- Gå igenom arrayen för att komma åt varje kontakt.
Följande kodexempel visar hur du importerar Gmail-kontakter från ett konto i Java.
OAuthUser user = new OAuthUser();
// Ställ in clientId, clientSecret och e-post
user.clientId = "<<clientID>>";
user.clientSecret = "<<clientSecret>>";
user.email = "<<email>>";
// Du måste hämta AuthorizationCode manuellt med genererad AuthorizationCodeUrl
// Ställ in auktoriseringskod
String authorizationCode = "<<authCode>>";
// Kopiera kodverifierare från föregående steg
// Ställ in codeVerifier
String codeVerifier = "<<codeVerifier>>";
// Få Refresh Token
String refreshToken = GoogleOAuthHelper.getAccessTokenByAuthCode(authorizationCode, codeVerifier, user);
user.refreshToken = refreshToken;
// Få åtkomsttoken
String accessToken = GoogleOAuthHelper.getAccessTokenByRefreshToken(user);
// Använd åtkomsttoken i 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));
Importera Gmail-kontakter från en grupp
Du kan också komma åt kontakter från en specifik e-postgrupp i Gmail genom att följa stegen nedan.
- Följ stegen som nämns i föregående avsnitt för att initiera IGmailClient.
- Ring IGmailClient.getAllGroups() för att få grupper till ett ContactGroupCollection-objekt.
- Filtrera den eller de grupper som krävs baserat på titeln.
- Få åtkomst till kontakter från en grupp med metoden IGmailClient.getContactsFromGroup(String).
- Gå igenom arrayen för att komma åt varje kontakt.
Följande kodexempel visar hur du importerar kontakter från en specifik Gmail-grupp i Java.
OAuthUser user = new OAuthUser();
// Ställ in clientId, clientSecret och e-post
user.clientId = "<<clientID>>";
user.clientSecret = "<<clientSecret>>";
user.email = "<<email>>";
// Du måste hämta AuthorizationCode manuellt med genererad AuthorizationCodeUrl
// Ställ in auktoriseringskod
String authorizationCode = "<<authCode>>";
// Kopiera kodverifierare från föregående steg
// Ställ in codeVerifier
String codeVerifier = "<<codeVerifier>>";
// Få Refresh Token
String refreshToken = GoogleOAuthHelper.getAccessTokenByAuthCode(authorizationCode, codeVerifier, user);
user.refreshToken = refreshToken;
// Få åtkomsttoken
String accessToken = GoogleOAuthHelper.getAccessTokenByRefreshToken(user);
// Använd åtkomsttoken i API
IGmailClient client = GmailClient.getInstance(accessToken, user.email);
// Hämta kontakter från en specifik grupp
ContactGroupCollection groups = client.getAllGroups();
GoogleContactGroup group = null;
for (GoogleContactGroup g : groups) {
if ("TestGroup".equals(g.getTitle())) {
group = g;
}
}
// Hämta kontakter från gruppen
if (group != null) {
Contact[] contacts2 = client.getContactsFromGroup(group.getId());
for (Contact con : contacts2)
System.out.println(con.getDisplayName() + "," + con.getEmailAddresses().get_Item(0).toString());
}
Skaffa en gratis API-licens
Du kan få en gratis temporär licens för att använda Aspose.Email för Java utan utvärderingsbegränsningar.
Slutsats
I den här artikeln har du lärt dig hur du importerar Gmail-kontakter från ett konto programmatiskt i Java. Dessutom har du sett hur du kommer åt kontakter från en viss e-postgrupp i Gmail. Bortsett från det kan du utforska dokumentationen för att läsa mer om Aspose.Email för Java. Du kan också ställa dina frågor via vårt forum.