streamalism.org

1. Overzicht

In dit artikel laten we zien hoe kort een URL af metHttpClient.

Een eenvoudig voorbeeld is wanneer de oorspronkelijke URL is één keer ingekort - door een dienst zoals bit.ly.

Een complexer voorbeeld is wanneer de URL is meerdere keren ingekort, door verschillende van dergelijke services, en er zijn meerdere passen nodig om naar de originele volledige URL te gaan.

Als je dieper wilt graven en andere coole dingen wilt leren die je kunt doen met de HttpClient - ga dan naar de belangrijkste HttpClient-zelfstudie.

2. Maak de verkorting van de URL een keer ongedaan

Laten we eenvoudig beginnen: een URL ongedaan maken die maar één keer is doorgegeven via een service voor het verkorten van URL's.

Het eerste dat we nodig hebben, is een http-client die volgt niet automatisch omleidingen:

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

Dit is nodig omdat we de omleidingsreactie handmatig moeten onderscheppen en er informatie uit moeten halen.

We beginnen met het verzenden van een verzoek naar de verkorte URL - het antwoord dat we terugkrijgen is een 301 is permanent verhuist.

Dan moeten we pak het Plaats koptekst wijzend naar de volgende, en in dit geval - uiteindelijke URL:

public String expandSingleLevel (String url) gooit IOException {HttpHead request = null; probeer {request = new HttpHead (url); HttpResponse httpResponse = client.execute (verzoek); int statusCode = httpResponse.getStatusLine (). getStatusCode (); if (statusCode! = 301 && statusCode! = 302) {return url; } Header [] headers = httpResponse.getHeaders (HttpHeaders.LOCATION); Preconditions.checkState (headers.length == 1); String newUrl = headers [0] .getValue (); retourneer newUrl; } catch (IllegalArgumentException uriEx) {return url; } eindelijk {if (request! = null) {request.releaseConnection (); }}}

Eindelijk een eenvoudige live test waarbij een URL wordt uitgebreid:

@Test openbare ongeldig gegevenShortenedOnce_whenUrlIsUnshortened_thenCorrectResult () gooit IOException {String verwachtResult = "/ rest-versioning"; String actualResult = expandSingleLevel ("// bit.ly/13jEoS1"); assertThat (actualResult, gelijk aan (verwachtResultaat)); }

3. Verwerk meerdere URL-niveaus

Het probleem met korte URL's is dat ze dat wel kunnen zijn meerdere keren ingekort, door totaal verschillende diensten. Voor het uitbreiden van een dergelijke URL zijn meerdere doorgangen nodig om bij de oorspronkelijke URL te komen.

We gaan de expandSingleLevel primitieve bewerking die eerder is gedefinieerd om eenvoudig doorloop alle tussenliggende URL's en bereik het uiteindelijke doel:

public String expand (String urlArg) genereert IOException {String originalUrl = urlArg; String newUrl = expandSingleLevel (originalUrl); while (! originalUrl.equals (newUrl)) {originalUrl = newUrl; newUrl = expandSingleLevel (originalUrl); } return newUrl; }

Nu, met het nieuwe mechanisme om meerdere URL-niveaus uit te breiden, laten we een test definiëren en dit aan het werk zetten:

@Test openbare leegte gegevenShortenedMultiple_whenUrlIsUnshortened_thenCorrectResult () gooit IOException {String verwachtResult = "/ rest-versioning"; String actualResult = expand ("// t.co/e4rDDbnzmk"); assertThat (actualResult, gelijk aan (verwachtResultaat)); }

Deze keer is de korte URL - //t.co/e4rDDbnzmk - dat eigenlijk twee keer wordt ingekort - eenmaal via bit.ly en een tweede keer via de t.co service - is correct uitgebreid naar de originele URL.

4. Detecteer op omleidingslussen

Ten slotte kunnen sommige URL's niet worden uitgebreid omdat ze een omleidingslus vormen. Dit type probleem wordt gedetecteerd door het HttpClient, maar aangezien we het automatisch volgen van omleidingen hebben uitgeschakeld, doet het dat niet meer.

De laatste stap in het URL-uitbreidingsmechanisme is het detecteren van de omleidingslussen en het snel mislukken voor het geval een dergelijke lus zich voordoet.

Om dit effectief te laten zijn, hebben we wat aanvullende informatie nodig uit de expandSingleLevel methode die we eerder hebben gedefinieerd - voornamelijk, we moeten ook de statuscode van het antwoord samen met de URL retourneren.

Omdat java meerdere retourwaarden niet ondersteunt, gaan we dat doen verpak de informatie in een org.apache.commons.lang3.tuple.Pair voorwerp - de nieuwe handtekening van de methode zal nu zijn:

public Pair expandSingleLevelSafe (String url) genereert IOException {

En tot slot, laten we de omleidingscyclusdetectie opnemen in het belangrijkste uitbreidingsmechanisme:

public String expandSafe (String urlArg) gooit IOException {String originalUrl = urlArg; String newUrl = expandSingleLevelSafe (originalUrl) .getRight (); Lijst alVisited = Lists.newArrayList (originalUrl, newUrl); while (! originalUrl.equals (newUrl)) {originalUrl = newUrl; Paar statusAndUrl = expandSingleLevelSafe (originalUrl); newUrl = statusAndUrl.getRight (); boolean isRedirect = statusAndUrl.getLeft () == 301 || statusAndUrl.getLeft () == 302; if (isRedirect && alVisited.contains (newUrl)) {throw new IllegalStateException ("Waarschijnlijk een omleidingslus"); } alVisited.add (newUrl); } return newUrl; }

En dat is het - de expandSafe mechanisme is in staat om URL's ongedaan te maken die door een willekeurig aantal URL-verkortingsservices gaan, terwijl het correct snel faalt bij omleidingslussen.

5. Conclusie

In deze tutorial werd besproken hoe vouw korte URL's uit in java - met behulp van de Apache HttpClient.

We zijn begonnen met een eenvoudige usecase met een URL die slechts één keer wordt ingekort, en hebben vervolgens een meer generiek mechanisme geïmplementeerd dat in staat is om meerdere niveaus van omleidingen te verwerken en omleidingslussen in het proces te detecteren.

De implementatie van deze voorbeelden is te vinden in het github-project - dit is een op Eclipse gebaseerd project, dus het zou gemakkelijk moeten kunnen worden geïmporteerd en uitgevoerd zoals het is.