Introduction

Let’s take a look at the following process:
• We have never manually started the PHP-related process, it runs with the startup of Apache ;
　• PHP is connected to Apache through the mod_php5.so module (specifically, SAPI, the server application programming interface);
　• PHP has a total of three modules: kernel, Zend engine, and extension layer;
　• PHP kernel is used to handle requests, file streams, error handling and other related operations;
　• Zend engine (ZE) is used to convert source files into machine language and then run it on a virtual machine;
　• The extension layer is a set of functions, libraries, and streams that PHP uses to perform specific operations. For example, we need the mysql extension to connect to the MySQL database;
• When ZE executes the program, it may need to connect to several extensions. At this time, ZE hands over the control to the extension and returns it after processing the specific task;
• Finally, ZE returns the program execution results to the PHP kernel, which then transmits the results to the SAPI layer and finally outputs them to the browser.
　In-depth discussion
Wait, it’s not that simple. The above process is just a simplified version, let’s dig a little deeper to see what else is going on behind the scenes.
　• After Apache is started, the PHP interpreter is also started;
　• There are two steps in the PHP startup process;
　• The first step is to initialize some environment variables, which will occur throughout the entire SAPI life cycle Function;
　• The second step is to generate some variable settings only for the current request.

The first step of starting PHP

I don’t know what the first and second steps are? Don’t worry, we’ll discuss this in detail next. Let's look at the first and most important step first. The thing to remember is that the first step of the operation happens before any requests arrive.
　• After starting Apache, the PHP interpreter will also start;
　• PHP calls the MINIT method of each extension to switch these extensions to an available state. Take a look at what extensions are opened in the php.ini file;
　• MINIT means "module initialization". Each module defines a set of functions, class libraries, etc. to handle other requests.
　A typical MINIT method is as follows:

PHP_MINIT_FUNCTION(extension_name){ /* Initialize functions, classes etc */ }

PHP startup step two

　• When a page request occurs, the SAPI layer hands over control to the PHP layer. So PHP sets the environment variables needed to reply to this request. At the same time, it also creates a variable table to store variable names and values generated during execution.
　• PHP calls the RINIT method of each module, which is "request initialization". A classic example is the RINIT of the Session module. If the Session module is enabled in php.ini, the $_SESSION variable will be initialized when RINIT of the module is called, and the relevant content will be read in;
　• The RINIT method can Considered as a preparation process, it will start automatically between program executions.
A typical RINIT method is as follows:

PHP_RINIT_FUNCTION(extension_name) { /* Initialize session variables, pre-populate variables, redefine global variables etc */ }

The first step of PHP shutdown

Just like PHP startup, PHP shutdown is also divided into two steps:
• Once the page is executed ( Whether the execution reaches the end of the file or is terminated using the exit or die function), PHP will start the cleanup program. It will call the RSHUTDOWN method of each module in sequence.
　• RSHUTDOWN is used to clear the symbol table generated when the program is running, that is, calling the unset function on each variable.
A typical RSHUTDOWN method is as follows:

PHP_RSHUTDOWN_FUNCTION(extension_name) { /* Do memory management, unset all variables used in the last PHP call etc */ }

PHP closes the second step

Finally, all requests have been processed, SAPI is ready to be closed, and PHP begins to execute the second step :
　• PHP calls the MSHUTDOWN method of each extension. This is the last opportunity for each module to release memory.
A typical RSHUTDOWN method is as follows:

PHP_MSHUTDOWN_FUNCTION(extension_name) { /* Free handlers and persistent memory etc */ }

In this way, the entire PHP life cycle is over. It should be noted that the "starting step one" and "closing step two" will only be executed if there is no request from the server.
The following are illustrated with some illustrations!

The underlying working principle of PHP

As can be seen from the picture, PHP is a 4-layer system from bottom to top
① Zend engine
Zend is implemented in pure C and is the core part of PHP. It translates PHP code (lexical and syntax) parsing and a series of compilation processes) to process executable opcodes and implement corresponding processing methods, implement basic data structures (such as hashtable, oo), memory allocation and management, and provide corresponding api methods for external calls. It is everything The core, all peripheral functions are implemented around zend.
　②Extensions
Around the zend engine, extensions provide various basic services in a component-based manner. Our common various built-in functions (such as array series), standard libraries, etc. are all implemented through extensions, and users can also Implement your own extension as needed to achieve function expansion, performance optimization and other purposes (for example, the PHP middle layer and rich text parsing currently used by Tieba are typical applications of extension).
　③Sapi
The full name of Sapi is Server Application Programming Interface, which is the server application programming interface. Sapi enables PHP to interact with peripheral data through a series of hook functions. This is a very elegant and successful design of PHP. Through SAPI successfully decouples and isolates PHP itself from upper-layer applications. PHP can no longer consider how to be compatible with different applications, and the application itself can also implement different processing methods according to its own characteristics. It will be introduced later in the sapi chapter
　④Upper-layer application
This is the PHP program we usually write. We can obtain various application modes through different sapi methods, such as implementing web applications through webserver and using the command line. Run as a script and more.

