针对网络服务器应用使用 OAuth 2.0

PHP

要运行本文档中的 PHP 代码示例，您需要：

• 安装了命令行界面 (CLI) 和 JSON 扩展程序的 PHP 5.6 或更高版本。
• Composer 依赖项管理工具。

• 适用于 PHP 的 Google API 客户端库：

  composer require google/apiclient:^2.10

Python

如需运行本文档中的 Python 代码示例，您需要：

• Python 2.6 或更高版本
• pip 软件包管理工具。
• Python 版 Google API 客户端库：

  pip install --upgrade google-api-python-client

• 用于用户授权的 google-auth、google-auth-oauthlib 和 google-auth-httplib2。

  pip install --upgrade google-auth google-auth-oauthlib google-auth-httplib2

• Flask Python Web 应用框架。

  pip install --upgrade flask

• requests HTTP 库。

  pip install --upgrade requests

Ruby

如需运行本文档中的 Ruby 代码示例，您需要：

• Ruby 2.2.2 或更高版本

• 适用于 Ruby 的 Google API 客户端库：

  gem install google-api-client

• Sinatra Ruby Web 应用框架。

  gem install sinatra

Node.js

如需运行本文档中的 Node.js 代码示例，您需要：

• 维护 LTS、活跃 LTS 或 Node.js 的当前版本。

• Google API Node.js 客户端：

  npm install googleapis

HTTP/REST

您无需安装任何库即可直接调用 OAuth 2.0 端点。

PHP

以下代码段会创建一个 Google\Client() 对象，用于定义授权请求中的参数。

该对象使用 client_secret.json 文件中的信息来标识您的应用。（如需详细了解该文件，请参阅创建授权凭据）。该对象还标识了您的应用请求访问权限的范围，以及应用的身份验证端点的网址，该端点将处理来自 Google OAuth 2.0 服务器的响应。最后，代码会设置可选的 access_type 和 include_granted_scopes 参数。

例如，以下代码请求以只读方式访问用户的 Google 云端硬盘：

$client = new Google\Client();
$client->setAuthConfig('client_secret.json');
$client->addScope(Google\Service\Drive::DRIVE_METADATA_READONLY);
$client->setRedirectUri('http://' . $_SERVER['HTTP_HOST'] . '/oauth2callback.php');
// offline access will give you both an access and refresh token so that
// your app can refresh the access token without user interaction.
$client->setAccessType('offline');
// Using "consent" ensures that your application always receives a refresh token.
// If you are not using offline access, you can omit this.
$client->setApprovalPrompt('consent');
$client->setIncludeGrantedScopes(true);   // incremental auth

该请求指定了以下信息：

$client = new Google\Client();
$client->setAuthConfig('client_secret.json');

$client->setRedirectUri('https://oauth2.example.com/code');

$client->addScope(Google\Service\Drive::DRIVE_METADATA_READONLY);

$client->setAccessType('offline');

$client->setState($sample_passthrough_value);

$client->setIncludeGrantedScopes(true);

$client->setLoginHint('None');

$client->setApprovalPrompt('consent');

Python

以下代码段使用 google-auth-oauthlib.flow 模块构建授权请求。

该代码会构建一个 Flow 对象，该对象使用您在创建授权凭据后下载的 client_secret.json 文件中的信息来识别您的应用。该对象还标识了您的应用请求访问的范围，以及应用的身份验证端点的网址，该端点将处理来自 Google OAuth 2.0 服务器的响应。最后，代码会设置可选的 access_type 和 include_granted_scopes 参数。

例如，以下代码请求以只读方式访问用户的 Google 云端硬盘：

import google.oauth2.credentials
import google_auth_oauthlib.flow

# Use the client_secret.json file to identify the application requesting
# authorization. The client ID (from that file) and access scopes are required.
flow = google_auth_oauthlib.flow.Flow.from_client_secrets_file(
    'client_secret.json',
    scopes=['https://www.googleapis.com/auth/drive.metadata.readonly'])

# Indicate where the API server will redirect the user after the user completes
# the authorization flow. The redirect URI is required. The value must exactly
# match one of the authorized redirect URIs for the OAuth 2.0 client, which you
# configured in the API Console. If this value doesn't match an authorized URI,
# you will get a 'redirect_uri_mismatch' error.
flow.redirect_uri = 'https://www.example.com/oauth2callback'

# Generate URL for request to Google's OAuth 2.0 server.
# Use kwargs to set optional request parameters.
authorization_url, state = flow.authorization_url(
    # Enable offline access so that you can refresh an access token without
    # re-prompting the user for permission. Recommended for web server apps.
    access_type='offline',
    # Enable incremental authorization. Recommended as a best practice.
    include_granted_scopes='true')

该请求指定了以下信息：

flow = google_auth_oauthlib.flow.Flow.from_client_secrets_file(
    'client_secret.json',
    scopes=['https://www.googleapis.com/auth/drive.metadata.readonly'])

flow.redirect_uri = 'https://oauth2.example.com/code'

flow = google_auth_oauthlib.flow.Flow.from_client_secrets_file(
    'client_secret.json',
    scopes=['https://www.googleapis.com/auth/drive.metadata.readonly'])

authorization_url, state = flow.authorization_url(
    access_type='offline',
    include_granted_scopes='true')

authorization_url, state = flow.authorization_url(
    access_type='offline',
    state=sample_passthrough_value,
    include_granted_scopes='true')

