YII framework source code analysis (created by Baidu PHP expert - original version - no ads and no watermark)_PHP tutorial

YII framework source code analysis

Baidu Alliance Business Department——Huang Yinfeng

Table of Contents

1. Introduction 3

1.1, Yii Introduction 3

1.2. Content and structure of this article 3

2. Componentization and modularization 4

2.1, Framework loading and running process 4

2.2, YiiBase static class 5

2.3, Component 6

2.4, Module 9

2.5, App application 10

2.6, WebApp application 11

3. System components 13

3.1. Log routing component 13

3.2, Url management component 15

3.3. Exception handling component 17

3.4, Cache component 17

3.5, Angular Access Control Component 19

3.6. Global state component 21

4. Controller layer 23

4.1, Action 23

4.2, Filter 24

4.3, Action and Filter execution process 26

4.4. Access control filter 27

5. Model layer 30

5.1, DAO layer 30

5.1.1, Database connection component 30

5.1.2, transaction object 31

5.1.3, Command object 31

5.2, Metadata and Command Constructor 32

5.2.1. Table structure query 32

5.2.2. Query condition object 33

5.2.1, Command constructor 33

5.3, ORM (ActiveRecord) 34

5.3.1, table metadata information 34

5.3.2, single table ORM 34

5.3.3, multi-table ORM 36

5.3.4, CModel and CValidator 37

6. View layer 38

6.1. View rendering process 38

6.2, Widget 39

6.3. Client script component 40

1. Introduction

1.1, Yii Introduction

The author of Yii is Chinese-American "Xue Qiang", who was originally one of the core development members of Prado. In 2008, Xue Qiang started anew and developed the Yii framework, and released the Yii1.0 version on December 3, 2008.

Yii is currently one of the more excellent PHP frameworks. Its supported features include: MVC, DAO/ActiveRecord, I18N/L10N, caching, AJAX support, user authentication and role-based access control, scaffolding, Input validation, widgets, events, theming, web services, and more.

Many of Yii’s ideas refer to some other excellent Web frameworks (Do we also like to refer to other people’s when writing things? Is that true? Hehe, we all like to stand on the shoulders of others and work!) , here is a short list:

框架名称	参考思想
Prado	基于组件和事件驱动编程模式、数据库抽象 层、模块化的应用架构、国际化和本地化等
Ruby on Rails	配置思想、基于 Active Record 的 ORM
jQuery	集成了 jQuery
Symfony	过滤设计和插件架构
Joomla	模块化设计和信息翻译方案

Frame name

Reference ideas

Prado

Based on component and event-driven programming model, database abstraction

layer, modular application architecture, internationalization and localization, etc.

Ruby on Rails

Configuration ideas, ORM based on Active Record

jQuery

Integrated jQuery

Symfony

Filter design and plug-in architecture

Joomla

Modular design and information translation solution

1.2. Content and structure of this article

This article conducts an in-depth analysis of the source code of Yii1.1.8 version. The content and structure of this article are: Componentization and modularization: Yii’s base class (CComponent) based on component and event-driven programming model Carry out points

Analysis; analyze the working principles of componentization and modularization; analyze the WebApp application creation Controller process, etc.

System components: Analyze the important components that come with the Yii framework, mainly including: log routing component, Url management component, exception handling component, Cache component, role-based access control component, etc.

Controller layer: The controller mainly includes Action and Filter, and analyzes the working principles of Action and Filter. Model layer: Analyze the principles of DAO layer, metadata, Command constructor, and ORM

View layer: Analyze the rendering process, Widget and client script components of the view layer

Errors or inadequacies in this document are inevitable. We sincerely hope that readers of this document will criticize and correct us!

2. Componentization and modularization

2.1, Framework loading and running process

start

Load YiiBase.php 1. Install the autoload method to prepare for instantiation of the class 2. Obtain the paths of all classes in the framework (208 classes in total in Yii1.1.8)

Create Action object based on ActionId 1. Find Action from member function 2. Find Action from ActionMap

Throw

Load request component

(Get,Post,Cookie)

Create Action No Is it successful? often

Create WebApp instance 1. Initialize aliases: application, webroot, ext 2. Install exception handling handles, and hand them over to the exception handling component when an exception is thrown 3. Configure core components: urlManager, errorHandler, session, db, etc. 4. Configure components, sub-modules, WebApp member attributes, etc. based on configuration information 5. Load preload components: log components, request components, etc.

