Initializing PHP classes in the Web server/browser context - php

Question

I am writing a script that talks to a database, and transforms the content and puts it into an XML file.
I am trying to utilize best practices, and as part of library re-use, I have found the following classes to be beneficial:
Symfony components:
Yaml : for parsing and loading database info.,
DI Container : for injecting dependencies
Others:
PHPExcel, the amazing excel library
Doctrine DBAL to get an easy PDO wrapper
Mockery for obtaining easy mocks during testing
My core business class, ExcelExporter, will need all these files functioning harmoniously with each other. I also need a place where I can initialize by own class, and inject these dependencies in.
I am confused as to where to do this. If I were building a web page, I'd say I'd put the initialization & configuration process inside index.php and finally call ExcelExporter to do its thing when a user loads index.php in the browser. Is there a better way for this bootstrapping process? What's the most common approach?

Answer 1

You should totaly use Composer for this task.
It will handle vendors and autoloading for you.
Here is a quick setup:
curl -s https://getcomposer.org/installer | php
php composer.phar init
php composer.phar require symfony/dom-crawler:dev-master doctrine/dbal:2.4.x-dev
php composer.phar install
You will have a vendor directory with your dependencies. Then the bootstrap file is simply initializing what you have to do. Autoloading is handled by Composer:
// Then add this on top of your bootstrap file
require 'vendor/autoload.php';

Answer 2

I assume you are not using any framework. Only using symphony components. If you were using a framework it would have been done by the framework. But for vanila framework you need
A single entry point for the application (say index.php)
A bootstrap.php file that loads initial classes and external resources. Many framework uses this bootstrap files. Just look at the file structure you'll find them. The name might not be bootstrap.php.
Once your application is loaded use a autoloader to load on-demand classes. This autoloader should be initialized on bootstrap.
function my_autoloader($class) {
include 'classes/' . $class . '.class.php';
}
spl_autoload_register('my_autoloader');

Answer 3

Based on Damien's answer, I found that Composer offers the easiest method to do this.
Now, my ExportExcel class lives in the src/ directory. The structure of my directory is:
src/
vendor/
index.php
bootstrap.php
composer.json
Within composer.json, I also asked it to load my classes for me:
{
"name": "adityamenon/excel_export",
"description": "Export data into a custom excel sheet format",
"require": {
"symfony/dependency-injection": "2.2.x-dev",
"symfony/yaml": "2.1.x-dev",
"doctrine/dbal": "2.4.x-dev",
"mockery/mockery": "dev-master",
"CodePlex/PHPExcel": "1.7.8"
},
"autoload": {
"psr-0": {"ExportExcel": "src/"}
},
"authors": [
{
"name": "aditya menon",
"email": "adityamenon90#gmail.com"
}
]
}
I just need to run $ composer install for all the dependencies to appear magically within vendor/.
PSR-0 is easy to follow. I just made a file called ExportExcel.php with a namespaced class inside called ExportExcel:
namespace ExportExcel;
class ExportExcel {
public function __construct(\ExportExcel\DbConvenience $db_convenience)
{
$this->DbConvenience = $db_convenience;
}
public function writeExcelFile()
{
// ...do stuff here
}
}
Finally, here's bootstrap.php, which takes care of autoloading stuff I need as well as injecting dependencies:
<?php
// composer autoloads dependencies
// also configured to load from src/
$loader = require('vendor/autoload.php');
// load configuration (only db right now)
use Symfony\Component\Yaml\Yaml;
$yaml_config = Yaml::parse('config.yml');
// load the database
$db_config = new Doctrine\DBAL\Configuration();
$conn = Doctrine\DBAL\DriverManager::getConnection($yaml_config, $db_config);
// load the convenience classes
$DbConvenience = new ExportExcel\DbConvenience($conn);
// use the dependency injector to load the exporter with DB
use Symfony\Component\DependencyInjection\ContainerBuilder;
use Symfony\Component\DependencyInjection\Reference;
$sc = new ContainerBuilder();
$sc->setParameter('dbconvenience.class', 'ExportExcel\DbConvenience');
$sc->setParameter('exportexcel.class', 'ExportExcel\ExportExcel');
$sc
->register('dbconvenience', '%dbconvenience.class%')
->addArgument($conn);
$sc
->register('exportexcel', '%exportexcel.class%')
->addArgument(new Reference('dbconvenience'));
// here's the most important class of 'em all
$ExportExcel = $sc->get('exportexcel');
Finally in index.php, the first line is require('bootstrap.php');, and off I go. I can make calls to functions inside ExportExcel with $ExportExcel->doStuff();
Please feel free to add comments and shorten/improve this answer. Solving this puzzle was a bit hard and took a bit of reading around but everything is so clear in hindsight.