authorization_url, state = flow.authorization_url(
    access_type='offline',
    include_granted_scopes='true')

authorization_url, state = flow.authorization_url(
    access_type='offline',
    login_hint='None',
    include_granted_scopes='true')

authorization_url, state = flow.authorization_url(
      access_type='offline',
      prompt='consent',
      include_granted_scopes='true')

Ruby

使用您创建的 client_secrets.json 文件配置应用中的客户端对象。配置客户端对象时，您需要指定应用需要访问的范围，以及应用的身份验证端点的网址，该端点将处理来自 OAuth 2.0 服务器的响应。

例如，以下代码请求以只读方式访问用户的 Google 云端硬盘：

require 'google/apis/drive_v2'
require 'google/api_client/client_secrets'

client_secrets = Google::APIClient::ClientSecrets.load
auth_client = client_secrets.to_authorization
auth_client.update!(
  :scope => 'https://www.googleapis.com/auth/drive.metadata.readonly',
  :redirect_uri => 'http://www.example.com/oauth2callback',
  :additional_parameters => {
    "access_type" => "offline",         # offline access
    "include_granted_scopes" => "true"  # incremental auth
  }
)

您的应用使用客户端对象执行 OAuth 2.0 操作，例如生成授权请求网址并将访问令牌应用于 HTTP 请求。

Node.js

以下代码段会创建一个 google.auth.OAuth2 对象，用于定义授权请求中的参数。

该对象使用 client_secret.json 文件中的信息来标识您的应用。如需请求用户检索访问令牌，您可以将用户重定向到用户意见征求页面。 要创建用户意见征求页面网址，请执行以下操作：

const {google} = require('googleapis');

/**
 * To use OAuth2 authentication, we need access to a CLIENT_ID, CLIENT_SECRET, AND REDIRECT_URI
 * from the client_secret.json file. To get these credentials for your application, visit
 * https://console.cloud.google.com/apis/credentials.
 */
const oauth2Client = new google.auth.OAuth2(
  YOUR_CLIENT_ID,
  YOUR_CLIENT_SECRET,
  YOUR_REDIRECT_URL
);

// Access scopes for read-only Drive activity.
const scopes = [
  'https://www.googleapis.com/auth/drive.metadata.readonly'
];

// Generate a url that asks permissions for the Drive activity scope
const authorizationUrl = oauth2Client.generateAuthUrl({
  // 'online' (default) or 'offline' (gets refresh_token)
  access_type: 'offline',
  /** Pass in the scopes array defined above.
    * Alternatively, if only one scope is needed, you can pass a scope URL as a string */
  scope: scopes,
  // Enable incremental authorization. Recommended as a best practice.
  include_granted_scopes: true
});

重要提示 - refresh_token 仅在首次授权时返回。如需了解详情，请点击此处。

HTTP/REST

Google 的 OAuth 2.0 端点位于 https://accounts.google.com/o/oauth2/v2/auth。此端点只能通过 HTTPS 访问。普通 HTTP 连接会被拒绝。

对于网络服务器应用，Google 授权服务器支持以下查询字符串参数：

PHP

1. 生成网址以向 Google 的 OAuth 2.0 服务器请求访问权限：

   $auth_url = $client->createAuthUrl();

2. 将用户重定向到 $auth_url：

   header('Location: ' . filter_var($auth_url, FILTER_SANITIZE_URL));

Python

此示例展示了如何使用 Flask Web 应用框架将用户重定向到授权网址：

return flask.redirect(authorization_url)

Ruby

1. 生成一个网址，以便向 Google 的 OAuth 2.0 服务器请求访问权限：

   auth_uri = auth_client.authorization_uri.to_s

2. 将用户重定向到 auth_uri。

Node.js

1. 使用在第 1 步生成的 generateAuthUrl 方法生成的网址 authorizationUrl 向 Google 的 OAuth 2.0 服务器请求访问权限。
2. 将用户重定向到 authorizationUrl。

   res.writeHead(301, { "Location": authorizationUrl });

HTTP/REST

Sample redirect to Google's authorization server

An example URL is shown below, with line breaks and spaces for readability.

https://accounts.google.com/o/oauth2/v2/auth?
 scope=https%3A//www.googleapis.com/auth/drive.metadata.readonly&
 access_type=offline&
 include_granted_scopes=true&
 response_type=code&
 state=state_parameter_passthrough_value&
 redirect_uri=https%3A//oauth2.example.com/code&
 client_id=client_id

创建请求网址后，将用户重定向到该网址。

PHP

如需用授权代码交换访问令牌，请使用 authenticate 方法：

$client->authenticate($_GET['code']);

您可以使用 getAccessToken 方法检索访问令牌：

$access_token = $client->getAccessToken();

Python

在回调页面上，使用 google-auth 库验证授权服务器响应。然后，使用 flow.fetch_token 方法用该响应中的授权代码换取访问令牌：

state = flask.session['state']
flow = google_auth_oauthlib.flow.Flow.from_client_secrets_file(
    'client_secret.json',
    scopes=['https://www.googleapis.com/auth/drive.metadata.readonly'],
    state=state)
flow.redirect_uri = flask.url_for('oauth2callback', _external=True)

authorization_response = flask.request.url
flow.fetch_token(authorization_response=authorization_response)