Run WebApp

1. Trigger onBeginRequest event

Load the Url management component, analyze the url according to the configuration information, and parse the route: route=ControllerId/ActionId

Create a controller based on ControllerId 1. Find from ControllerMap 2. Find from submodule 3. Find from ControllerPath

Create Controller Throw Successfully? No Different

Often

Create all Filter objects of the current Action according to the filters() configuration

Run the preFilter method of Filter1 Run the preFilter method of Filter2

Check whether the parameters of Get parameter and Action are different

Consistent

Run Action

Partial render

Render the core part of html

Layout render

Render the overall html

Client Script render 嵌入javascript、css生 成最终的html

Client Script render embeds javascript and css to generate the final html

echo html

2. Processing requests

Run Controller

Run the postFilter method of Filter2 Run the postFilter method of Filter1

3. Trigger onEndRequest event

Registered handle:

Exception handling component

Exception thrown at XX

throw Exception. . .

end

For example, recording logs

The Yii framework loading and running process is divided into 4 stages (it may look a little scary, but it doesn’t matter, let’s get a rough idea first):

Step1: WebApp initialization and running

1.1. Load YiiBase.php, install the autoload method; load the user's configuration file;

1.2. Create a WebApp application, initialize the App, load some components, and finally execute WebApp

Step2: Controller initialization and operation

2.1. Load the request component, load the Url management component, and obtain routing information route=ControllerId/ActionId 2.2. Create a controller instance and run the controller

Step3: Controller initialization and operation

3.1. Create Action

based on routing

3.2. Create the Filter of the Action according to the configuration; 3.3. Execute Filter and Action

Step4: Rendering stage

4.1, Rendering partial view and rendering layout view

4.2. Render registered javascript and css

2.2, YiiBase static class

YiiBase provides common basic functions for the operation of the YII framework: alias management and object creation management. When creating a php object, you need to include the definition file of this class first, and then new the object.

In different environments (development environment/test environment/online environment), the configuration of apache's webroot path may be different, so the full path of the definition file of this class will be different. The Yii framework passes YiiBase Alias ​​management solves this problem.

When creating an object, you need to import the definition of the corresponding class. You often need to use these 5 functions: include(), include_once(), require(), require_once(), set_include_path(). Yii solves this problem uniformly by using YiiBase::import(). The following figure describes the working principle of "alias management and object creation management" provided by YiiBase:

Create objects through createComponent

1. If the class does not exist, import

Create objects through new

2. The new object

3. Initialize the attributes of this object according to the input

import

Import a class definition

Import a path into

include_path

autoload

If the class starts with an alias, obtain the full path through the ignore management interface

Alias ​​Management

getPathOfAlias ​​setPathOfAlias

Add the full path of an alias

First look at alias management, which is to give an alias to a folder (a folder often corresponds to a module). In the YII framework, you can use this alias to replace the full path of the folder, such as : The system alias represents the path of the framework /home/work/yii/framework, so you can use system.base.CApplication to represent

The path to the /home/work/yii/framework/base/CApplication.php file. Of course, in the application layer (our) code, you can also register aliases through Yii::setPathOfAlias.

Generally, we use absolute paths or relative paths to reference files. Of course, both cases have disadvantages. Absolute path: When our code is deployed to the test environment or online environment, we need to modify the path of the included file in large quantities; Relative path: When the location of some module folders is adjusted (renamed), all relative paths All need to be modified. The way to use aliases only needs to change one thing: when registering aliases, that is Yii::setPathOfAlias(). In this way, code changes caused by changes in folders can be concentrated in one place.

Look at the import function: a. Import the definition of a class so that objects of that class can be created; b. Add a folder to include_path so that you can directly include all files under this file. Yii::import is equivalent to the following

Unification of 5 functions: include(), include_once(), require(), require_once(), set_include_path(). And generally the speed will be faster than these functions. Of course, Yii::import supports the alias function, which can solve the trouble caused by path changes.

Finally, let’s look at object creation. There are 2 methods to create objects in the YII framework: 1. Use the new keyword; 2.

Use Yii::createComponent method.

When using the new keyword to create an object, autoload will look for the definition of the corresponding class in three steps: a. Determine whether it is a class in the framework (all classes of the framework and the full path of this class are saved in A member variable of YiiBase is equivalent to the entire framework being imported); 2. Determine whether to use Yii::import to import this class. For non-framework classes, we need to import this first when creating objects of this class. Class definition; 3. Search the php script named after this class name from the include_path directory, so when developing, try to keep the class name consistent with the file name, so that we can import the folder containing this file. This eliminates the need to import every file in this folder.

