streamalism.org

1. Oversigt

I denne artikel skal vi vise, hvordan man gør det fjerne kortlægning af en URL-adresse ved hjælp afHttpClient.

Et simpelt eksempel er hvornår den oprindelige URL er blevet forkortet en gang - af en tjeneste som bit.ly.

Et mere komplekst eksempel er hvornår URL'en er blevet forkortet flere gange, af forskellige sådanne tjenester, og det tager flere gennemløb for at komme til den oprindelige fulde URL.

Hvis du vil grave dybere og lære andre seje ting, kan du gøre med HttpClient - gå videre til den vigtigste HttpClient-tutorial.

2. Afbryd URL'en en gang

Lad os starte simpelt - afskær en URL, der kun er sendt gennem en forkorte URL-tjeneste en gang.

Den første ting, vi har brug for, er en http-klient, der følger ikke automatisk omdirigeringer:

CloseableHttpClient client = HttpClientBuilder.create (). DisableRedirectHandling (). Build ();

Dette er nødvendigt, fordi vi bliver nødt til manuelt at opfange omdirigeringssvaret og udtrække oplysninger ud af det.

Vi starter med at sende en anmodning til den forkortede URL - svaret vi får tilbage vil være et 301 Flyttet permanent.

Så skal vi udtræk Beliggenhed header peger på den næste, og i dette tilfælde - endelig URL:

offentlig String expandSingleLevel (String url) kaster IOException {HttpHead anmodning = null; prøv {anmodning = ny HttpHead (url); HttpResponse httpResponse = client.execute (anmodning); int statusCode = httpResponse.getStatusLine (). getStatusCode (); hvis (statusCode! = 301 && statusCode! = 302) {return url; } Overskrift [] overskrifter = httpResponse.getHeaders (HttpHeaders.LOCATION); Forudsætninger. CheckState (headers.length == 1); Streng newUrl = overskrifter [0] .getValue (); returner newUrl; } fange (IllegalArgumentException uriEx) {return url; } endelig {if (anmodning! = null) {anmodning.releaseConnection (); }}}

Endelig en simpel live test, der udvider en URL:

@Test offentlig ugyldighed givenShortenedOnce_whenUrlIsUnshortened_thenCorrectResult () kaster IOException {String expectResult = "/ rest-versioning"; String actualResult = expandSingleLevel ("// bit.ly/13jEoS1"); assertThat (actualResult, equalTo (expectResult)); }

3. Behandl flere URL-niveauer

Problemet med korte webadresser er, at de kan være forkortet flere gange, ved helt forskellige tjenester. Udvidelse af en sådan URL skal have flere passeringer for at komme til den oprindelige URL.

Vi anvender expandSingleLevel primitiv operation defineret tidligere til simpelthen gentage gennem al den mellemliggende URL og komme til det endelige mål:

public String expand (String urlArg) throw IOException {String originalUrl = urlArg; String newUrl = expandSingleLevel (originalUrl); mens (! originalUrl.equals (newUrl)) {originalUrl = newUrl; newUrl = expandSingleLevel (originalUrl); } returner newUrl; }

Nu, med den nye mekanisme til udvidelse af flere niveauer af URL'er, lad os definere en test og sætte den i gang:

@Test offentlig ugyldighed givenShortenedMultiple_whenUrlIsUnshortened_thenCorrectResult () kaster IOException {String expectResult = "/ rest-versioning"; String actualResult = udvid ("// t.co/e4rDDbnzmk"); assertThat (actualResult, equalTo (expectResult)); }

Denne gang er den korte URL - //t.co/e4rDDbnzmk - som faktisk forkortes to gange - en gang via bit.ly og en anden gang via t.co service - udvides korrekt til den oprindelige URL.

4. Registrer på omdirigeringssløjfer

Endelig kan nogle webadresser ikke udvides, fordi de danner en omdirigeringssløjfe. Denne type problemer vil blive opdaget af HttpClient, men da vi slukkede for den automatiske følge af omdirigeringer, gør det ikke længere.

Det sidste trin i URL-udvidelsesmekanismen vil være at opdage omdirigeringssløjferne og mislykkes hurtigt, hvis en sådan løkke opstår.

For at dette skal være effektivt, har vi brug for yderligere oplysninger ud af expandSingleLevel metode, vi definerede tidligere - hovedsageligt skal vi også returnere statuskoden for svaret sammen med URL'en.

Da java ikke understøtter flere returværdier, skal vi pakk informationen ind i en org.apache.commons.lang3.tuple.Pair objekt - den nye signatur af metoden bliver nu:

public Pair expandSingleLevelSafe (String url) kaster IOException {

Og endelig, lad os inkludere omdirigeringscyklusdetektering i hovedudvidelsesmekanismen:

offentlig String expandSafe (String urlArg) kaster IOException {String originalUrl = urlArg; String newUrl = expandSingleLevelSafe (originalUrl) .getRight (); List alreadyVisited = Lists.newArrayList (originalUrl, newUrl); mens (! originalUrl.equals (newUrl)) {originalUrl = newUrl; Par statusAndUrl = expandSingleLevelSafe (originalUrl); newUrl = statusAndUrl.getRight (); boolsk isRedirect = statusAndUrl.getLeft () == 301 || statusAndUrl.getLeft () == 302; if (isRedirect && alreadyVisited.contains (newUrl)) {throw new IllegalStateException ("Sandsynligvis en omdirigeringssløjfe"); } alreadyVisited.add (newUrl); } returner newUrl; }

Og det er det - den udvid sikker mekanisme er i stand til at afkorte URL, der går gennem et vilkårligt antal URL-afkortningstjenester, mens det korrekt fejler hurtigt på omdirigeringssløjfer.

5. Konklusion

Denne vejledning diskuterede, hvordan man gør udvid korte webadresser i java - ved hjælp af Apache HttpClient.

Vi startede med en simpel usecase med en URL, der kun forkortes en gang, og implementerede derefter en mere generisk mekanisme, der er i stand til at håndtere flere niveauer af omdirigeringer og registrere omdirigeringssløjfer i processen.

Implementeringen af ​​disse eksempler findes i github-projektet - dette er et Eclipse-baseret projekt, så det skal være let at importere og køre som det er.