Are you eager to dive into the world of PHP web development? Look no further! In this comprehensive guide, we’ll walk you through the creation of a simple PHP MVC (Model-View-Controller) framework from scratch. Whether you’re a beginner or an experienced developer looking to enhance your skills, this tutorial is designed to equip you with the knowledge and confidence to build robust web applications using industry-standard practices.

Understanding MVC Architecture

Before we delve into the practical implementation, let’s grasp the fundamentals of MVC architecture. MVC, which stands for Model-View-Controller, is a powerful design pattern widely used in web application development. It divides an application into three interconnected components:

  1. Model (M): Responsible for handling data and business logic.
  2. View (V): Deals with the presentation layer, showcasing data to users.
  3. Controller (C): Acts as an intermediary between the Model and the View, handling user input and directing data flow.

By separating concerns, MVC promotes maintainability, scalability, and code reusability, making it an indispensable tool for modern web development.

Setting Up Your Project Environment

To kickstart our journey, let’s set up a new PHP MVC project. We’ll cover the essential prerequisites and directory structure to ensure a streamlined development process. Key prerequisites include a basic understanding of PHP OOP concepts, familiarity with Composer (the PHP package manager), and basic HTML/CSS knowledge for front-end development.

Setting up the Project

Create a new directory for your project and open it in your favorite editor. Then, in the terminal, run composer init to initialize a new Composer project.

>composer init

You can press enter, leaving all the questions empty except for the dev dependencies. When you are asked to add the dependencies and dev dependencies, type “no” and press enter for now.

Once completed, you will see a message like this:

“PSR-4 autoloading configured. Use “namespace user\phpmvc;” in src/”

For simplicity, we’ll change the namespace to something shorter, such as App. To do that, change the key of the “psr-4” in composer.json file:“user\\phpmvc\\” -> “App\\”

Then, run composer dump-autoload to which will update the classes that must be included in the project.

Directory Structure

public/ # this is where the domain is pointed
vendor/ # automatically created by the composer

Building the Core Components

With our project environment ready, it’s time to dive into the core components of our MVC framework. We’ll start by creating the Router, responsible for mapping URLs to appropriate controllers and actions. Next, we’ll define Controllers to handle user requests and Views to render the presentation layer. By adhering to the MVC principles, we ensure clear separation of concerns and maintainable codebase.

Setting up the public folder

Create a new file called index.php in the public/ folder. This file will serve as the entry point of the application.


// index.php - Entry point of the application

// Require the Composer autoloader to autoload classes
require '../vendor/autoload.php';

// Create an instance of Router to handle routing
$router = require '../src/Routes/index.php';

Handling the Routes

Create a Router.php file inside src/ folder. This will map the routes to the correct controller.


// Router.php - Class to handle routing

namespace App;

class Router
    // Array to store routes
    protected $routes = [];

    // Method to add a route
    private function addRoute($route, $controller, $action, $method)
        // Store route details in the routes array
        $this->routes[$method][$route] = ['controller' => $controller, 'action' => $action];

    // Method to define a GET route
    public function get($route, $controller, $action)
        $this->addRoute($route, $controller, $action, "GET");

    // Method to define a POST route
    public function post($route, $controller, $action)
        $this->addRoute($route, $controller, $action, "POST");

    // Method to dispatch routes
    public function dispatch()
        // Get the requested URI and method
        $uri = strtok($_SERVER['REQUEST_URI'], '?');
        $method = $_SERVER['REQUEST_METHOD'];

        // Check if the requested route exists
        if (array_key_exists($uri, $this->routes[$method])) {
            // Retrieve controller and action for the route
            $controller = $this->routes[$method][$uri]['controller'];
            $action = $this->routes[$method][$uri]['action'];

            // Create an instance of the controller and call the action
            $controller = new $controller();
        } else {
            // Throw an exception if route not found
            throw new \Exception("No route found for URI: $uri");

Now, to set the initial route, create aindex.php file inside src/Routes/ folder. You can map the routes for POST and GET requests here separately.

// index.php inside src/Routes/ folder

use App\Controllers\HomeController;
use App\Router;

$router = new Router();

// Define a route for the home page
$router->get('/', HomeController::class, 'index');

// Dispatch routes

Controllers — Handling the home page

First, create a Controller.php inside the src/ folder.

// Controller.php inside src/ folder

namespace App;

class Controller
    // Method to render views
    protected function render($view, $data = [])
        // Extract data for use in the view

        // Include the view file
        include "Views/$view.php";

Now, we need to add a HomeController to handle the request. Inside thesrc/Controllers/ folder, create HomeController.php with an index method to handle the home page.

// HomeController.php inside src/Controllers/ folder

namespace App\Controllers;

use App\Controller;

class HomeController extends Controller
    // Method to handle the home page request
    public function index()
        // Render the index view

Now, let’s add some Journals to the Home page. Update the HomeController.php to load come Journals.


namespace App\Controllers;

use App\Controller;
use App\Models\Journal;

class HomeController extends Controller
    public function index()
        $journals = [
            new Journal('My Third Journal Entry', '2023'),
            new Journal('My Second Journal Entry', '2022'),
            new Journal('My First Journal Entry', '2021')
        $this->render('index', ['journals' => $journals]);

Creating a Model

Create a new file Journals.php inside the Models/ directory. This represents the Journals in the application.


namespace App\Models;

class Journal
    public $name;
    public $publishedYear;

    public function __construct($name, $publishedYear)
        $this->name = $name;
        $this->publishedYear = $publishedYear;

Adding the Views

Finally, to serve the home page, create index.php file inside thesrc/Views/ folder.

<!-- index.php inside src/Views/ folder -->

<!-- HTML content for the home page -->
<h1>Welcome to Simple PHP MVC Starter!</h1>

    <?php foreach ($journals as $journal) : ?>
        <!-- Display journal name and published year -->
        <li><?= $journal->name ?> (<?= $journal->publishedYear ?>)</li>
    <?php endforeach; ?>

Testing the progress

Now, the app is ready to serve the home page. Navigate to the public folder and run the built-in PHP web server to test it.

>cd phpmvc

>php -S localhost:9999

If everything works, you should see this in the browser:

Conclusion: Empowering Future Web Developers

Congratulations! You’ve successfully built your first PHP MVC framework from scratch. While this tutorial provides a solid foundation, remember that mastering web development is an ongoing journey. By continuously honing your skills and exploring advanced concepts, you’ll be well-equipped to tackle complex projects and make meaningful contributions to the ever-evolving tech landscape.

In conclusion, embracing MVC architecture empowers developers to build scalable, maintainable web applications. Whether you’re a student at CSLab Sikar or an aspiring developer elsewhere, the skills acquired through this tutorial will undoubtedly propel your career forward. So, roll up your sleeves, explore the example code on GitHub, and embark on your journey to becoming a proficient PHP developer. Happy coding!

Similar Posts

Leave a Reply

Your email address will not be published. Required fields are marked *