phpaddiction » url routing http://www.phpaddiction.com Wed, 23 Sep 2009 19:08:34 +0000 en hourly 1 http://wordpress.org/?v=3.0 Url Routing with PHP – Part Three http://www.phpaddiction.com/tags/php/url-routing-with-php-part-three/ http://www.phpaddiction.com/tags/php/url-routing-with-php-part-three/#comments Mon, 16 Apr 2007 03:01:21 +0000 Doug Hill http://www.phpaddiction.com/tags/php/url-routing-with-php-part-three/ Url Routing with PHP - Part One and Url Routing with PHP - Part Two.]]> In the final part of this series, I will build a functional modular front controller that can be easily adapted to small projects. It is basically the "C" in MVC for a simple MVC framework. If you haven't read the first two articles I recommend that you read over them first. Url Routing with PHP – Part One and Url Routing with PHP – Part Two.

Requirements

  • Apache with mod_rewrite enabled
  • PHP

A few changes

If you have followed along with the series you will see a few changes to the code that I left you with in Url Routing with PHP – Part Two. The Axial_URLInterpreter and the Axial_Command object received a few minor changes suggested via comments on the previous articles. Most of the changes are in the Axial_CommandDispatch class. A new class Axial_Controller is introduced in this article, along with some changes to the directory structure.

Dispatch via convention

Using a front controller allows creation and access to controllers in a standard way. By using a consistent naming convention and directory structure, command objects can be dispatched via a generic piece of code. When a command is dispatched the appropriate controller is loaded and its execute() method called.

  1. class Axial_CommandDispatcher
  2.       {
  3.       var $Command;
  4.  
  5.       function Axial_CommandDispatcher(&$command)
  6.             {
  7.             $this->Command = $command;
  8.             }
  9.  
  10.       function isController($controllerName)
  11.             {
  12.             if(file_exists('axial/controllers/'.$controllerName.'/controller.'.$controllerName.'.php'))
  13.                   {
  14.                   return true;
  15.                   }
  16.             else
  17.                   {
  18.                   return false;
  19.                   }
  20.             }
  21.  
  22.  
  23.       function Dispatch()
  24.             {
  25.             $controllerName = $this->Command->getControllerName();
  26.  
  27.             if($this->isController($controllerName) == false)
  28.                   {
  29.                   $controllerName = 'error';
  30.                   }
  31.             include('axial/controllers/'.$controllerName.'/controller.'.$controllerName.'.php');
  32.             $controllerClass = $controllerName."Controller";
  33.             $controller = new $controllerClass($this->Command);
  34.             $controller->execute();
  35.             }
  36.       }

As you can see from the code above on line 31, the controller must reside in a directory under 'axial/controllers/controllername and be named using the convention controller.controllername.php.

The Controller

All controllers must descend from the base class Axial_Controller. The execute() function in the base class searches for the function passed in the Axial_Command object prepended with a '_' within the controller, if this method is found it is executed if it is not found the _error() function is called, if no function is specified the _default() function is called.

  1. class Axial_Controller
  2.       {
  3.       var $Command;
  4.       function Axial_Controller(&$command)
  5.             {
  6.             $this->Command = $command;
  7.             }
  8.  
  9.       function _default()
  10.             {
  11.  
  12.             }
  13.       function _error()
  14.             {
  15.  
  16.             }
  17.       function execute()
  18.             {
  19.             $functionToCall = $this->Command->getFunction();
  20.             if($this->Command->getFunction() == ")
  21.                   {
  22.                   $functionToCall = 'default';
  23.                   }
  24.  
  25.             if(!is_callable(array(&$this,'_'.$functionToCall)))
  26.                   {
  27.                   $functionToCall = 'error';
  28.                   }
  29.  
  30.  
  31.             call_user_func(array(&$this,'_'.$functionToCall));
  32.             }
  33.       }

Try it out

You can visit examples.phpaddiction.com/urlrouter/part_3/ to see it in action and download the sample code.

Conclusion

If you look at the index.php from the sample code in the second part in the series you will see that the code is virtually unchanged from this version. The main change is in the Axial_CommandDispatcher class and with the addition fo the Axial_Controller class I have build a pluggable extendable front controller based framework. Take a look at the example page and code to get a feel for what you can do with this mini framework.

When I began this series I left out any discussion of the view portion of MVC since it was beyond the scope of the title and what I intended to discuss, I discovered though that in order to build any further on the front controller portion of the framework I would need to introduce that concept. So I'm going to stop this series here and will pick it up again later together with a more fitting title and topic.

]]> http://www.phpaddiction.com/tags/php/url-routing-with-php-part-three/feed/ 18 Url Routing with PHP – Part Two http://www.phpaddiction.com/tags/php/url-routing-with-php-part-two/ http://www.phpaddiction.com/tags/php/url-routing-with-php-part-two/#comments Fri, 30 Mar 2007 06:12:39 +0000 Doug Hill http://www.phpaddiction.com/tags/php/url-routing-with-php-part-two/ Url Routing with PHP - Part One as it covers the basics that I'll build on in Part Two. I will move the code covered in Part One into classes, and separate the areas of responsibility to create a flexible architecture. ]]> This is the second part of a series, I assume you have read Url Routing with PHP – Part One as it covers the basics that I'll build on in Part Two.

