หน้านี้ได้รับการแปลโดย Cloud Translation API

การใช้ OAuth 2.0 กับไลบรารีของไคลเอ็นต์ Google API สำหรับ Java

ภาพรวม

จุดประสงค์: เอกสารนี้อธิบายวิธีใช้คลาสยูทิลิตี GoogleCredential เพื่อให้สิทธิ์ OAuth 2.0 กับบริการของ Google ดูข้อมูลเกี่ยวกับฟังก์ชัน OAuth 2.0 ทั่วไปที่เรามีให้ได้ที่ OAuth 2.0 และไลบรารีของไคลเอ็นต์ Google OAuth สำหรับ Java

สรุป: หากต้องการเข้าถึงข้อมูลที่มีการป้องกันซึ่งจัดเก็บไว้ในบริการของ Google ให้ใช้ OAuth 2.0 เพื่อให้สิทธิ์ Google API รองรับโฟลว์ OAuth 2.0 สำหรับแอปพลิเคชันไคลเอ็นต์ประเภทต่างๆ ในขั้นตอนทั้งหมดนี้ แอปพลิเคชันไคลเอ็นต์จะขอโทเค็นเพื่อการเข้าถึงที่เชื่อมโยงกับแอปพลิเคชันไคลเอ็นต์และเจ้าของข้อมูลที่มีการป้องกันที่มีการเข้าถึงเท่านั้น โทเค็นเพื่อการเข้าถึงยังเชื่อมโยงกับขอบเขตที่จำกัดซึ่งกำหนดประเภทข้อมูลที่แอปพลิเคชันไคลเอ็นต์ของคุณมีสิทธิ์เข้าถึง (เช่น "จัดการงานของคุณ") เป้าหมายสำคัญของ OAuth 2.0 คือการให้สิทธิ์เข้าถึงข้อมูลที่ได้รับการปกป้องอย่างปลอดภัยและสะดวกสบาย ขณะเดียวกันก็ลดผลกระทบที่อาจเกิดขึ้นหากโทเค็นเพื่อการเข้าถึงถูกขโมย

แพ็กเกจ OAuth 2.0 ในไลบรารีของไคลเอ็นต์ Google API สำหรับ Java สร้างขึ้นจากไลบรารีของไคลเอ็นต์ Google OAuth 2.0 สำหรับ Java ที่มีวัตถุประสงค์ทั่วไป

โปรดดูรายละเอียดในเอกสารประกอบ Javadoc สำหรับแพ็กเกจต่อไปนี้

com.google.api.client.googleapis.auth.oauth2 (จาก google-api-client)
com.google.api.client.googleapis.extensions.appengine.auth.oauth2 (จาก google-api-client-appengine)

คอนโซล Google API

ก่อนที่จะเข้าถึง Google API ได้ คุณต้องสร้างโปรเจ็กต์ในคอนโซล Google API เพื่อวัตถุประสงค์ในการตรวจสอบสิทธิ์และการเรียกเก็บเงิน ไม่ว่าไคลเอ็นต์จะเป็นแอปพลิเคชันที่ติดตั้ง แอปพลิเคชันบนอุปกรณ์เคลื่อนที่ เว็บเซิร์ฟเวอร์ หรือไคลเอ็นต์ที่ทำงานในเบราว์เซอร์ก็ตาม

สำหรับวิธีการตั้งค่าข้อมูลเข้าสู่ระบบอย่างถูกต้อง ให้ดูความช่วยเหลือเกี่ยวกับคอนโซล API

ข้อมูลเข้าสู่ระบบ

GoogleCredential

GoogleCredential เป็นคลาสตัวช่วยที่ปลอดภัยของเทรดสำหรับ OAuth 2.0 สำหรับการเข้าถึงทรัพยากรที่ป้องกันโดยใช้โทเค็นเพื่อการเข้าถึง ตัวอย่างเช่น หากคุณมีโทเค็นเพื่อการเข้าถึงอยู่แล้ว คุณสามารถส่งคำขอได้ด้วยวิธีต่อไปนี้

GoogleCredential credential = new GoogleCredential().setAccessToken(accessToken);
Plus plus = new Plus.builder(new NetHttpTransport(),
                             GsonFactory.getDefaultInstance(),
                             credential)
    .setApplicationName("Google-PlusSample/1.0")
    .build();

ข้อมูลประจำตัวของ Google App Engine

