Build-Autorisierungs-Callback-Handler

In diesem Dokument wird anhand einer Beispielwebanwendung, in der die Aufgaben des Nutzers mit der Google Tasks API angezeigt werden, erläutert, wie Sie einen OAuth 2.0-Autorisierungs-Callback-Handler mit Java-Servlets implementieren. Die Beispielanwendung fordert zuerst die Autorisierung für den Zugriff auf die Google-Aufgaben des Nutzers an und zeigt dann die Aufgaben des Nutzers in der Standardaufgabenliste an.

Zielgruppe

Dieses Dokument richtet sich an Personen, die mit Java und der J2EE-Webanwendungsarchitektur vertraut sind. Es wird empfohlen, sich mit dem OAuth 2.0-Autorisierungsvorgang vertraut zu machen.

Inhalt

Damit Sie ein solches voll funktionsfähiges Beispiel erhalten, sind mehrere Schritte erforderlich:

Servlet-Zuordnungen in der Datei „web.xml“ deklarieren

Diese Anwendung verwendet die folgenden beiden Servlets:

  • PrintTasksTitlesServlet (zugeordnet zu /): Der Einstiegspunkt der Anwendung, der die Nutzerauthentifizierung übernimmt und die Aufgaben des Nutzers anzeigt.
  • OAuthCodeCallbackHandlerServlet (zugeordnet zu /oauth2callback): Der OAuth 2.0-Callback, der die Antwort vom OAuth-Autorisierungsendpunkt verarbeitet.

Die folgende web.xml-Datei ordnet diese beiden Servlets URLs in unserer Anwendung zu:

<?xml version="1.0" encoding="UTF-8"?>
<web-app version="2.5" xmlns="http://java.sun.com/xml/ns/javaee"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd">

 <servlet>
   <servlet-name>PrintTasksTitles</servlet-name>
   <servlet-class>com.google.oauthsample.PrintTasksTitlesServlet</servlet-class>
 </servlet>

 <servlet-mapping>
   <servlet-name>PrintTasksTitles</servlet-name>
   <url-pattern>/</url-pattern>
 </servlet-mapping>

 <servlet>
   <servlet-name>OAuthCodeCallbackHandlerServlet</servlet-name>
   <servlet-class>com.google.oauthsample.OAuthCodeCallbackHandlerServlet</servlet-class>
 </servlet>

 <servlet-mapping>
   <servlet-name>OAuthCodeCallbackHandlerServlet</servlet-name>
   <url-pattern>/oauth2callback</url-pattern>
 </servlet-mapping>

</web-app>
Datei „/WEB-INF/web.xml“

Nutzer auf ihrem System authentifizieren und die Autorisierung für den Zugriff auf ihre Aufgaben anfordern

Der Nutzer ruft die Anwendung über die Stamm-URL „/“ auf, die dem Servlet PrintTaskListsTitlesServlet zugeordnet ist. In diesem Servlet werden die folgenden Aufgaben ausgeführt:

  • Prüft, ob der Nutzer im System authentifiziert ist.
  • Wenn der Nutzer nicht authentifiziert ist, wird er zur Authentifizierungsseite weitergeleitet.
  • Wenn der Nutzer authentifiziert ist, wird geprüft, ob bereits ein Aktualisierungstoken im Datenspeicher vorhanden ist. Dies wird durch die OAuthTokenDao unten behandelt. Wenn keine Tokens im Speicher für den Nutzer verfügbar sind, hat der Nutzer der Anwendung noch keine Autorisierung für den Zugriff auf seine Aufgaben erteilt. Der Nutzer wird dann zum OAuth 2.0-Autorisierungsendpunkt von Google weitergeleitet.

Im Folgenden wird eine Möglichkeit zur Implementierung gezeigt:

package com.google.oauthsample;

import ...

/**
 * Simple sample Servlet which will display the tasks in the default task list of the user.
 */
@SuppressWarnings("serial")
public class PrintTasksTitlesServlet extends HttpServlet {

  /**
   * The OAuth Token DAO implementation, used to persist the OAuth refresh token.
   * Consider injecting it instead of using a static initialization. Additionally, a
   * simple memory implementation is used as a mock. Change the implementation to
   * using the user's own user/login implementation.
   */
  public static OAuthTokenDao oauthTokenDao = new OAuthTokenDaoMemoryImpl();