Requirements

  • Apache with mod_rewrite enabled
  • PHP

Assign Responsibilities

The first problem I want to address is that there are two different things going on with the script in part one. 1. The parsing of the URL to obtain a command array and 2. The actual dispatch of the command by the switch statement. I want to create an architecture that easily allows changing the way incoming URLs are formatted, and also the substitution of alternative dispatch schemes.

Standardized Command Objects

To achieve this goal, I create a standard command object. This will allow changing the way the urls are interpreted or dispatched as long as the interpreter creates command objects and the dispatcher accepts them.

  1. class Axial_Command
  2.         {
  3.         var $commandName = ";
  4.         var $parameters = array();
  5.        
  6.         function Axial_Command($commandName,$parameters)
  7.                 {
  8.                 $this->commandName = $commandName;
  9.                 $this->parameters = $parameters;
  10.                 }
  11.         function getCommandName()
  12.                 {
  13.                 return $this->commandName;
  14.                 }
  15.         function getParameters()
  16.                 {
  17.                 return $this->parameters;
  18.                 }
  19.         }

Interpreting URLs

Next we need a class that handles interpreting the incoming URL and creating a command object. The following class uses the same method as in part one and creates commands based on a simple format for the incoming URL, a command followed by its parameters separated by forward slashes.

  1. class Axial_UrlInterpreter
  2.         {
  3.  
  4.         function Axial_UrlInterpreter()
  5.                 {
  6.                 $requestURI = explode('/', $_SERVER['REQUEST_URI']);
  7.                 $scriptName = explode('/',$_SERVER['SCRIPT_NAME']);
  8.                         for($i= 0;$i < sizeof($scriptName);$i++)
  9.                                 {
  10.                                 if ($requestURI[$i] == $scriptName[$i])
  11.                                         {
  12.                                         unset($requestURI[$i]);
  13.                                         }
  14.                                 }
  15.                 $commandArray = array_values($requestURI);
  16.                 $commandName = $commandArray[0];
  17.                 $parameters = array_slice($commandArray,1);
  18.                 $this->command = new Axial_Command($commandArray[0],$parameters);
  19.                      }
  20.        
  21.         function getCommand()
  22.                 {
  23.                 return $this->command;
  24.          }
  25.         }

Dispatching Commands

And finally we can pass the command object to the dispatcher. In order to keep the code simple I use a switch statement that includes different scripts based on the command. There are many other methods that could be used in fact thats the point the of architecture I'm presenting.

  1. class Axial_CommandDispatcher
  2.         {
  3.         var $command;
  4.         function Axial_CommandDispatcher($command)
  5.                 {
  6.                 $this->command = $command;
  7.                 }
  8.  
  9.         function Dispatch()
  10.                 {
  11.                 switch ($this->command->getCommandName())
  12.                         {
  13.                         case 'commandOne' :
  14.                                 include('commandone.php');
  15.                                 break;
  16.                         case 'commandTwo' :
  17.                                 include('commandtwo.php');
  18.                                 break;
  19.                         case ":
  20.                                 include('root.php');
  21.                                 break;
  22.                         default:
  23.                                 include('default.php');
  24.                                 break;
  25.                         }
  26.                 }
  27.         }

Put it all together

In the first part of this series I used an .htaccess file to redirect to index.php. The same .htaccess is all we need now. Our new index.php will look a bit different though. With the changes from part one made we can now substitute different classes to handle the interpretation of URLs or command dispatching easily.

  1. include('axial.command.php');
  2. include('axial.urlinterpreter.php');
  3. include('axial.commanddispatcher.php');
  4. $urlInterpreter = new Axial_UrlInterpreter();
  5. $command = $urlInterpreter->getCommand();
  6. $commandDispatcher = new Axial_CommandDispatcher($command);
  7. $commandDispatcher->Dispatch();

