Http is a client-server protocol: requests are sent by an entity, i. E. A user agent (user agent), or an agent (proxy) that can represent it. In most cases, this user agent is a web browser, but it can also be anything, like a machine reptile that climbs pages to enrich and maintain the search engine index。
Each request is sent to a server, which processes the request and provides a response called a response. There are a large number of entities referred to as agents between clients and servers that perform different roles, such as acting as gateways or caches。
In fact, between browsers and servers that process their requests, there are many computers such as routers, modems, etc. Thanks to web's stratification design, these machines are hidden in the network and transmission layers. And http is on the application layer above these machines. While the next tier is important in the diagnosis of network problems, most of the http designs are irrelevant。
User agents are any tool that can represent user behaviour. Such tools are primarily browser-oriented, although they may also be those used by engineers and web developers to debug applications。
The browser will always be the first entity to initiate a request and will never be a service provider (although mechanisms have since been added that can simulate information initiated by the service)。
In order to display a web page, the browser needs to send an initial request to get an HTML document that describes this page. The document is then analyzed and several other requests are sent, correspondingly obtaining enforceable scripts, layout information for displays (css) and other sub-resources (generally pictures and videos) on pages. The web browser then consolidates these resources and presents a complete document, the web page. At a later stage, the scripts implemented in the browser will obtain additional resources and the browser will update the web page accordingly。
The web page is a hypertext document. This means that there's a part of the show that's going to be linked -- a new web page that can be accessed through activation (usually by clicking the mouse) -- – users can use these links to instruct their proxy and to browse through web. Browser converts instructions received to http requests and further interprets the http response to provide a clear response to users。
The other side of the communication process described above is the server, which is responsible for providing the documents requested by the client. Servers can be shown to have only one machine, but in practice they can be a group of load-sharing servers (load-balanced) or other types of software (e. G., caches, database services, electrical services, etc.) that generate documents in whole or in part as required。
The server may not necessarily have only one machine, but may also host several examples of server software on the same machine. Using http/1. 1 and host headers, they can even share the same ip address。
Between web browsers and servers, many computers and equipment are involved in transmitting http messages. Based on the hierarchical structure of the web technology stack, most of the operations during the transmission are in the transmission, network or physical layers, which are transparent for http applications and have a silent and significant impact on network performance. Some entities are also involved in the transmission of information at the application level, generally referred to as proxy. The agent may be transparent, i. E. The request they receive is transmitted without modification or may be shown to be non-transparent, using some means to modify the request before it is transmitted to the service provider. The role of an agent can be many:
Generally, http is designed to be simple and easy to read, although in http/2 http messages are sealed into frame (f)This introduces additional complexity. The http paper can be read and understood, providing developers with simpler testing and lowering the threshold for beginners。
The introduction of http markers in http/1. 0 makes the agreement easy to expand and experiment with. As long as the semantics of the new header are easily negotiated between the server client, the new feature can be added。
Http is non-state: in the same connection, there is no relationship between two successful requests. This raises the problem that users do not have the means to interact consistently with the same website, such as the use of shopping carts on the electrician website. Although http is essentially non-state, by http cLookie can use a status session. Use extension of the header, http cLookie is added to the protocol workflow so that each request creates a session between requests where each request can share the same context information or state。
The connection is controlled by the transfer layer and therefore fundamentally does not belong to http. Http does not need the bottom transfer protocol to be connected, simply to be reliable or not to lose the message (at least, in some cases, to be misinformed). Tcp is reliable and udp is not. Http therefore relies on tcp criteria, i. E. On connections。
Tcp connections must be established between the client and the server before they can transmit requests and respond, a process that requires multiple round-trip interactions. Http/1. 0 default to open a separate tcp connection for each http request/response. When multiple requests need to be initiated consecutively, it is less efficient than sharing the same tcp connection between them。
To mitigate this deficiency, http/1. 1 introduces current lines (which have proved difficult to achieve) and durable connections: through coNsection header to partially control the bottom tcp connection. Http/2 goes further, allowing this connection to remain active and more efficient by combining multiple messages in a connection。
Experiments are under way to design a more compatible http transmission protocol. Google, for example, is testing a more reliable and efficient transmission protocol based on udp。
For years, good expansiveness made http involve more web functions and control. In the early days of http, caches and authentications can be handled by this protocol. Only in 2010 did the ability to release the same source limit be added to the protocol。
Here are common features that can be controlled by http。
When the client wants to interact with the server, whether the final server or the intermediary, the process takes the following steps:
Opens a tcp connection: tcp connection is used to send one or more requests and to receive response messages. The client may open a new connection, or reuse an already existing connection, or may open several new tcp connections to the server。
Sending a http newspaper: http (before http/2) is human-readable. In http/2, these simple messages were sealed in frames, which prevented the paper from being read directly, but the rationale remained the same. For example:
Get / http/1. 1
host: developer. Mozilla. Org
accept-language:Read messages returned by service:
Http/1. 1 200 ok
date: sat, 09 oct 2010 14:28:02 gmt
server: apache
last-modified: tue, 01 dec 2009 20:18:22 gmt
etag: "51142bc1-7449-479b075b2891b"
accept-ranges: bytes
content-length: 29769
content-type: text/HTML
... (this is the 29769 bytes of the requested page)Closes the connection or reuses it for subsequent requests。
When the http streaming line is enabled, follow-up requests can be sent directly, without waiting for the first response to be fully received. However, http currents have proved difficult to achieve in the existing network, where older software exists alongside modern versions. Thus, the http current line has been replaced in http/2 by a stronger, frame-based multi-road reuse request。
The http/1. 1 and earlier http protocols are semantic. In http/2, these papers are embedded into a new binary structure, frame. The frame allows for many optimizations, such as compression of the header and multiple re-use. Even if only part of the original http message is sent in http/2, the semantic of each message remains the same, and the client reorganizes the original http/1. 1 request. The http/2 message is therefore still valid using the http/1. 1 format。
There are two types of http submission, request and response, each with a specific format。
An example of a http request:
The request comprises the following elements:
An example of an http response:
The response contains the following elements:
Fetch api is based on the most common api for http, which can be used in javasLaunch http request in cript. Fetch api replaced xmlttprequest api。
Another api, server-sent event is a one-way service that allows the service to send the event to the client as a http transmission mechanism. Using the eventsource interface, the client can open the connection and create the event processor. Client browser automatically converts information from http streams to an appropriate event object. Then the known type of event is passed on to the previously registered event processor, while other unspecified types of events are passed to oNmessage event processor。
Http is a simple, user-friendly, scalable agreement whose client-server model structure, together with the ability to increase the header, allows http to develop with the expanding capability in web。
Although some complexity has been added - http/2 embedded http in frame to improve performance - the basic structure of the paper has remained unchanged since http/1. 0. The session stream remains the basis for viewing and debugging via the http network monitor。
