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

PHP

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

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

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

  php composer.phar require google/apiclient:^2.0

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.0

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

   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，您还可以在用户撤消授予应用的权限后，应用仍尝试使用已撤消的访问令牌授权请求，从而获得 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. 确保已安装 Node.js 的维护 LTS、活跃 LTS 或当前版本。
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();

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

如果吊销成功处理，则响应的状态代码是 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 以及错误代码。