streamalism.org

Innholdsfortegnelse

• 1. Oversikt
• 2. Sette opp RestTemplate på våren
• 3. Manuell styring av HTTP-header for autorisasjon
• 4. Automatisk styring av HTTP-header for autorisasjon
• 5. Maven avhengigheter
• 6. Konklusjon

1. Oversikt

Denne artikkelen viser hvordan du bruker Springs RestTemplate til konsumere en RESTful-tjeneste som er sikret med grunnleggende godkjenning.

Når grunnleggende godkjenning er satt opp for malen, blir hver forespørsel sendt preemptively inneholder fullstendig legitimasjon nødvendig for å utføre godkjenningsprosessen. Påloggingsinformasjonen vil bli kodet og vil bruke Autorisasjon HTTP Header, i samsvar med spesifikasjonene til Basic Authentication-ordningen. Et eksempel vil se slik ut:

Autorisasjon: Grunnleggende QWxhZGRpbjpvcGVuIHNlc2FtZQ ==

2. Sette opp RestTemplate

Bootstrapping av RestTemplate inn i vårkonteksten kan gjøres ved ganske enkelt å erklære en bønne for den; imidlertid sette opp RestTemplate med Grunnleggende godkjenning vil kreve manuell inngrep, så i stedet for å erklære bønnen direkte, en vår FactoryBean vil bli brukt for mer fleksibilitet. Denne fabrikken oppretter og konfigurerer malen ved initialisering:

@Komponent offentlig klasse RestTemplateFactory implementerer FactoryBean, InitializingBean {privat RestTemplate restTemplate; offentlig RestTemplate getObject () {return restTemplate; } offentlig klasse getObjectType () {return RestTemplate.class; } offentlig boolsk isSingleton () {return true; } offentlig tomrom etterPropertiesSet () {HttpHost vert = ny HttpHost ("localhost", 8082, "http"); restTemplate = ny RestTemplate (ny HttpComponentsClientHttpRequestFactoryBasicAuth (vert)); }}

De vert og havn verdier skal være avhengig av miljøet - slik at klienten får fleksibilitet til å definere ett sett verdier for integrasjonstesting og et annet for produksjonsbruk. Verdiene kan administreres av førsteklasses vårstøtte for eiendomsfiler.

3. Manuell styring av HTTP-header for autorisasjon

Prosessen med å skape Autorisasjon header er relativt grei for grunnleggende godkjenning, så det kan stort sett gjøres manuelt med noen få kodelinjer:

HttpHeaders createHeaders (String brukernavn, String passord) {return new HttpHeaders () {{String auth = username + ":" + password; byte [] encodedAuth = Base64.encodeBase64 (auth.getBytes (Charset.forName ("US-ASCII"))); String authHeader = "Basic" + new String (encodedAuth); sett ("Autorisasjon", authHeader); }}; }

Da blir det like enkelt å sende en forespørsel:

restTemplate.exchange (uri, HttpMethod.POST, ny HttpEntity (createHeaders (brukernavn, passord)), clazz);

4. Automatisk styring av HTTP-header for autorisasjon

Både Spring 3.0 og 3.1 og nå 4.x har veldig god støtte for Apache HTTP-bibliotekene:

• Våren 3.0, den CommonsClientHttpRequestFactory integrert med det nå livets sluttHttpClient 3.x
• Våren 3.1 introduserte støtte for strømmen HttpClient 4.x via HttpComponentsClientHttpRequestFactory (støtte lagt til i JIRA SPR-6180)
• Våren 4.0 introduserte async-støtte via HttpComponentsAsyncClientHttpRequestFactory

La oss begynne å sette opp ting med HttpClient 4 og Spring 4.

De RestTemplate vil kreve en HTTP-forespørselfabrikk - en fabrikk som støtter grunnleggende godkjenning - så langt, så bra. Imidlertid bruker du den eksisterende HttpComponentsClientHttpRequestFactory direkte vil vise seg å være vanskelig, slik arkitekturen til RestTemplate ble designet uten god støtte for HttpContext - et instrumentalt stykke av puslespillet. Og så må vi underklasse HttpComponentsClientHttpRequestFactory og overstyre createHttpContext metode:

offentlig klasse HttpComponentsClientHttpRequestFactoryBasicAuth utvider HttpComponentsClientHttpRequestFactory {HttpHost vert; public HttpComponentsClientHttpRequestFactoryBasicAuth (HttpHost host) {super (); this.host = vert; } beskyttet HttpContext createHttpContext (HttpMethod httpMethod, URI uri) {return createHttpContext (); } privat HttpContext createHttpContext () {AuthCache authCache = ny BasicAuthCache (); BasicScheme basicAuth = ny BasicScheme (); authCache.put (vert, basicAuth); BasicHttpContext localcontext = ny BasicHttpContext (); localcontext.setAttribute (HttpClientContext.AUTH_CACHE, authCache); returner lokalkontekst; }}

Det er her - i opprettelsen av HttpContext - at den grunnleggende autentiseringsstøtten er innebygd. Som du kan se, er det å gjøre forebyggende grunnleggende autentisering med HttpClient 4.x litt av en belastning: autentiseringsinformasjonen er hurtigbufret og prosessen med å sette opp denne autentiseringsbufferen er veldig manuell og uintuitiv .

Og med det er alt på plass - RestTemplate vil nå kunne støtte ordningen for grunnleggende godkjenning bare ved å legge til en BasicAuthorizationInterceptor;

restTemplate.getInterceptors (). legg til (ny BasicAuthorizationInterceptor ("brukernavn", "passord"));

Og forespørselen:

restTemplate.exchange ("// localhost: 8082 / spring-security-rest-basic-auth / api / foos / 1", HttpMethod.GET, null, Foo.class);

For en grundig diskusjon om hvordan du kan sikre REST-tjenesten selv, sjekk ut denne artikkelen.

5. Maven-avhengigheter

Følgende Maven-avhengigheter kreves for RestTemplate seg selv og for HttpClient-biblioteket:

 org.springframework spring-webmvc 5.0.6.RELEASE org.apache.httpcomponents httpclient 4.5.3 

Eventuelt hvis HTTP Autorisasjon topptekst er konstruert manuelt, og det kreves et ekstra bibliotek for kodingsstøtten:

 commons-codec commons-codec 1.10 

Du finner de nyeste versjonene i Maven-arkivet.

6. Konklusjon

Selv om 3.x-utviklingsgrenen for Apache HttpClient har nådd slutten av livet en stund nå, og vårstøtten for den versjonen er fullstendig avviklet, er mye av informasjonen som finnes på RestTemplate og sikkerhet står fortsatt ikke for gjeldende HttpClient 4.x utgivelser. Denne artikkelen er et forsøk på å endre det gjennom en detaljert, trinnvis diskusjon om hvordan du setter opp grunnleggende autentisering med RestTemplate og hvordan du bruker den til å konsumere en sikret REST API.

For å gå utover kodeeksemplene i artikkelen med implementeringen av både den forbrukende siden, undersøkt her, men også den faktiske RESTful Service, se på prosjektet på Github.

Dette er et Maven-basert prosjekt, så det skal være enkelt å importere og kjøre som det er.