En este documento, se explica cómo implementar un controlador de devolución de llamada de autorización de OAuth 2.0 con servlets de Java a través de una aplicación web de ejemplo que mostrará las tareas del usuario con la API de Google Tasks. La aplicación de ejemplo primero solicitará autorización para acceder a Google Tasks del usuario y luego mostrará las tareas del usuario en la lista de tareas predeterminadas.
Público
Este documento está diseñado para personas que conocen la arquitectura de aplicaciones web Java y J2EE. Se recomienda tener conocimientos del flujo de autorización de OAuth 2.0.
Contenido
Para tener una muestra tan funcional, se necesitan varios pasos:
- Declara las asignaciones de servlet en el archivo web.xml
- Autentica a los usuarios en tu sistema y solicita autorización para acceder a sus tareas
- Escucha el código de autorización del extremo de autorización de Google
- Intercambia el código de autorización por un token de actualización y acceso
- Leer las tareas del usuario y mostrarlas
Declara las asignaciones de servlet en el archivo web.xml
Usaremos 2 servlets en nuestra aplicación:
- PrintTasksTitlesServlet (asignado a /): Es el punto de entrada de la aplicación que controlará la autenticación del usuario y mostrará las tareas del usuario.
- OAuthCodeCallbackHandlerServlet (asignado a /oauth2callback): Es la devolución de llamada de OAuth 2.0 que controla la respuesta desde el extremo de autorización de OAuth.
A continuación, se muestra el archivo web.xml, que asigna estos 2 servlets a las URL de nuestra aplicación:
<?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>
Autenticar a los usuarios en tu sistema y solicitar autorización para acceder a sus tareas
El usuario ingresa a la aplicación a través de la raíz '/'. La URL está asignada al servlet PrintTaskListsTitlesServlet. En ese servlet, se realizan las siguientes tareas:
- Comprueba si el usuario está autenticado en el sistema
- Si el usuario no está autenticado, se lo redirecciona a la página de autenticación.
- Si se autentica al usuario, comprobamos si ya tenemos un token de actualización en nuestro almacenamiento de datos, que se maneja con el OAuthTokenDao a continuación. Si no hay un token de actualización almacenado para el usuario, esto significa que el usuario aún no ha otorgado autorización a la aplicación para acceder a sus tareas. En ese caso, se redirecciona al usuario al extremo de autorización de OAuth 2.0 de Google.
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. 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 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;
}
}
/**
* 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;
}
}
Nota: La implementación anterior usa algunas bibliotecas de App Engine, que se usan con fines de simplificación. Si estás desarrollando contenido para otra plataforma, puedes volver a implementar la interfaz UserService que controla la autenticación de usuarios.
La aplicación usa un DAO para conservar los tokens de autorización del usuario y acceder a ellos. A continuación, se muestra la interfaz OAuthTokenDao, y una implementación simulada (en la memoria), OAuthTokenDaoMemoryImpl, que se usan en este ejemplo:
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);
}
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
Además, las credenciales de OAuth 2.0 para la aplicación se almacenan en un archivo de propiedades. De manera alternativa, puedes tenerlos como una constante en alguna parte de una de tus clases de Java, aunque aquí están la clase OAuthProperties y el archivo oauth.properties que se usa en la muestra:
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 of the right format (does not contains 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 {
}
}
A continuación, se muestra el archivo oauth.properties que contiene las credenciales de OAuth 2.0 de tu aplicación. Debes cambiar los siguientes valores por tu cuenta.
# 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
El ID de cliente de OAuth 2.0 y el secreto del cliente identifican tu aplicación y permiten que la API de Tasks aplique los filtros y las reglas de cuota que estén definidos para tu aplicación. Puedes encontrar el ID de cliente y el secreto en la Consola de APIs de Google. Cuando estés en la consola, deberás hacer lo siguiente:
- Crea o selecciona un proyecto.
- Para habilitar la API de Tasks, cambia el estado de la API a ACTIVADA en la lista de servicios.
- En Acceso a la API, crea un ID de cliente de OAuth 2.0 si aún no se creó uno.
- Asegúrate de que la URL del controlador de devolución de llamada de código de OAuth 2.0 esté registrada o incluida en la lista blanca en URI de redireccionamiento. Por ejemplo, en este proyecto de muestra, deberías registrar https://www.example.com/oauth2callback si la aplicación web se entrega desde el dominio https://www.example.com.
Detecta el código de autorización del extremo de autorización de Google.
En caso de que el usuario aún no haya autorizado a la aplicación para que acceda a sus tareas y, por lo tanto, se lo haya redirigido al extremo de autorización de OAuth 2.0 de Google, se muestra al usuario un cuadro de diálogo de autorización de Google en el que se le solicita que conceda a tu aplicación acceso a sus tareas:
Después de conceder o denegar el acceso, se redireccionará al usuario al controlador de devolución de llamada de código OAuth 2.0 que se especificó como redireccionamiento/devolución de llamada cuando se construye la URL de autorización de Google:
new GoogleAuthorizationRequestUrl(oauthProperties.getClientId(),
OAuthCodeCallbackHandlerServlet.getOAuthCodeCallbackHandlerUrl(req), oauthProperties
.getScopesAsString()).build()
El controlador de devolución de llamada de código OAuth 2.0, OAuthCodeCallbackHandlerServlet, se encarga del redireccionamiento desde el extremo de Google OAuth 2.0. Hay 2 casos para manejar:
- El usuario otorgó acceso: analiza la solicitud para obtener el código de OAuth 2.0 a partir de los parámetros de URL.
- El usuario rechazó el acceso: Se le muestra un mensaje al usuario
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;
}
}
Intercambia el código de autorización por un token de actualización y acceso
Luego, OAuthCodeCallbackHandlerServlet intercambia el código de Auth 2.0 por una actualización y tokens de acceso, lo conserva en el almacén de datos y redirecciona al usuario de vuelta a la URL OAuthCodeCallbackHandlerServlet:
El código agregado al archivo a continuación tiene la sintaxis destacada, el código existente aparece inhabilitado.
/** La URL a la que se redireccionará al usuario después de administrar la devolución de llamada. Reflexiona
* guardar esto en una cookie antes de redireccionar a los usuarios a la
* URL de autorización si tienes varias URL posibles a las que puedes redireccionar a los usuarios. */
cadena final estática pública REDIRECT_URL = "/";
/** La implementación de DAO de token de OAuth. Considere inyectarla en lugar de usar
* una inicialización estática. También usamos una implementación de memoria sencilla
* como modelo. Cambia la implementación para que use tu sistema de base de datos. */
OAuthTokenDao público estático oauthTokenDao = new OAuthTokenDaoMemoryImpl();
// Construir la URL de solicitud entrante
Cadena requestUrl = getOAuthCodeCallbackHandlerUrl(req);
// Intercambia el código por tokens de OAuth
AccessTokenResponse accessTokenResponse = ExchangeCodeForAccessAndRefreshTokens(code[0],
requestUrl);
// Cómo obtener el usuario actual
// Esto utiliza el servicio de usuario de App Engine, pero deberías reemplazarlo por
// tu propia implementación de usuario/acceso
UserService userService = UserServiceFactory.getUserService();
String email = userService.getCurrentUser().getEmail();
// Guarda los tokens
oauthTokenDao.saveKeys(accessTokenResponse, correo electrónico);
resp.sendRedirect(REDIRECT_URL);
}.
/**
* Intercambia el código proporcionado por un intercambio y un token de actualización.
*
* @param code El código que devolvió el servicio de autorización
* @param currentUrl La URL de la devolución de llamada
* @param oauthProperties El objeto que contiene la configuración de OAuth
* @return El objeto que contiene un token de acceso y un token de actualización
* @arroja IOException.
*/
public AccessTokenResponse ExchangeCodeForAccessAndRefreshTokens(código de cadena, currentUrl)
throws IOException {
httpTransport de HttpTransport = nuevo NetHttpTransport();
JacksonFactory jsonFactory = nueva JacksonFactory();
// Cargar el archivo de configuración de OAuth
OAuthProperties oauthProperties = nuevas OAuthProperties();
devolver GoogleAuthorizationCodeGrant(httpTransport, jsonFactory, oauthProperties
.getClientId(), oauthProperties.getClientSecret(), code, currentUrl).execute();
}.
}.Archivo OAuthCodeCallbackHandlerserv.javaNota: La implementación anterior usa algunas bibliotecas de App Engine, que se usan con fines de simplificación. Si estás desarrollando contenido para otra plataforma, puedes volver a implementar la interfaz UserService que controla la autenticación de usuarios.
Leer las tareas del usuario y mostrarlas
El usuario otorgó a la aplicación acceso a sus tareas. La aplicación tiene un token de actualización que se guarda en el almacén de datos, al que se puede acceder a través de OAuthTokenDao. El servlet PrintTaskListsTitlesServlet ahora puede usar estos tokens para acceder a las tareas del usuario y mostrarlas:
El código agregado al archivo a continuación tiene la sintaxis destacada, el código existente aparece inhabilitado.