class Net::HTTP

Die Klasse Net::HTTP bietet eine reichhaltige Bibliothek, die den Client in einem Client-Server-Modell implementiert, das das HTTP-Request-Response-Protokoll verwendet. Informationen zu HTTP finden Sie unter

Über die Beispiele

Die hier angenommenen Codebeispiele erfordern, dass net/http geladen wurde (was auch uri lädt)

require 'net/http'

Viele Codebeispiele hier verwenden diese Beispiel-Websites

Einige Beispiele gehen auch von diesen Variablen aus

uri = URI('https://jsonplaceholder.typicode.com/')
uri.freeze # Examples may not modify.
hostname = uri.hostname # => "jsonplaceholder.typicode.com"
path = uri.path         # => "/"
port = uri.port         # => 443

So dass Beispielanfragen geschrieben werden können als

Net::HTTP.get(uri)
Net::HTTP.get(hostname, '/index.html')
Net::HTTP.start(hostname) do |http|
  http.get('/todos/1')
  http.get('/todos/2')
end

Ein Beispiel, das eine modifizierte URI benötigt, dupliziert zuerst uri und modifiziert dann die Kopie

_uri = uri.dup
_uri.path = '/todos/1'

Strategien

Die oben genannten Methoden sind Komfortmethoden, die über ihre wenigen Argumente eine minimale Kontrolle über die Anfragen ermöglichen. Für mehr Kontrolle sollten Sie Anfrageobjekte verwenden.

URIs

Im Internet ist eine URI (Universal Resource Identifier) eine Zeichenkette, die eine bestimmte Ressource identifiziert. Sie besteht aus einigen oder allen der folgenden Teile: Schema, Hostname, Pfad, Abfrage und Fragment; siehe URI-Syntax.

Ein Ruby URI::Generic-Objekt repräsentiert eine Internet-URI. Es bietet unter anderem die Methoden scheme, hostname, path, query und fragment.

Schemata

Eine Internet-URI hat ein Schema.

Die beiden von Net::HTTP unterstützten Schemata sind 'https' und 'http'

uri.scheme                       # => "https"
URI('http://example.com').scheme # => "http"

Hostnamen

Ein Hostname identifiziert einen Server (Host), an den Anfragen gesendet werden können

hostname = uri.hostname # => "jsonplaceholder.typicode.com"
Net::HTTP.start(hostname) do |http|
  # Some HTTP stuff.
end

Pfade

Ein Host-spezifischer Pfad identifiziert eine Ressource auf dem Host

_uri = uri.dup
_uri.path = '/todos/1'
hostname = _uri.hostname
path = _uri.path
Net::HTTP.get(hostname, path)

Abfragen

Eine Host-spezifische Abfrage fügt der URI Name/Wert-Paare hinzu

_uri = uri.dup
params = {userId: 1, completed: false}
_uri.query = URI.encode_www_form(params)
_uri # => #<URI::HTTPS https://jsonplaceholder.typicode.com?userId=1&completed=false>
Net::HTTP.get(_uri)

Fragmente

Ein URI-Fragment hat in Net::HTTP keine Auswirkung; es werden die gleichen Daten zurückgegeben, unabhängig davon, ob ein Fragment enthalten ist.

Anfrageheader

Anfrageheader können verwendet werden, um zusätzliche Informationen an den Host zu übergeben, ähnlich wie Argumente, die in einem Methodenaufruf übergeben werden; jeder Header ist ein Name/Wert-Paar.

Jede der Net::HTTP-Methoden, die eine Anfrage an den Host sendet, verfügt über ein optionales Argument headers, wobei die Header als Hash von Feldnamen/Wert-Paaren ausgedrückt werden

headers = {Accept: 'application/json', Connection: 'Keep-Alive'}
Net::HTTP.get(uri, headers)

Siehe Listen von Standard- und gängigen Anfragefeldern unter Request Fields. Ein Host kann auch andere benutzerdefinierte Felder akzeptieren.

