HTTP | Node.js v13.14.0 Documentation
HTTP#
Stability: 2 - StableTo use the HTTP server and client one must require('http')
.
The HTTP interfaces in Node.js are designed to support many features of the protocol which have been traditionally difficult to use. In particular, large, possibly chunk-encoded, messages. The interface is careful to never buffer entire requests or responses, so the user is able to stream data.
HTTP message headers are represented by an object like this:
{ 'content-length': '123',
'content-type': 'text/plain',
'connection': 'keep-alive',
'host': 'mysite.com',
'accept': '*/*' }
Keys are lowercased. Values are not modified.
In order to support the full spectrum of possible HTTP applications, the Node.js HTTP API is very low-level. It deals with stream handling and message parsing only. It parses a message into headers and body but it does not parse the actual headers or the body.
See message.headers
for details on how duplicate headers are handled.
The raw headers as they were received are retained in the rawHeaders
property, which is an array of [key, value, key2, value2, ...]
. For
example, the previous message header object might have a rawHeaders
list like the following:
[ 'ConTent-Length', '123456',
'content-LENGTH', '123',
'content-type', 'text/plain',
'CONNECTION', 'keep-alive',
'Host', 'mysite.com',
'accepT', '*/*' ]
Class: http.Agent
#
Added in: v0.3.4
An Agent
is responsible for managing connection persistence
and reuse for HTTP clients. It maintains a queue of pending requests
for a given host and port, reusing a single socket connection for each
until the queue is empty, at which time the socket is either destroyed
or put into a pool where it is kept to be used again for requests to the
same host and port. Whether it is destroyed or pooled depends on the
keepAlive
option.
Pooled connections have TCP Keep-Alive enabled for them, but servers may
still close idle connections, in which case they will be removed from the
pool and a new connection will be made when a new HTTP request is made for
that host and port. Servers may also refuse to allow multiple requests
over the same connection, in which case the connection will have to be
remade for every request and cannot be pooled. The Agent
will still make
the requests to that server, but each one will occur over a new connection.
When a connection is closed by the client or the server, it is removed
from the pool. Any unused sockets in the pool will be unrefed so as not
to keep the Node.js process running when there are no outstanding requests.
(see socket.unref()
).
It is good practice, to destroy()
an Agent
instance when it is no
longer in use, because unused sockets consume OS resources.
Sockets are removed from an agent when the socket emits either
a 'close'
event or an 'agentRemove'
event. When intending to keep one
HTTP request open for a long time without keeping it in the agent, something
like the following may be done:
http.get(options, (res) => {
// Do stuff
}).on('socket', (socket) => {
socket.emit('agentRemove');
});
An agent may also be used for an individual request. By providing
{agent: false}
as an option to the http.get()
or http.request()
functions, a one-time use Agent
with default options will be used
for the client connection.
agent:false
:
http.get({
hostname: 'localhost',
port: 80,
path: '/',
agent: false // Create a new agent just for this one request
}, (res) => {
// Do stuff with response
});
new Agent([options])
#
Added in: v0.3.4
-
options
<Object> Set of configurable options to set on the agent. Can have the following fields:keepAlive
<boolean> Keep sockets around even when there are no outstanding requests, so they can be used for future requests without having to reestablish a TCP connection. Not to be confused with thekeep-alive
value of theConnection
header. TheConnection: keep-alive
header is always sent when using an agent except when theConnection
header is explicitly specified or when thekeepAlive
andmaxSockets
options are respectively set tofalse
andInfinity
, in which caseConnection: close
will be used. Default:false
.keepAliveMsecs
<number> When using thekeepAlive
option, specifies the initial delay for TCP Keep-Alive packets. Ignored when thekeepAlive
option isfalse
orundefined
. Default:1000
.maxSockets
<number> Maximum number of sockets to allow per host. Each request will use a new socket until the maximum is reached. Default:Infinity
.maxFreeSockets
<number> Maximum number of sockets to leave open in a free state. Only relevant ifkeepAlive
is set totrue
. Default:256
.timeout
<number> Socket timeout in milliseconds. This will set the timeout when the socket is created.
options
in socket.connect()
are also supported.
The default http.globalAgent
that is used by http.request()
has all
of these values set to their respective defaults.
To configure any of them, a custom http.Agent
instance must be created.
const http = require('http');
const keepAliveAgent = new http.Agent({ keepAlive: true });
options.agent = keepAliveAgent;
http.request(options, onResponseCallback);
agent.createConnection(options[, callback])
#
Added in: v0.11.4
options
<Object> Options containing connection details. Checknet.createConnection()
for the format of the optionscallback
<Function> Callback function that receives the created socket- Returns: <stream.Duplex>
Produces a socket/stream to be used for HTTP requests.
By default, this function is the same as net.createConnection()
. However,
custom agents may override this method in case greater flexibility is desired.
A socket/stream can be supplied in one of two ways: by returning the
socket/stream from this function, or by passing the socket/stream to callback
.
This method is guaranteed to return an instance of the <net.Socket> class, a subclass of <stream.Duplex>, unless the user specifies a socket type other than <net.Socket>.
callback
has a signature of (err, stream)
.
agent.keepSocketAlive(socket)
#
Added in: v8.1.0
socket
<stream.Duplex>
Called when socket
is detached from a request and could be persisted by the
Agent
. Default behavior is to:
socket.setKeepAlive(true, this.keepAliveMsecs);
socket.unref();
return true;
This method can be overridden by a particular Agent
subclass. If this
method returns a falsy value, the socket will be destroyed instead of persisting
it for use with the next request.
The socket
argument can be an instance of <net.Socket>, a subclass of
<stream.Duplex>.
agent.reuseSocket(socket, request)
#
Added in: v8.1.0
socket
<stream.Duplex>request
<http.ClientRequest>
Called when socket
is attached to request
after being persisted because of
the keep-alive options. Default behavior is to:
socket.ref();
This method can be overridden by a particular Agent
subclass.
The socket
argument can be an instance of <net.Socket>, a subclass of
<stream.Duplex>.
agent.destroy()
#
Added in: v0.11.4
Destroy any sockets that are currently in use by the agent.
It is usually not necessary to do this. However, if using an
agent with keepAlive
enabled, then it is best to explicitly shut down
the agent when it will no longer be used. Otherwise,
sockets may hang open for quite a long time before the server
terminates them.
agent.freeSockets
#
Added in: v0.11.4
An object which contains arrays of sockets currently awaiting use by
the agent when keepAlive
is enabled. Do not modify.
Sockets in the freeSockets
list will be automatically destroyed and
removed from the array on 'timeout'
.
agent.getName(options)
#
Added in: v0.11.4
Get a unique name for a set of request options, to determine whether a
connection can be reused. For an HTTP agent, this returns
host:port:localAddress
or host:port:localAddress:family
. For an HTTPS agent,
the name includes the CA, cert, ciphers, and other HTTPS/TLS-specific options
that determine socket reusability.
agent.maxFreeSockets
#
Added in: v0.11.7
By default set to 256. For agents with keepAlive
enabled, this
sets the maximum number of sockets that will be left open in the free
state.
agent.maxSockets
#
Added in: v0.3.6
By default set to Infinity
. Determines how many concurrent sockets the agent
can have open per origin. Origin is the returned value of agent.getName()
.
agent.requests
#
Added in: v0.5.9
An object which contains queues of requests that have not yet been assigned to sockets. Do not modify.
agent.sockets
#
Added in: v0.3.6
An object which contains arrays of sockets currently in use by the agent. Do not modify.
Class: http.ClientRequest
#
Added in: v0.1.17
- Extends: <Stream>
This object is created internally and returned from http.request()
. It
represents an in-progress request whose header has already been queued. The
header is still mutable using the setHeader(name, value)
,
getHeader(name)
, removeHeader(name)
API. The actual header will
be sent along with the first data chunk or when calling request.end()
.
To get the response, add a listener for 'response'
to the request object.
'response'
will be emitted from the request object when the response
headers have been received. The 'response'
event is executed with one
argument which is an instance of http.IncomingMessage
.
During the 'response'
event, one can add listeners to the
response object; particularly to listen for the 'data'
event.
If no 'response'
handler is added, then the response will be
entirely discarded. However, if a 'response'
event handler is added,
then the data from the response object must be consumed, either by
calling response.read()
whenever there is a 'readable'
event, or
by adding a 'data'
handler, or by calling the .resume()
method.
Until the data is consumed, the 'end'
event will not fire. Also, until
the data is read it will consume memory that can eventually lead to a
'process out of memory' error.
Unlike the request
object, if the response closes prematurely, the
response
object does not emit an 'error'
event but instead emits the
'aborted'
event.
Node.js does not check whether Content-Length and the length of the body which has been transmitted are equal or not.
Event: 'abort'
#
Added in: v1.4.1
Emitted when the request has been aborted by the client. This event is only
emitted on the first call to abort()
.
Event: 'connect'
#
Added in: v0.7.0
response
<http.IncomingMessage>socket
<stream.Duplex>head
<Buffer>
Emitted each time a server responds to a request with a CONNECT
method. If
this event is not being listened for, clients receiving a CONNECT
method will
have their connections closed.
This event is guaranteed to be passed an instance of the <net.Socket> class, a subclass of <stream.Duplex>, unless the user specifies a socket type other than <net.Socket>.
A client and server pair demonstrating how to listen for the 'connect'
event:
const http = require('http');
const net = require('net');
const { URL } = require('url');
// Create an HTTP tunneling proxy
const proxy = http.createServer((req, res) => {
res.writeHead(200, { 'Content-Type': 'text/plain' });
res.end('okay');
});
proxy.on('connect', (req, clientSocket, head) => {
// Connect to an origin server
const { port, hostname } = new URL(`http://${req.url}`);
const serverSocket = net.connect(port || 80, hostname, () => {
clientSocket.write('HTTP/1.1 200 Connection Established\r\n' +
'Proxy-agent: Node.js-Proxy\r\n' +
'\r\n');
serverSocket.write(head);
serverSocket.pipe(clientSocket);
clientSocket.pipe(serverSocket);
});
});
// Now that proxy is running
proxy.listen(1337, '127.0.0.1', () => {
// Make a request to a tunneling proxy
const options = {
port: 1337,
host: '127.0.0.1',
method: 'CONNECT',
path: 'www.google.com:80'
};
const req = http.request(options);
req.end();
req.on('connect', (res, socket, head) => {
console.log('got connected!');
// Make a request over an HTTP tunnel
socket.write('GET / HTTP/1.1\r\n' +
'Host: www.google.com:80\r\n' +
'Connection: close\r\n' +
'\r\n');
socket.on('data', (chunk) => {
console.log(chunk.toString());
});
socket.on('end', () => {
proxy.close();
});
});
});
Event: 'continue'
#
Added in: v0.3.2
Emitted when the server sends a '100 Continue' HTTP response, usually because the request contained 'Expect: 100-continue'. This is an instruction that the client should send the request body.
Event: 'information'
#
Added in: v10.0.0
-
info
<Object>
Emitted when the server sends a 1xx intermediate response (excluding 101 Upgrade). The listeners of this event will receive an object containing the HTTP version, status code, status message, key-value headers object, and array with the raw header names followed by their respective values.
const http = require('http');
const options = {
host: '127.0.0.1',
port: 8080,
path: '/length_request'
};
// Make a request
const req = http.request(options);
req.end();
req.on('information', (info) => {
console.log(`Got information prior to main response: ${info.statusCode}`);
});
101 Upgrade statuses do not fire this event due to their break from the
traditional HTTP request/response chain, such as web sockets, in-place TLS
upgrades, or HTTP 2.0. To be notified of 101 Upgrade notices, listen for the
'upgrade'
event instead.
Event: 'response'
#
Added in: v0.1.0
response
<http.IncomingMessage>
Emitted when a response is received to this request. This event is emitted only once.
Event: 'socket'
#
Added in: v0.5.3
socket
<stream.Duplex>
This event is guaranteed to be passed an instance of the <net.Socket> class, a subclass of <stream.Duplex>, unless the user specifies a socket type other than <net.Socket>.
Event: 'timeout'
#
Added in: v0.7.8
Emitted when the underlying socket times out from inactivity. This only notifies that the socket has been idle. The request must be aborted manually.
See also: request.setTimeout()
.
Event: 'upgrade'
#
Added in: v0.1.94
response
<http.IncomingMessage>socket
<stream.Duplex>head
<Buffer>
Emitted each time a server responds to a request with an upgrade. If this event is not being listened for and the response status code is 101 Switching Protocols, clients receiving an upgrade header will have their connections closed.
This event is guaranteed to be passed an instance of the <net.Socket> class, a subclass of <stream.Duplex>, unless the user specifies a socket type other than <net.Socket>.
A client server pair demonstrating how to listen for the 'upgrade'
event.
const http = require('http');
// Create an HTTP server
const server = http.createServer((req, res) => {
res.writeHead(200, { 'Content-Type': 'text/plain' });
res.end('okay');
});
server.on('upgrade', (req, socket, head) => {
socket.write('HTTP/1.1 101 Web Socket Protocol Handshake\r\n' +
'Upgrade: WebSocket\r\n' +
'Connection: Upgrade\r\n' +
'\r\n');
socket.pipe(socket); // echo back
});
// Now that server is running
server.listen(1337, '127.0.0.1', () => {
// make a request
const options = {
port: 1337,
host: '127.0.0.1',
headers: {
'Connection': 'Upgrade',
'Upgrade': 'websocket'
}
};
const req = http.request(options);
req.end();
req.on('upgrade', (res, socket, upgradeHead) => {
console.log('got upgraded!');
socket.end();
process.exit(0);
});
});
request.abort()
#
Added in: v0.3.8Deprecated since: v13.14.0
Marks the request as aborting. Calling this will cause remaining data in the response to be dropped and the socket to be destroyed.
request.aborted
#
History
Version | Changes |
---|---|
v11.0.0
|
0条评论