When using the Yii::createComponent method to create an object, it provides more functions than the new keyword: a. Specify the location and class name of the class through the full path alias of this class (the class name must Consistent with the file name), when this class has not been imported, the definition of this class will be automatically imported based on the full path; 2. Assign values ​​to the member variables of the created object. That is, as described in the figure below, it used to take more than 3 lines of code to write, but now it can be done with one line of code (write less, do more).

Yii::import('application.models.Student');

$obj = new Student();

$obj->age = 16;

$obj->name = 'jerry';

$obj = Yii::createComponent(array( 'class'=>'application.models.Student', 'age'=>16,

'name'=>'jerry'

));

2.3. Components

The CComponent class is a component, which provides the basis for component programming and event-driven programming of the entire framework. Most classes in the YII framework use the CComponent class as a base class. The CComponent class provides 3 features for its subclasses: 1. Member variable expansion

Define a member variable by defining two member functions (getXXX/setXXX), such as:

public function getText() {…} public function setText {…}

This is equivalent to defining a text member variable, which can be called like this

$a=new CComponent;

$a=$component->text; // Equivalent to $a=$component->getText();

$component->text='abc'; // Equivalent to $component->setText('abc');

CComponent implements the "member variable expansion" feature through the magic methods get and set. If a member variable that does not exist in the class itself is operated on, php will call the get and set methods of this class for processing. . CComponent uses these two magic methods to implement the "member variable expansion" feature. The figure below describes a subclass of CComponent, which adds two member variables active and sessionName. The figure describes the calling process for these two member variables.

getActive

setActive

Whether this member variable exists

No set()

get()

getSessionName

setSessionName

is to use the member variables of this object

getXXX setXXX

In object-oriented programming, it is enough to directly define a member variable. Why does CComponent implement a member variable by defining 2 functions? One of the main reasons is the need to "delay loading" of member variables. Generally, the member variables of a class are uniformly assigned in the constructor or initialization function, but not every member variable is assigned during the processing of a web request. will be used. For example, the App class defines two member variables: $cache and $db

($cache is a cache object, $db is a database link object), these two objects are initialized when the App class is initialized

is created at the moment, but for some pages of a web website, the content of which can be obtained through cache, then the database link object does not actually need to be created. If you define App as a subclass of CComponent, define two methods in the App class: getCache/getDb, so that when you use the db member variable for the first time, you can call the getDb function to initialize the database link, thus Implement lazy loading - i.e. initialize on first use. Although delayed loading will add one more function call, it can reduce unnecessary initialization of member variables (generally improving the access speed of the website), and can make our code easier to maintain and expand.

Delayed loading should be the most important use of the "member variable expansion" feature. Of course, this feature also has other uses. Think about it, when you operate a member variable, you are actually calling getXXX and setXXX member functions, you are calling a piece of code!

2. Event model

The event model is the "observer pattern" in the design pattern: when the state of an object changes, then this object can notify other objects of the event.

In order to use the event model, you need to implement these three steps: 1. Define the event; 2. Register the event handler; 3. Trigger the event.

A subclass of CComponent defines an event by defining a member function starting with on, such as: public function onClick(){…}, and then registers the event handler by calling the attachEventHandler member function (you can register multiple event handle), and finally trigger the event by calling raiseEvent.

attachEventHandler detachEventHandler raiseEvent

Event handler container

onclick

fun_11 fun_12

„ fun_1n

beforeinsert

fun_2n

afterinsert

fun_3n

„„

Key

fun_m1

fun_m1

Value

fun_mn

The CComponent class uses a private member variable to save the event and all handles for processing the event. This member variable can be regarded as a hash table. The key of the hash table is the name of the event, and the value of the hash table is Event handling function linked list.

3. Behavioral binding

There are two ways to add features to a class: 1. Directly modify the code of this class: add some member functions and member variables; 2. Derive: extend through subclasses. Obviously the second method is easier to maintain and expand. If multiple features need to be added to a class (multiple people at different times), then multi-level derivation is required, which obviously increases maintenance costs. CComponent uses a special way to extend class information - behavior class binding. Behavior class is a subclass of CBehavior class. CComponent can add member functions and member variables of one or more CBehavior classes

