Interpreting the request and response processing process in PHP Yii Framework

This article mainly introduces the request and response processing process in the PHP Yii Framework, which is also the most basic function of Yii processing website background. For more information, see 1. request (Requests)
Request:
An application Request is represented by a yii \ web \ Request object, which provides Request parameters such as GET or POST parameters), HTTP header, cookies, and other information. By default, for a given request, you can access the corresponding Request object through the request application component (yii \ web \ Request class instance. This section describes how to use this component in your application.

1. request parameters

To obtain request parameters, you can call the yii \ web \ Request: get () method and yii \ web \ Request: post () method of the request component. They return the values of $ _ GET and $ _ POST respectively. For example,

$ request = Yii :: $ app-> request;

$ get = $ request-> get ();
// Equivalent to: $ get = $ _GET;

$ id = $ request-> get ('id');
// equivalent to: $ id = isset ($ _ GET ['id'])? $ _GET ['id']: null;

$ id = $ request-> get ('id', 1);
// Equivalent to: $ id = isset ($ _ GET ['id'])? $ _GET ['id']: 1;

$ post = $ request-> post ();
// Equivalent to: $ post = $ _POST;

$ name = $ request-> post ('name');
// equivalent to: $ name = isset ($ _ POST ['name'])? $ _POST ['name']: null;

$ name = $ request-> post ('name', '');
// equivalent to: $ name = isset ($ _ POST ['name'])? $ _POST ['name']: '';

Information: It is recommended that you obtain the request parameters through the request component as above, instead of directly accessing $ _GET and $ _POST. This makes it easier for you to write test cases because you can fake data to create a mock request component.
When implementing the RESTful APIs interface, you often need to get the parameters submitted by PUT, PATCH or other request methods. You can get these parameters by calling yii \ web \ Request :: getBodyParam () method. E.g,

$ request = Yii :: $ app-> request;

// return all parameters
$ params = $ request-> bodyParams;

// return parameter "id"
$ param = $ request-> getBodyParam ('id');

Information: Unlike GET parameters, POST, PUT, PATCH, etc. These submitted parameters are sent in the request body. When you access these parameters through the methods described above, the request component will parse these parameters. You can customize how to parse these parameters by configuring the yii \ web \ Request :: parsers property.

2. Request method

You can use the Yii :: $ app-> request-> method expression to get the HTTP method used in the current request. There is also a set of Boolean properties used to detect if the current request is of a certain type. E.g,

$ request = Yii :: $ app-> request;

if ($ request-> isAjax) {/ * The request is an AJAX request * /}
if ($ request-> isGet) {/ * The request method is GET * /}
if ($ request-> isPost) {/ * The request method is POST * /}
if ($ request-> isPut) {/ * The request method is PUT * /}

3. Request URLs

The request component provides many ways to detect the URL of the current request.

Assuming the requested URL is http://example.com/admin/index.php/product?id=100, you can obtain the various parts of the URL as described below:

yii \ web \ Request :: url: returns /admin/index.php/product?id=100, this URL does not include the host info part.
yii \ web \ Request :: absoluteUrl: returns http://example.com/admin/index.php/product?id=100, which contains the entire URL of host infode.
yii \ web \ Request :: hostInfo: returns http://example.com, only the host info part.
yii \ web \ Request :: pathInfo: returns / product, this is the part after the entry script and before the question mark (query string).
yii \ web \ Request :: queryString: returns id = 100, the part after the question mark.
yii \ web \ Request :: baseUrl: after returning / admin, host info, before the entry script.
yii \ web \ Request :: scriptUrl: returns /admin/index.php, without path info and query string parts.
yii \ web \ Request :: serverName: returns the host name in example.com, URL.
yii \ web \ Request :: serverPort: returns 80, which is the port used in the web service.
4.HTTP header

You can get the HTTP header information through the yii \ web \ HeaderCollection returned by the yii \ web \ Request :: headers property. E.g,

// $ headers is a yii \ web \ HeaderCollection object
$ headers = Yii :: $ app-> request-> headers;

// return Accept header value
$ accept = $ headers-> get ('Accept');

if ($ headers-> has ('User-Agent')) {/ * This is a User-Agent header * /}

The request component also provides methods to support quick access to commonly used headers, including:

yii \ web \ Request :: userAgent: returns the User-Agent header.
yii \ web \ Request :: contentType: Returns the value of the Content-Type header. Content-Type is the MIME type data in the request body.
yii \ web \ Request :: acceptableContentTypes: Returns the content MIME types that are acceptable to the user. The returned types are sorted by their quality score. The type with the highest score will be returned first.
yii \ web \ Request :: acceptableLanguages: returns the language acceptable to the user. The languages returned are sorted according to their preference hierarchy. The first parameter represents the language with the highest priority.
If your application supports multiple languages and you want to display the page in the end user's favorite language, you can use the language negotiation method yii \ web \ Request :: getPreferredLanguage (). This method uses yii \ web \ Request :: acceptableLanguages to compare and filter in the list of languages supported by your application, and returns the most suitable language.

Tip: You can also use the yii \ filters \ ContentNegotiator filter to dynamically determine which content types and languages should be used in the response. This filter implements the properties and methods of content negotiation described above.

5. Client information

You can obtain the host name and the client's IP address through yii \ web \ Request :: userHost and yii \ web \ Request :: userIP, for example,

$ userHost = Yii :: $ app-> request-> userHost;
$ userIP = Yii :: $ app-> request-> userIP;

Second, response (Responses)
response:
When the application finishes processing a request, it will generate a yii \ web \ Response response object and send it to the end user. The response object contains HTTP status codes, HTTP headers, and body content. Different requests construct these response objects.

In most cases, it mainly deals with the response application component inherited from yii \ web \ Response. However, Yii also allows you to create your own response object and send it to the end user, which will be explained later.

In this section, we will describe how to construct the response and send it to the end user.

1. Status Code

When constructing a response, the first thing to do is to identify whether the request has been successfully processed. You can set the yii \ web \ Response :: statusCode attribute, which uses a valid HTTP status code. For example, to identify that the process has been processed successfully, you can set the status code to 200, as shown below:

Yii :: $ app-> response-> statusCode = 200;
However, in most cases, you do not need to explicitly set the status code, because the yii \ web \ Response :: statusCode status code defaults to 200. If you need to specify that the request fails, you can throw the corresponding HTTP exception as follows:

throw new \ yii \ web \ NotFoundHttpException;
When an error handler catches an exception, it will extract the status code from the exception and assign it to the response. For the above yii \ web \ NotFoundHttpException corresponding to the HTTP 404 status code, the following are Yii's predefined HTTP exceptions:

yii \ web \ BadRequestHttpException: status code 400.
yii \ web \ ConflictHttpException: status code 409.
yii \ web \ ForbiddenHttpException: status code 403.
yii \ web \ GoneHttpException: status code 410.
yii \ web \ MethodNotAllowedHttpException: status code 405.
yii \ web \ NotAcceptableHttpException: status code 406.
yii \ web \ NotFoundHttpException: status code 404.
yii \ web \ ServerErrorHttpException: status code 500.
yii \ web \ TooManyRequestsHttpException: status code 429.
yii \ web \ UnauthorizedHttpException: status code 401.
yii \ web \ UnsupportedMediaTypeHttpException: status code 415.
If the exception you want to throw is not in the above list, you can create a yii \ web \ HttpException exception and throw it with the status code, as follows:

throw new \ yii \ web \ HttpException (402);

2.HTTP header

You can manipulate yii \ web \ Response :: headers in the response component to send HTTP headers, for example:

$ headers = Yii :: $ app-> response-> headers;

// Add a Pragma header, the existing Pragma header will not be overwritten.
$ headers-> add ('Pragma', 'no-cache');

// Set a Pragma header. Any existing Pragma header will be discarded
$ headers-> set ('Pragma', 'no-cache');

// Delete the Pragma header and return the value of the deleted Pragma header to the array
$ values = $ headers-> remove ('Pragma');

Added: The header name is case sensitive. The newly registered header information is not sent to the user before the yii \ web \ Response :: send () method is called.

3. Response body

Mostly the response should have a body that stores what you want to display to the end user.

If there is already a formatted body string, it can be assigned to the yii \ web \ Response :: content attribute of the response, for example:

Yii :: $ app-> response-> content = 'hello world!';
If formatting is required before sending to the end user, set the yii \ web \ Response :: format and yii \ web \ Response :: data attributes, yii \ web \The Response :: format attribute specifies the formatted format of the data in yii \ web \ Response :: data, for example:

$ response = Yii :: $ app-> response;
$ response-> format = \ yii \ web \ Response :: FORMAT_JSON;
$ response-> data = ['message' => 'hello world'];
Yii supports the following formats that can be used directly. Each implements the yii \ web \ ResponseFormatterInterface class. You can customize these formatters or add formatters by configuring the yii \ web \ Response :: formatters property.

yii \ web \ Response :: FORMAT_HTML: through yii \ web \ HtmlResponseFormatter.
yii \ web \ Response :: FORMAT_XML: via yii \ web \ XmlResponseFormatter.
yii \ web \ Response :: FORMAT_JSON: through yii \ web \ JsonResponseFormatter.
yii \ web \ Response :: FORMAT_JSONP: through yii \ web \ JsonResponseFormatter.
The above response body can be set explicitly, but in most cases it is implicitly set by the return value of the operation method. Common scenarios are as follows:

public function actionIndex ()
{
 return $ this-> render ('index');
}
The above index operation returns the rendering result of the index view. The returned value will be formatted by the response component and sent to the end user.

Because the response format defaults to yii \ web \ Response :: FORMAT_HTML, you only need to return a string in the operation method. If you want to use other response formats, you should set the format before returning the data, for example:

public function actionInfo ()
{
 \ Yii :: $ app-> response-> format = \ yii \ web \ Response :: FORMAT_JSON;
 return [
  'message' => 'hello world',
  'code' => 100,
 ];
}
As mentioned above, Thunder uses the default response application component, and can also create its own response object and send it to the end user. The response object can be returned in the operation method as follows:

public function actionInfo ()
{
 return \ Yii :: createObject ([
  'class' => 'yii \ web \ Response',
  'format' => \ yii \ web \ Response :: FORMAT_JSON,
  'data' => [
   'message' => 'hello world',
   'code' => 100,
  ],
 ]);
}
Note: If you create your own response object, you will not be able to set the response component in the application configuration. However, you can use dependency injection to apply the common configuration to your new response object.

4. Browser Jump

Browser redirection relies on sending a Location HTTP header, as this feature is commonly used and Yii provides special support for it.

You can call the yii \ web \ Response :: redirect () method to redirect the user's browser to a URL address. This method sets the appropriate Location header with the specified URL and returns itself as the response object. In the operation method, you can Call the abbreviated version of yii \ web \ Controller :: redirect (), for example:

public function actionOld ()
{
 return $ this-> redirect ('http://example.com/new', 301);
}
In the above code, the operation method returns the result of the redirect () method. As mentioned earlier, the response object returned by the operation method will be sent to the end user as the total response.

In addition to the operation method, you can directly call yii \ web \ Response :: redirect () and then call the yii \ web \ Response :: send () method to ensure that nothing else is appended to the response.

\ Yii :: $ app-> response-> redirect ('http://example.com/new', 301)-> send ();
Added: The yii \ web \ Response :: redirect () method will set the response status code to 302 by default. This status code will tell the browser to temporarily place the requested resource on another URI address. You can pass a 301 status code to inform the browser The requested resource has been permanently redirected to the new URId address.
If the current request is an AJAX request, sending a Location header will not automatically redirect the browser. To solve this problem, the yii \ web \ Response :: redirect () method sets an X-Redirect header for the URL to be redirected On the client side, you can write JavaScript code to read the header value and let the browser jump to the corresponding URL.

Supplement: Yii is equipped with a yii.js JavaScript file to provide common JavaScript functions, including browser jumps based on the X-Redirect header, so if you use the JavaScript file (registered through the yii \ web \ YiiAsset resource package), it will not Need to write AJAX jump code.

5. Send the file

Similar to browser jumps, file sending is another feature that relies on specifying HTTP headers. Yii provides a set of methods to support various file sending requirements. They have built-in support for HTTP headers.

yii \ web \ Response :: sendFile (): send an existing file to the client
yii \ web \ Response :: sendContentAsFile (): send a text string as a file to the client
yii \ web \ Response :: sendStreamAsFile (): send an existing file stream as a file to the client
These methods all use the response object as the return value. If the file to be sent is very large, you should consider using yii \ web \ Response :: sendStreamAsFile () because it saves more memory. The following example shows how to send the file in the controller operation:

public function actionDownload ()
{
 return \ Yii :: $ app-> response-> sendFile ('path / to / file.txt');
}
If the file sending method is not called in the operation method, yii \ web \ Response :: send () should be called later. No other content is appended to the response.

\ Yii :: $ app-> response-> sendFile ('path / to / file.txt')-> send ();
Some browsers provide a special file sending function called X-Sendfile. The principle is to redirect the request to a file on the server. The web application can end before the server sends the file. To use this function, you can call yii \ web \ Response :: xSendFile (). Here is a brief list of how some common web servers enable the X-Sendfile function:

Apache: X-Sendfile
Lighttpd v1.4: X-LIGHTTPD-send-file
Lighttpd v1.5: X-Sendfile
Nginx: X-Accel-Redirect
Cherokee: X-Sendfile and X-Accel-Redirect

6. Send a response

The content of the response will not be sent to the user before the yii \ web \ Response :: send () method is called. This method is automatically called by default at the end of yii \ base \ Application :: run (). However, this method can be called explicitly Force immediate response.

The yii \ web \ Response :: send () method uses the following steps to send a response:

Trigger the yii \ web \ Response :: EVENT_BEFORE_SEND event.
Call yii \ web \ Response :: prepare () to format yii \ web \ Response :: data as yii \ web \ Response :: content.
Trigger the yii \ web \ Response :: EVENT_AFTER_PREPARE event.
Call yii \ web \ Response :: sendHeaders () to send the registered HTTP headers
Call yii \ web \ Response :: sendContent () to send the response body content
Trigger the yii \ web \ Response :: EVENT_AFTER_SEND event.
Once the yii \ web \ Response :: send () method is executed, calling this method elsewhere will be ignored, which means that once the response is sent, no other content can be appended.

As you can see, yii \ web \ Response :: send () triggers several useful events. You can adjust or wrap the response by responding to these events.