# Store the credentials in the session.
# ACTION ITEM for developers:
#     Store user's access and refresh tokens in your data store if
#     incorporating this code into your real app.
credentials = flow.credentials
flask.session['credentials'] = {
    'token': credentials.token,
    'refresh_token': credentials.refresh_token,
    'token_uri': credentials.token_uri,
    'client_id': credentials.client_id,
    'client_secret': credentials.client_secret,
    'scopes': credentials.scopes}

Ruby

如需用授权代码交换访问令牌，请使用 fetch_access_token! 方法：

auth_client.code = auth_code
auth_client.fetch_access_token!

Node.js

如需用授权代码交换访问令牌，请使用 getToken 方法：

const url = require('url');

// Receive the callback from Google's OAuth 2.0 server.
if (req.url.startsWith('/oauth2callback')) {
  // Handle the OAuth 2.0 server response
  let q = url.parse(req.url, true).query;

  // Get access and refresh tokens (if access_type is offline)
  let { tokens } = await oauth2Client.getToken(q.code);
  oauth2Client.setCredentials(tokens);
}

HTTP/REST

如需用授权代码换取访问令牌，请调用 https://oauth2.googleapis.com/token 端点并设置以下参数：

以下代码段展示了一个示例请求：

POST /token HTTP/1.1
Host: oauth2.googleapis.com
Content-Type: application/x-www-form-urlencoded

code=4/P7q7W91a-oMsCeLvIaQm6bTrgtp7&
client_id=your_client_id&
client_secret=your_client_secret&
redirect_uri=https%3A//oauth2.example.com/code&
grant_type=authorization_code

Google 通过返回包含短期访问令牌和刷新令牌的 JSON 对象来响应此请求。请注意，只有在向 Google 的授权服务器发出初始请求时，您的应用将 access_type 参数设置为 offline，才会返回刷新令牌。

响应包含以下字段：

以下代码段展示了一个响应示例：

{
  "access_token": "1/fFAGRNJru1FTz70BzhT3Zg",
  "expires_in": 3920,
  "token_type": "Bearer",
  "scope": "https://www.googleapis.com/auth/drive.metadata.readonly",
  "refresh_token": "1//xEoDL4iW3cxlI7yDbSRFYNG01kVKM2C-259HOF2aQbI"
}

PHP

完成以下步骤，使用访问令牌调用 Google API：

1. 如果您需要将访问令牌应用于新的 Google\Client 对象（例如，如果您将访问令牌存储在用户会话中），请使用 setAccessToken 方法：

   $client->setAccessToken($access_token);

2. 为您要调用的 API 构建服务对象。您可以通过为要调用的 API 的构造函数提供已获授权的 Google\Client 对象来构建服务对象。例如，如需调用 Drive API：

   $drive = new Google\Service\Drive($client);

3. 使用服务对象提供的接口向 API 服务发出请求。 例如，如需列出经过身份验证的用户的 Google 云端硬盘中的文件，请按以下步骤操作：

   $files = $drive->files->listFiles(array())->getItems();

Python

获取访问令牌后，您的应用可以使用该令牌代表指定的用户帐号或服务帐号对 API 请求进行授权。使用特定于用户的授权凭据为您要调用的 API 构建服务对象，然后使用该对象发出已获授权的 API 请求。

1. 为您要调用的 API 构建服务对象。您可以使用 API 的名称和用户凭据调用 googleapiclient.discovery 库的 build 方法来构建服务对象： 例如，调用 Drive API 的版本 2：

   from googleapiclient.discovery import build
   
   drive = build('drive', 'v2', credentials=credentials)

2. 使用服务对象提供的接口向 API 服务发出请求。 例如，如需列出经过身份验证的用户的 Google 云端硬盘中的文件，请按以下步骤操作：

   files = drive.files().list().execute()

Ruby

完成以下步骤，使用 auth_client 对象调用 Google API：

1. 为您要调用的 API 构建服务对象。 例如，调用 Drive API 版本 2：

   drive = Google::Apis::DriveV2::DriveService.new

2. 为服务设置凭据：

   drive.authorization = auth_client

3. 使用服务对象提供的接口向 API 服务发出请求。 例如，如需列出经过身份验证的用户的 Google 云端硬盘中的文件，请按以下步骤操作：

   files = drive.list_files

或者，您也可以通过向方法提供 options 参数，为每个方法提供授权：

files = drive.list_files(options: { authorization: auth_client })

Node.js

获取访问令牌并将其设置为 OAuth2 对象后，使用该对象调用 Google API。您的应用可以使用该令牌代表指定的用户帐号或服务帐号对 API 请求进行授权。为您要调用的 API 构建服务对象。

const { google } = require('googleapis');

// Example of using Google Drive API to list filenames in user's Drive.
const drive = google.drive('v3');
drive.files.list({
  auth: oauth2Client,
  pageSize: 10,
  fields: 'nextPageToken, files(id, name)',
}, (err1, res1) => {
  if (err1) return console.log('The API returned an error: ' + err1);
  const files = res1.data.files;
  if (files.length) {
    console.log('Files:');
    files.map((file) => {
      console.log(`${file.name} (${file.id})`);
    });
  } else {
    console.log('No files found.');
  }
});

HTTP/REST

