Anleitung zu ScribeJava

1. Einführung

In diesem Tutorial werden wir uns dieScribeJava-Bibliothek ansehen.

ScribeJava ist ein einfacher OAuth-Client für Java, mit dem der OAuth-Fluss verwaltet werden kann.

Das Hauptmerkmal der Bibliothek ist, dass sie alle wichtigen 1.0- und 2.0-OAuth-APIs ab Werk unterstützt. Wenn wir mit einer API arbeiten müssen, die nicht unterstützt wird, bietet die Bibliothek außerdem einige Klassen für die Implementierung der OAuth-APIs.

Ein weiteres wichtiges Merkmal ist, dass Sie auswählen können, welchen Client Sie verwenden möchten. In der Tat unterstützt ScribeJava mehrere HTTP-Clients:

Darüber hinaus ist die Bibliothek thread-sicher und Java7-kompatibel, sodass wir sie in älteren Umgebungen verwenden können.

2. Abhängigkeiten

ScribeJava is organized into a core and APIs module, letzteres enthält eine Reihe externer APIs (Google, GitHub, Twitter usw.) und das Kernartefakt:


    com.github.scribejava
    scribejava-apis
    latest-version

Wenn wir nur Kernklassen ohne externe API benötigen, müssen wir nur das Kernmodul ziehen:


    com.github.scribejava
    scribejava-core
    latest-version

Die neuesten Versionen finden Sie unterMaven repository.

3. OAuthService

The main part of the library is the abstract class OAuthService, das alle Parameter enthält, die zur korrekten Verwaltung des OAuth-Handshakes erforderlich sind.

Abhängig von der Version des Protokolls verwenden wir fürOAuth 1.0 undOAuth 2.0Oauth10Service bzw.Oauth20Service konkrete Klassen.

Um die Implementierungen vonOAuthService zu erstellen, stellt die BibliothekServiceBuilder: bereit

OAuthService service = new ServiceBuilder("api_key")
  .apiSecret("api_secret")
  .scope("scope")
  .callback("callback")
  .build(GoogleApi20.instance());

Wir sollten die vom Autorisierungsserver bereitgestellten Tokenapi_key undapi_secret setzen.

Außerdem können wir diescope der Anforderung und diecallback festlegen, zu denen der Autorisierungsserver den Benutzer am Ende des Autorisierungsflusses umleiten soll.

Beachten Sie, dass je nach Version des Protokolls nicht alle Parameter obligatorisch sind.

Schließlich müssen wir dieOAuthService erstellen, die diebuild()-Methode aufrufen und ihr eine Instanz der APIs übergeben, die wir verwenden möchten. Eine vollständige Liste der bei ScribeJavaGitHub unterstützten APIs finden Sie.

3.1. HTTP-Client

Darüber hinaus sindthe library allows us to choose which HTTP Client to use:

ServiceBuilder builder = new ServiceBuilder("api_key")
  .httpClient(new OkHttpHttpClient());

Nachdem wir natürlich die erforderlichen Abhängigkeiten für das vorherige Beispiel aufgenommen haben:


    com.github.scribejava
    scribejava-httpclient-okhttp
    latest-version

Die neuesten Versionen finden Sie unterMaven repository.

3.2. Debug-Modus

Zusätzlichthere’s a debug mode we can use to help us troubleshooting:

ServiceBuilder builder = new ServiceBuilder("api_key")
  .debug();

Wir müssen einfach die Methode vondebug()aufrufen. Das Debuggen gibt einige relevante Informationen anSystem.outaus.

Wenn wir eine andere Ausgabe verwenden möchten, gibt es eine andere Methode, dieOutputStream akzeptiert, um die Debugging-Informationen an folgende Adresse zu senden:

FileOutputStream debugFile = new FileOutputStream("debug");

ServiceBuilder builder = new ServiceBuilder("api_key")
  .debug()
  .debugStream(debugFile);

4. OAuth 1.0 Flow

Konzentrieren wir uns nun darauf, wie ein OAuth1-Flow behandelt wird.

In diesem Beispielwe’re going to get an access token with the Twitter APIs and we’ll use it to make a request.

Zunächst müssen wir dieOauth10Service, wie wir zuvor gesehen haben, mit dem Builder erstellen:

OAuth10aService service = new ServiceBuilder("api_key")
  .apiSecret("api_secret")
  .build(TwitterApi.instance());

Sobald wir dasOAuth10Service, we haben, können wir einrequestToken erhalten und es verwenden, um die Autorisierungs-URL zu erhalten:

