Google Kalender ist ein Planungsdienst, mit dem Sie Ereignisse wie Besprechungen erstellen und verfolgen können. Sie können die Ereignisse im Kalender protokollieren und Erinnerungen an die bevorstehenden erhalten. Google ermöglicht es Ihnen auch, seinen Kalenderdienst programmgesteuert zu verwenden. So können Sie Ihre Termine mit Google Kalender aus Ihren Anwendungen heraus verwalten. In diesem Artikel erfahren Sie, wie Sie Google Kalender programmgesteuert in Java erstellen, aktualisieren und löschen.
- Java-API zum Erstellen und Bearbeiten von Google Kalender
- Erstellen Sie einen Google-Kalender in Java
- Aktualisieren Sie einen Google-Kalender in Java
- Löschen Sie einen Google-Kalender in Java
Java-API zum Erstellen und Bearbeiten von Google Kalender
Um mit dem Google Kalender-Dienst zu arbeiten, verwenden wir Aspose.Email for Java. Es ist eine leistungsstarke API, die eine Reihe von Funktionen für die Verarbeitung von E-Mails, die Arbeit mit E-Mail-Clients und die Nutzung der Zusammenarbeitsdienste von Google bietet. 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.3</version>
<classifier>jdk16</classifier>
</dependency>
Erstellen Sie einen Google-Kalender in Java
Bevor Sie beginnen, müssen Sie ein Projekt in der Google Developer Console erstellen, damit Ihre Anwendung mit den Diensten von Google kommunizieren kann. Um eine zu erstellen, können Sie dieser Anleitung folgen.
Erstellen Sie nun eine Hilfsklasse namens GoogleOAuthHelper, die sich um die Authentifizierung eines Google-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();
}
}
Sobald Sie die obige Konfiguration vorgenommen haben, können Sie mit der Arbeit mit dem Google Kalender-Dienst fortfahren. Im Folgenden sind die Schritte zum Erstellen und Aktualisieren eines Google-Kalenders in Java aufgeführt.
- Rufen Sie mithilfe der Methode GmailClient.getInstance(String, String) eine Instanz der Klasse GmailClient in ein Objekt IGmailClient ab.
- Erstellen Sie eine Instanz der Klasse Calendar und initialisieren Sie sie mit Name, Beschreibung und anderen Eigenschaften.
- Rufen Sie die Methode IGmailClient.createCalendar(Calendar) auf, um den Google-Kalender zu erstellen.
- Rufen Sie die zurückgegebene ID des Kalenders ab.
Das folgende Codebeispiel zeigt, wie Sie einen Google-Kalender in Java erstellen.
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);
// Gmail-Client erstellen
try (IGmailClient client = GmailClient.getInstance(accessToken, user.email)) {
// Kalender einfügen, abrufen und aktualisieren
Calendar calendar = new Calendar("Summary", "Description", "Location", "America/Los_Angeles");
// Kalender einfügen und denselben Kalender mit ID abrufen
String id = client.createCalendar(calendar);
}
Aktualisieren Sie einen Google-Kalender in Java
Im Folgenden finden Sie die Schritte zum programmgesteuerten Aktualisieren eines Google-Kalenders in Java.
- Rufen Sie mithilfe der Methode GmailClient.getInstance(String, String) eine Instanz der Klasse GmailClient in ein Objekt IGmailClient ab.
- Verwenden Sie die Methode IGmailClient.fetchCalendar(String), um die Kalenderinstanz anhand ihrer ID abzurufen.
- Aktualisieren Sie die Eigenschaften des Kalenders und rufen Sie die Methode IGmailClient.updateCalendar(Calendar) auf, um den Kalender zu aktualisieren.
Das folgende Codebeispiel zeigt, wie Sie einen Google-Kalender in Java aktualisieren.
// Gmail-Client erstellen
try (IGmailClient client = GmailClient.getInstance(accessToken, email)) {
// Kalender-ID angeben
String id ="<<calendar ID>>"
// Kalender abrufen
Calendar cal = client.fetchCalendar(id);
// Informationen im abgerufenen Kalender ändern und Kalender aktualisieren
cal.setDescription("New Description");
cal.setLocation("New Location");
// Kalender aktualisieren
client.updateCalendar(cal);
}
Löschen Sie einen Google-Kalender in Java
Sie können auch einen bestimmten Kalender mit Aspose.Email für Java löschen. Im Folgenden sind die Schritte zum Ausführen dieses Vorgangs aufgeführt.
- Rufen Sie mithilfe der Methode GmailClient.getInstance(String, String) eine Instanz der Klasse GmailClient in ein Objekt IGmailClient ab.
- Rufen Sie die Liste der Kalender mit der Methode IGmailClient.listCalendars() ab.
- Durchlaufen Sie die Liste und filtern Sie die gewünschte.
- Löschen Sie den Kalender mit der Methode IGmailClient.deleteCalendar(Calendar.getId()).
Das folgende Codebeispiel zeigt, wie Sie einen Google-Kalender in Java löschen.
// Gmail-Client erstellen
try (IGmailClient client = GmailClient.getInstance(accessToken, email)) {
// Kalender mit Zusammenfassung aufrufen und löschen, beginnend mit „Kalenderzusammenfassung“
String summary = "Calendar summary";
// Kalenderliste abrufen
ExtendedCalendar[] lst = client.listCalendars();
for (ExtendedCalendar extCal : lst) {
// Ausgewählte Kalender löschen
if (extCal.getSummary().startsWith(summary))
client.deleteCalendar(extCal.getId());
}
}
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 Google Kalender programmgesteuert in Java erstellen. Außerdem haben Sie gesehen, wie Sie einen bestimmten Google-Kalender in Java aktualisieren und löschen. Außerdem können Sie die Dokumentation durchsuchen, um mehr über Aspose.Email für Java zu erfahren. Sie können Ihre Fragen auch über unser Forum stellen.