streamalism.org

1. Oversikt

I denne artikkelen skal vi vise hvordan unshorten en URL-er ved hjelp avHttpClient.

Et enkelt eksempel er når den opprinnelige URL-en er forkortet en gang - av en tjeneste som bit.ly.

Et mer komplekst eksempel er når URL-en er forkortet flere ganger, av forskjellige slike tjenester, og det tar flere passeringer å komme til den opprinnelige fullstendige URL-en.

Hvis du vil grave dypere og lære andre kule ting du kan gjøre med HttpClient - gå videre til den viktigste HttpClient-opplæringen.

2. Fjern URLen en gang

La oss begynne enkelt - fjerne en URL som bare har blitt sendt gjennom en forkorte URL-tjeneste en gang.

Det første vi trenger er en http-klient det følger ikke automatisk viderekoblinger:

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

Dette er nødvendig fordi vi må avlytte omdirigeringsresponsen manuelt og trekke ut informasjon ut av den.

Vi starter med å sende en forespørsel til den forkortede URL-en - svaret vi får tilbake vil være et 301 Flyttet permanent.

Så må vi trekke ut plassering Overskrift peker til neste, og i dette tilfellet - endelig URL:

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

Til slutt, en enkel live test som utvider en URL:

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

3. Behandle flere URL-nivåer

Problemet med korte nettadresser er at de kan være det forkortet flere ganger, av helt forskjellige tjenester. Å utvide en slik URL vil trenge flere passeringer for å komme til den opprinnelige URL-en.

Vi skal bruke utvideSingleLevel primitiv operasjon definert tidligere til ganske enkelt iterere gjennom all mellomliggende URL og komme til det endelige målet:

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

Nå, med den nye mekanismen for å utvide flere nivåer av nettadresser, la oss definere en test og sette denne i gang:

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

Denne gangen, den korte nettadressen - //t.co/e4rDDbnzmk - som faktisk forkortes to ganger - en gang via bit.ly og en gang til via t.co tjeneste - er riktig utvidet til den opprinnelige URL-en.

4. Oppdag på omdirigeringsløkker

Til slutt kan noen nettadresser ikke utvides fordi de danner en viderekoblingssløyfe. Denne typen problemer vil bli oppdaget av HttpClient, men siden vi har slått av automatisk videreføring av viderekoblinger, gjør det ikke lenger.

Det siste trinnet i URL-utvidelsesmekanismen vil være å oppdage viderekoblingssløyfene og mislykkes raskt i tilfelle en slik løkke oppstår.

For at dette skal være effektivt, trenger vi litt tilleggsinformasjon fra utvideSingleLevel metoden vi definerte tidligere - hovedsakelig må vi også returnere statuskoden til svaret sammen med URL-en.

Siden java ikke støtter flere returverdier, skal vi pakk informasjonen inn i en org.apache.commons.lang3.tuple.Pair gjenstand - den nye signaturen til metoden vil nå være:

public Pair expandSingleLevelSafe (String url) kaster IOException {

Og til slutt, la oss inkludere omdirigeringssyklusdeteksjonen i hovedutvidelsesmekanismen:

offentlig String expandSafe (String urlArg) kaster IOException {String originalUrl = urlArg; Streng newUrl = expandSingleLevelSafe (originalUrl) .getRight (); List alreadyVisited = Lists.newArrayList (originalUrl, newUrl); mens (! originalUrl.equals (newUrl)) {originalUrl = newUrl; Pair statusAndUrl = expandSingleLevelSafe (originalUrl); newUrl = statusAndUrl.getRight (); boolsk isRedirect = statusAndUrl.getLeft () == 301 || statusAndUrl.getLeft () == 302; if (isRedirect && alreadyVisited.contains (newUrl)) {kast ny IllegalStateException ("Sannsynligvis en viderekoblingssløyfe"); } alreadyVisited.add (newUrl); } returner newUrl; }

Og det er det - den expandSafe mekanismen er i stand til å unshorten URL går gjennom et vilkårlig antall URL forkortelse tjenester, mens riktig mislykkes raskt på omdirigere sløyfer.

5. Konklusjon

Denne opplæringen diskuterte hvordan utvide korte nettadresser i java - bruker Apache HttpClient.

Vi startet med en enkel brukstilfelle med en URL som bare forkortes en gang, og implementerte deretter en mer generell mekanisme som er i stand til å håndtere flere nivåer av viderekoblinger og oppdage omdirigeringsløkker i prosessen.

Implementeringen av disse eksemplene finnes i github-prosjektet - dette er et formørkelsesbasert prosjekt, så det skal være enkelt å importere og kjøre som det er.