Cache Content to Speed Up Slow Loading Web Pages

Dynamic web pages that make constant database calls and run many data processing tasks eat up server resources and increase page load times. In this tutorial, learn 3 content caching techniques to increase web page speed.

More and more sites contain dynamic vs static content web pages. These pages make constant database calls and run many data processing tasks. This eats up server resources and also increases your page load times. In this tutorial I will show you 3 server side content caching methods I’ve used in my web applications.

I will also show you how to use and implement Zend_Cache (part of the Zend Framework) to start caching content in your web apps.

#1 Caching All the Output

Caching page output is a great quick way to increase web page speed. The script content is generated once and cached for a duration of time, subsequent requests always get pulled from the content cache. The key benefit here is that all content going to the browser is cached and almost all server side processing is eliminated.

Using Zend_Cache to implement:

<?php 

require_once 'Zend/Cache.php';

$cache = Zend_Cache::factory
(
	'Page' // frontend caching method
	, 'File'
	, array('lifetime'=>3600)
	, array('cache_dir'=>$_SERVER['DOCUMENT_ROOT'] . '/cache')
);

$cache->start('uniquePageName');

// PAGE CONTENT

?>

Keep in mind that this is still a server side solution. There are added benefits to also implementing a client side caching solution using Expire and Modified-If or E-Tag headers where the browser pulls content from it’s web page cache rather than make another server request.

For the moment, it’s not implemented but we plan to add a HTTP conditional system to save bandwidth (the system will send a HTTP 304 Not Modified if the cache is hit and if the browser has already the good version).

#2 Cache Protions of the Output

This technique is rather interesting, allowing portions of a web page to remain dynamic while making other portions static through content caching. The benefit (which is speed) comes when you strike a balance between what content can be static and what remains dynamic. Ask yourself, what does “dynamic” mean to you and your users. If your content does not need to be “to-the-second” fresh, perhaps setting a lower cache expiration time (10-30 minutes) would suffice.

Using Zend_Cache to implement:

<?php 

require_once 'Zend/Cache.php';

$cache = Zend_Cache::factory
(
	'Output' // frontend caching method
	, 'File'
	, array('lifetime'=>3600)
	, array('cache_dir'=>$_SERVER['DOCUMENT_ROOT'] . '/cache')
);

if (!($cache->start('uniqueContentName'))) 
{
	// PAGE CONTENT

	$cache->end(); // output buffering ends
}

// DYNAMIC PAGE CONTENT

?>

#3 Caching Function Output

Another unique concept is the idea of caching the output of functions and methods. Reading cached function output is typically faster then hitting the database with a query. For data that doesn’t often change or data that doesn’t require constant freshness, this may be an ideal solution. I think this caching method is more attractive when dealing with complex web applications where you have interconnected components.

Using Zend_Cache to implement:

<?php 

function fooBar()
{
	require_once 'Zend/Cache.php';

	$cache = Zend_Cache::factory
	(
		'Core' // frontend caching method
		, 'File'
		, array('lifetime'=>3600,'automatic_serialization' => TRUE)
		, array('cache_dir'=>$_SERVER['DOCUMENT_ROOT'] . '/cache')
	);

	$cache_id = 'uniqueFunctionName';

	$rows = $cache->load($cache_id);

	if (!$rows)
	{
		$rows = array();

		// FUNCTION CONTENT

		$cache->save($rows, $cache_id);
	}

	return $rows;
}

?>

Here is a real world example from a method call I use at YomoMedia:

static function getSubscriberCounts()
{
	require_once 'Zend/Cache.php';

	$cache = Zend_Cache::factory
	(
		'Core'
		, 'File'
		, array
		(
			'lifetime' => 3600
			,'automatic_serialization' => TRUE
		)
		, array
		(
			'cache_dir' => SP_CACHE_LOCATION
		)
	);

	$cache_id = 'Bundle_getSubscriberCounts';

	$rows = $cache->load($cache_id);
	
	// check if rows were cached
	if (!$rows)
	{
		$rows = array();

		$sql =
		"
			SELECT
				b.bundle_id
				, COUNT(DISTINCT bs.user_id) AS subscriber_count

			FROM
				bundle_subscriptions AS bs

				INNER JOIN bundles AS b
					ON b.bundle_id = bs.bundle_id

				INNER JOIN users AS u
					ON u.user_id = bs.user_id
					AND u.role != 'temp'

			GROUP BY
				b.bundle_id
		";

		$result = @mysql_query($sql);

		if ($result)
		{
			while($row = @mysql_fetch_assoc($result))
			{
				// use id as key to be able to do faster lookups
				$rows[$row['bundle_id']] = $row['subscriber_count'];
			}

			@mysql_free_result($result);

			// generate a table to provide other methods and queries a JOIN
			
			$tb = 'gen_bundle_subscriber_counts';
			
			@mysql_query("DROP TABLE IF EXISTS `$tb`");

			$sql_create =
			"
				CREATE TABLE `$tb`
				(
					`bundle_id` int(11) unsigned NOT NULL DEFAULT '0'
					, `subscriber_count` int(10) NOT NULL DEFAULT '0'
					, PRIMARY KEY (`bundle_id`)
				) TYPE=MyISAM;
			";

			@mysql_query($sql_create);

			$sql = 'INSERT INTO `' . $tb . '` ' . $sql;

			@mysql_query($sql);

			$cache->save($rows, $cache_id);
		}
	}
	
	return $rows;
}

Tell me if you’ve used any of these content caching methods before and how it’s worked for you?