Simple page buffering technology in PHP

Page

Actually say it is technology, may not be said to be the real technology. This is just the way I want to deal with the page, of course, with other people's ideas may be consistent. But I still want to give it a nice name. So what is the page buffer I'm referring to here? is to save a dynamically generated page for the next use. So the next time you access it, it may not need to be dynamically generated. It's like providing a cache. On my website, maybe your site is the same, using a technology like a template
So that the page that the user sees is dynamically generated. But a page for you is this, for others may still be, that is, in a period of time will not change, if the last generated results directly to the next access to the user is not better? Reduces the generation time, the efficiency is some higher. I think with the development of the site, speed and efficiency issues still need to be considered. Here I give my realization, hope to be helpful to everybody. Just a thought, no concrete implementation.

Use conditions

Is it best to use all the pages? I think it's not necessary and impossible. Buffering is because the next access may be exactly the same as the previous access. So it's not appropriate for pages that are constantly changing. For example, the page to display the count information is not appropriate. Also is if your dynamic page output, not first output to the variable, but directly back to the user, such as the use of Echo,print, ReadFile and so on output, I personally think that is still not done. Because the output knot cannot be
Get it, save it to the file (anyway, I was thinking for a long time not figuring out what to cut down and redirect the output directly to the file). Then the more appropriate dynamic page processing is: The output should be able to put into a string. So the use of the condition is: 1. The page basically does not change 2. Dynamic page processing results can be stored in a string.

It would be nice to use a template class to process a dynamic page. The processing of a template class is ideal for saving a processed page by setting replaceable variables in the template, and then replacing the variables in the corresponding template with the actual values, as well as putting the results in a string for output. Of course, it is also possible to generate output results from the processing of strings without using template classes. As for how to do it, we will not discuss it.


Realize

As mentioned earlier, not a real implementation, but a realization of the idea.

Processing process:

1. Generate the buffer file name according to the requirements of the visit

2. See if the filename exists, if the file does not exist, generate a dynamic page, save the page, output the results, end; If present, perform step 3rd

3. Time of modification of statistical files and time of modification of files related to dynamic page generation

4. Compare buffer file modification time and other page modification time, if other page modification time is larger than the buffer file modification time, thought the dynamic result may change, then regenerates the dynamic page result, saves in the file, and the output result, ends; otherwise, perform step 5th

5. Description of the latest buffer file, then direct output buffer file

That's what I'm dealing with. As for how to save a buffer file, you can build a temporary directory or use database processing. If the database is used to determine whether the latest way the file should also be changed, such as in the database to increase the generation time field, compare this time field and other files modified time. Method everyone wants to be himself.

Examples of my specific implementations

To help everyone have a perceptual knowledge, here I give a file-based approach implemented on my home page. Only the main processing code is incomplete.

----------------------------------------------------------------------
----------
?
1 $tmpfile = ". /tmp/". basename ($REQUEST _uri);
2 $tmpfile =str_replace ("?", "_", $tmpfile);
3 $tmpfile =str_replace ("&", "_", $tmpfile);
4 if (file_exists ($tmpfile))
5 {
6 $cflag =false;
7 $dtmp =filemtime ($tmpfile);
8 $itmp =filemtime ($incfile);
9 $cflag = $cflag | ($dtmp < $itmp);
$ctmp =filemtime (_self) (basename ($PHP));
One $cflag = $cflag | ($dtmp < $ctmp);
$ttmp =filemtime ("template/content.ihtml");
$cflag = $cflag | ($dtmp < $ttmp);
14}
Else
$cflag =true;
17
if (! $cflag)//Use Existing Files
19 {
ReadFile ($tmpfile);
Exit;
22}
23
24//Create a new file
Include "TEMPLATE.CLASS.PHP3";
26
$FP =fopen ($incfile, "R");
$content =fread ($fp, FileSize ($incfile));
Fclose ($FP);
30
31//below template processing
$t = new Template ("Template", "keep");
33
$t->set_file ("ContentFile", "content.ihtml");
35
$t->set_var (
Panax Notoginseng Array (
"Content" => $content
39));
40
$t->parse ("Outputcontent", "contentfile");
42
$FP =fopen ($tmpfile, "w");
if ($FP)
45 {
Flock ($FP, 3);
Fwrite ($fp, $t->get_var ("outputcontent"));
Flock ($FP, 1);
Fclose ($FP);
50}
Wuyi $t->p ("outputcontent");
?>
----------------------------------------------------------------------
----------
Let me introduce you to my directory structure:

/---Directory of bin/executing programs
| |--CONTENT.PHP3 program for working with file display
| |--template/the directory used to store template files
| | |---content.ihtml template file
|-docs/Data files
|-tmp/Storage Buffer File

CONTENT.PHP3 files are used to process dynamic pages. Users can read a data file through the Content.php3?page=id number. I will not say the specific method, as long as you know each data file has a different ID number, so that the way the Content.php3?page=id number can uniquely identify a data file.

第1-3 line to generate a temporary file name. Replace the '? ', ' & ' characters with ' _ '.
Line 4th, to determine whether the temporary file name exists, and if so, execute the 第18-22 line and end it.
第6-13 the row to determine which update of the file modification time associated with generating the dynamic page and the temporary file, and set the rebuild flag. Use Filemtime () here to get the last modification time.
第24-41 rows, using the template class to generate dynamic results, placed in the variable. About the template processing can refer to the "template, Phplib processing method" article.
第43-50 line to generate temporary files. The file is lock processed here as a write conflict.
Line 51st, output results.

This is my deal, you can change it by yourself.

Buffering is a meaningful technology that can improve access speed and reduce system consumption. But there may be a variety of ways in which we can play freely.