Question

My current router / FrontController is setup to dissect URL’s in the format:

http://localhost/controller/method/arg1/arg2/etc...

However, I’m not sure how to get certain requests to default to the IndexController so that I can type:

http://localhost/contact
or
http://localhost/about/portfolio

Instead of:

http://localhost/index/contact
or
http://localhost/index/about/portfolio

How is this accomplished?

<?php

namespace framework;

class FrontController {
    const DEFAULT_CONTROLLER = 'framework\controllers\IndexController';
    const DEFAULT_METHOD     = 'index';

    public $controller       = self::DEFAULT_CONTROLLER;
    public $method           = self::DEFAULT_METHOD;
    public $params           = array();
    public $model;
    public $view;

    function __construct() {
        $this->model = new ModelFactory();
        $this->view = new View();
    }

    // route request to the appropriate controller
    public function route() {
        // get request path
        $basePath = trim(substr(PUBLIC_PATH, strlen($_SERVER['DOCUMENT_ROOT'])), '/') . '/';
        $path = trim(parse_url($_SERVER["REQUEST_URI"], PHP_URL_PATH), '/');
        if($basePath != '/' && strpos($path, $basePath) === 0) {
            $path = substr($path, strlen($basePath));
        }

        // determine what action to take
        @list($controller, $method, $params) = explode('/', $path, 3);
        if(isset($controller, $method)) {
            $obj = __NAMESPACE__ . '\\controllers\\' . ucfirst(strtolower($controller)) . 'Controller';
            $interface = __NAMESPACE__ . '\\controllers\\' . 'InterfaceController';
            // make sure a properly implemented controller and corresponding method exists
            if(class_exists($obj) && method_exists($obj, $method) && in_array($interface, class_implements($obj))) {
                $this->controller = $obj;
                $this->method = $method;

                if(isset($params)) {
                    $this->params = explode('/', $params);
                }
            }
        }
        // make sure we have the appropriate number of arguments
        $args = new \ReflectionMethod($this->controller, $this->method);
        $totalArgs = count($this->params);
        if($totalArgs >= $args->getNumberOfRequiredParameters() && $totalArgs <= $args->getNumberOfParameters()) {
            call_user_func_array(array(new $this->controller, $this->method), $this->params);
        } else {
            $this->view->load('404');
        }
    }
}

Answer 1

You can use your URLs by one of two methods:

Establish the controllers the way your routing defines them

example.com/contact => Have a “contact” controller with default or index action

example.com/about/portfolio => Have an “about” controller with a “portfolio” action

Because your currently available routing says your URL is treated like “/controller/method”, there is no other way.

Establish dynamic routing to allow multiple URLs to be handled by a single controller

Obviously this needs a bit of configuration because one cannot know which URLs are valid and which one should be redirected to the generic controller, and which ones should not. This is somehow a replacement for any of the rewriting or redirecting solutions, but as it is handled on the PHP level, change might be easier to handle (some webserver configurations do not offer .htaccess because of performance reasons, and it generally is more effort to create these).

Your configuration input is:

1. The URL you want to be handled and
2. The controller you want the URL passed to, and it’s action.

You’ll end up having an array structure like this:

$specialRoutes = array(
    "/contact" => "IndexController::indexAction",
    "/about/portfolio" => "IndexController::indexAction"
);

What’s missing is that this action should get the current URL passed as a parameter, or that the path parts become designated parameters within your URL schema.

All in all this approach is a lot harder to code. To get an idea, try to look at the routing of common MVC frameworks, like Symfony and Zend Framework. They offer highly configurable routing, and because of this, the routing takes place in multiple classes. The main router only reads the configuration and then passes the routing of any URL to the configured routers if a match is detected.