ข้อมูลเข้าสู่ระบบทางเลือกนี้อิงตาม Google App Engine App Identity Java API App Identity API จะให้สิทธิ์เข้าถึงข้อมูลแอปพลิเคชันไคลเอ็นต์เหมือนกับข้อมูลเข้าสู่ระบบที่แอปพลิเคชันไคลเอ็นต์จะขอสิทธิ์เข้าถึงข้อมูลของผู้ใช้ปลายทาง

ใช้ AppIdentityCredential (จาก google-api-client-appengine) ข้อมูลเข้าสู่ระบบนี้ง่ายกว่ามากเพราะ Google App Engine จะดูแลรายละเอียดทั้งหมด โดยคุณจะระบุเฉพาะขอบเขต OAuth 2.0 ที่ต้องการเท่านั้น

ตัวอย่างโค้ดที่นํามาจาก urlshortener-robots-appengine-sample

static Urlshortener newUrlshortener() {
  AppIdentityCredential credential =
      new AppIdentityCredential(
          Collections.singletonList(UrlshortenerScopes.URLSHORTENER));
  return new Urlshortener.Builder(new UrlFetchTransport(),
                                  GsonFactory.getDefaultInstance(),
                                  credential)
      .build();
}

ที่เก็บข้อมูล

โดยทั่วไปโทเค็นเพื่อการเข้าถึงจะมีวันที่หมดอายุอยู่ที่ 1 ชั่วโมง หลังจากนั้นระบบจะแสดงข้อผิดพลาดหากพยายามใช้ GoogleCredential จะ "รีเฟรช" โทเค็นโดยอัตโนมัติ ซึ่งหมายถึงการรับโทเค็นเพื่อการเข้าถึงใหม่ ซึ่งทำได้ด้วยการใช้โทเค็นการรีเฟรชที่มีระยะเวลานาน ซึ่งโดยปกติจะได้รับพร้อมกับโทเค็นเพื่อการเข้าถึงหากคุณใช้พารามิเตอร์ access_type=offline ระหว่างขั้นตอนรหัสการให้สิทธิ์ (ดู GoogleAuthorizationCodeFlow.Builder.setAccessType(String))

แอปพลิเคชันส่วนใหญ่จะต้องคงโทเค็นเพื่อการเข้าถึงและ/หรือโทเค็นการรีเฟรชของข้อมูลเข้าสู่ระบบไว้ หากต้องการรักษาสิทธิ์เข้าถึงของข้อมูลเข้าสู่ระบบและ/หรือโทเค็นการรีเฟรช คุณอาจระบุการใช้งาน DataStoreFactory ของคุณเองด้วย StoredCredential หรือจะใช้การติดตั้งใช้งานอย่างใดอย่างหนึ่งต่อไปนี้ที่ไลบรารีมีให้ก็ได้

AppEngineDataStoreFactory: เก็บข้อมูลเข้าสู่ระบบไว้โดยใช้ Google App Engine Data Store API
MemoryDataStoreFactory: "คงอยู่" ข้อมูลเข้าสู่ระบบในหน่วยความจำ ซึ่งมีประโยชน์ในการเป็นพื้นที่เก็บข้อมูลระยะสั้นตลอดอายุของกระบวนการนี้
FileDataStoreFactory: เก็บข้อมูลเข้าสู่ระบบไว้ในไฟล์เสมอ

ผู้ใช้ AppEngine: เลิกใช้งาน AppEngineCredentialStore แล้วและจะนำออกเร็วๆ นี้ เราขอแนะนำให้คุณใช้ AppEngineDataStoreFactory ด้วย StoredCredential หากมีข้อมูลเข้าสู่ระบบที่จัดเก็บในรูปแบบเก่า คุณจะใช้เมธอดตัวช่วยที่เพิ่มเข้ามาได้ MigrateTo(AppEngineDataStoreFactory) หรือ migrateTo(DataStore) เพื่อดำเนินการย้ายข้อมูล

คุณอาจใช้ DataStoreCredentialRefreshListener และตั้งเป็นข้อมูลเข้าสู่ระบบโดยใช้ GoogleCredential.Builder.addRefreshListener(CredentialRefreshListener))

ขั้นตอนรหัสการให้สิทธิ์

ใช้ขั้นตอนการใช้รหัสการให้สิทธิ์เพื่ออนุญาตให้ผู้ใช้ปลายทางให้สิทธิ์แอปพลิเคชันในการเข้าถึงข้อมูลที่มีการป้องกันบน Google APIs โปรโตคอลสำหรับขั้นตอนนี้มีระบุไว้ในการให้สิทธิ์รหัสการให้สิทธิ์

