App Engine中的Google Services身份验证，第1部分
这篇文章背后的动机是，我很难找到以前将这些技术真正联系在一起的任何示例。 然而，这些技术确实代表了许多想要利用大量Google API服务的Web应用程序的基础。
为了简单起见，该演示仅允许用户通过Google域登录； 授权访问用户的Google文档服务； 并显示用户的Google Docs Word和电子表格文档的列表。 在本教程中，我会对读者的专业知识做出一些假设，例如对Java的深入了解。
流程概述
在我们直接进入教程/演示之前，让我们简要介绍一下导航流程。
尽管它看起来很复杂，但是主要流程可以总结为：
- 用户请求访问listFiles.jsp（实际上可以使用任何JSP页面）。
- 检查用户是否已登录Google。 如果不是，它们将被重定向到Google登录页面-登录后，它们将返回。
- 然后进行检查以确定用户是否存储在本地数据存储中。 如果没有，则将用户与用户的Google域电子邮件地址一起添加。
- 接下来，我们检查用户是否已向Google Docs API服务授予OAuth凭据。 如果不是，则启动OAuth身份验证过程。 授予OAuth凭据后，它们将存储在本地用户表中（因此我们不必在每次用户尝试访问服务时都询问）。
- 最后，显示Google文档电子表格或Word文档的列表。
可以使用相同的方法访问其他Google服务，例如YouTube（例如，您可以显示用户喜欢的视频的列表）。
环境设定
对于本教程，我使用以下内容：
- Eclipse Indigo Service Release 2以及适用于Eclipse的Google插件（请参阅设置说明 ）。
- Google GData Java SDK Eclipse插件版本1.47.1（请参阅设置说明 ）。
- Google App Engine 1.6.5版。 早期版本存在一些问题，因此我建议确保您正在使用它。 它应该作为Eclipse的Google插件的一部分自动安装。
- Objectify版本3.1。 所需的库已安装在项目的war / WEB-INF / lib目录中。
将项目导入Eclipse之后，您的构建路径应类似于：
App Engine设置应类似于：
您将需要设置自己的GAE应用程序，并指定自己的应用程序ID（请参阅Google GAE开发人员文档 ）。
描述如何使用OAuth访问谷歌API服务我见过的最好的教程可以找到这里 。 我发现最令人困惑的方面之一是如何获取放置OAuth请求时所需的必要的消费者**和消费者秘密值。 我完成此操作的方式是：
- 使用GAE管理控制台创建GAE应用程序。 您将需要创建自己的应用程序ID（只是您的Web应用程序的名称）。 有了它，您将在上面显示的Eclipse App Engine设置面板中更新您的应用程序ID。
- 为该应用程序创建一个新的域。 例如，由于我的应用程序ID在上面指定为“ tennis-coachrx”，因此我将目标URL路径前缀配置为：http://tennis-coachrx.appspot.com/authSub。 您将看到我们如何配置该Servlet以便很快接收凭证。
- 要完成域名注册，Google将为您提供可以上传HTML文件。 将该文件的根路径包括在/ src / war目录下，然后将应用程序上载到GAE。 这样，当Google运行检查时，该文件将存在并会生成必要的消费者凭证。 这是设置完成后的屏幕截图：
拥有OAuth使用者**和OAuth使用者**之后 ，您将替换com.zazarie.shared.Constant文件中的以下值：
最后的静态字符串CONSUMER_KEY =''; 最后的静态字符串CONSUMER_SECRET ='';
哇，这似乎是很多工作！ 但是，这是一次性交易，您不必再次大惊小怪。
代码演练
既然我们已经完成了OAuth的配置/设置，那么我们就可以深入研究代码了。 让我们从查看战争目录的结构开始，您的Web资产位于该目录中：
listFiles.jsp是您首次进入Web应用程序时显示的默认JSP页面。 现在让我们看一下web.xml文件，看看如何配置它，以及对所有内容都至关重要的servlet过滤器。
<?xml version='1.0' encoding='UTF-8'?>
<web-app xmlns:xsi='http:www.w3.org2001XMLSchema-instance'
xsi:schemaLocation='http:java.sun.comxmlnsjavaee
http:java.sun.comxmlnsjavaeeweb-app_2_5.xsd'
version='2.5' xmlns='http:java.sun.comxmlnsjavaee'>
<!-- Filters -->
<filter>
<filter-name>AuthorizationFilter<filter-name>
<filter-class>com.zazarie.server.servlet.filter.AuthorizationFilter<filter-class>
<filter>
<filter-mapping>
<filter-name>AuthorizationFilter<filter-name>
<url-pattern>html*<url-pattern>
<filter-mapping>
<!-- Servlets -->
<servlet>
<servlet-name>Step2<servlet-name>
<servlet-class>com.zazarie.server.servlet.RequestTokenCallbackServlet<servlet-class>
<servlet>
<servlet-mapping>
<servlet-name>Step2<servlet-name>
<url-pattern>authSub<url-pattern>
<servlet-mapping>
<!-- Default page to serve -->
<welcome-file-list>
<welcome-file>htmllistFiles.jsp<welcome-file>
<welcome-file-list>
<web-app>
每当请求位于html目录中的JSP文件时，就会调用称为AuthorizationFilter的servlet过滤器。 我们稍后将介绍的过滤器负责确保用户已登录Google，如果是，则确保已为该用户授予OAuth凭据（即，它将启动OAuth认证过程（如果需要）。
步骤2的Servlet名称代表已授予OAuth凭据时Google调用的Servlet-将其视为回调。 我们将对此进行更详细的介绍。
让我们更详细地看一下AuthorizationFilter。
AuthorizationFilter深潜
doFilter方法是在servlet过滤器中进行工作的地方。 这是实现：
@Override
public void doFilter(ServletRequest req, ServletResponse res,
FilterChain chain) throws IOException, ServletException {
HttpServletRequest request = (HttpServletRequest) req;
HttpServletResponse response = (HttpServletResponse) res;
HttpSession session = request.getSession();
LOGGER.info('Invoking Authorization Filter');
LOGGER.info('Destination URL is: ' + request.getRequestURI());
if (filterConfig == null)
return;
get the Google user
AppUser appUser = LoginService.login(request, response);
if (appUser != null) {
session.setAttribute(Constant.AUTH_USER, appUser);
}
identify if user has an OAuth accessToken - it not, will set in motion
oauth procedure
if (appUser.getCredentials() == null) {
need to save the target URI in session so we can forward to it when
oauth is completed
session.setAttribute(Constant.TARGET_URI, request.getRequestURI());
OAuthRequestService.requestOAuth(request, response, session);
return;
} else
store DocService in the session so it can be reused
session.setAttribute(Constant.DOC_SESSION_ID,
LoginService.docServiceFactory(appUser));
chain.doFilter(request, response);
}
除了通常的家务管理之外，主要逻辑还从以下几行开始：
AppUser appUser = LoginService.login（request，response）;
稍后我们将看到，LoginService负责将用户登录到Google，并在本地BigTable数据存储区中创建用户。 通过将用户存储在本地，我们可以存储用户的OAuth凭据，从而无需用户每次访问受限制/过滤的页面时都必须授予权限。
LoginService返回用户（AppUser对象）后，我们将该用户对象存储到会话中（注意：要启用会话，必须在appengine-web.xml文件中将session-enabled设置为：）
session.setAttribute（Constant.AUTH_USER，appUser）;
然后，我们检查OAuth凭据是否与该用户相关联：
如果（appUser.getCredentials（）== null）{
session.setAttribute（Constant.TARGET_URI，request.getRequestURI（））;
OAuthRequestService.requestOAuth（请求，响应，会话）;
返回;
}其他
session.setAttribute（Constant.DOC_SESSION_ID，LoginService.docServiceFactory（appUser））;
如果getCredentials（）返回null，则尚未为用户分配OAuth凭据。 这意味着OAuth流程需要启动。 由于此过程分两步进行：将请求发布到Google，然后通过回调（上面提到的Step2 servlet）取回结果，因此我们需要存储目标URL，以便在授权后可以将用户重定向到该URL。处理完成。 这是通过使用setAttribute方法将请求的URL存储到会话中来完成的。
然后，我们通过调用OAuthRequestService.requestOAuth（）方法开始OAuth流程（详细信息将在下面讨论）。
如果getCredentials（）返回一个非null值，则表明我们已经从数据存储区中的本地AppUser条目中获取了用户的OAuth凭据，我们只需将其添加到会话中，以便以后使用。
LoginService深入研究
LoginService类有一个称为login的主要方法，其后是一堆JPA帮助器方法，用于保存或更新数据存储区中的本地用户。 我们将重点放在login（）上，因为这是大多数业务逻辑所在的位置。
public static AppUser login(HttpServletRequest req, HttpServletResponse res) {
LOGGER.setLevel(Constant.LOG_LEVEL);
LOGGER.info('Initializing LoginService');
String URI = req.getRequestURI();
UserService userService = UserServiceFactory.getUserService();
User user = userService.getCurrentUser();
if (user != null) {
LOGGER.info('User id is: '' + userService.getCurrentUser().getUserId()
+ ''');
String userEmail = userService.getCurrentUser().getEmail();
AppUser appUser = (AppUser) req.getSession().getAttribute(
Constant.AUTH_USER);
if (appUser == null) {
LOGGER.info('appUser not found in session');
see if it is a new user
appUser = findUser(userEmail);
if (appUser == null) {
LOGGER.info('User not found in datastore...creating');
appUser = addUser(userEmail);
} else {
LOGGER.info('User found in datastore...updating');
appUser = updateUserTimeStamp(appUser);
}
} else {
appUser = updateUserTimeStamp(appUser);
}
return appUser;
} else {
LOGGER.info('Redirecting user to login page');
try {
res.sendRedirect(userService.createLoginURL(URI));
} catch (IOException e) {
e.printStackTrace();
}
}
return null;
}
我们要做的第一件事是使用Google UserService类确定用户是否登录到Google：
UserService userService = UserServiceFactory.getUserService（）;
用户用户= userService.getCurrentUser（）;
如果Google的调用返回的User对象为null，则不会登录该用户，并使用以下命令将其重定向到登录页面：
res.sendRedirect（userService.createLoginURL（URI））;
如果用户已登录（即不为null），则下一步是确定该用户是否存在于本地数据存储中。 这是通过使用appUser = findUser（userEmail）查找用户及其登录的Google电子邮件地址来完成的。 由于JPA / Objectify并不是本教程的主要讨论点，因此我将不介绍该方法的工作原理。 但是， Objectify网站上有一些很棒的教程/文档。
如果用户不在本地，则使用Google的电子邮件地址填充该对象，并使用appUser = addUser（userEmail）创建该对象。 如果用户确实存在，我们仅出于登录目的而更新登录时间戳。
OAuthRequestService深入研究
您可能会回忆起，在本地设置了用户之后，AuthorizationFilter便会检查该用户是否已授予OAuth凭据。 如果不是，则调用OAuthRequestService.requestOAuth（）方法。 如下图所示：
public static void requestOAuth(HttpServletRequest req,
HttpServletResponse res, HttpSession session) {
LOGGER.setLevel(Constant.LOG_LEVEL);
LOGGER.info('Initializing OAuthRequestService');
GoogleOAuthParameters oauthParameters = new GoogleOAuthParameters();
oauthParameters.setOAuthConsumerKey(Constant.CONSUMER_KEY);
oauthParameters.setOAuthConsumerSecret(Constant.CONSUMER_SECRET);
Set the scope.
oauthParameters.setScope(Constant.GOOGLE_RESOURCE);
Sets the callback URL.
oauthParameters.setOAuthCallback(Constant.OATH_CALLBACK);
GoogleOAuthHelper oauthHelper = new GoogleOAuthHelper(
new OAuthHmacSha1Signer());
try {
Request is still unauthorized at this point
oauthHelper.getUnauthorizedRequestToken(oauthParameters);
Generate the authorization URL
String approvalPageUrl = oauthHelper
.createUserAuthorizationUrl(oauthParameters);
session.setAttribute(Constant.SESSION_OAUTH_TOKEN,
oauthParameters.getOAuthTokenSecret());
LOGGER.info('Session attributes are: '
+ session.getAttributeNames().hasMoreElements());
res.getWriter().print(
'<a href='' + approvalPageUrl
+ ''>Request token for the Google Documents Scope');
} catch (OAuthException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
为了简化OAuth的使用，Google提供了一组我们正在使用的Java帮助器类。 我们需要做的第一件事是设置使用者凭据（获取这些凭据之前已经讨论过）：
GoogleOAuthParameters oauthParameters =新的GoogleOAuthParameters（）;
oauthParameters.setOAuthConsumerKey（Constant.CONSUMER_KEY）;
oauthParameters.setOAuthConsumerSecret（Constant.CONSUMER_SECRET）;
然后，我们使用以下命令设置OAuth请求的范围：
oauthParameters.setScope（Constant.GOOGLE_RESOURCE）;
Constant.GOOGLE_RESOURCE解析为https://docs.google.com/feeds/的位置。 发出OAuth请求时，请指定您试图获得访问权限的资源范围。 在这种情况下，我们尝试访问Google文档（每个服务的GData API都提供了作用域URL）。 接下来，我们确定希望Google返回答复的位置。
oauthParameters.setOAuthCallback（Constant.OATH_CALLBACK）;
无论我们是以开发人员模式在本地运行还是部署到Google App Engine，此值都会更改。 在Constant接口中定义值的方法如下：
//用于在GAE上运行
//最终静态字符串OATH_CALLBACK ='http://tennis-coachrx.appspot.com/authSub';
//用于本地测试
最后的静态字符串OATH_CALLBACK ='http://127.0.0.1:8888/authSub';
然后，使用Google的帮助程序签署请求时：
GoogleOAuthHelper oauthHelper =新的GoogleOAuthHelper（新的OAuthHmacSha1Signer（））;
然后，我们生成用户将导航到的URL，以授权对资源的访问。 这是使用以下方法动态生成的：
字符串rovalPageUrl = oauthHelper.createUserAuthorizationUrl（oauthParameters）;
最后一步是向用户提供链接，以便他们可以导航到该URL来批准请求。 这是通过构造一些简单HTML来完成的，这些HTML使用res.getWriter（）。print（）输出。
用户授予访问权限后，Google便会调用由URL参数/ authSub标识的servlet，该参数对应于servlet类RequestTokenCallbackServlet。 接下来，我们将对此进行检查。
RequestTokenCallbackServlet深入研究
该servlet使用Google OAuth帮助程序类来生成所需的访问令牌和秘密访问令牌，这些访问令牌和秘密访问令牌将在随后对Google API文档服务的调用中被使用。 这是从Google接收回叫响应的doGet方法：
public void doGet(HttpServletRequest req, HttpServletResponse resp)
throws ServletException, IOException {
Create an instance of GoogleOAuthParameters
GoogleOAuthParameters oauthParameters = new GoogleOAuthParameters();
oauthParameters.setOAuthConsumerKey(Constant.CONSUMER_KEY);
oauthParameters.setOAuthConsumerSecret(Constant.CONSUMER_SECRET);
GoogleOAuthHelper oauthHelper = new GoogleOAuthHelper(
new OAuthHmacSha1Signer());
String oauthTokenSecret = (String) req.getSession().getAttribute(
Constant.SESSION_OAUTH_TOKEN);
AppUser appUser = (AppUser) req.getSession().getAttribute(
Constant.AUTH_USER);
oauthParameters.setOAuthTokenSecret(oauthTokenSecret);
oauthHelper.getOAuthParametersFromCallback(req.getQueryString(),
oauthParameters);
try {
String accessToken = oauthHelper.getAccessToken(oauthParameters);
String accessTokenSecret = oauthParameters.getOAuthTokenSecret();
appUser = LoginService.getById(appUser.getId());
appUser = LoginService.updateUserCredentials(appUser,
new OauthCredentials(accessToken, accessTokenSecret));
req.getSession().setAttribute(Constant.DOC_SESSION_ID,
LoginService.docServiceFactory(appUser));
RequestDispatcher dispatcher = req.getRequestDispatcher((String) req
.getSession().getAttribute(Constant.TARGET_URI));
if (dispatcher != null)
dispatcher.forward(req, resp);
} catch (OAuthException e) {
e.printStackTrace();
}
}
Google GoogleOAuthHelper用于执行填充我们感兴趣的两个值所需的内务处理任务：
字符串accessToken = oauthHelper.getAccessToken（oauthParameters）;
字符串accessTokenSecret = oauthParameters.getOAuthTokenSecret（）;
获得这些值之后，我们便从数据存储区中重新查询用户对象，并将这些值保存到AppUser.OauthCredentials子类中：
appUser = LoginService.getById（appUser.getId（））;
appUser = LoginService.updateUserCredentials（appUser，
新的OauthCredentials（accessToken，accessTokenSecret））;
req.getSession（）。setAttribute（Constant.DOC_SESSION_ID，
LoginService.docServiceFactory（appUser））;
此外，您还会看到它们也存储在会话中，因此当向Google Docs发出API请求时，我们可以随时使用它们。
现在我们有了所需的一切，我们只需将用户重定向到他们最初请求的资源即可：
RequestDispatcher调度程序= req.getRequestDispatcher（（String）req
.getSession（）。getAttribute（Constant.TARGET_URI））;
dispatcher.forward（req，resp）;
现在，当他们访问列出他们的文档的JSP页面时，一切都会正常！
这是最终产品的截屏演示：
希望您喜欢本教程和演示-期待您的评论！
继续本教程的第二部分 。
参考：来自Jeff's SOA Ruminations博客的JCG合作伙伴 Jeff Davis 对Google App Engine中的Google Services进行身份验证 。
翻译自: https://www.javacodegeeks.com/2012/06/google-services-authentication-in-app.html