Architectural idea:

The engine (Zend) + component (ext) model reduces internal coupling
The middle layer (sapi) isolates the web server and PHP
********************************************** ******************
If php is a car, then
The framework of the car is php itself
Zend is the engine of the car
The various components below Ext are the wheels of the car
Sapi can be regarded as a road, and the car can run on different types of roads
And the execution of a php program is Cars run on the road.
Therefore, we need: excellent performance engine + suitable wheels + correct runway

The relationship between Apache and php

Apache’s analysis of php is through php in many Modules Module to complete.

To finally integrate PHP into the Apache system, you need to make some necessary settings for Apache. Here, we will take the mod_php5 SAPI operating mode of php as an example to explain. As for the concept of SAPI, we will explain it in detail later.
Assuming that the versions we install are Apache2 and Php5, then you need to edit Apache’s main configuration file http.conf and add the following lines to it:
In Unix/Linux environment:
LoadModule php5_module modules/ mod_php5.so
　AddType application/x-httpd-php .php
　Note: modules/mod_php5.so is the installation location of the mod_php5.so file in the X system environment.
In Windows environment:
LoadModule php5_module d:/php/php5apache2.dll
AddType application/x-httpd-php .php
Note: d:/php/php5apache2.dll is in Windows The installation location of the php5apache2.dll file in the environment.
These two configurations tell Apache Server that any URL user request received in the future with php as the suffix needs to be processed by calling the php5_module module (mod_php5.so/php5apache2.dll).

Apache’s life cycle

Apache’s request processing process

Apache request processing cycle detailed explanation

What are done in the 11 stages of the Apache request processing cycle?
1. Post-Read-Request stage
In the normal request processing process, this is the first stage where the module can insert hooks. This stage can be exploited for modules that want to get into processing requests very early.
　2. URI Translation Stage
　The main work of Apache in this stage: mapping the requested URL to the local file system. Modules can insert hooks at this stage to execute their own mapping logic. mod_alias uses this phase to work.
　3. Header Parsing stage
The main work of Apache in this stage is to check the header of the request. Since the module can perform the task of checking request headers at any point in the request processing flow, this hook is rarely used. mod_setenvif uses this phase to work.
　4. Access Control Phase
　The main work of Apache in this stage is to check whether access to the requested resources is allowed according to the configuration file. Apache's standard logic implements allow and deny directives. mod_authz_host uses this phase to work.
　5. Authentication stage
　The main work of Apache in this stage is to authenticate users according to the policy set in the configuration file and set the user name area. Modules can insert hooks at this stage to implement an authentication method.
6. Authorization phase
The main work of Apache in this phase is to check whether authenticated users are allowed to perform the requested operation according to the configuration file. The module can insert hooks at this stage to implement a user rights management method.
　7. MIME Type Checking Phase
　The main work of Apache in this stage: determine the content processing function to be used according to the relevant rules of the MIME type of the requested resource. The standard modules mod_negotiation and mod_mime implement this hook.
8. FixUp stage
This is a general stage that allows the module to run any necessary processing before the content generator. Similar to Post_Read_Request, this is a hook that can capture any information and is also the most commonly used hook.
9. Response stage
The main work of Apache in this stage is to generate content returned to the client and be responsible for sending an appropriate reply to the client. This stage is the core part of the entire process.
　10. Logging phase
　The main work of Apache in this stage: recording the transaction after the reply has been sent to the client. Modules may modify or replace Apache's standard logging.
11. CleanUp Phase
The main work of Apache in this phase: clean up the environment left after the completion of this request transaction, such as the processing of files and directories or the closing of Socket, etc. This is processed by Apache in one request. The final stage.

LAMP architecture

①liunx belongs to the bottom layer of the operating system
②apache server, which belongs to the secondary server and communicates linux and PHP
　③php: Belongs to the server-side programming language, and is associated with apache through the php_module module
　④Mysql and other web services: Belongs to application services, and is associated with mysql through PHP's Extensions plug-in module

The above is the detailed content of Detailed explanation of the graphic code of PHP's execution principles and processes. For more information, please follow other related articles on the PHP Chinese website!