Sometimes, when you are creating custom solutions in PHP, you don’t have the luxury of speedup caches in Ecommerce and CMS frameworks. The problem is that people arent always experts in database design, and SQL, so pages with messy queries in them tend to load slowly. This can lose visitors interest, and if its ecommerce related, sales.

The idea is simple. Only query the databases when the content changes. If the same content is going to be fed out all the time, then why would you waste your time re-building that content, every time something hit your page?

It’ll save you money if your page gets hit a lot, and it’ll make people happier when they get your page quicker.

So, we keep a copy of the generated page first time its looked at. Using the full url as a reference, we keep them, and when someone asks for the same page again, we give them the cached copy. It’s much faster to do this.

So, lets get stuck in

Create a file called “cache_header.php” containing this:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

<?php
 
$starttime = microtime();
$startarray = explode(" ", $starttime);
$starttime = $startarray[1] + $startarray[0];
 
// Settings
$cachedir = 'cache/'; // Directory to cache files in (keep outside web root)
$cachetime = 600; // Seconds to cache files for
$cacheext = 'cache'; // Extension to give cached files (usually cache, htm, txt)
 
// Ignore List
$ignore_list = array(
'domainname.co.uk/ignorethis.php',
'domainname.co.uk/ignorethisaswell.php'
);
 
// Script
$page = 'http://' . $_SERVER['HTTP_HOST'] . $_SERVER['REQUEST_URI']; // Requested page
$cachefile = $cachedir . md5($page) . '.' . $cacheext; // Cache file to either load or create
 
$ignore_page = false;
for ($i = 0; $i < count($ignore_list); $i++) {
$ignore_page = (strpos($page, $ignore_list[$i]) !== false) ? true : $ignore_page;
}
 
$cachefile_created = ((@file_exists($cachefile)) and ($ignore_page === false)) ? @filemtime($cachefile) : 0;
@clearstatcache();
 
// Show file from cache if still valid
if (time() - $cachetime < $cachefile_created) {
ob_start('ob_gzhandler');
@readfile($cachefile);
ob_end_flush();
exit();
 
}
 
// If we're still here, we need to generate a cache file
 
ob_start();
?>

Then create a file called “cache_footer.php” containing:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

<?php
 
$endtime = microtime();
$endarray = explode(" ", $endtime);
$endtime = $endarray[1] + $endarray[0];
$totaltime = $endtime - $starttime;
$totaltime = round($totaltime,5);
 
echo "<!-- This page took $totaltime seconds to generate -->";
 
// Now the script has run, generate a new cache file
$fp = @fopen($cachefile, 'w');
 
// save the contents of output buffer to the file
@fwrite($fp, ob_get_contents());
@fclose($fp);
 
ob_end_flush();
 
?>

in the same folder, create a folder called ‘cache’ and set it to writable by the php, using an FTP client:

Screenshot of permissions

Finally, implement the cache on your dynamic page:

1
2
3
4
5
6
7

<? require('cache_header.php'); ?>
 
<?
//this is dynamic php
?>
 
<? require('cache_footer.php'); ?>

This effectively creates static html of a dynamic file and saves it to the cache. The cache is used if the same url is requested within a certain timeframe. This means that database intensive popular pages load instantly.

Good eh?

The real problem with this system is that it does not pay any attention to pages that are dynamically different due to logins and sessions.

Don’t randomly implement this on any old php software. this is a bare bones example. In order for this to work in a complex example where individuals with different credentials are likely to see different pages, you’d need to have the system aware of their credentials, and display a fresh version of the page, based on the presence of an individual. This is NOT covered in the example, and it assumes that every user gets the same page.

What I tend to do, is leave the main page uncached, and any elements that are custom to the user and experience uncached.

The included elements i will cache. For example, my popular products block, i will cache. When they are pulled into the page by the server, the server merely includes a file, instead of drawing from a database.

Overall this hybrid approach isnt as speedy as caching the entire page, but its very close and as a performance versus benefit tradeoff, it works very well indeed.