  public void doGet(HttpServletRequest req, HttpServletResponse resp) throws IOException {
    // Getting the current user
    // This is using App Engine's User Service but you should replace this to
    // your own user/login implementation
    UserService userService = UserServiceFactory.getUserService();
    User user = userService.getCurrentUser();

    // If the user is not logged-in it is redirected to the login service, then back to this page
    if (user == null) {
      resp.sendRedirect(userService.createLoginURL(getFullRequestUrl(req)));
      return;
    }

    // Checking if we already have tokens for this user in store
    AccessTokenResponse accessTokenResponse = oauthTokenDao.getKeys(user.getEmail());

    // If tokens are not available for this user
    if (accessTokenResponse == null) {
      OAuthProperties oauthProperties = new OAuthProperties();
      // Redirects to the Google OAuth 2.0 authorization endpoint
      resp.sendRedirect(new GoogleAuthorizationRequestUrl(oauthProperties.getClientId(),
          OAuthCodeCallbackHandlerServlet.getOAuthCodeCallbackHandlerUrl(req), oauthProperties
              .getScopesAsString()).build());
      return;
    }
  }

  /**
   * Construct the request's URL without the parameter part.
   *
   * @param req the HttpRequest object
   * @return The constructed request's URL
   */
  public static String getFullRequestUrl(HttpServletRequest req) {
    String scheme = req.getScheme() + "://";
    String serverName = req.getServerName();
    String serverPort = (req.getServerPort() == 80) ? "" : ":" + req.getServerPort();
    String contextPath = req.getContextPath();
    String servletPath = req.getServletPath();
    String pathInfo = (req.getPathInfo() == null) ? "" : req.getPathInfo();
    String queryString = (req.getQueryString() == null) ? "" : "?" + req.getQueryString();
    return scheme + serverName + serverPort + contextPath + servletPath + pathInfo + queryString;
  }
}

Hinweis: Bei der oben beschriebenen Implementierung werden einige App Engine-Bibliotheken verwendet. Sie werden zur Vereinfachung verwendet. Wenn Sie für eine andere Plattform entwickeln, implementieren Sie die UserService-Schnittstelle, die die Nutzerauthentifizierung übernimmt, neu.

Die Anwendung verwendet ein DAO, um die Autorisierungstokens des Nutzers zu speichern und darauf zuzugreifen. Die OAuthTokenDao-Schnittstelle und eine Mock-Implementierung (im Arbeitsspeicher) – OAuthTokenDaoMemoryImpl –, die in diesem Beispiel verwendet werden, sind in den folgenden Beispielen zu sehen:

package com.google.oauthsample;

import com.google.api.client.auth.oauth2.draft10.AccessTokenResponse;

/**
 * Allows easy storage and access of authorization tokens.
 */
public interface OAuthTokenDao {

  /**
   * Stores the given AccessTokenResponse using the {@code username}, the OAuth
   * {@code clientID} and the tokens scopes as keys.
   *
   * @param tokens The AccessTokenResponse to store
   * @param userName The userName associated wit the token
   */
  public void saveKeys(AccessTokenResponse tokens, String userName);

  /**
   * Returns the AccessTokenResponse stored for the given username, clientId and
   * scopes. Returns {@code null} if there is no AccessTokenResponse for this
   * user and scopes.
   *
   * @param userName The username of which to get the stored AccessTokenResponse
   * @return The AccessTokenResponse of the given username
   */
  public AccessTokenResponse getKeys(String userName);
}
OAuthTokenDao.java-Datei
package com.google.oauthsample;

import com.google.api.client.auth.oauth2.draft10.AccessTokenResponse;
...

/**
 * Quick and Dirty memory implementation of {@link OAuthTokenDao} based on
 * HashMaps.
 */
public class OAuthTokenDaoMemoryImpl implements OAuthTokenDao {

  /** Object where all the Tokens will be stored */
  private static Map<String, AccessTokenResponse> tokenPersistance = new HashMap<String, AccessTokenResponse>();

  public void saveKeys(AccessTokenResponse tokens, String userName) {
    tokenPersistance.put(userName, tokens);
  }

  public AccessTokenResponse getKeys(String userName) {
    return tokenPersistance.get(userName);
  }
}
Datei „OAuthTokenDaoMemoryImpl.java“

Die OAuth 2.0-Anmeldedaten für die Anwendung werden in einer Attributdatei gespeichert. Alternativ können Sie sie als Konstante in einer Ihrer Java-Klassen speichern. Hier sehen Sie die Klasse OAuthProperties und die Datei oauth.properties, die im Beispiel verwendet wird:

