One trivial optimization you can do to increase the speed of class loading is to pay careful attention to your include_path. In particular, you should do four things: use absolute paths (or paths relative to absolute paths), reduce the number of include paths you define, have your Zend Framework include_path as early as possible, and only include the current directory path at the end of your include_path.
While this may seem a micro-optimization, the fact is that if you don't, you'll get very little benefit from PHP's realpath cache, and as a result, opcode caching will not perform nearly as you may expect.
There are two easy ways to ensure this. First, you can hardcode
the paths in your
.htaccess. Second, you
can use PHP's
realpath() function when
setting your include_path:
$paths = array( realpath(dirname(__FILE__) . '/../library'), '.', ); set_include_path(implode(PATH_SEPARATOR, $paths);
You can use relative paths -- so long as they are relative to an absolute path:
define('APPLICATION_PATH', realpath(dirname(__FILE__))); $paths = array( APPLICATION_PATH . '/../library'), '.', ); set_include_path(implode(PATH_SEPARATOR, $paths);
However, even so, it's typically a trivial task to simply pass
the path to
Include paths are scanned in the order in which they appear in the include_path. Obviously, this means that you'll get a result faster if the file is found on the first scan rather than the last. Thus, a rather obvious enhancement is to simply reduce the number of paths in your include_path to only what you need. Look through each include_path you've defined, and determine if you actually have any functionality in that path that is used in your application; if not, remove it.
Another optimization is to combine paths. For instance, Zend Framework follows PEAR naming conventions; thus, if you are using PEAR libraries (or libraries from another framework or component library that follows PEAR CS), try to put all of these libraries on the same include_path. This can often be achieved by something as simple as symlinking one or more libraries into a common directory.
Continuing from the previous suggestion, another obvious optimization is to define your Zend Framework include_path as early as possible in your include_path. In most cases, it should be the first path in the list. This ensures that files included from Zend Framework are found on the first scan.
Most include_path examples show using the current directory, or '.'. This is convenient for ensuring that scripts in the same directory as the file requiring them can be loaded. However, these same examples typically show this path item as the first item in the include_path -- which means that the current directory tree is always scanned first. In most cases, with Zend Framework applications, this is not desired, and the path may be safely pushed to the last item in the list.
Example 1070. Example: Optimized include_path
Let's put all of these suggestions together. Our assumption will be that you
are using one or more PEAR libraries in conjunction with
Zend Framework -- perhaps the PHPUnit and
libraries -- and that you occasionally need to include
files relative to the current file.
First, we'll create a library directory in our project. Inside that
directory, we'll symlink our Zend Framework's
directory, as well as the necessary directories from our PEAR
library Archive/ PEAR/ PHPUnit/ Zend/
This allows us to add our own library code if necessary, while keeping shared libraries intact.
Next, we'll opt to create our include_path programmatically
public/index.php file. This allows us to move
our code around on the file system, without needing to edit the
include_path every time.
We'll borrow ideas from each of the suggestions above: we'll use
absolute paths, as determined using
we'll include Zend Framework's include path early; we've
already consolidated include_paths; and we'll put the current
directory as the last path. In fact, we're doing really well
here -- we're going to end up with only two paths.
$paths = array( realpath(dirname(__FILE__) . '/../library'), '.' ); set_include_path(implode(PATH_SEPARATOR, $paths));