to yourself and uninstall certain CBehavior classes when not needed. Here is a simple example:

//Calculator class

class Calculator extends CBehavior

{

public function add($x, $y) { return $x + $y; } public function sub($x, $y) { return $x - $y; }

...

}

$comp = new CComponent();

//Add calculator function to my class

$comp->attachbehavior('calculator', new Calculator());

$comp->add(2, 5);

$comp->sub(2, 5);

CComponent implements the "behavior class binding" feature through three magic methods: get, set and call. When calling member variables and member methods that do not exist in the CComponent class, the CComponent class will pass these three magic methods. A magic method is looked up on a "dynamically bound behavior object". That is, routing non-existent member variables and member methods to "dynamic binding objects".

attachBehavior detachBehavior

Bind an object Unbind

obj1

set()

obj2

Doesn’t exist

No get()

Query each object

call()

obj3

is

Use the member variables and member functions of this object

„

Bound object

Use binding object process Binding maintenance process

You can use 3 sentences to summarize the characteristics of the CComponent class:

1. Better configure an object. When setting the member variables of the object, you are actually running a piece of code;

2. Better monitor an object. When the internal state of the object changes, other objects can be notified;

3. To better extend an object, you can add member variables and member functions to an object, and you can also monitor the status of the object.

2.4, module

Modules are relatively independent program units in the entire system, completing a relatively independent software function. For example, the gii module that comes with Yii implements the function of online code generation. CModule is the base class of all module classes. It consists of 3 parts:

a. Basic attributes (module id, module path, etc.); b. Component, which is the core component of the module. The module can be regarded as a container for these components; c. Submodule, which provides the module with Scalability, for example, if a module becomes larger, it can be split into multiple sub-modules (each

sub-module also consists of these 3 parts and is a recursive structure). The following figure is a diagram of the inclusion relationship between a module and its members:

Template base

This attribute component submodule

The following table lists the various components of CModule:

3 部分	详细成员	说明
基本属性 (用户对整个模块的全局性 的东西进行配置)	id	模块的 id
	parentModule	父模块
	basePath	当前模块的路径
	modulePath	子模块的路径
	params	模块的参数
	preload	需要预先加载的组件 id
	behaviors	绑定的行为类
	aliases	新增加的别名，添加到 YiiBase 的别名管理中
	import	需要包含的文件或者路径
组件 (这是模块的核心组成部分)	components	数组类型，数组的每个成员描述了一个组件
子模块 (这为模块提供了扩展性)	modules	数组类型，数组的每个成员描述了一个模块， 每个模块也是有这 3 部分组成，是递归结构

Part 3

Detailed members

Description

Basic attributes

(Users configure global things of the entire module)

id

Module id

parentModule

Parent module

basePath

Path of the current module

modulePath

Path of submodule

params

Module parameters

preload

Component id that needs to be pre-loaded

behaviors

Binded behavior class

aliases

The newly added alias is added to the alias management of YiiBase

import

File or path to be included

Component

(This is the core component of the module)

components

Array type, each member of the array describes a component

Submodule

(This provides extensibility to the module)

modules

Array type, each member of the array describes a module,

Each module also consists of these 3 parts, which is a recursive structure

It is very convenient to initialize these three components of the module: use an array for configuration. The key of the array is the attribute that needs to be configured, and the value is the value that needs to be configured. The figure below is an example. Why Will it be configured in this way? Because CModule inherits from the CComponent class, when configuring member properties, it is actually running a piece of code, that is, a member function.

array(

'basePath'=>dirname( FILE ).DIRECTORY_SEPARATOR.'..',//The path of the module 'preload'=>array('log'),//The log component needs to be preloaded

'import'=>array('application.models.*', 'application.components.*',),//The path to include

//Component configuration

'components'=>array( 'user'=>array(//Configuration of user components

'allowAutoLogin'=>true

),

'log'=>array(//Configuration of log component 'class'=>'CLogRouter',

'routes'=>array(array('class'=>'CWebLogRoute','levels'=>'trace, profile'))

)

),

//Module configuration

'modules'=>array(

'gii'=>array(//Automatically generate code module configuration 'class'=>'system.gii.GiiModule', 'password'=>'123456'

),

),

);

2.5, App Application

Application refers to the execution context in request processing. Its main task is to analyze user requests and dispatch them to the appropriate controller for further processing. It also serves as a service center, maintaining application-level configurations. For this reason, applications are also called "front-end controllers".