在您的应用获得访问令牌后，您可以使用该令牌代表指定用户帐号调用 Google API（如果已授予 API 所需的访问权限范围）。为此，请在向 API 发出的请求中添加访问令牌，具体方法是添加 access_token 查询参数或 Authorization HTTP 标头 Bearer 值。最好使用 HTTP 标头，因为查询字符串往往会显示在服务器日志中。在大多数情况下，您可以使用客户端库设置对 Google API 的调用（例如，在调用 Drive Files API 时）。

您可以访问 OAuth 2.0 Playground，试用所有 Google API 及其范围。

HTTP GET 示例

使用 Authorization: Bearer HTTP 标头对 drive.files 端点 (Drive Files API) 的调用可能如下所示。请注意，您需要指定自己的访问令牌：

GET /drive/v2/files HTTP/1.1
Host: www.googleapis.com
Authorization: Bearer access_token

以下是使用 access_token 查询字符串参数对经过身份验证的用户的同一 API 的调用：

GET https://www.googleapis.com/drive/v2/files?access_token=access_token

curl 示例

您可以使用 curl 命令行应用测试这些命令。下面是一个使用 HTTP 标头选项（首选）的示例：

curl -H "Authorization: Bearer access_token" https://www.googleapis.com/drive/v2/files

或者，查询字符串参数选项：

curl https://www.googleapis.com/drive/v2/files?access_token=access_token

PHP

如需运行此示例，请执行以下操作：

1. 在 API Console中，将本地机器的网址添加到重定向网址列表中。例如，添加 http://localhost:8080。
2. 创建一个新目录并切换到该目录。例如：

   mkdir ~/php-oauth2-example
   cd ~/php-oauth2-example

   。
3. 使用 Composer 安装适用于 PHP 的 Google API 客户端库：

   composer require google/apiclient:^2.10

4. 使用以下内容创建 index.php 和 oauth2callback.php 文件。
5. 使用配置为提供 PHP 的网络服务器运行该示例。如果您使用的是 PHP 5.6 或更高版本，则可以使用 PHP 的内置测试 Web 服务器：

   php -S localhost:8080 ~/php-oauth2-example

index.php

<?php
require_once __DIR__.'/vendor/autoload.php';

session_start();

$client = new Google\Client();
$client->setAuthConfig('client_secrets.json');
$client->addScope(Google\Service\Drive::DRIVE_METADATA_READONLY);

if (isset($_SESSION['access_token']) && $_SESSION['access_token']) {
  $client->setAccessToken($_SESSION['access_token']);
  $drive = new Google\Service\Drive($client);
  $files = $drive->files->listFiles(array())->getItems();
  echo json_encode($files);
} else {
  $redirect_uri = 'http://' . $_SERVER['HTTP_HOST'] . '/oauth2callback.php';
  header('Location: ' . filter_var($redirect_uri, FILTER_SANITIZE_URL));
}

oauth2callback.php

<?php
require_once __DIR__.'/vendor/autoload.php';

session_start();

$client = new Google\Client();
$client->setAuthConfigFile('client_secrets.json');
$client->setRedirectUri('http://' . $_SERVER['HTTP_HOST'] . '/oauth2callback.php');
$client->addScope(Google\Service\Drive::DRIVE_METADATA_READONLY);

if (! isset($_GET['code'])) {
  $auth_url = $client->createAuthUrl();
  header('Location: ' . filter_var($auth_url, FILTER_SANITIZE_URL));
} else {
  $client->authenticate($_GET['code']);
  $_SESSION['access_token'] = $client->getAccessToken();
  $redirect_uri = 'http://' . $_SERVER['HTTP_HOST'] . '/';
  header('Location: ' . filter_var($redirect_uri, FILTER_SANITIZE_URL));
}

Python

此示例使用 Flask 框架。它会在 http://localhost:8080 中运行 Web 应用，让您可以测试 OAuth 2.0 流程。如果您转到该网址，应该会看到四个链接：

• 测试 API 请求：此链接指向尝试执行示例 API 请求的页面。必要时，它会启动授权流程。如果成功，该页面会显示 API 响应。
• 直接测试身份验证流程：此链接指向一个尝试通过授权流程将用户引导至的页面。应用请求代表用户提交已获授权的 API 请求的权限。
• 撤消当前凭据：此链接指向的页面会撤消用户已授予应用的权限。
• 清除 Flask 会话凭据：此链接会清除 Flask 会话中存储的授权凭据。这样一来，您就可以了解如果已经向您的应用授予权限的用户尝试在新会话中执行 API 请求会发生什么情况。此外，如果用户已撤消向您的应用授予的权限，并且您的应用仍尝试使用已撤消的访问令牌授权请求，您还可以查看应用收到的 API 响应。

# -*- coding: utf-8 -*-

import os
import flask
import requests

import google.oauth2.credentials
import google_auth_oauthlib.flow
import googleapiclient.discovery

# This variable specifies the name of a file that contains the OAuth 2.0
# information for this application, including its client_id and client_secret.
CLIENT_SECRETS_FILE = "client_secret.json"

# This OAuth 2.0 access scope allows for full read/write access to the
# authenticated user's account and requires requests to use an SSL connection.
SCOPES = ['https://www.googleapis.com/auth/drive.metadata.readonly']
API_SERVICE_NAME = 'drive'
API_VERSION = 'v2'

app = flask.Flask(__name__)
# Note: A secret key is included in the sample so that it works.
# If you use this code in your application, replace this with a truly secret
# key. See https://flask.palletsprojects.com/quickstart/#sessions.
app.secret_key = 'REPLACE ME - this value is here as a placeholder.'