ระบบจะใช้งานขั้นตอนนี้โดยใช้ GoogleAuthorizationCodeFlow ขั้นตอนมีดังต่อไปนี้

ผู้ใช้ปลายทางจะเข้าสู่ระบบแอปพลิเคชันของคุณ คุณจะต้องเชื่อมโยงผู้ใช้รายนั้นกับ รหัสผู้ใช้ที่ไม่ซ้ำกันสำหรับแอปพลิเคชันของคุณ
เรียกใช้ AuthorizationCodeFlow.loadCredential(String)) ตามรหัสผู้ใช้ เพื่อตรวจสอบว่าข้อมูลเข้าสู่ระบบของผู้ใช้ปลายทางทราบอยู่แล้วหรือไม่ หากใช้ได้ เราแก้ปัญหาเรียบร้อยแล้ว
หากไม่มี ให้เรียก AuthorizationCodeFlow.newAuthorizationUrl() และนำเบราว์เซอร์ของผู้ใช้ปลายทางไปยังหน้าการให้สิทธิ์ เพื่อให้แอปพลิเคชันของคุณมีสิทธิ์เข้าถึงข้อมูลที่มีการคุ้มครองของพวกเขา
จากนั้นเซิร์ฟเวอร์การให้สิทธิ์ของ Google จะเปลี่ยนเส้นทางเบราว์เซอร์กลับไปยัง URL เปลี่ยนเส้นทางที่แอปพลิเคชันระบุไว้ พร้อมกับพารามิเตอร์การค้นหา code ใช้พารามิเตอร์ code เพื่อขอโทเค็นเพื่อการเข้าถึงโดยใช้ AuthorizationCodeFlow.newTokenRequest(String))
ใช้ AuthorizationCodeFlow.createAndStoreCredential(TokenResponse, String)) เพื่อจัดเก็บและรับข้อมูลรับรองสำหรับการเข้าถึงทรัพยากรที่มีการป้องกัน

หรือหากคุณไม่ได้ใช้ GoogleAuthorizationCodeFlow คุณสามารถใช้คลาสระดับต่ำลงมาได้ ดังนี้

ใช้ DataStore.get(String) เพื่อโหลดข้อมูลเข้าสู่ระบบจาก Store โดยอิงตามรหัสผู้ใช้
ใช้ GoogleAuthorizationCodeRequestUrl เพื่อนำเบราว์เซอร์ไปยังหน้าการให้สิทธิ์
ใช้ AuthorizationCodeResponseUrl เพื่อประมวลผลการตอบกลับการให้สิทธิ์และแยกวิเคราะห์รหัสการให้สิทธิ์
ใช้ GoogleAuthorizationCodeTokenRequest เพื่อขอโทเค็นเพื่อการเข้าถึงและอาจใช้โทเค็นการรีเฟรช
สร้าง GoogleCredential ใหม่และจัดเก็บโดยใช้ DataStore.set(String, V)
เข้าถึงทรัพยากรที่มีการป้องกันโดยใช้ GoogleCredential ระบบจะรีเฟรชโทเค็นเพื่อการเข้าถึงที่หมดอายุแล้วโดยอัตโนมัติโดยใช้โทเค็นการรีเฟรช (หากมี) อย่าลืมใช้ DataStoreCredentialRefreshListener และตั้งเป็นข้อมูลเข้าสู่ระบบโดยใช้ GoogleCredential.Builder.addRefreshListener(CredentialRefreshListener))

เมื่อตั้งค่าโปรเจ็กต์ในคอนโซล Google API คุณจะได้เลือกข้อมูลเข้าสู่ระบบที่แตกต่างกันโดยขึ้นอยู่กับขั้นตอนที่คุณใช้ ดูรายละเอียดเพิ่มเติมได้ที่การตั้งค่า OAuth 2.0 และสถานการณ์ OAuth 2.0 ข้อมูลโค้ดสำหรับแต่ละขั้นตอนมีดังนี้

แอปพลิเคชันเว็บเซิร์ฟเวอร์

โปรโตคอลสำหรับขั้นตอนนี้อธิบายไว้ในการใช้ OAuth 2.0 สำหรับแอปพลิเคชันเว็บเซิร์ฟเวอร์