package com.google.oauthsample;

import ...

/**
 * Object representation of an OAuth properties file.
 */
public class OAuthProperties {

  public static final String DEFAULT_OAUTH_PROPERTIES_FILE_NAME = "oauth.properties";

  /** The OAuth 2.0 Client ID */
  private String clientId;

  /** The OAuth 2.0 Client Secret */
  private String clientSecret;

  /** The Google APIs scopes to access */
  private String scopes;

  /**
   * Instantiates a new OauthProperties object reading its values from the
   * {@code OAUTH_PROPERTIES_FILE_NAME} properties file.
   *
   * @throws IOException IF there is an issue reading the {@code propertiesFile}
   * @throws OauthPropertiesFormatException If the given {@code propertiesFile}
   *           is not of the right format (does not contains the keys {@code
   *           clientId}, {@code clientSecret} and {@code scopes})
   */
  public OAuthProperties() throws IOException {
    this(OAuthProperties.class.getResourceAsStream(DEFAULT_OAUTH_PROPERTIES_FILE_NAME));
  }

  /**
   * Instantiates a new OAuthProperties object, reading its values from the given
   * properties file.
   *
   * @param propertiesFile the InputStream to read an OAuth Properties file. The
   *          file should contain the keys {@code clientId}, {@code
   *          clientSecret} and {@code scopes}
   * @throws IOException if there is an issue reading the {@code propertiesFile}
   * @throws OAuthPropertiesFormatException If the given {@code propertiesFile}
   *           is not in the correct format (does not contain the keys {@code
   *           clientId}, {@code clientSecret} and {@code scopes})
   */
  public OAuthProperties(InputStream propertiesFile) throws IOException {
    Properties oauthProperties = new Properties();
    oauthProperties.load(propertiesFile);
    clientId = oauthProperties.getProperty("clientId");
    clientSecret = oauthProperties.getProperty("clientSecret");
    scopes = oauthProperties.getProperty("scopes");
    if ((clientId == null) || (clientSecret == null) || (scopes == null)) {
      throw new OAuthPropertiesFormatException();
    }
  }

  /**
   * @return the clientId
   */
  public String getClientId() {
    return clientId;
  }

  /**
   * @return the clientSecret
   */
  public String getClientSecret() {
    return clientSecret;
  }

  /**
   * @return the scopes
   */
  public String getScopesAsString() {
    return scopes;
  }

  /**
   * Thrown when the OAuth properties file was not at the right format, i.e not
   * having the right properties names.
   */
  @SuppressWarnings("serial")
  public class OAuthPropertiesFormatException extends RuntimeException {
  }
}
Datei „OAuthProperties.java“

Die Datei oauth.properties, die die OAuth 2.0-Anmeldedaten für Ihre Anwendung enthält, ist im folgenden Beispiel zu sehen. Sie müssen die Werte in dieser Datei ändern.

# Client ID and secret. They can be found in the APIs console.
clientId=1234567890.apps.googleusercontent.com
clientSecret=aBcDeFgHiJkLmNoPqRsTuVwXyZ
# API scopes. Space separated.
scopes=https://www.googleapis.com/auth/tasks
Datei „oauth.properties“

Die OAuth 2.0-Client-ID und das Client-Secret identifizieren die Anwendung und ermöglichen es der Tasks API, Filter und Kontingentregeln anzuwenden, die für die Anwendung definiert sind. Die Client-ID und das Client-Secret finden Sie in der Google APIs Console. In der Console muss der Nutzer Folgendes tun:

  • Erstellen Sie ein neues Projekt oder wählen Sie ein vorhandenes Projekt aus.
  • Aktivieren Sie die Tasks API, indem Sie den Status der Tasks API in der Liste der Dienste auf EIN setzen.
  • Erstellen Sie unter API-Zugriff eine OAuth 2.0-Client-ID, falls noch keine erstellt wurde.
  • Achten Sie darauf, dass die OAuth 2.0-Code-Callback-Handler-URL des Projekts in den Weiterleitungs-URIs registriert bzw. auf der Zulassungsliste steht. In diesem Beispielprojekt müsste der Nutzer beispielsweise https://www.example.com/oauth2callback registrieren, wenn die Webanwendung über die Domain https://www.example.com bereitgestellt wird.

Weiterleitungs-URI in der APIs Console
Weiterleitungs-URI in der APIs Console

Autorisierungscode vom Google-Autorisierungsendpunkt verarbeiten