Yii uses the CApplication class to represent App applications. CApplication inherits from CModule. It has made three extensions based on the parent class: 1. Added a run method; 2. Added several member attributes; 3. Added several components.

The run method is equivalent to the main function of C language. It is the entry point for the entire program to start running. The virtual function processRequest is called internally to process each request. CApplication has 2 subclasses: CWebApplication and CConsoleApplication, both of which are implemented the method. The onBeginRequest and onEndRequest events are initiated at the beginning and end of processing each request to notify listening observers. Review the "Yii Framework Loading and Running Process" diagram, from which you can find the role of this method in the entire process.

The added member variables, member functions and components are shown in the table below:

Category	Name	Description
Member variables	name	Name of the application
	charset	The encoding set applied, the default is UTF-8
	sourceLanguage	The language and region ID number used for encoding, which is needed when developing multiple languages, Default is UTF-8
	language	The language and region ID required by the app, the default is sourceLanguage
	runtimePath	The path during runtime, for example, the global state will be saved to this path, default thinks application.runtime
	extensionPath	The path to put third-party extensions, the default is application.ext
	timezone	Get or set time zone
	locale	Localization object, used to localize time, numbers, etc.
	globalsate	Global state array, which will be persisted (implemented by statePersister)
Component	coreMessages	Translate the framework layer content and support multiple languages
	messages	Translate application layer content and support multiple languages

	db	数据库组件
	errorHandler	异常处理组件，该组件与 App 配合来处理所有的异常
	securityManager	安全管理组件
	statePersister	状态持久化组件
	urlManager	url 管理组件
	request	请求组件
	format	格式化组件

db Database component errorHandler Exception handling component, which works with the App to handle all exceptions securityManager Security Management Component statePersister State persistence component urlManager url management component request Request component format Formatting component

2.6, WebApp Application

Each web request is processed by the WebApp application, that is, the WebApp application provides a running environment for the processing of http requests. The WebApp application is the CWebApplication class. Its main job is to create the corresponding control class based on the route in the url. The following figure describes the controller creation process, which mainly consists of 3 steps:

1. Search in the member variable controllerMap to determine whether there is a corresponding Controller. ControllerMap has the highest priority

2. Search in the sub-module to determine whether there is a corresponding Controller 3. Search

in the ControllerPath and its subfolders

The process of searching for a controller

The input route is: seg1/seg2/seg3

Call createController(‘seg1/seg2/seg3’,$app)

1

Look for the control class with id seg1 in controllerMap

Call createController(‘seg2/seg3’,

$subModule)

2 does not exist

Recursive call

在id为seg1的子模块 中寻找

Look for

in the submodule with id seg1

does not exist

3

Look for

layer by layer under the ControllerPath path

Does ControllerPath/seg1/Seg2Controller.php exist? ControlId is /seg1/seg2

does not exist. Does ControllerPath/seg1/seg2/Seg3Controller.php exist?

ControlId is /seg1/seg2/seg3

类别	名称	说明
成员变量	defaultController	默认的控制类，如果没有指定控制器，则使用该控制器
	layout	默认的布局，如果控制器没有指定布局，则使用该布局
	controllerMap	控制器映射表，给某些特定的路由指定控制器
	theme	设置主题
	controller	当前的控制器对象
	controllerPath	控制器文件的路径

The important member variables, member functions and components added are shown in the table below:

Category	Name	Description
Member variables	defaultController	Default control class, if no controller is specified, this controller will be used
	layout	Default layout, if the controller does not specify a layout, this layout will be used
	controllerMap	Controller mapping table, specify controllers for certain routes
	theme	Set theme
	controller	Current controller object
	controllerPath	Path to controller file

	ViewPath	视图层文件的路径，默认为 protected/views/
	SystemViewPath	系统视图文件的路径，默认为 protected/views/system/
	LayoutPath	布局文件的路径，默认为 protected/views/layouts/
组件	session	session 组件
	assetManager	资源管理组件，用于发布私有的 js、css 和 image
	user	用户组件，用户登录等
	themeManager	主题组件
	authManager	权限组件，实现了基于角色的权限控制
	clientScript	客户端脚本管理组件，管理 js 和 css 代码

ViewPath

The path of the view layer file, the default is protected/views/

SystemViewPath

The path of the system view file, the default is protected/views/system/