ไลบรารีนี้มีคลาสตัวช่วยของเซิร์ฟเล็ตเพื่อลดความซับซ้อนของขั้นตอนรหัสการให้สิทธิ์สำหรับกรณีการใช้งานขั้นพื้นฐานได้อย่างมาก คุณเพียงแค่ระบุคลาสย่อยที่เป็นรูปธรรมของ AbstractAuthorizationCodeServlet และ AbstractAuthorizationCodeCallbackServlet (จาก google-oauth-client-servlet) แล้วเพิ่มลงในไฟล์ web.xml ของคุณ โปรดทราบว่าคุณยังคงต้องดูแลการเข้าสู่ระบบของผู้ใช้ สำหรับเว็บแอปพลิเคชันและดึงข้อมูลรหัสผู้ใช้

public class CalendarServletSample extends AbstractAuthorizationCodeServlet {

  @Override
  protected void doGet(HttpServletRequest request, HttpServletResponse response)
      throws IOException {
    // do stuff
  }

  @Override
  protected String getRedirectUri(HttpServletRequest req) throws ServletException, IOException {
    GenericUrl url = new GenericUrl(req.getRequestURL().toString());
    url.setRawPath("/oauth2callback");
    return url.build();
  }

  @Override
  protected AuthorizationCodeFlow initializeFlow() throws IOException {
    return new GoogleAuthorizationCodeFlow.Builder(
        new NetHttpTransport(), GsonFactory.getDefaultInstance(),
        "[[ENTER YOUR CLIENT ID]]", "[[ENTER YOUR CLIENT SECRET]]",
        Collections.singleton(CalendarScopes.CALENDAR)).setDataStoreFactory(
        DATA_STORE_FACTORY).setAccessType("offline").build();
  }

  @Override
  protected String getUserId(HttpServletRequest req) throws ServletException, IOException {
    // return user ID
  }
}

public class CalendarServletCallbackSample extends AbstractAuthorizationCodeCallbackServlet {

  @Override
  protected void onSuccess(HttpServletRequest req, HttpServletResponse resp, Credential credential)
      throws ServletException, IOException {
    resp.sendRedirect("/");
  }

  @Override
  protected void onError(
      HttpServletRequest req, HttpServletResponse resp, AuthorizationCodeResponseUrl errorResponse)
      throws ServletException, IOException {
    // handle error
  }

  @Override
  protected String getRedirectUri(HttpServletRequest req) throws ServletException, IOException {
    GenericUrl url = new GenericUrl(req.getRequestURL().toString());
    url.setRawPath("/oauth2callback");
    return url.build();
  }

  @Override
  protected AuthorizationCodeFlow initializeFlow() throws IOException {
    return new GoogleAuthorizationCodeFlow.Builder(
        new NetHttpTransport(), GsonFactory.getDefaultInstance()
        "[[ENTER YOUR CLIENT ID]]", "[[ENTER YOUR CLIENT SECRET]]",
        Collections.singleton(CalendarScopes.CALENDAR)).setDataStoreFactory(
        DATA_STORE_FACTORY).setAccessType("offline").build();
  }

  @Override
  protected String getUserId(HttpServletRequest req) throws ServletException, IOException {
    // return user ID
  }
}

แอปพลิเคชันของ Google App Engine

ขั้นตอนรหัสการให้สิทธิ์ใน App Engine จะเหมือนกับขั้นตอนรหัสการให้สิทธิ์ของเซิร์ฟเล็ต เว้นแต่ว่าเราจะใช้ประโยชน์จาก Users Java API ของ Google App Engine ได้ ผู้ใช้ต้องเข้าสู่ระบบเพื่อเปิดใช้ Java API ของผู้ใช้ หากต้องการข้อมูลเกี่ยวกับการเปลี่ยนเส้นทางผู้ใช้ไปยังหน้าเข้าสู่ระบบในกรณีที่ยังไม่ได้เข้าสู่ระบบ โปรดดูความปลอดภัยและการตรวจสอบสิทธิ์ (ใน web.xml)

