Göra en förfrågan med HttpClient

4.1 Metoden send(), BodyHandlers

Du har lärt dig färdigt hur du skapar en http-förfrågan , så du kan gå vidare till det viktigaste - att skicka denna förfrågan. I det enklaste fallet är detta lätt att göra:

HttpRequest request = HttpRequest.newBuilder(new URI("https://codegym.cc")).build();

   HttpClient client = HttpClient.newBuilder()
        .version(Version.HTTP_1_1)
        .build();

   HttpResponse<String> response = client.send(request, BodyHandlers.ofString());
   System.out.println(response.statusCode() );
   System.out.println(response.body() );

Och vad är BodyHandlersdessa? Vad tror du? Du skickade en förfrågan, vilket innebär att du ska få ett svar - http response. Och det här svaret kan ha response body: en sträng, en fil, en array av byte, en InputStream.

Ja, ja, det stämmer. Precis som när du skapar en begäran måste du ange typen response bodyav svar. Det kan vara 8 stycken totalt:

• BodyHandlers.ofByteArray
• BodyHandlers.ofString
• BodyHandlers.ofFile
• BodyHandlers.discarding
• BodyHandlers.replacing
• BodyHandlers.ofLines
• BodyHandlers.fromLineSubscriber

Beroende på vilken typ BodyHandlersdu skickade till metoden send()kommer den att returnera en sådan resultattyp. Exempel:

// response body is ignored
HttpResponse<Void> response = client.send(request, BodyHandlers.discarding());

// response body is a string
 HttpResponse<String>response = client.send(request, BodyHandlers.ofString());

// response body is a file
HttpResponse<Path> response = client.send(request, BodyHandlers.ofFile(Paths.get("readme.txt")));

// response body is an InputStream
HttpResponse<InputStream> response = client.send(request, BodyHandlers.ofInputStream());

Om en fil ska skickas till dig som ett svar, BodyHandlers.ofFile()måste du skicka namnet på den lokala filen till metoden, där den kommer att sparas av HttpClient-objektet.

4.2 metoden followRedirects().

301När du skickar en förfrågan kan du också ange vad HttpClient ska göra om servern skickar eller 302(tillfällig eller permanent omdirigering) som svar . Föreställ dig att servern har skickat en kod 302och du måste: spåra denna situation, få en ny URL från svaret och skicka förfrågan till den nya adressen.

Jag skulle inte vilja göra det här, speciellt med tanke på att den här situationen är vanlig och länge har automatiserats i alla http-klienter. Även i denna HttpClient behöver du bara ange vilket omdirigeringsläge du väljer när du skickar förfrågan.

HttpResponse response = HttpClient.newBuilder()
  .followRedirects( HttpClient.Redirect.ALWAYS )
  .build()
  .send(request, BodyHandlers.ofString());

Det finns bara tre alternativ för en omdirigering:

• ALLTID - alltid;
• ALDRIG - aldrig;
• NORMAL - alltid, förutom HTTPS -> HTTP.

Som du kan se finns det inte många alternativ här, men det är alltid bättre att ha möjligheten att anpassa än att inte ha det.

4.4 Proxy()-metoden

Det finns ett par mer användbara, men inte ofta använda alternativ. Du behöver dem inte exakt förrän du behöver dem :)

Den första är proxy. I det vanliga livet stöter du inte ofta på dem, men många stora företag har ett komplext säkerhetssystem för Internettrafik inuti sig, och därav olika proxyinställningar.

Jo, naturligtvis, din programvara, som kommer att fungera någonstans i tarmen av ett sådant företag, kommer en dag att stöta på det faktum att den kommer att behöva använda en proxy. Därför är det bra att ett sådant alternativ också finns här.

Att ställa in en proxy är väldigt enkelt - ett exempel:

HttpResponse<String> response = HttpClient.newBuilder()
  .proxy( ProxySelector.getDefault())
  .build()
  .send(request, BodyHandlers.ofString());

Standardproxyn har valts här, men du kanske vill ställa in din egen:

HttpResponse response = HttpClient.newBuilder()
  .proxy(ProxySelector.of(new InetSocketAddress("proxy.microsoft.com", 80)))
  .build()
  .send(request, BodyHandlers.ofString());

Hur man exakt arbetar med en proxy kommer vi inte att överväga, eftersom detta inte ingår i denna kurs.

4.5 authenticator()

Och ytterligare en viktig punkt. HTTP-protokollet stöder autentisering. Precis på protokollnivå.

Nu används nästan inte detta tillvägagångssätt, men för cirka 20 år sedan var det vanligt. Http-förfrågan såg ut så här:

http://username@example.com/

Eller till och med så här:

http://username:password@example.com/

Detta är inte post. Detta är exakt länken. Och ja, det trodde du inte. Inloggningen och till och med lösenordet kan anges direkt i http-förfrågan. Ja, även nu kan du. Det är därför jag skriver att ingen brukar göra så här nu. Men det finns en sådan möjlighet.

Authenticator auth = new Authenticator() {
    @Override
    protected PasswordAuthentication getPasswordAuthentication() {
    return new PasswordAuthentication(
     "username",
        "password".toCharArray());
    }
};

HttpResponse<String> response = HttpClient.newBuilder()
  .authenticator(auth).build()
  .send(request, BodyHandlers.ofString());

Det här är intressant! Vet du varför “password"det står i stället för i koden "password".toCharArray()?

Eftersom den andra parametern för konstruktorn PasswordAuthentication inte är String, men CharArray.

Och varför är den andra parametern inte det, Stringva CharArray?

Eftersom alla lösenord inte tillåts lagras som en hel sträng av säkerhetsskäl, inte ens i din egen applikation . Det vill säga, din applikation i sitt minne ska inte lagra lösenordet som en sträng. Så att om någon gjorde fukt-minne, kunde lösenordet inte dras ur det ...

Men samtidigt kan lösenordet överföras över ett osäkert HTTP-protokoll över halva världen :) :) :)

Väl. Världen är inte perfekt.

Du kan läsa mer om detta ämne på länkarna nedan:

HTTP-autentisering

Förstå HTTP-autentisering