Guida a ScribeJava

1. Introduzione

In questo tutorial, esamineremo la libreria ScribeJava.

ScribeJava è un semplice client OAuth per Java che aiuta a gestire il flusso OAuth.

La caratteristica principale della libreria è che supporta tutte le principali API OAuth 1.0 e 2.0 out-of-the-box. Inoltre, se dovremo lavorare con un'API non supportata, la libreria fornisce un paio di classi per implementare le nostre API di OAuth.

Un'altra caratteristica importante è che è possibile scegliere quale client utilizzare. Infatti, ScribeJava supporta diversi client HTTP:

  • Client Http asincrono
  • OkHttp
  • Apache HttpComponents HttpClient

Inoltre, la libreria è thread-safe e compatibile con Java7, quindi possiamo usarla in ambienti legacy.

2. Dipendenze

ScribeJava è organizzato in un modulo core e API , quest'ultimo include un set di API esterne (Google, GitHub, Twitter, ecc.) E l'artefatto principale:

 com.github.scribejava scribejava-apis latest-version 

Nel caso in cui abbiamo bisogno solo di classi core senza alcuna API esterna, dobbiamo estrarre solo il modulo principale:

 com.github.scribejava scribejava-core latest-version 

Le versioni più recenti possono essere trovate nel repository Maven.

3. OAuthService

La parte principale della libreria è la classe astratta OAuthService che contiene tutti i parametri necessari per gestire correttamente l'handshake di OAuth.

A seconda della versione del protocollo, utilizzeremo le classi concrete Oauth10Service o Oauth20Service rispettivamente per OAuth 1.0 e OAuth 2.0.

Per creare le implementazioni di OAuthService , la libreria fornisce un ServiceBuilder:

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

Dovremmo impostare i token api_key e api_secret forniti dal server di autorizzazione.

Inoltre, possiamo impostare l' ambito della richiesta e il callback a cui il server di autorizzazione deve reindirizzare l'utente alla fine del flusso di autorizzazione.

Notare che a seconda della versione del protocollo non tutti i parametri sono obbligatori.

Infine, dobbiamo creare OAuthService chiamando il metodo build () e passandogli un'istanza delle API che vogliamo utilizzare. Possiamo trovare un elenco completo delle API supportate su ScribeJava GitHub.

3.1. Client HTTP

Inoltre, la libreria ci permette di scegliere quale client HTTP utilizzare:

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

Dopo, ovviamente, abbiamo incluso le dipendenze richieste, per l'esempio precedente:

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

Le versioni più recenti possono essere trovate nel repository Maven.

3.2. Modalità di debug

Inoltre, c'è una modalità di debug che possiamo utilizzare per aiutarci a risolvere i problemi:

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

Dobbiamo semplicemente chiamare il metodo debug () . Il debug restituirà a System.out alcune informazioni rilevanti.

Inoltre, se vogliamo utilizzare un output diverso, esiste un altro metodo che accetta un OutputStream per inviare le informazioni di debug a:

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

4. Flusso OAuth 1.0

Ora concentriamoci su come gestire un flusso OAuth1.

In questo esempio, otterremo un token di accesso con le API di Twitter e lo useremo per effettuare una richiesta.

Prima di tutto, dobbiamo costruire Oauth10Service , come abbiamo visto in precedenza, utilizzando builder:

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

Una volta che abbiamo OAuth10Service, possiamo ottenere un requestToken e utilizzarlo per ottenere l'URL di autorizzazione:

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

A questo punto è necessario reindirizzare l'utente ad authUrl e ottenere il oauthVerifier fornito dalla pagina.

Quindi, usiamo oauthVerifier per ottenere accessToken :

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

Infine, possiamo creare una richiesta utilizzando l' oggetto OAuthRequest e aggiungervi il token con il metodo signRequest () :

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

Come risultato dell'esecuzione di quella richiesta , otteniamo un oggetto Response .

5. Flusso OAuth 2.0

Il flusso OAuth 2.0 non è molto diverso da OAuth 1.0. Per spiegare queste variazioni, otterremo un token di accesso con le API di Google.

Allo stesso modo, abbiamo fatto nel flusso OAuth 1.0, dobbiamo creare OAuthService e ottenere authUrl , ma questa volta useremo un'istanza OAuth20Service :

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

Tieni presente che, in questo caso, dobbiamo fornire l' ambito della richiesta e la richiamata alla quale saremo contattati al termine del flusso di autorizzazione.

Allo stesso modo, dobbiamo reindirizzare l'utente ad authUrl e prendere il parametro code nell'URL del callback:

OAuth2AccessToken accessToken = service.getAccessToken(code); OAuthRequest request = new OAuthRequest(Verb.GET, "//www.googleapis.com/oauth2/v1/userinfo?alt=json"); service.signRequest(accessToken, request); Response response = service.execute(request);

Alla fine, per effettuare la richiesta , otteniamo accessToken con il metodo getAccessToken () .

6. API personalizzate

Probabilmente dovremo lavorare con un'API non supportata da ScribeJava. In queste circostanze, la libreria ci consente di implementare le nostre API .

L'unica cosa che dobbiamo fare è fornire un'implementazione della classe DefaultApi10 o DefaultApi20 .

Immaginiamo di avere un server di autorizzazione OAuth 2.0 con concessione della password. In questo caso, possiamo implementare DefaultApi20 in modo da poter prendere un token di accesso :

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 "//localhost:8080/oauth/token"; } @Override protected String getAuthorizationBaseUrl() { return null; } }

Pertanto, possiamo ottenere un token di accesso in modo simile a come abbiamo fatto prima:

OAuth20Service service = new ServiceBuilder("baeldung_api_key") .apiSecret("baeldung_api_secret") .scope("read write") .build(MyApi.instance()); OAuth2AccessToken token = service.getAccessTokenPasswordGrant(username, password); OAuthRequest request = new OAuthRequest(Verb.GET, "//localhost:8080/me"); service.signRequest(token, request); Response response = service.execute(request);

7. Conclusione

In questo articolo, abbiamo esaminato le classi più utili fornite da ScribeJava.

Abbiamo imparato a gestire i flussi OAuth 1.0 e OAuth 2.0 con API esterne. Abbiamo anche imparato a configurare la libreria per utilizzare le nostre API.

Come al solito, tutti gli esempi di codice mostrati in questo tutorial sono disponibili su GitHub.