HTTP-Sitzungen

Eine Sitzung ist eine Verbindung zwischen einem Server (Host) und einem Client, die

Siehe Beispiel-Sitzungen unter Strategien.

Sitzung mit Net::HTTP.start

Wenn Sie viele Anfragen an einen einzelnen Host (und Port) stellen müssen, sollten Sie die Singleton-Methode Net::HTTP.start mit einem Block verwenden. Die Methode kümmert sich automatisch um die Sitzung, indem sie

Im Block können Sie diese Instanzmethoden verwenden, von denen jede eine einzelne Anfrage sendet

Sitzung mit Net::HTTP.start und Net::HTTP.finish

Sie können eine Sitzung manuell mit den Methoden start und finish verwalten

http = Net::HTTP.new(hostname)
http.start
http.get('/todos/1')
http.get('/todos/2')
http.delete('/posts/1')
http.finish # Needed to free resources.

Sitzung mit einer einzigen Anfrage

Bestimmte Komfortmethoden verwalten eine Sitzung automatisch, indem sie

Solche Methoden, die GET-Anfragen senden

Solche Methoden, die POST-Anfragen senden

HTTP-Anfragen und -Antworten

Viele der oben genannten Methoden sind Komfortmethoden, von denen jede eine Anfrage sendet und einen String zurückgibt, ohne direkt Net::HTTPRequest- und Net::HTTPResponse-Objekte zu verwenden.

Sie können jedoch direkt ein Anfrageobjekt erstellen, die Anfrage senden und das Antwortobjekt abrufen. Siehe

Weiterleitung verfolgen

Jede zurückgegebene Antwort ist eine Instanz einer Unterklasse von Net::HTTPResponse. Siehe die Antwortklassenhierarchie.

Insbesondere die Klasse Net::HTTPRedirection ist die Elternklasse aller Umleitungsklassen. Dies ermöglicht es Ihnen, eine Fallunterscheidung zu erstellen, um Umleitungen korrekt zu behandeln

def fetch(uri, limit = 10)
  # You should choose a better exception.
  raise ArgumentError, 'Too many HTTP redirects' if limit == 0

  res = Net::HTTP.get_response(URI(uri))
  case res
  when Net::HTTPSuccess     # Any success class.
    res
  when Net::HTTPRedirection # Any redirection class.
    location = res['Location']
    warn "Redirected to #{location}"
    fetch(location, limit - 1)
  else                      # Any other class.
    res.value
  end
end

fetch(uri)

Basisauthentifizierung

Die Basisauthentifizierung erfolgt gemäß RFC2617

req = Net::HTTP::Get.new(uri)
req.basic_auth('user', 'pass')
res = Net::HTTP.start(hostname) do |http|
  http.request(req)
end

Streaming von Antwortkörpern

Standardmäßig liest Net::HTTP eine vollständige Antwort in den Speicher. Wenn Sie große Dateien verarbeiten oder eine Fortschrittsanzeige implementieren möchten, können Sie den Körper stattdessen direkt in eine IO streamen.

Net::HTTP.start(hostname) do |http|
  req = Net::HTTP::Get.new(uri)
  http.request(req) do |res|
    open('t.tmp', 'w') do |f|
      res.read_body do |chunk|
        f.write chunk
      end
    end
  end
end

HTTPS

HTTPS wird für eine HTTP-Verbindung durch Net::HTTP#use_ssl= aktiviert

Net::HTTP.start(hostname, :use_ssl => true) do |http|
  req = Net::HTTP::Get.new(uri)
  res = http.request(req)
end

Oder wenn Sie einfach nur eine GET-Anfrage stellen möchten, können Sie ein URI-Objekt übergeben, das eine HTTPS-URL hat. Net::HTTP schaltet die TLS-Verifizierung automatisch ein, wenn das URI-Objekt ein 'https'-URI-Schema hat

