How to create a simple MVC framework in PHP

Today we will create an MVC framework in PHP. This will be very simple but will allow us to understand how this works.

MVC was originally used over the GUI desktop applications, but recently (not so recent) with the growth and maturity of web languages, started appearing some frameworks drawn with this architecture.

I think the starter of this web vision was David Heinemeier Hansson the creator of Ruby On Rails, It was him that lunched the MVC for the first time to the web.

But let’s get started on our MVC tutorial.
MVC in a nutshell it’s a efficient, clean and fast way to separate your code from you HTML, or the UI if your prefer.
MVC means, Model – View – Controller.

Model: Responsible for the data management like SQL databases and SELECT, UPDATE, DELETE,etc…

View: Shows the UI, html, css, javascript and so on

Controller: The brain and heart of MVC architecture, this is were all comes in, the controller is the middle man between the view and the model.

Here’s a simple scheme how all this works.

1º the user types http://www.umsite.com/blog
2º The framework go fetch out controller blog.php
3º The controller will process and format the information
4º The model will deliver to the controller the data needed from the controller.
5º The controller will format this information and pass it to the view.
6º Finally the controller will invoke the view and output the UI.

Not all MVC frameworks works such as this, but this is pretty much the basic of our framework in this tutorial.

So let get started.

Define our data structure

./my_mvc
./my_mvc/application
./my_mvc/application/controller
./my_mvc/application/model
./my_mvc/application/view

That’s pretty much explanatory

/.htaccess

Before anything else, we must create an .htaccess file, this file will redirect all HTTP request to index.php.

RewriteEngine On
RewriteBase /my_mvc/
RewriteCond %{REQUEST_FILENAME} !-f
RewriteCond %{REQUEST_FILENAME} !-d
RewriteRule ^(.*)$ index.php/$1 [L]

Note: You must have mod_rewrite activated in out Apache configuration.

/index.php

Index.php like I said before it’s our gateway , everytime we access an URL the .htaccess file will redirect us to index.php and this file will load our framework API (which in our case is a very small footprint), and API will be responsible for calling the controllers and so on.

//Define our site URL
define("BASE_PATH", "http://localhost");

//Define our basepath
$path = "/my_mvc";

//Take the initial PATH.
$url = $_SERVER['REQUEST_URI'];
$url = str_replace($path,"",$url);

//creates an array from the rest of the URL
$array_tmp_uri = preg_split('[\\/]', $url, -1, PREG_SPLIT_NO_EMPTY);

//Here, we will define what is what in the URL
$array_uri['controller'] 	= $array_tmp_uri[0]; //a class
$array_uri['method']	= $array_tmp_uri[1]; //a função
$array_uri['var']		= $array_tmp_uri[2]; //a variavel

//Load our base API
require_once("application/base.php");

//loads our controller
$application = new Application($array_uri);
$application->loadController($array_uri['controller']);

/application/base.php

This class is vital, since that it’s from here that our controllers will get loaded, and such as views and models.

class Application
{
	var $uri;
	var $model;

	function __construct($uri)
	{
		$this->uri = $uri;
	}

	function loadController($class)
	{
		$file = "application/controller/".$this->uri['controller'].".php";

		if(!file_exists($file)) die();

		require_once($file);

		$controller = new $class();

		if(method_exists($controller, $this->uri['method']))
		{
			$controller->{$this->uri['method']}($this->uri['var']);
		} else {
			$controller->index();
		}
	}

	function loadView($view,$vars="")
	{
		if(is_array($vars) && count($vars) > 0)
			extract($vars, EXTR_PREFIX_SAME, "wddx");
		require_once('view/'.$view.'.php');
	}

	function loadModel($model)
	{
		require_once('model/'.$model.'.php');
		$this->$model = new $model;
	}
}

You may not believe it, but we already have our ultra-slim-light MVC framework done.
That wasn’t so hard wasn’t ?

Now let’s start using it, to create a controller, model and two views.

/application/controller/blog.php

This will be the name of our controller, so every time we access http://localhost/my_mvc/blog/ the class Application by now has already filtered the URL from index.php, and it will now load our blog.php.

class Blog extends Application
{
	function __construct()
	{
		$this->loadModel('model_blog');
	}

	function index()
	{
		$articles = $this->model_blog->select();
		$data['articles'] = $articles;
		$this->loadView('view_blog',$data);
	}

	function add($title="")
	{
		$data['title'] = $title;
		$this->loadView('view_blog_add',$data);
	}
}

If you notice, in the class constructor we can define what will be the model that we will use, in this case i’ve choose model_blog, and this model will be loaded from ./application/model/model_blog.php as you will see further on.
By default, this class will run everything inside index(), but if we access http://localhost/my_mvc/blog/add, our class Blog will invoke our add function. Simple ?

Inside every class function we can call model functions as well, or define variables that will be used inside our views.
On a close inspection over index() we will see that:
- Call a function select from model_blog.php
- Creates an array with vars
- Loads a view in and variable array

/application/model/model_blog.php

class model_blog extends Application
{

	function __construct()
	{
		//do something, DB connections, etc..
	}

	function select()
	{
		return array("title 1","title 2","title3");
	}
}

This class is responsible for the DB treatment, in our model I’ve created a simple select() function that will simulate the return of DB array with rows.

/application/view/view_blog.php

<html>
	<head>
		<title>My Blog</title>
	</head>
	<body>
		<h1>My Blog</h1>

		<?foreach($articles as $article):?>
			<h3><?=$article?></h3>
		<?endforeach?>
	</body>
</html>

/application/view/view_blog_add.php

<html>
	<head>
		<title>My Blog</title>
	</head>
	<body>
		<h1>My Blog</h1>
		<h3>Title:</h3>
		<input type="text" value="<?=$title?>">
	</body>
</html>

Finally, we have two views like I’ve said earlier. They will show or final “result”, in HTML of course.

Download the sample framework.