Wenn der Nutzer der Anwendung noch keinen Zugriff auf seine Aufgaben gewährt hat und daher zum OAuth 2.0-Autorisierungsendpunkt von Google weitergeleitet wird, wird ihm ein Autorisierungsdialogfeld von Google angezeigt, in dem er aufgefordert wird, der Anwendung Zugriff auf seine Aufgaben zu gewähren:

Google-Autorisierungsdialogfeld
Google-Autorisierungsdialogfeld

Nachdem der Zugriff gewährt oder verweigert wurde, wird der Nutzer zum OAuth 2.0-Code-Callback-Handler zurückgeleitet, der beim Erstellen der Google-Autorisierungs-URL als Weiterleitung/Callback angegeben wurde:

new GoogleAuthorizationRequestUrl(oauthProperties.getClientId(),
      OAuthCodeCallbackHandlerServlet.getOAuthCodeCallbackHandlerUrl(req), oauthProperties
          .getScopesAsString()).build()

Der OAuth 2.0-Code-Callback-Handler – OAuthCodeCallbackHandlerServlet – verarbeitet die Weiterleitung vom Google OAuth 2.0-Endpunkt. Es gibt zwei Fälle:

  • Der Nutzer hat den Zugriff gewährt: Die Anfrage wird geparst, um den OAuth 2.0-Code aus den URL-Parametern abzurufen.
  • Der Nutzer hat den Zugriff verweigert: Dem Nutzer wird eine Meldung angezeigt.
package com.google.oauthsample;

import ...

/**
 * Servlet handling the OAuth callback from the authentication service. We are
 * retrieving the OAuth code, then exchanging it for a refresh and an access
 * token and saving it.
 */
@SuppressWarnings("serial")
public class OAuthCodeCallbackHandlerServlet extends HttpServlet {

  /** The name of the Oauth code URL parameter */
  public static final String CODE_URL_PARAM_NAME = "code";

  /** The name of the OAuth error URL parameter */
  public static final String ERROR_URL_PARAM_NAME = "error";

  /** The URL suffix of the servlet */
  public static final String URL_MAPPING = "/oauth2callback";

  public void doGet(HttpServletRequest req, HttpServletResponse resp) throws IOException {
    // Getting the "error" URL parameter
    String[] error = req.getParameterValues(ERROR_URL_PARAM_NAME);

    // Checking if there was an error such as the user denied access
    if (error != null && error.length > 0) {
      resp.sendError(HttpServletResponse.SC_NOT_ACCEPTABLE, "There was an error: \""+error[0]+"\".");
      return;
    }
    // Getting the "code" URL parameter
    String[] code = req.getParameterValues(CODE_URL_PARAM_NAME);

    // Checking conditions on the "code" URL parameter
    if (code == null || code.length == 0) {
      resp.sendError(HttpServletResponse.SC_BAD_REQUEST, "The \"code\" URL parameter is missing");
      return;
    }
  }

  /**
   * Construct the OAuth code callback handler URL.
   *
   * @param req the HttpRequest object
   * @return The constructed request's URL
   */
  public static String getOAuthCodeCallbackHandlerUrl(HttpServletRequest req) {
    String scheme = req.getScheme() + "://";
    String serverName = req.getServerName();
    String serverPort = (req.getServerPort() == 80) ? "" : ":" + req.getServerPort();
    String contextPath = req.getContextPath();
    String servletPath = URL_MAPPING;
    String pathInfo = (req.getPathInfo() == null) ? "" : req.getPathInfo();
    return scheme + serverName + serverPort + contextPath + servletPath + pathInfo;
  }
}
Datei „OAuthCodeCallbackHandlerServlet.java“

Autorisierungscode gegen ein Aktualisierungs- und Zugriffstoken eintauschen

Anschließend tauscht OAuthCodeCallbackHandlerServlet den Auth 2.0-Code gegen ein Aktualisierungs- und ein Zugriffstoken ein, speichert ihn im Datenspeicher und leitet den Nutzer zurück zur PrintTaskListsTitlesServlet-URL:

Der der Datei hinzugefügte Code ist hervorgehoben.

package com.google.oauthsample;

import ...

/**
 * Servlet handling the OAuth callback from the authentication service. We are
 * retrieving the OAuth code, then exchanging it for a refresh and an access
 * token and saving it.
 */
@SuppressWarnings("serial")
public class OAuthCodeCallbackHandlerServlet extends HttpServlet {