@app.route('/')
def index():
  return print_index_table()


@app.route('/test')
def test_api_request():
  if 'credentials' not in flask.session:
    return flask.redirect('authorize')

  # Load credentials from the session.
  credentials = google.oauth2.credentials.Credentials(
      **flask.session['credentials'])

  drive = googleapiclient.discovery.build(
      API_SERVICE_NAME, API_VERSION, credentials=credentials)

  files = drive.files().list().execute()

  # Save credentials back to session in case access token was refreshed.
  # ACTION ITEM: In a production app, you likely want to save these
  #              credentials in a persistent database instead.
  flask.session['credentials'] = credentials_to_dict(credentials)

  return flask.jsonify(**files)


@app.route('/authorize')
def authorize():
  # Create flow instance to manage the OAuth 2.0 Authorization Grant Flow steps.
  flow = google_auth_oauthlib.flow.Flow.from_client_secrets_file(
      CLIENT_SECRETS_FILE, scopes=SCOPES)

  # The URI created here must exactly match one of the authorized redirect URIs
  # for the OAuth 2.0 client, which you configured in the API Console. If this
  # value doesn't match an authorized URI, you will get a 'redirect_uri_mismatch'
  # error.
  flow.redirect_uri = flask.url_for('oauth2callback', _external=True)

  authorization_url, state = flow.authorization_url(
      # Enable offline access so that you can refresh an access token without
      # re-prompting the user for permission. Recommended for web server apps.
      access_type='offline',
      # Enable incremental authorization. Recommended as a best practice.
      include_granted_scopes='true')

  # Store the state so the callback can verify the auth server response.
  flask.session['state'] = state

  return flask.redirect(authorization_url)


@app.route('/oauth2callback')
def oauth2callback():
  # Specify the state when creating the flow in the callback so that it can
  # verified in the authorization server response.
  state = flask.session['state']

  flow = google_auth_oauthlib.flow.Flow.from_client_secrets_file(
      CLIENT_SECRETS_FILE, scopes=SCOPES, state=state)
  flow.redirect_uri = flask.url_for('oauth2callback', _external=True)

  # Use the authorization server's response to fetch the OAuth 2.0 tokens.
  authorization_response = flask.request.url
  flow.fetch_token(authorization_response=authorization_response)

  # Store credentials in the session.
  # ACTION ITEM: In a production app, you likely want to save these
  #              credentials in a persistent database instead.
  credentials = flow.credentials
  flask.session['credentials'] = credentials_to_dict(credentials)

  return flask.redirect(flask.url_for('test_api_request'))


@app.route('/revoke')
def revoke():
  if 'credentials' not in flask.session:
    return ('You need to <a href="/authorize">authorize</a> before ' +
            'testing the code to revoke credentials.')

  credentials = google.oauth2.credentials.Credentials(
    **flask.session['credentials'])

  revoke = requests.post('https://oauth2.googleapis.com/revoke',
      params={'token': credentials.token},
      headers = {'content-type': 'application/x-www-form-urlencoded'})

  status_code = getattr(revoke, 'status_code')
  if status_code == 200:
    return('Credentials successfully revoked.' + print_index_table())
  else:
    return('An error occurred.' + print_index_table())


@app.route('/clear')
def clear_credentials():
  if 'credentials' in flask.session:
    del flask.session['credentials']
  return ('Credentials have been cleared.<br><br>' +
          print_index_table())


def credentials_to_dict(credentials):
  return {'token': credentials.token,
          'refresh_token': credentials.refresh_token,
          'token_uri': credentials.token_uri,
          'client_id': credentials.client_id,
          'client_secret': credentials.client_secret,
          'scopes': credentials.scopes}

def print_index_table():
  return ('<table>' +
          '<tr><td><a href="/test">Test an API request</a></td>' +
          '<td>Submit an API request and see a formatted JSON response. ' +
          '    Go through the authorization flow if there are no stored ' +
          '    credentials for the user.</td></tr>' +
          '<tr><td><a href="/authorize">Test the auth flow directly</a></td>' +
          '<td>Go directly to the authorization flow. If there are stored ' +
          '    credentials, you still might not be prompted to reauthorize ' +
          '    the application.</td></tr>' +
          '<tr><td><a href="/revoke">Revoke current credentials</a></td>' +
          '<td>Revoke the access token associated with the current user ' +
          '    session. After revoking credentials, if you go to the test ' +
          '    page, you should see an <code>invalid_grant</code> error.' +
          '</td></tr>' +
          '<tr><td><a href="/clear">Clear Flask session credentials</a></td>' +
          '<td>Clear the access token currently stored in the user session. ' +
          '    After clearing the token, if you <a href="/test">test the ' +
          '    API request</a> again, you should go back to the auth flow.' +
          '</td></tr></table>')


if __name__ == '__main__':
  # When running locally, disable OAuthlib's HTTPs verification.
  # ACTION ITEM for developers:
  #     When running in production *do not* leave this option enabled.
  os.environ['OAUTHLIB_INSECURE_TRANSPORT'] = '1'

  # Specify a hostname and port that are set as a valid redirect URI
  # for your API project in the Google API Console.
  app.run('localhost', 8080, debug=True)

Ruby

此示例使用 Sinatra 框架。