uri # => #<URI::HTTPS https://jsonplaceholder.typicode.com/>
Net::HTTP.get(uri)

Proxy-Server

Ein HTTP-Objekt kann einen Proxy-Server haben.

Sie können ein HTTP-Objekt mit einem Proxy-Server erstellen, indem Sie die Methode Net::HTTP.new oder die Methode Net::HTTP.start verwenden.

Der Proxy kann entweder über das Argument p_addr oder über die Umgebungsvariable 'http_proxy' definiert werden.

Proxy mit Argument p_addr als String

Wenn das Argument p_addr ein String-Hostname ist, hat das zurückgegebene http den angegebenen Host als Proxy

http = Net::HTTP.new(hostname, nil, 'proxy.example')
http.proxy?          # => true
http.proxy_from_env? # => false
http.proxy_address   # => "proxy.example"
# These use default values.
http.proxy_port      # => 80
http.proxy_user      # => nil
http.proxy_pass      # => nil

Port, Benutzername und Passwort für den Proxy können ebenfalls angegeben werden

http = Net::HTTP.new(hostname, nil, 'proxy.example', 8000, 'pname', 'ppass')
# => #<Net::HTTP jsonplaceholder.typicode.com:80 open=false>
http.proxy?          # => true
http.proxy_from_env? # => false
http.proxy_address   # => "proxy.example"
http.proxy_port      # => 8000
http.proxy_user      # => "pname"
http.proxy_pass      # => "ppass"

Proxy mit ‘ENV['http_proxy']’

Wenn die Umgebungsvariable 'http_proxy' auf einen URI-String gesetzt ist, hat das zurückgegebene http den Server unter diesem URI als Proxy. Beachten Sie, dass der URI-String ein Protokoll wie 'http' oder 'https' haben muss

ENV['http_proxy'] = 'http://example.com'
http = Net::HTTP.new(hostname)
http.proxy?          # => true
http.proxy_from_env? # => true
http.proxy_address   # => "example.com"
# These use default values.
http.proxy_port      # => 80
http.proxy_user      # => nil
http.proxy_pass      # => nil

Der URI-String kann Proxy-Benutzernamen, -Passwort und -Portnummer enthalten

ENV['http_proxy'] = 'http://pname:ppass@example.com:8000'
http = Net::HTTP.new(hostname)
http.proxy?          # => true
http.proxy_from_env? # => true
http.proxy_address   # => "example.com"
http.proxy_port      # => 8000
http.proxy_user      # => "pname"
http.proxy_pass      # => "ppass"

Proxys filtern

Mit der Methode Net::HTTP.new (aber nicht mit Net::HTTP.start) können Sie das Argument p_no_proxy verwenden, um Proxys zu filtern

Kompression und Dekompression

Net::HTTP komprimiert den Körper einer Anfrage vor dem Senden nicht.

Standardmäßig fügt Net::HTTP den Header 'Accept-Encoding' einem neuen Anfrageobjekt hinzu

Net::HTTP::Get.new(uri)['Accept-Encoding']
# => "gzip;q=1.0,deflate;q=0.6,identity;q=0.3"

Dies fordert den Server auf, den Antwortkörper zu zippen, falls vorhanden; der Server ist nicht verpflichtet, dies zu tun.

Net::HTTP dekomprimiert einen Antwortkörper nicht automatisch, wenn die Antwort den Header 'Content-Range' hat.

Andernfalls hängt die Dekompression (oder nicht) vom Wert des Headers Content-Encoding ab

Was gibt es hier

Zuerst, was ist anderswo. Klasse Net::HTTP

Dies ist eine kategorisierte Zusammenfassung von Methoden und Attributen.

Net::HTTP-Objekte

Sitzungen

Verbindungen

Anfragen

Antworten

Proxys

Security

Adressen und Ports

HTTP-Version

Debugging