Google Calendar è un servizio di pianificazione che ti consente di creare e tenere traccia di eventi come le riunioni. Puoi registrare gli eventi sul calendario e ricevere promemoria su quelli imminenti. Google ti consente anche di utilizzare il suo servizio di calendario in modo programmatico. Pertanto, puoi gestire i tuoi eventi utilizzando Google Calendars dalle tue applicazioni. In questo articolo imparerai come creare, aggiornare ed eliminare Google Calendar in modo programmatico in Java.
- API Java per creare e manipolare Google Calendar
- Crea un Google Calendar in Java
- Aggiorna un Google Calendar in Java
- Elimina un Google Calendar in Java
API Java per creare e manipolare Google Calendar
Per lavorare con il servizio Google Calendar, utilizzeremo Aspose.Email for Java. È una potente API che fornisce una gamma di funzionalità per l’elaborazione delle e-mail, l’utilizzo dei client di posta elettronica e l’utilizzo dei servizi di collaborazione di Google. 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.3</version>
<classifier>jdk16</classifier>
</dependency>
Crea un Google Calendar in Java
Prima di iniziare, devi creare un progetto nella Console per gli sviluppatori di Google affinché la tua applicazione possa comunicare con i servizi di Google. Per crearne uno, puoi seguire questa guida.
Ora, crea una classe helper denominata GoogleOAuthHelper per occuparsi dell’autenticazione di un account Google. 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();
}
}
Dopo aver eseguito la configurazione di cui sopra, puoi procedere a lavorare con il servizio Google Calendar. Di seguito sono riportati i passaggi per creare e aggiornare un Google Calendar in Java.
- Ottieni un’istanza della classe GmailClient in un oggetto IGmailClient utilizzando il metodo GmailClient.getInstance(String, String).
- Crea un’istanza della classe Calendar e inizializzala con nome, descrizione e altre proprietà.
- Chiama il metodo IGmailClient.createCalendar(Calendar) per creare il Google Calendar.
- Ottieni l’ID restituito del calendario.
L’esempio di codice seguente mostra come creare un Google Calendar 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);
// Crea client Gmail
try (IGmailClient client = GmailClient.getInstance(accessToken, user.email)) {
// Inserisci, ottieni e aggiorna il calendario
Calendar calendar = new Calendar("Summary", "Description", "Location", "America/Los_Angeles");
// Inserisci il calendario e recupera lo stesso calendario usando l'id
String id = client.createCalendar(calendar);
}
Aggiorna un Google Calendar in Java
Di seguito sono riportati i passaggi per aggiornare un Google Calendar a livello di codice in Java.
- Ottieni un’istanza della classe GmailClient in un oggetto IGmailClient utilizzando il metodo GmailClient.getInstance(String, String).
- Utilizzare il metodo IGmailClient.fetchCalendar(String) per recuperare l’istanza del calendario utilizzando il relativo ID.
- Aggiorna le proprietà del calendario e chiama il metodo IGmailClient.updateCalendar(Calendar) per aggiornare il calendario.
L’esempio di codice seguente mostra come aggiornare un calendario di Google in Java.
// Crea client Gmail
try (IGmailClient client = GmailClient.getInstance(accessToken, email)) {
// Specificare l'ID calendario
String id ="<<calendar ID>>"
// Recupera il calendario
Calendar cal = client.fetchCalendar(id);
// Modifica le informazioni nel calendario recuperato e aggiorna il calendario
cal.setDescription("New Description");
cal.setLocation("New Location");
// Aggiorna calendario
client.updateCalendar(cal);
}
Elimina un Google Calendar in Java
Puoi anche eliminare un determinato calendario utilizzando Aspose.Email per Java. Di seguito sono riportati i passaggi per eseguire questa operazione.
- Ottieni un’istanza della classe GmailClient in un oggetto IGmailClient utilizzando il metodo GmailClient.getInstance(String, String).
- Ottieni l’elenco dei calendari usando il metodo IGmailClient.listCalendars().
- Scorri l’elenco e filtra quello desiderato.
- Elimina il calendario utilizzando il metodo IGmailClient.deleteCalendar(Calendar.getId()).
L’esempio di codice seguente mostra come eliminare un Google Calendar in Java.
// Crea client Gmail
try (IGmailClient client = GmailClient.getInstance(accessToken, email)) {
// Accedi ed elimina calendario con riepilogo a partire da "Riepilogo calendario"
String summary = "Calendar summary";
// Ottieni l'elenco dei calendari
ExtendedCalendar[] lst = client.listCalendars();
for (ExtendedCalendar extCal : lst) {
// Elimina i calendari selezionati
if (extCal.getSummary().startsWith(summary))
client.deleteCalendar(extCal.getId());
}
}
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 creare Google Calendar in modo programmatico in Java. Inoltre, hai visto come aggiornare ed eliminare un determinato Google Calendar in Java. Inoltre, puoi esplorare la documentazione per saperne di più su Aspose.Email per Java. Inoltre, puoi porre le tue domande tramite il nostro forum.