  /** The name of the Oauth code URL parameter */
  public static final String CODE_URL_PARAM_NAME = "code";

  /** The name of the OAuth error URL parameter */
  public static final String ERROR_URL_PARAM_NAME = "error";

  /** The URL suffix of the servlet */
  public static final String URL_MAPPING = "/oauth2callback";
  /** The URL to redirect the user to after handling the callback. Consider
   * saving this in a cookie before redirecting users to the Google
   * authorization URL if you have multiple possible URL to redirect people to. */
  public static final String REDIRECT_URL = "/";

  /** The OAuth Token DAO implementation. Consider injecting it instead of using
   * a static initialization. Also we are using a simple memory implementation
   * as a mock. Change the implementation to using your database system. */
  public static OAuthTokenDao oauthTokenDao = new OAuthTokenDaoMemoryImpl();

  public void doGet(HttpServletRequest req, HttpServletResponse resp) throws IOException {
    // Getting the "error" URL parameter
    String[] error = req.getParameterValues(ERROR_URL_PARAM_NAME);

    // Checking if there was an error such as the user denied access
    if (error != null && error.length > 0) {
      resp.sendError(HttpServletResponse.SC_NOT_ACCEPTABLE, "There was an error: \""+error[0]+"\".");
      return;
    }

    // Getting the "code" URL parameter
    String[] code = req.getParameterValues(CODE_URL_PARAM_NAME);

    // Checking conditions on the "code" URL parameter
    if (code == null || code.length == 0) {
      resp.sendError(HttpServletResponse.SC_BAD_REQUEST, "The \"code\" URL parameter is missing");
      return;
    }
    // Construct incoming request URL
    String requestUrl = getOAuthCodeCallbackHandlerUrl(req);

    // Exchange the code for OAuth tokens
    AccessTokenResponse accessTokenResponse = exchangeCodeForAccessAndRefreshTokens(code[0],
        requestUrl);

    // Getting the current user
    // This is using App Engine's User Service, but the user should replace this
    // with their own user/login implementation
    UserService userService = UserServiceFactory.getUserService();
    String email = userService.getCurrentUser().getEmail();

    // Save the tokens
    oauthTokenDao.saveKeys(accessTokenResponse, email);

    resp.sendRedirect(REDIRECT_URL);
  }

  /**
   * Construct the OAuth code callback handler URL.
   *
   * @param req the HttpRequest object
   * @return The constructed request's URL
   */
  public static String getOAuthCodeCallbackHandlerUrl(HttpServletRequest req) {
    String scheme = req.getScheme() + "://";
    String serverName = req.getServerName();
    String serverPort = (req.getServerPort() == 80) ? "" : ":" + req.getServerPort();
    String contextPath = req.getContextPath();
    String servletPath = URL_MAPPING;
    String pathInfo = (req.getPathInfo() == null) ? "" : req.getPathInfo();
    return scheme + serverName + serverPort + contextPath + servletPath + pathInfo;
  }
  /**
   * Exchanges the given code for an exchange and a refresh token.
   *
   * @param code The code gotten back from the authorization service
   * @param currentUrl The URL of the callback
   * @param oauthProperties The object containing the OAuth configuration
   * @return The object containing both an access and refresh token
   * @throws IOException
   */
  public AccessTokenResponse exchangeCodeForAccessAndRefreshTokens(String code, String currentUrl)
      throws IOException {

    HttpTransport httpTransport = new NetHttpTransport();
    JacksonFactory jsonFactory = new JacksonFactory();

    // Loading the oauth config file
    OAuthProperties oauthProperties = new OAuthProperties();

    return new GoogleAuthorizationCodeGrant(httpTransport, jsonFactory, oauthProperties
        .getClientId(), oauthProperties.getClientSecret(), code, currentUrl).execute();
  }
}
Datei „OAuthCodeCallbackHandlerServlet.java“

Hinweis: Bei der vorherigen Implementierung werden einige App Engine-Bibliotheken verwendet, um die Sache zu vereinfachen. Wenn Sie für eine andere Plattform entwickeln, implementieren Sie die UserService-Schnittstelle, die die Nutzerauthentifizierung übernimmt, neu.

Aufgaben des Nutzers lesen und anzeigen

Der Nutzer hat der Anwendung Zugriff auf seine Aufgaben gewährt. Die Anwendung hat ein Aktualisierungstoken, das im Datenspeicher gespeichert ist, auf den über OAuthTokenDao zugegriffen werden kann. Das PrintTaskListsTitlesServlet-Servlet kann jetzt mit diesen Tokens auf die Aufgaben des Nutzers zugreifen und sie anzeigen:

Der der Datei hinzugefügte Code ist hervorgehoben.

package com.google.oauthsample;

import ...

/**
 * Simple sample Servlet which will display the tasks in the default task list of the user.
 */
@SuppressWarnings("serial")
public class PrintTasksTitlesServlet extends HttpServlet {

  /**
   * The OAuth Token DAO implementation, used to persist the OAuth refresh token.
   * Consider injecting it instead of using a static initialization. Additionally, a
   * simple memory implementation is used as a mock. Change the implementation to
   * use your own database system.
   */
  public static OAuthTokenDao oauthTokenDao = new OAuthTokenDaoMemoryImpl();

  public void doGet(HttpServletRequest req, HttpServletResponse resp) throws IOException {
    // Getting the current user
    // This is using App Engine's User Service but you should replace this to
    // your own user/login implementation
    UserService userService = UserServiceFactory.getUserService();
    User user = userService.getCurrentUser();

    // If the user is not logged-in it is redirected to the login service, then back to this page
    if (user == null) {
      resp.sendRedirect(userService.createLoginURL(getFullRequestUrl(req)));
      return;
    }

    // Checking if we already have tokens for this user in store
    AccessTokenResponse accessTokenResponse = oauthTokenDao.getKeys(user.getEmail());

    // If we don't have tokens for this user
    if (accessTokenResponse == null) {
      OAuthProperties oauthProperties = new OAuthProperties();
      // Redirect to the Google OAuth 2.0 authorization endpoint
      resp.sendRedirect(new GoogleAuthorizationRequestUrl(oauthProperties.getClientId(),
          OAuthCodeCallbackHandlerServlet.getOAuthCodeCallbackHandlerUrl(req), oauthProperties
              .getScopesAsString()).build());
      return;
    }
// Prints the user's task list titles in the response
    resp.setContentType("text/plain");
    resp.getWriter().append("Task Lists titles for user " + user.getEmail() + ":\n\n");
    printTasksTitles(accessTokenResponse, resp.getWriter());
  }

  /**
   * Construct the request's URL without the parameter part.
   *
   * @param req the HttpRequest object
   * @return The constructed request's URL
   */
  public static String getFullRequestUrl(HttpServletRequest req) {
    String scheme = req.getScheme() + "://";
    String serverName = req.getServerName();
    String serverPort = (req.getServerPort() == 80) ? "" : ":" + req.getServerPort();
    String contextPath = req.getContextPath();
    String servletPath = req.getServletPath();
    String pathInfo = (req.getPathInfo() == null) ? "" : req.getPathInfo();
    String queryString = (req.getQueryString() == null) ? "" : "?" + req.getQueryString();
    return scheme + serverName + serverPort + contextPath + servletPath + pathInfo + queryString;
  }
  /**
   * Uses the Google Tasks API to retrieve a list of the user's tasks in the default
   * tasks list.
   *
   * @param accessTokenResponse The OAuth 2.0 AccessTokenResponse object
   *          containing the access token and a refresh token.
   * @param output The output stream writer to write the task list titles to.
   * @return A list of the user's task titles in the default task list.
   * @throws IOException
   */
  public void printTasksTitles(AccessTokenResponse accessTokenResponse, Writer output) throws IOException {

    // Initializing the Tasks service
    HttpTransport transport = new NetHttpTransport();
    JsonFactory jsonFactory = new JacksonFactory();
    OAuthProperties oauthProperties = new OAuthProperties();

    GoogleAccessProtectedResource accessProtectedResource = new GoogleAccessProtectedResource(
        accessTokenResponse.accessToken, transport, jsonFactory, oauthProperties.getClientId(),
        oauthProperties.getClientSecret(), accessTokenResponse.refreshToken);

    Tasks service = new Tasks(transport, accessProtectedResource, jsonFactory);

    // Using the initialized Tasks API service to query the list of tasks lists
    com.google.api.services.tasks.model.Tasks tasks = service.tasks.list("@default").execute();

    for (Task task : tasks.items) {
      output.append(task.title + "\n");
    }
  }
}
Datei „PrintTasksTitlesServlet.java“

Die Aufgaben des Nutzers werden angezeigt:

Eine Liste der Aufgaben des Nutzers.
Aufgaben des Nutzers

Beispielanwendung

Hier können Sie den Code für diese Beispielanwendung herunterladen.