Erstellen, aktualisieren oder löschen Sie Google Kalender in Java

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

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.

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.

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.

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.

Siehe auch