require 'google/apis/drive_v2'
require 'google/api_client/client_secrets'
require 'json'
require 'sinatra'

enable :sessions
set :session_secret, 'setme'

get '/' do
  unless session.has_key?(:credentials)
    redirect to('/oauth2callback')
  end
  client_opts = JSON.parse(session[:credentials])
  auth_client = Signet::OAuth2::Client.new(client_opts)
  drive = Google::Apis::DriveV2::DriveService.new
  files = drive.list_files(options: { authorization: auth_client })
  "<pre>#{JSON.pretty_generate(files.to_h)}</pre>"
end

get '/oauth2callback' do
  client_secrets = Google::APIClient::ClientSecrets.load
  auth_client = client_secrets.to_authorization
  auth_client.update!(
    :scope => 'https://www.googleapis.com/auth/drive.metadata.readonly',
    :redirect_uri => url('/oauth2callback'))
  if request['code'] == nil
    auth_uri = auth_client.authorization_uri.to_s
    redirect to(auth_uri)
  else
    auth_client.code = request['code']
    auth_client.fetch_access_token!
    auth_client.client_secret = nil
    session[:credentials] = auth_client.to_json
    redirect to('/')
  end
end

Node.js

如需运行此示例，请执行以下操作：

1. 在 API Console中，将本地机器的网址添加到重定向网址列表中。例如，添加 http://localhost。
2. 请确保您已安装维护 LTS、有效 LTS 或已安装 Node.js 的当前版本。
3. 创建一个新目录并切换到该目录。例如：

   mkdir ~/nodejs-oauth2-example
   cd ~/nodejs-oauth2-example

4. Install the Google API Client Library for Node.js using npm:

   npm install googleapis

5. 使用以下内容创建 main.js 文件。
6. 运行示例：

   node .\main.js

main.js

const http = require('http');
const https = require('https');
const url = require('url');
const { google } = require('googleapis');

/**
 * To use OAuth2 authentication, we need access to a CLIENT_ID, CLIENT_SECRET, AND REDIRECT_URI.
 * To get these credentials for your application, visit
 * https://console.cloud.google.com/apis/credentials.
 */
const oauth2Client = new google.auth.OAuth2(
  YOUR_CLIENT_ID,
  YOUR_CLIENT_SECRET,
  YOUR_REDIRECT_URL
);

// Access scopes for read-only Drive activity.
const scopes = [
  'https://www.googleapis.com/auth/drive.metadata.readonly'
];

// Generate a url that asks permissions for the Drive activity scope
const authorizationUrl = oauth2Client.generateAuthUrl({
  // 'online' (default) or 'offline' (gets refresh_token)
  access_type: 'offline',
  /** Pass in the scopes array defined above.
    * Alternatively, if only one scope is needed, you can pass a scope URL as a string */
  scope: scopes,
  // Enable incremental authorization. Recommended as a best practice.
  include_granted_scopes: true
});

/* Global variable that stores user credential in this code example.
 * ACTION ITEM for developers:
 *   Store user's refresh token in your data store if
 *   incorporating this code into your real app.
 *   For more information on handling refresh tokens,
 *   see https://github.com/googleapis/google-api-nodejs-client#handling-refresh-tokens
 */
let userCredential = null;

async function main() {
  const server = http.createServer(async function (req, res) {
    // Example on redirecting user to Google's OAuth 2.0 server.
    if (req.url == '/') {
      res.writeHead(301, { "Location": authorizationUrl });
    }

    // Receive the callback from Google's OAuth 2.0 server.
    if (req.url.startsWith('/oauth2callback')) {
      // Handle the OAuth 2.0 server response
      let q = url.parse(req.url, true).query;

      if (q.error) { // An error response e.g. error=access_denied
        console.log('Error:' + q.error);
      } else { // Get access and refresh tokens (if access_type is offline)
        let { tokens } = await oauth2Client.getToken(q.code);
        oauth2Client.setCredentials(tokens);

        /** Save credential to the global variable in case access token was refreshed.
          * ACTION ITEM: In a production app, you likely want to save the refresh token
          *              in a secure persistent database instead. */
        userCredential = tokens;

        // Example of using Google Drive API to list filenames in user's Drive.
        const drive = google.drive('v3');
        drive.files.list({
          auth: oauth2Client,
          pageSize: 10,
          fields: 'nextPageToken, files(id, name)',
        }, (err1, res1) => {
          if (err1) return console.log('The API returned an error: ' + err1);
          const files = res1.data.files;
          if (files.length) {
            console.log('Files:');
            files.map((file) => {
              console.log(`${file.name} (${file.id})`);
            });
          } else {
            console.log('No files found.');
          }
        });
      }
    }

    // Example on revoking a token
    if (req.url == '/revoke') {
      // Build the string for the POST request
      let postData = "token=" + userCredential.access_token;

      // Options for POST request to Google's OAuth 2.0 server to revoke a token
      let postOptions = {
        host: 'oauth2.googleapis.com',
        port: '443',
        path: '/revoke',
        method: 'POST',
        headers: {
          'Content-Type': 'application/x-www-form-urlencoded',
          'Content-Length': Buffer.byteLength(postData)
        }
      };

      // Set up the request
      const postReq = https.request(postOptions, function (res) {
        res.setEncoding('utf8');
        res.on('data', d => {
          console.log('Response: ' + d);
        });
      });

      postReq.on('error', error => {
        console.log(error)
      });

      // Post the request with data
      postReq.write(postData);
      postReq.end();
    }
    res.end();
  }).listen(80);
}
main().catch(console.error);