Try it out

You can visit examples.phpaddiction.com/urlrouter/part_2/ to see it in action and download the sample code.

Next up

In the next part of this series I will explore some ways to get rid of the switch statement in the dispatcher and create a small framework to hang your code from.

]]> http://www.phpaddiction.com/tags/php/url-routing-with-php-part-two/feed/ 12 Url Routing with PHP – Part One http://www.phpaddiction.com/tags/axial/url-routing-with-php-part-one/ http://www.phpaddiction.com/tags/axial/url-routing-with-php-part-one/#comments Tue, 27 Mar 2007 17:38:07 +0000 Doug Hill http://www.phpaddiction.com/tags/axial/url-routing-with-php-part-one/ URL routing method that contains many of the disadvantages. In later articles we will build upon this basis and address the disadvantages.]]> Most PHP frameworks use some variation of the front controller pattern to centralize common code and logic. There are advantages and disadvantages to this. I am going to ignore those for now. In fact the first part of this series will explore a simple procedural URL routing method that contains many of the disadvantages. In later articles we will build upon this basis and address the disadvantages.

Requirements

  • PHP
  • Apache with mod_rewrite enabled.

Redirecting with mod_rewrite

This article doesn't discuss mod_rewrite and the .htaccess in detail, the following .htaccess file is sufficient for the needs of our simple front controller. The .htaccess file should be placed in the same directory as the front controller script. All requests will be sent to index.php while requests for a file or directory that does exist will bypass the mod_rewrite rules and be served directly by the web server.

file: .htaccess

  1. Options +FollowSymLinks
  2. IndexIgnore */*
  3. # Turn on the RewriteEngine
  4. RewriteEngine On
  5. #  Rules
  6. RewriteCond %{REQUEST_FILENAME} !-f
  7. RewriteCond %{REQUEST_FILENAME} !-d
  8. RewriteRule . index.php

The Entry Point

I chose a simple format for the incoming URL, a command followed by its parameters separated by forward slashes "/".

For example:
www.example.com/command/parameter1/parameter2/

  1. $requestURI = explode('/', $_SERVER['REQUEST_URI']);

in this example $requestURI would contain.

  1. Array ( [0] => [1] => command [2] => parameter1 [3] => parameter2 [4] => )

This works fine except in the case where the front controller is not in the root directory.

For example:
www.example.com/myapps/app1/command/parameter1/parameter2/

in this case $requestURI would contain.

  1. Array ( [0] => [1] => myapps [2] => app1 [3] => command [4] => parameter1 [5] => parameter2  [6] => )

To filter out the path to the front controller we will need to use the $_SERVER['SCRIPT_NAME'] variable.

  1. $requestURI = explode('/', $_SERVER['REQUEST_URI']);
  2. $scriptName = explode('/',$_SERVER['SCRIPT_NAME']);

In the above example $scriptName would contain.

Array ( [0] => [1] => myapps[2] => app1 [3] => index.php )

Which can be used to remove the path and script name from the URI.
Note: As you can see the explode method leaves an empty array member at the first position. This will be fixed by the following code.

  1. $requestURI = explode('/', $_SERVER['REQUEST_URI']);
  2. $scriptName = explode('/',$_SERVER['SCRIPT_NAME']);
  3.  
  4. for($i= 0;$i < sizeof($scriptName);$i++)
  5.         {
  6.       if ($requestURI[$i]     == $scriptName[$i])
  7.               {
  8.                 unset($requestURI[$i]);
  9.             }
  10.       }
  11.  
  12. $command = array_values($requestURI);

After the code above $command would contain.

Array ( [0] => command [1] => parameter1 [2] => parameter2  [3] => )

Dispatching the command

Now that we have a command with its parameters stored in an array it is trivial to handle them via a switch statement. The following is a short example.

  1. switch($command[0])
  2.       {
  3.  
  4.       case 'commandOne' :
  5.                 echo 'You entered command: '.$command[0];
  6.                 break;
  7.  
  8.       case 'commandTwo' :
  9.                 echo 'You entered command: '.$command[0];
  10.                 break;
  11.  
  12.       default:
  13.                 echo 'That command does not exist.';
  14.                   break;
  15.       }

Try it out

You can visit examples.phpaddiction.com/urlrouter/part_1/ to see it in action and download the sample code.

Next up

The next part in the series will focus on moving the URL router into a class and out of the global namespace.

Update I've updated the .htaccess per the comment made by DrBacchus.

]]> http://www.phpaddiction.com/tags/axial/url-routing-with-php-part-one/feed/ 38