OAuth1RequestToken requestToken = service.getRequestToken();
String authUrl = service.getAuthorizationUrl(requestToken);

Zu diesem Zeitpunkt ist es erforderlich, den Benutzer zuauthUrl umzuleiten und dieoauthVerifier von der Seite zu erhalten.

Daher verwenden wiroauthVerifier , umaccessToken zu erhalten:

OAuth1AccessToken accessToken = service.getAccessToken(requestToken,oauthVerifier);

Schließlich können wir eine Anforderung mit dem ObjektOAuthRequesterstellen und das Token mit der MethodesignRequest()hinzufügen:

OAuthRequest request = new OAuthRequest(Verb.GET,
    "https://api.twitter.com/1.1/account/verify_credentials.json");
service.signRequest(accessToken, request);

Response response = service.execute(request);

Als Ergebnis der Ausführung diesesrequest erhalten wir einResponse-Objekt.

5. OAuth 2.0 Flow

Der OAuth 2.0-Fluss unterscheidet sich nicht wesentlich von OAuth 1.0. Um diese Variationen zu erklären, wirdwe’re going to get an access token with Google APIs.

Auf die gleiche Weise wie im OAuth 1.0-Flow müssen wir dieOAuthService erstellen und dieauthUrl, abrufen, aber dieses Mal verwenden wir eineOAuth20Service-Instanz:

OAuth20Service service = new ServiceBuilder("api_key")
  .apiSecret("api_secret")
  .scope("https://www.googleapis.com/auth/userinfo.email")
  .callback("http://localhost:8080/auth")
  .build(GoogleApi20.instance());

String authUrl = service.getAuthorizationUrl();

Beachten Sie, dass wir in diesem Fall diescope der Anforderung und diecallback angeben müssen, mit denen wir am Ende des Autorisierungsflusses kontaktiert werden.

Ebenso müssen wir den Benutzer zuauthUrl umleiten und den Parametercode in der URL des Rückrufs übernehmen:

OAuth2AccessToken accessToken = service.getAccessToken(code);

OAuthRequest request = new OAuthRequest(Verb.GET, "https://www.googleapis.com/oauth2/v1/userinfo?alt=json");
service.signRequest(accessToken, request);

Response response = service.execute(request);

Am Ende erhalten wir, umrequest zu machen, die MethodeaccessToken withgetAccessToken().

6. Benutzerdefinierte APIs

Wir müssen wahrscheinlich mit einer API arbeiten, die von ScribeJava nicht unterstützt wird. Unter diesen Umständenthe library allows us to implement our own APIs.

Das einzige, was wir tun müssen, ist eine Implementierung derDefaultApi10- oderDefaultApi20 -Skala bereitzustellen.

Stellen wir uns vor, wir haben einen OAuth 2.0-Autorisierungsserver mit Kennwortgewährung. In diesem Fall können wirDefaultApi20 implementieren, so dass wiraccess token nehmen können:

public class MyApi extends DefaultApi20 {

    public MyApi() {}

    private static class InstanceHolder {
        private static final MyApi INSTANCE = new MyApi();
    }

    public static MyApi instance() {
        return InstanceHolder.INSTANCE;
    }

    @Override
    public String getAccessTokenEndpoint() {
        return "http://localhost:8080/oauth/token";
    }

    @Override
    protected String getAuthorizationBaseUrl() {
        return null;
    }
}

Auf diese Weise können wir auf ähnliche Weise wie zuvor ein Zugriffstoken erhalten:

OAuth20Service service = new ServiceBuilder("example_api_key")
  .apiSecret("example_api_secret")
  .scope("read write")
  .build(MyApi.instance());

OAuth2AccessToken token = service.getAccessTokenPasswordGrant(username, password);

OAuthRequest request = new OAuthRequest(Verb.GET, "http://localhost:8080/me");
service.signRequest(token, request);
Response response = service.execute(request);

7. Fazit

In diesem Artikel haben wir uns die nützlichsten Klassen angesehen, die ScribeJava von der Stange bietet.

Wir haben gelernt, wie man mit OAuth 1.0- und OAuth 2.0-Flows mit externen APIs umgeht. Wir haben auch gelernt, wie die Bibliothek konfiguriert wird, um unsere eigenen APIs zu verwenden.

Wie üblich sind alle in diesem Lernprogramm gezeigten Codebeispieleover on GitHub verfügbar.

TOC

Anleitung zu ScribeJava