LayoutPath

The path to the layout file, the default is protected/views/layouts/

Component

session

session component

assetManager

Resource management component for publishing private js, css and image

user

User components, user login, etc.

themeManager

Theme Component

authManager

Permission component implements role-based permission control

clientScript

Client-side script management component, manages js and css code

3. System components

3.1. Log routing component

Every Web system needs to record logs during operation. Logs can be recorded to files or databases. During the development phase, logs can be output directly to the bottom of the page, which can speed up development. Yii has done the following two important tasks in log processing:

1. Each Http request may need to record multiple logs (database update log/interaction log with other systems). For example, if a certain HTTP request needs to record 18 logs, should we write to the hard disk once for each log (that is, write 18 hard disks), or should we write to the hard disk all at once when the request is about to end? Obviously, it is faster to save these logs in a php array first. When the request is about to end, it is faster to write all the logs in the array to the hard disk at once.

2. Each log can be classified from 2 dimensions: the severity level of the log and the business logic of the log. Use the table below

To describe the logs of "Baidu Creative Expert" products in these two dimensions:

业务逻辑 严重级别	数据库日志	用户中心接口日志	Drmc 接口日志	Memcache 日志
trace
info
profile
warning
error

Business logic

Severity Level

Database log

User Center Interface Log

Drmc interface log

Memcache Log

trace

info

profile

warning

error

According to business logic, it is divided into: database operation log, user center interface log, Drmc interface log, Memcache update log, etc.

Divided according to severity level: trace, info, profile, warning, error. We may want to record logs of different business logic (database logs, logs interacting with other systems) to different

In the files of

, you can view them by categories. Because error logs are generally serious, we may also want to log all errors to a separate file or mongodb. The log routing component in Yii can route different types of logs to different destinations (files, databases, mailboxes, and pages), which makes it very convenient to maintain and manage logs.

The following is the configuration of a log routing component. This configuration records logs of different business logic into different files, records error logs separately into the error.log file, and sends serious logs directly to emails. During the development process, logs are also output to the page, which speeds up development. The specific configuration is as follows:

'log'=>array(

'class'=>'CLogRouter', 'routes'=>array(

array(//Database logs are recorded in db.log 'class'=>'CFileLogRoute', 'categories'=>'db.*', 'logFile'=>'db.log ',

),

array(//The log of interaction with the user center is recorded in uc.log 'class'=>'CFileLogRoute', 'categories'=>'uc.*',

'logFile'=>'uc.log',

),

array(//The log of interaction with Drmc is recorded in uc.log 'class'=>'CFileLogRoute', 'categories'=>'drmc.*', 'logFile'=>' drmc.log',

),

array(//All error logs are recorded in error.log 'class'=>'CFileLogRoute', 'levels'=>'error', 'logFile'=>'error.log ',

),

array(//Because the user center is very important, all user center error logs need to be sent out of the email

'class'=>'CEmailLogRoute', 'categories'=>'uc.*', 'levels'=>'error', 'emails'=>'admaker@baidu.com ',

),

array(//During the development process, print all logs directly to the bottom of the page, so you don’t need to log in to the server to view the logs

'class'=>'CWebLogRoute' 'levels'=>'trace,info,profile,warning,error',

),

)

As you can know from the above code, Yii’s logging is driven by the configuration array. Next, log in Yii

Processing for in-depth analysis, the following figure describes the process and principle of log processing in Yii:

1. Generate multiple logging objects according to the configuration of the log routing component

Log routing component

Logging object 1

db.log

2. Save the log to the log buffer

Log buffer

3. Notify the log routing component when the buffer is full or the request ends

Logging object 2

. . .

uc.log

Logging object i

5. Output the log to the specified destination

Send email log

4. Each logging object takes out the log it needs from the buffer

Logging object N

Log output to page

During an HTTP request, the log processing process is divided into the following 5 stages:

Step1: Based on the configuration information of the log router, generate each logging object, namely CFileLogRoute,

CEmailLogRoute and CWebLogRoute objects, the log routing component manages these objects uniformly;

Step2: The programmer calls the logging interface (see the table below) to record logs. All logs are temporarily saved in a php array buffer;

Step3: When the buffer is full or the request processing ends, a Flush event will be triggered to notify the log routing component to retrieve the log. The observer mode is used here;

Step4: Each logging object takes out the logs it needs, such as database logs, user center interaction logs, and error level logs.