ความแตกต่างหลักจากกรณีของเซิร์ฟเล็ตคือคุณระบุคลาสย่อยของ AbstractAppEngineAuthorizationCodeServlet และ AbstractAppEngineAuthorizationCodeCallbackServlet (จาก google-oauth-client-appengine โดยขยายคลาส Abstract servlet และใช้เมธอด getUserId ให้คุณโดยใช้ Users Java API AppEngineDataStoreFactory (จาก google-http-client-appengine) เป็นตัวเลือกที่ดีในการรักษาข้อมูลเข้าสู่ระบบโดยใช้ Google App Engine Data Store API

ตัวอย่างที่นำมา (แก้ไขเล็กน้อย) จาก calendar-appengine-sample

public class CalendarAppEngineSample extends AbstractAppEngineAuthorizationCodeServlet {

  @Override
  protected void doGet(HttpServletRequest request, HttpServletResponse response)
      throws IOException {
    // do stuff
  }

  @Override
  protected String getRedirectUri(HttpServletRequest req) throws ServletException, IOException {
    return Utils.getRedirectUri(req);
  }

  @Override
  protected AuthorizationCodeFlow initializeFlow() throws IOException {
    return Utils.newFlow();
  }
}

class Utils {
  static String getRedirectUri(HttpServletRequest req) {
    GenericUrl url = new GenericUrl(req.getRequestURL().toString());
    url.setRawPath("/oauth2callback");
    return url.build();
  }

  static GoogleAuthorizationCodeFlow newFlow() throws IOException {
    return new GoogleAuthorizationCodeFlow.Builder(HTTP_TRANSPORT, JSON_FACTORY,
        getClientCredential(), Collections.singleton(CalendarScopes.CALENDAR)).setDataStoreFactory(
        DATA_STORE_FACTORY).setAccessType("offline").build();
  }
}

public class OAuth2Callback extends AbstractAppEngineAuthorizationCodeCallbackServlet {

  private static final long serialVersionUID = 1L;

  @Override
  protected void onSuccess(HttpServletRequest req, HttpServletResponse resp, Credential credential)
      throws ServletException, IOException {
    resp.sendRedirect("/");
  }

  @Override
  protected void onError(
      HttpServletRequest req, HttpServletResponse resp, AuthorizationCodeResponseUrl errorResponse)
      throws ServletException, IOException {
    String nickname = UserServiceFactory.getUserService().getCurrentUser().getNickname();
    resp.getWriter().print("<h3>" + nickname + ", why don't you want to play with me?</h1>");
    resp.setStatus(200);
    resp.addHeader("Content-Type", "text/html");
  }

  @Override
  protected String getRedirectUri(HttpServletRequest req) throws ServletException, IOException {
    return Utils.getRedirectUri(req);
  }

  @Override
  protected AuthorizationCodeFlow initializeFlow() throws IOException {
    return Utils.newFlow();
  }
}

ดูตัวอย่างเพิ่มเติมได้ที่ storage-serviceaccount-appengine-sample

บัญชีบริการ

GoogleCredential ยังรองรับบัญชีบริการด้วย บัญชีบริการจะให้สิทธิ์เข้าถึงข้อมูลของแอปพลิเคชันไคลเอ็นต์ ซึ่งต่างจากข้อมูลเข้าสู่ระบบที่แอปพลิเคชันไคลเอ็นต์ขอสิทธิ์เข้าถึงข้อมูลของผู้ใช้ปลายทาง แอปพลิเคชันไคลเอ็นต์จะลงนามคำขอโทเค็นเพื่อการเข้าถึงโดยใช้คีย์ส่วนตัวที่ดาวน์โหลดจากคอนโซล Google API

ตัวอย่างโค้ดที่ได้จาก plus-serviceaccount-cmdline-sample

HttpTransport httpTransport = GoogleNetHttpTransport.newTrustedTransport();
JsonFactory jsonFactory = GsonFactory.getDefaultInstance();
...
// Build service account credential.

GoogleCredential credential = GoogleCredential.fromStream(new FileInputStream("MyProject-1234.json"))
    .createScoped(Collections.singleton(PlusScopes.PLUS_ME));
// Set up global Plus instance.
plus = new Plus.Builder(httpTransport, jsonFactory, credential)
    .setApplicationName(APPLICATION_NAME).build();
...

ดูตัวอย่างเพิ่มเติมได้ที่ storage-serviceaccount-cmdline-sample

หมายเหตุ: แม้ว่าคุณจะสามารถใช้บัญชีบริการในแอปพลิเคชันที่ทำงานจากโดเมน Google Apps แต่บัญชีบริการไม่ใช่สมาชิกของบัญชี Google Apps และไม่ขึ้นอยู่กับนโยบายโดเมนที่ผู้ดูแลระบบ Google Apps ตั้งค่าไว้ ตัวอย่างเช่น นโยบายที่กำหนดไว้ในคอนโซลผู้ดูแลระบบ Google Apps เพื่อจำกัดความสามารถของผู้ใช้ Apps ในการแชร์เอกสารนอกโดเมนจะไม่มีผลต่อบัญชีบริการ

การแอบอ้างเป็นบุคคลอื่น

นอกจากนี้ยังใช้ขั้นตอนของบัญชีบริการเพื่อแอบอ้างเป็นผู้ใช้ในโดเมนที่คุณเป็นเจ้าของได้ด้วย ขั้นตอนนี้คล้ายกับขั้นตอนของบัญชีบริการข้างต้นมาก แต่คุณจะเรียกใช้ GoogleCredential.Builder.setServiceAccountUser(String) เพิ่มเติมด้วย

แอปพลิเคชันที่ติดตั้ง

นี่คือขั้นตอนรหัสการให้สิทธิ์บรรทัดคำสั่งที่อธิบายไว้ในการใช้ OAuth 2.0 สำหรับแอปพลิเคชันที่ติดตั้ง

ตัวอย่างข้อมูลโค้ดจาก plus-cmdline-sample

public static void main(String[] args) {
  try {
    httpTransport = GoogleNetHttpTransport.newTrustedTransport();
    dataStoreFactory = new FileDataStoreFactory(DATA_STORE_DIR);
    // authorization
    Credential credential = authorize();
    // set up global Plus instance
    plus = new Plus.Builder(httpTransport, JSON_FACTORY, credential).setApplicationName(
        APPLICATION_NAME).build();
   // ...
}

private static Credential authorize() throws Exception {
  // load client secrets
  GoogleClientSecrets clientSecrets = GoogleClientSecrets.load(JSON_FACTORY,
      new InputStreamReader(PlusSample.class.getResourceAsStream("/client_secrets.json")));
  // set up authorization code flow
  GoogleAuthorizationCodeFlow flow = new GoogleAuthorizationCodeFlow.Builder(
      httpTransport, JSON_FACTORY, clientSecrets,
      Collections.singleton(PlusScopes.PLUS_ME)).setDataStoreFactory(
      dataStoreFactory).build();
  // authorize
  return new AuthorizationCodeInstalledApp(flow, new LocalServerReceiver()).authorize("user");
}

แอปพลิเคชันฝั่งไคลเอ็นต์

หากต้องการใช้โฟลว์ไคลเอ็นต์บนเบราว์เซอร์ที่อธิบายในการใช้ OAuth 2.0 สำหรับแอปพลิเคชันฝั่งไคลเอ็นต์ โดยปกติคุณจะต้องทำตามขั้นตอนต่อไปนี้

เปลี่ยนเส้นทางผู้ใช้ปลายทางในเบราว์เซอร์ไปยังหน้าการให้สิทธิ์โดยใช้ GoogleBrowserClientRequestUrl เพื่อให้แอปพลิเคชันเบราว์เซอร์เข้าถึงข้อมูลที่มีการป้องกันของผู้ใช้ปลายทางได้
ใช้ไลบรารีของไคลเอ็นต์ Google API สำหรับ JavaScript เพื่อประมวลผลโทเค็นเพื่อการเข้าถึงที่พบในส่วนย่อยของ URL ที่ URI การเปลี่ยนเส้นทางที่ลงทะเบียนไว้ในคอนโซล Google API

ตัวอย่างการใช้งานสำหรับเว็บแอปพลิเคชัน

public void doGet(HttpServletRequest request, HttpServletResponse response)throws IOException {
  String url = new GoogleBrowserClientRequestUrl("812741506391.apps.googleusercontent.com",
      "https://oauth2.example.com/oauthcallback", Arrays.asList(
          "https://www.googleapis.com/auth/userinfo.email",
          "https://www.googleapis.com/auth/userinfo.profile")).setState("/profile").build();
  response.sendRedirect(url);
}

Android

@เบต้า

ไลบรารีใดที่ใช้กับ Android ได้

หากคุณพัฒนาสำหรับ Android และ Google API ที่ต้องการใช้รวมอยู่ในไลบรารีบริการ Google Play ให้ใช้ไลบรารีนั้นเพื่อประสิทธิภาพและประสบการณ์การใช้งานที่ดีที่สุด หาก Google API ที่คุณต้องการใช้กับ Android ไม่ได้เป็นส่วนหนึ่งของไลบรารีบริการ Google Play คุณสามารถใช้ไลบรารีของไคลเอ็นต์ Google API สำหรับ Java ซึ่งรองรับ Android 4.0 (Ice Cream Sandwich) (หรือสูงกว่า) ซึ่งมีคำอธิบายในที่นี้ การรองรับ Android ในไลบรารีของไคลเอ็นต์ Google API สำหรับ Java คือ @Beta

ข้อมูลเบื้องต้น

ตั้งแต่ Eclair (SDK 2.1) เป็นต้นไป บัญชีผู้ใช้จะได้รับการจัดการในอุปกรณ์ Android โดยใช้เครื่องมือจัดการบัญชี การให้สิทธิ์แอปพลิเคชัน Android ทั้งหมดได้รับการจัดการจากส่วนกลางโดย SDK โดยใช้ AccountManager โดยคุณจะระบุขอบเขต OAuth 2.0 ที่แอปพลิเคชันต้องใช้ และจะแสดงโทเค็นเพื่อการเข้าถึงเพื่อใช้งาน

มีการระบุขอบเขต OAuth 2.0 ผ่านพารามิเตอร์ authTokenType เป็น oauth2: บวกกับขอบเขต เช่น

oauth2:https://www.googleapis.com/auth/tasks

ซึ่งระบุสิทธิ์การอ่าน/การเขียน Google Tasks API หากต้องการขอบเขต OAuth 2.0 หลายรายการ ให้ใช้รายการที่คั่นด้วยการเว้นวรรค

API บางรายการมีพารามิเตอร์ authTokenType พิเศษที่ทำงานร่วมกันได้ ตัวอย่างเช่น "จัดการงานของคุณ" เป็นชื่อแทนสําหรับตัวอย่าง authtokenType ที่แสดงด้านบน

คุณต้องระบุคีย์ API จากคอนโซล Google API ด้วย มิฉะนั้น โทเค็นที่ AccountManager จะให้เฉพาะโควต้าที่ไม่ระบุชื่อแก่คุณ ซึ่งโดยปกติแล้วจะอยู่ในระดับต่ำมาก ในทางกลับกัน เมื่อระบุคีย์ API คุณจะได้รับโควต้าฟรีที่สูงขึ้น และจะเลือกตั้งค่าการเรียกเก็บเงินสำหรับการใช้งานที่มากกว่านั้นได้

ตัวอย่างข้อมูลโค้ดที่ได้จาก tasks-android-sample

com.google.api.services.tasks.Tasks service;

@Override
public void onCreate(Bundle savedInstanceState) {
  credential =
      GoogleAccountCredential.usingOAuth2(this, Collections.singleton(TasksScopes.TASKS));
  SharedPreferences settings = getPreferences(Context.MODE_PRIVATE);
  credential.setSelectedAccountName(settings.getString(PREF_ACCOUNT_NAME, null));
  service =
      new com.google.api.services.tasks.Tasks.Builder(httpTransport, jsonFactory, credential)
          .setApplicationName("Google-TasksAndroidSample/1.0").build();
}

private void chooseAccount() {
  startActivityForResult(credential.newChooseAccountIntent(), REQUEST_ACCOUNT_PICKER);
}

@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
  super.onActivityResult(requestCode, resultCode, data);
  switch (requestCode) {
    case REQUEST_GOOGLE_PLAY_SERVICES:
      if (resultCode == Activity.RESULT_OK) {
        haveGooglePlayServices();
      } else {
        checkGooglePlayServicesAvailable();
      }
      break;
    case REQUEST_AUTHORIZATION:
      if (resultCode == Activity.RESULT_OK) {
        AsyncLoadTasks.run(this);
      } else {
        chooseAccount();
      }
      break;
    case REQUEST_ACCOUNT_PICKER:
      if (resultCode == Activity.RESULT_OK && data != null && data.getExtras() != null) {
        String accountName = data.getExtras().getString(AccountManager.KEY_ACCOUNT_NAME);
        if (accountName != null) {
          credential.setSelectedAccountName(accountName);
          SharedPreferences settings = getPreferences(Context.MODE_PRIVATE);
          SharedPreferences.Editor editor = settings.edit();
          editor.putString(PREF_ACCOUNT_NAME, accountName);
          editor.commit();
          AsyncLoadTasks.run(this);
        }
      }
      break;
  }
}