HTTP/REST

此 Python 示例使用 Flask 框架和 Requests 库来演示 OAuth 2.0 Web 流程。对于此流程，我们建议使用 Python 版 Google API 客户端库。（Python 标签页中的示例确实使用了客户端库。）

import json

import flask
import requests


app = flask.Flask(__name__)

CLIENT_ID = '123456789.apps.googleusercontent.com'
CLIENT_SECRET = 'abc123'  # Read from a file or environmental variable in a real app
SCOPE = 'https://www.googleapis.com/auth/drive.metadata.readonly'
REDIRECT_URI = 'http://example.com/oauth2callback'


@app.route('/')
def index():
  if 'credentials' not in flask.session:
    return flask.redirect(flask.url_for('oauth2callback'))
  credentials = json.loads(flask.session['credentials'])
  if credentials['expires_in'] <= 0:
    return flask.redirect(flask.url_for('oauth2callback'))
  else:
    headers = {'Authorization': 'Bearer {}'.format(credentials['access_token'])}
    req_uri = 'https://www.googleapis.com/drive/v2/files'
    r = requests.get(req_uri, headers=headers)
    return r.text


@app.route('/oauth2callback')
def oauth2callback():
  if 'code' not in flask.request.args:
    auth_uri = ('https://accounts.google.com/o/oauth2/v2/auth?response_type=code'
                '&client_id={}&redirect_uri={}&scope={}').format(CLIENT_ID, REDIRECT_URI, SCOPE)
    return flask.redirect(auth_uri)
  else:
    auth_code = flask.request.args.get('code')
    data = {'code': auth_code,
            'client_id': CLIENT_ID,
            'client_secret': CLIENT_SECRET,
            'redirect_uri': REDIRECT_URI,
            'grant_type': 'authorization_code'}
    r = requests.post('https://oauth2.googleapis.com/token', data=data)
    flask.session['credentials'] = r.text
    return flask.redirect(flask.url_for('index'))


if __name__ == '__main__':
  import uuid
  app.secret_key = str(uuid.uuid4())
  app.debug = False
  app.run()

PHP

$client->setIncludeGrantedScopes(true);

Python

在 Python 中，将 include_granted_scopes 关键字参数设置为 true，以确保授权请求包含先前授予的范围。极有可能是因为 include_granted_scopes 不是您设置的唯一关键字参数，如以下示例所示。

authorization_url, state = flow.authorization_url(
    # Enable offline access so that you can refresh an access token without
    # re-prompting the user for permission. Recommended for web server apps.
    access_type='offline',
    # Enable incremental authorization. Recommended as a best practice.
    include_granted_scopes='true')

Ruby

auth_client.update!(
  :additional_parameters => {"include_granted_scopes" => "true"}
)

Node.js

const authorizationUrl = oauth2Client.generateAuthUrl({
  // 'online' (default) or 'offline' (gets refresh_token)
  access_type: 'offline',
  /** Pass in the scopes array defined above.
    * Alternatively, if only one scope is needed, you can pass a scope URL as a string */
  scope: scopes,
  // Enable incremental authorization. Recommended as a best practice.
  include_granted_scopes: true
});

HTTP/REST

GET https://accounts.google.com/o/oauth2/v2/auth?
  client_id=your_client_id&
  response_type=code&
  state=state_parameter_passthrough_value&
  scope=https%3A//www.googleapis.com/auth/drive.file&
  redirect_uri=https%3A//oauth2.example.com/code&
  prompt=consent&
  include_granted_scopes=true

PHP

如果您的应用需要离线访问 Google API，请将 API 客户端的访问权限类型设置为 offline：

$client->setAccessType("offline");

在用户针对请求的作用域授予离线访问权限后，您可以在用户离线时继续使用 API 客户端代表用户访问 Google API。客户端对象将根据需要刷新访问令牌。

Python

在 Python 中，将 access_type 关键字参数设置为 offline，以确保您可以刷新访问令牌，而无需重新提示用户授予权限。access_type 很可能不是您设置的唯一关键字参数，如以下示例所示。

authorization_url, state = flow.authorization_url(
    # Enable offline access so that you can refresh an access token without
    # re-prompting the user for permission. Recommended for web server apps.
    access_type='offline',
    # Enable incremental authorization. Recommended as a best practice.
    include_granted_scopes='true')

在用户针对请求的作用域授予离线访问权限后，您可以在用户离线时继续使用 API 客户端代表用户访问 Google API。客户端对象将根据需要刷新访问令牌。

Ruby

如果您的应用需要离线访问 Google API，请将 API 客户端的访问权限类型设置为 offline：

auth_client.update!(
  :additional_parameters => {"access_type" => "offline"}
)

在用户针对请求的作用域授予离线访问权限后，您可以在用户离线时继续使用 API 客户端代表用户访问 Google API。客户端对象将根据需要刷新访问令牌。

Node.js

如果您的应用需要离线访问 Google API，请将 API 客户端的访问权限类型设置为 offline：

