streamalism.org

Indholdsfortegnelse

• 1. Oversigt
• 2. Opsætning af RestTemplate om foråret
• 3. Manuel styring af HTTP-header for autorisation
• 4. Automatisk styring af HTTP-header for autorisation
• 5. Maven afhængigheder
• 6. Konklusion

1. Oversigt

Denne artikel viser, hvordan du bruger fjedre RestTemplate til forbruge en RESTful service sikret med grundlæggende godkendelse.

Når grundlæggende godkendelse er konfigureret til skabelonen, sendes hver anmodning forebyggende indeholdende de fulde legitimationsoplysninger nødvendigt for at udføre godkendelsesprocessen. Legitimationsoplysningerne vil blive kodet og vil bruge Bemyndigelse HTTP-header, i overensstemmelse med specifikationerne i Basic Authentication-ordningen. Et eksempel vil se sådan ud:

Autorisation: Grundlæggende QWxhZGRpbjpvcGVuIHNlc2FtZQ ==

2. Opsætning af RestTemplate

Bootstrapping af RestTemplate i forårssammenhæng kan man gøre ved blot at erklære en bønne for den; dog opsætning af RestTemplate med Grundlæggende godkendelse vil kræve manuel indgriben, så i stedet for at erklære bønnen direkte, en fjeder FactoryBean vil blive brugt til mere fleksibilitet. Denne fabrik opretter og konfigurerer skabelonen ved initialisering:

@Komponent offentlig klasse RestTemplateFactory implementerer FactoryBean, InitializingBean {privat RestTemplate restTemplate; offentlig RestTemplate getObject () {return restTemplate; } offentlig klasse getObjectType () {return RestTemplate.class; } public boolean isSingleton () {return true; } offentlig ugyldighed afterPropertiesSet () {HttpHost vært = ny HttpHost ("localhost", 8082, "http"); restTemplate = ny RestTemplate (ny HttpComponentsClientHttpRequestFactoryBasicAuth (vært)); }}

Det vært og Havn værdier skal være afhængige af miljøet - hvilket giver klienten fleksibilitet til at definere et sæt værdier til integrationstest og et andet til produktionsbrug. Værdierne kan styres af den første klasse Spring support til egenskabsfiler.

3. Manuel styring af HTTP-header for godkendelse

Processen med at skabe Bemyndigelse header er relativt ligetil for grundlæggende godkendelse, så det kan stort set gøres manuelt med et par kodelinjer:

HttpHeaders createHeaders (String brugernavn, String password) {returner nye HttpHeaders () {{String auth = username + ":" + password; byte [] encodedAuth = Base64.encodeBase64 (auth.getBytes (Charset.forName ("US-ASCII"))); String authHeader = "Grundlæggende" + ny streng (kodetAuth); sæt ("Autorisation", authHeader); }}; }

Derefter bliver afsendelse af en anmodning lige så enkel:

restTemplate.exchange (uri, HttpMethod.POST, ny HttpEntity (createHeaders (brugernavn, adgangskode)), clazz);

4. Automatisk styring af HTTP-header for godkendelse

Både Spring 3.0 og 3.1 og nu 4.x har meget god support til Apache HTTP-bibliotekerne:

• Spring 3.0, den CommonsClientHttpRequestFactory integreret med nuet livets slutningHttpClient 3.x
• Forår 3.1 indførte støtte til strømmen HttpClient 4.x via HttpComponentsClientHttpRequestFactory (support tilføjet i JIRA SPR-6180)
• Spring 4.0 introducerede async-support via HttpComponentsAsyncClientHttpRequestFactory

Lad os begynde at indstille tingene med HttpClient 4 og Spring 4.

Det RestTemplate kræver en HTTP-anmodningsfabrik - en fabrik, der understøtter grundlæggende godkendelse - indtil videre så god. Brug dog det eksisterende HttpComponentsClientHttpRequestFactory direkte vil vise sig at være vanskeligt, som arkitekturen i RestTemplate blev designet uden god støtte til HttpContext - et instrumentalt stykke af puslespillet. Og så bliver vi nødt til at underklasse HttpComponentsClientHttpRequestFactory og tilsidesætte createHttpContext metode:

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

Det er her - i skabelsen af HttpContext - at den grundlæggende godkendelsesstøtte er indbygget. Som du kan se, er det lidt af en byrde at gøre forebyggende grundlæggende godkendelse med HttpClient 4.x: godkendelsesinformationen er cache, og processen med at opsætte denne godkendelsescache er meget manuel og uintuitiv .

Og med det er alt på plads - RestTemplate vil nu være i stand til at understøtte Basic Authentication-ordningen bare ved at tilføje en BasicAuthorizationInterceptor;

restTemplate.getInterceptors (). tilføj (ny BasicAuthorizationInterceptor ("brugernavn", "adgangskode"));

Og anmodningen:

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

For en grundig diskussion om, hvordan du sikrer REST-tjenesten selv, skal du tjekke denne artikel.

5. Maven-afhængigheder

Følgende Maven-afhængigheder er nødvendige for RestTemplate sig selv og for HttpClient-biblioteket:

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

Eventuelt, hvis HTTP Bemyndigelse header er konstrueret manuelt, derefter kræves et ekstra bibliotek til kodningsunderstøttelsen:

 commons-codec commons-codec 1.10 

Du finder de nyeste versioner i Maven-arkivet.

6. Konklusion

Selvom 3.x-udviklingsgrenen for Apache HttpClient har nået slutningen af ​​livet i et stykke tid nu, og Spring-understøttelsen til den version er fuldstændig forældet, er meget af den information, der findes RestTemplate og sikkerhed tager stadig ikke højde for den aktuelle HttpClient 4.x udgivelser. Denne artikel er et forsøg på at ændre det gennem en detaljeret, trin for trin diskussion om, hvordan du opretter grundlæggende godkendelse med RestTemplate og hvordan man bruger det til at forbruge en sikret REST API.

For at gå ud over kodeeksemplerne i artiklen med implementeringen af ​​både den forbrugende side, der er undersøgt her, men også den faktiske RESTful Service, skal du se på projektet på Github.

Dette er et Maven-baseret projekt, så det skal være let at importere og køre som det er.