const authorizationUrl = oauth2Client.generateAuthUrl({
  // 'online' (default) or 'offline' (gets refresh_token)
  access_type: 'offline',
  /** Pass in the scopes array defined above.
    * Alternatively, if only one scope is needed, you can pass a scope URL as a string */
  scope: scopes,
  // Enable incremental authorization. Recommended as a best practice.
  include_granted_scopes: true
});

在用户针对请求的作用域授予离线访问权限后，您可以在用户离线时继续使用 API 客户端代表用户访问 Google API。客户端对象将根据需要刷新访问令牌。

访问令牌会过期。此库将在即将过期时自动使用刷新令牌来获取新的访问令牌。若要确保始终存储最新的令牌，一种简单的方法是使用令牌事件：

oauth2Client.on('tokens', (tokens) => {
  if (tokens.refresh_token) {
    // store the refresh_token in your secure persistent database
    console.log(tokens.refresh_token);
  }
  console.log(tokens.access_token);
});

此令牌事件仅在第一次授权中发生，在调用 generateAuthUrl 方法以接收刷新令牌时，您需要将 access_type 设置为 offline。如果您已为应用授予必要的权限，但未设置适当的限制来接收刷新令牌，则需要重新向应用授权以接收新的刷新令牌。

如需稍后设置 refresh_token，您可以使用 setCredentials 方法：

oauth2Client.setCredentials({
  refresh_token: `STORED_REFRESH_TOKEN`
});

客户端获得刷新令牌后，系统就会获取访问令牌并在下次调用该 API 时自动刷新。

HTTP/REST

如需刷新访问令牌，您的应用会向 Google 的授权服务器 (https://oauth2.googleapis.com/token) 发送 HTTPS POST 请求，其中包含以下参数：

以下代码段展示了一个示例请求：

POST /token HTTP/1.1
Host: oauth2.googleapis.com
Content-Type: application/x-www-form-urlencoded

client_id=your_client_id&
client_secret=your_client_secret&
refresh_token=refresh_token&
grant_type=refresh_token

只要用户尚未撤消授予应用的访问权限，令牌服务器就会返回一个包含新访问令牌的 JSON 对象。以下代码段是一个示例响应：

{
  "access_token": "1/fFAGRNJru1FTz70BzhT3Zg",
  "expires_in": 3920,
  "scope": "https://www.googleapis.com/auth/drive.metadata.readonly",
  "token_type": "Bearer"
}

请注意，将颁发的刷新令牌数量有限；每个客户端/用户组合各有一个限制，而所有客户端上每个用户都各有一个限制。您应将刷新令牌保存在长期存储空间中，并只要这些令牌保持有效状态，就会继续使用它们。如果您的应用请求过多的刷新令牌，可能会受这些限制的影响，在这种情况下，较旧的刷新令牌将停止运行。

PHP

如需以编程方式撤消令牌，请调用 revokeToken()：

$client->revokeToken();

Python

如需以编程方式撤消令牌，请向 https://oauth2.googleapis.com/revoke 发出请求，将该令牌作为参数并设置 Content-Type 标头：

requests.post('https://oauth2.googleapis.com/revoke',
    params={'token': credentials.token},
    headers = {'content-type': 'application/x-www-form-urlencoded'})

Ruby

如需以编程方式撤消令牌，请向 oauth2.revoke 端点发出 HTTP 请求：

uri = URI('https://oauth2.googleapis.com/revoke')
response = Net::HTTP.post_form(uri, 'token' => auth_client.access_token)

该令牌可以是访问令牌，也可以是刷新令牌。如果令牌是访问令牌，并且具有相应的刷新令牌，则刷新令牌也会被撤消。

如果成功处理了撤消，则响应的状态代码为 200。对于错误情况，系统会返回状态代码 400 以及错误代码。

Node.js

如需以编程方式撤消令牌，请向 /revoke 端点发出 HTTPS POST 请求：

const https = require('https');

// Build the string for the POST request
let postData = "token=" + userCredential.access_token;

// Options for POST request to Google's OAuth 2.0 server to revoke a token
let postOptions = {
  host: 'oauth2.googleapis.com',
  port: '443',
  path: '/revoke',
  method: 'POST',
  headers: {
    'Content-Type': 'application/x-www-form-urlencoded',
    'Content-Length': Buffer.byteLength(postData)
  }
};

// Set up the request
const postReq = https.request(postOptions, function (res) {
  res.setEncoding('utf8');
  res.on('data', d => {
    console.log('Response: ' + d);
  });
});

postReq.on('error', error => {
  console.log(error)
});

// Post the request with data
postReq.write(postData);
postReq.end();

令牌参数可以是访问令牌或刷新令牌。如果令牌是访问令牌，并且具有相应的刷新令牌，则刷新令牌也会被撤消。

如果成功处理了撤消，则响应的状态代码为 200。对于错误情况，系统会返回状态代码 400 以及错误代码。

HTTP/REST

如需以编程方式撤消令牌，您的应用会向 https://oauth2.googleapis.com/revoke 发出请求，并将该令牌添加为参数：

curl -d -X -POST --header "Content-type:application/x-www-form-urlencoded" \
        https://oauth2.googleapis.com/revoke?token={token}

该令牌可以是访问令牌，也可以是刷新令牌。如果令牌是访问令牌，并且具有相应的刷新令牌，则刷新令牌也会被撤消。

如果成功处理了撤消操作，则响应的 HTTP 状态代码为 200。对于错误情况，系统会返回 HTTP 状态代码 400 以及错误代码。