DEV Community: Johirul Islam

How does #PHP automatically find your classes without endless require() statements? In Part 05 of my “Build Your Own PHP Framework from Scratch” series, I’m exploring #Composer, #PSR-4 #autoloading, controllers, and unified error/exception handling.

Johirul Islam — Wed, 30 Sep 2026 15:35:53 +0000

Johirul Islam

Sep 30

Part 05 - Composer

#composer #errors #exception #packages

6 min read

Part 05 - Composer

Johirul Islam — Wed, 30 Sep 2026 02:28:06 +0000

Source Code Files of this Chapter

project-root/
├── app/
│   ├── Controllers/
│   │   └── HomeController.php      # new file
│   └── Core/
│       └── Bootstrap.php           # modified file
├── public/
│    └── index.php                  # modified file
│
├── vendor/                         # new directory
│
├── composer.json                   # new file
├── composer.lock                   # new file
└── .gitignore                      # new file

Using Composer

This project is using core php that means no php package will be used. So someone may be surprised that why we are configuring composer?

The answer in a single word is autoload. Autoload will load required PHP classes based on their namespace and directory structure without using the require() or include() statement.

Configure Composer

Go to the project root directory and run following command:

composer init

Above command will create a composer.json file in the project root directory.

Edit composer.json file:

{
    "name": "leafvein/own-framework-php-core-oop",
    "description": "Create Own Framework Using PHP Core OOP",
    "type": "project",
    "require": {
        "php": ">=8.0"
    },
    "autoload": {
        "psr-4": {
            "App\\": "app/"
        }
    },
    "minimum-stability": "dev",
    "license": "MIT"
}

Code Explain:

name : a required attribute that is used as a unique identifier of the application within the composer ecosystem. composer.

description: a short description of the package.

require: another required attribute used to specify your project's dependencies. Current now our project dependency is php 8.

autoload: configure the method to load PHP classes and files of a project automatically. Here PSR-4 is used to map namespace App to app directory.

Install Dependency and Generate Autoload File

From your project-root directory run this command:

composer install

After running composer install command composer will read project dependencies from the composer.json file then create vendor directory and composer.lock file to the project root directory.

vendor: directory stores dependencies and autoload.php file.

composer.lock: file locks version of all dependencies to make an option so that all team members can use the same versions of dependencies.

Integrate the `autoload.php` File into the Application

We are integrating vendor/autoload.php file through the Bootstrap. So, open the app/Core/Bootstrap.php file and add this line:

require __DIR__ . '/../../vendor/autoload.php';

See full code: app/Core/Bootstrap.php

<?php
declare(strict_types = 1);

require __DIR__ . '/../../vendor/autoload.php';

// load environment
$config = [
    'app_name'=> 'PHP core OOP project'
];

// route define
$route = ltrim($_SERVER['REQUEST_URI'], '/');

echo($route);

if ($route == "get-error") {
    // trigger a fatal error
    trigger_error("An Intentional Error Occurred.", E_USER_ERROR);
}

if ($route == 'get-exception') {
    // throw an exception
    throw new Exception("An Intentional Exception Occurred.");
}

echo 'Welcome to the ' . $config['app_name'];

Load a Controller Class Using Composer Autoload

Create a new app/Controllers/HomeController.php file and add following code:

<?php

namespace App\Controllers;

class HomeController
{
    private $appName;

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

    public function getGreeting()
    {
        return 'Welcome to the ' . $this->appName;
    }
}

Code Explain

A new Controller Class file is created, now it is require to update classmap of composer autoload. So, run following command:
composer dump-autoload
This command will update classmap of composer autoload to ensure all latest classes are available to use.

Now you will be able to call the controller's method from the bootstrap. Open the app/Core/Bootstrap.php file and add the following code:

use App\Controllers\HomeController;

$homeController = new HomeController($config['app_name']);
echo $homeController->getGreeting();

Code Explain

use App\Controllers\HomeController;
Loading HomeController class using fully qualified class names (FQCNs)
$homeController = new HomeController($config['app_name']);
echo $homeController->getGreeting();
Instantiation of HomeController class and Displaying content of the getGreeting()

See full code: app/Core/Bootstrap.php

<?php
declare(strict_types = 1);

require __DIR__ . '/../../vendor/autoload.php';

use App\Controllers\HomeController;

// load environment
$config = [
    'app_name'=> 'PHP core OOP project'
];

// route define
$route = ltrim($_SERVER['REQUEST_URI'], '/');

if ($route == "get-error") {
    // trigger a fatal error
    trigger_error("An Intentional Error Occurred.", E_USER_ERROR);
}

if ($route == 'get-exception') {
    // throw an exception
    throw new Exception("An Intentional Exception Occurred.");
}

$homeController = new HomeController($config['app_name']);
echo $homeController->getGreeting();

Unified Error and Exception Handler

On chapter 03 we've used set_error_handler() and set_exception_handler() to handle error and exception respectively. In this chapter we will use try-catch statement to simplify the Error and Exception Handling.
Open the public/index.php file and modify as below:

- // error handler
- set_error_handler(function ($errno, $errstr, $errfile, $errline) {
-    echo 'Message: ' . $errno   . ' - ' . $errstr . '<br>';
-    echo 'File: '    . $errfile . '<br>';
-    echo 'Line: '    . $errline . '<br>';
- });
-
- // exception handler
- set_exception_handler(function (Exception $e) {
-     echo 'Message: ' . $e->getMessage() . '<br>';
-     echo 'File: '    . $e->getFile()    . '<br>';
-     echo 'Line: '    . $e->getLine()    . '<br>';
-});
-
+ try {
    require __DIR__ . '/../app/Core/Bootstrap.php';
+ } catch (Throwable $e) {
+    echo 'Message: ' . $e->getMessage() . '<br>';
+    echo 'File: '    . $e->getFile()    . '<br>';
+    echo 'Line: '    . $e->getLine()    . '<br>';
+}

Code Explain

Instead of handling Error and Exception separately we are using unified handler Throwable. In PHP 7 and later, a single try-catch block can catch both traditional exceptions and critical internal PHP errors.

See full code: public/index.php

<?php
declare(strict_types = 1);

try {
    require __DIR__ . '/../app/Core/Bootstrap.php';
} catch (Throwable $e) {
    echo 'Message: ' . $e->getMessage() . '<br>';
    echo 'File: '    . $e->getFile()    . '<br>';
    echo 'Line: '    . $e->getLine()    . '<br>';
}

Result

Make sure server is running or go to the project-root directory and run command php -S localhost:8000 -t public/ on the terminal.

Browse http://localhost:8000 -> Returns a welcome greeting message
Browse: http://localhost:8000/get-error -> It will return a 500 Internal Server Error. However, if you check the terminal, you will see more information about what caused the error.
In PHP, errors and exceptions are different concepts, and there are several ways to throw, catch, and handle exceptions and errors.
In the next part, Part 06 — Error and Exception, we’ll discuss errors and exceptions in PHP in more detail.
Browse: http://localhost:8000/get-exception -> Returns exception information
Git : Add .gitignore File and Push Changes to Remote

If testing result is satisfactory then it is time to push changes to the remote repository.

Run Command:

> git status

As expected you will see the vendor directory in untracked stage but it is not recommended to push the vendor directory to the remote repository. In Git terminology, this is called 'ignore or not track'. Git uses .gitignore file to ignore directory and files.

Create .gitignore file on project-root directory with following content:

/vendor

Add the files that are newly created in this chapter.

> git add HomeController.php composer.json composer.lock .gitignore

git add <file_path> command add specific file content to the staging area for the next commit. We are adding HomeController.php, composer.json, .gitignore, and composer.lock files to the staging area for next commit.

⚠️ composer.lock! 🤔. Yes, commit your composer.lock file to git repository.

⚠️ .gitignore! 🤔 🤔. Yes, yes, Commit the .gitignore file to ensure everyone using the repository ignores the same files.

Add the files that are modified in this chapter.

> git add -p Bootstrap.php
> git add -p index.php

💡 git add -p <file_path> command provides an review option that steps through each hunk (section of changes) in the specified filename and asks you whether you want to stage that specific hunk or not. To add specific section of changes just type y otherwise n. It will prevent you to add any unintentional testing code and it your code will clean.

Commit your changes and push to the remote repository.

> git commit -m "Configured composer"
> git push origin <branch_name>

Learn More

⬇SOURCE CODE: Chapter 05

Part 04 - Configure Git for Collaboration

Johirul Islam — Wed, 30 Sep 2026 02:27:41 +0000

Source Code Files of this Chapter

project-root/
├── app/
│   └── Core/
│       └── Bootstrap.php
├── .git/                                   # new directory
└── public/
    └── index.php

Using Git

We are in the very initial stages of a framework creation. Now it is time to configure git.

You are creating a framework, right! So Git will be a handful tool for collaborating with colleagues, teams, or friends, or for sharing code by embedding it in blog posts.

Do you have any account of git cloud repository hosting like GitHub or any other? If not, just create an account and it is free.

Configure Git on Local

# Go to the project root
> cd <project_root> 

> git init

> git add .

> git commit -m "Initial commit"

Configure Git on Remote

Create a new repository on the github and configure

Copy the remote repository url

Push Changes to GitHub

To make a connection between your local and remote repository first of all you have to set the remote origin. So, set the remote repository url as a remote origin and push changes.

# Go to the project root
> git remote add origin <remote_repository_URL>
>
> git push -u origin <branch_name>

⚠️ Important

Github uses SSH Key to establish a connection between your local machine and github.com. You have to generate SSH key to your local machine if it is not exist and add to your github account.

Result

Go to your remote repository and you will see your source code is uploaded.

Learn More

⬇SOURCE CODE: Chapter 04

[Boost]

Johirul Islam — Sat, 26 Sep 2026 07:24:27 +0000

Johirul Islam

Sep 26

Part 03 - Bootstrap

#php #webdev #developer #learning

3 min read

Part 03 - Bootstrap

Johirul Islam — Sat, 26 Sep 2026 06:15:08 +0000

Prepare Runnable Environment by Loading Common Dependencies

When a client’s request comes to the front controller, we want to pass the request through a middle layers instead of directly starting the process. That’s why we need the Bootstrap that will load configuration data, request information, (autoload) classes and if required it could be response for exception.

Source Code Files of this Chapter

project-root/
├── app/
│   └── Core/
│       └── Bootstrap.php                   # new file
└── public/
    └── index.php                           # modified file

Create `Bootstrap.php` File

Create app/Core/Bootstrap.php file and write following code:

<?php
declare(strict_types = 1);

// load environment
$config = [
    'app_name'=> 'PHP core OOP project'
];

// route define
$route = ltrim($_SERVER['REQUEST_URI'], '/');

if ($route == "get-error") {
    // trigger a fatal error
    trigger_error("An Intentional Error Occurred.", E_USER_ERROR);
}

if ($route == 'get-exception') {
    // throw an exception
    throw new Exception("An intentional Exception Occurred.");
}

echo 'Welcome to the ' . $config['app_name'];

Code Explain:

declare(strict_types = 1)
As we explained in Front Controller index.php file chapter, the declare(strict_types=1) cannot be set globally for the whole project It only works per file and should be placed at the top of every PHP file.
$route = ltrim($_SERVER['REQUEST_URI'], '/');

if ($route == "get-error") {
   // trigger a fatal error
   trigger_error("An Intentional Error Occurred.", E_USER_ERROR);
}

if ($route == 'get-exception') {
   // throw an exception
   throw new Exception("An intentional Exception Occurred.> ");
}
Get the route path using Global $_SERVER variable.

Based on the route triggered error and thrown exception intentionally using a hard-coded condition
$config = [
   'app_name'=> 'PHP core OOP project'
];

echo 'Welcome to the ' . $config['app_name'];
Using static configuration variable, displaying a welcome greeting message.

Inject Bootstrap into Front Controller

The front controller will only receive the request and will not contain any application logic or data. Open the public/index.php file in editor and update the code:

require __DIR__ . '/../app/Core/Bootstrap.php';

Code Explain:

First, load and execute the bootstrap file into the front-controller.

Bootstrap injecting in the front-controller is done, now we will add the following code to the front-controller file to handle the errors and exceptions that we conditionally triggered in the bootstrap file.

// error handler
set_error_handler(function ($errno, $errstr, $errfile, $errline) {
    echo 'Message: ' . $errno   . ' - ' . $errstr . '<br>';
    echo 'File: '    . $errfile . '<br>';
    echo 'Line: '    . $errline . '<br>';
});

// exception handler
set_exception_handler(function (Exception $e) {
    echo 'Message: ' . $e->getMessage() . '<br>';
    echo 'File: '    . $e->getFile()    . '<br>';
    echo 'Line: '    . $e->getLine()    . '<br>';
});

Code Explain:

When an error occurs in the application, set_error_handler() will be called and it will display information about the error.

When an exception occurs in the application, set_exception_handler() will be called and it will display information about the exception.

See full code: public/index.php

<?php
declare(strict_types = 1);

// error handler
set_error_handler(function ($errno, $errstr, $errfile, $errline) {
    echo 'Message: ' . $errno   . ' - ' . $errstr . '<br>';
    echo 'File: '    . $errfile . '<br>';
    echo 'Line: '    . $errline . '<br>';
});

// exception handler
set_exception_handler(function (Exception $e) {
    echo 'Message: ' . $e->getMessage() . '<br>';
    echo 'File: '    . $e->getFile()    . '<br>';
    echo 'Line: '    . $e->getLine()    . '<br>';
});

require __DIR__ . '/../app/Core/Bootstrap.php';

Result

Make sure server is running or go to the project-root directory and run command php -S localhost:8000 -t public/ on the terminal.

Browse http://localhost:8000 -> Returns a welcome greeting message

Browse: http://localhost:8000/get-error -> Returns error information

Browse: http://localhost:8000/get-exception -> Returns exception information

Learn More

PHP's error are not exception

trigger_error():

Throwing exception:

⬇SOURCE CODE: Chapter 03

Part 02 - Front Controller (index.php) File

Johirul Islam — Sat, 26 Sep 2026 06:14:08 +0000

Source Code Files of this Chapter:

project-root/
└── public/
   └──index.php                             # new file

Front Controller Design Pattern

Front controller is a central (obviously a single) entry point to handle incoming client request.

To implement front controller design pattern in this project, our central entry point will be an index.php file. So let's create an index.php file in the public directory. We have chosen to create the index.php file in the public directory instead of the project root directory because we want to protect our project’s confidential and sensitive code from publicly access. This access restriction could be implemented by setting file permission, and off course we will do this but also separate public resources so that no one can access the rest of the project except the public resources.

Create Front Controller

Now open the public/index.php file, write the following code.

<?php
declare(strict_types = 1);

echo 'Welcome to the PHP core OOP Project!';

Code Explain:

declare(strict_types = 1)
declare(strict_types=1) enforces strict type checking for function arguments and return values within a specific PHP file. Only exact type of the type declaration will be accepted, or a TypeError will be thrown.

Unfortunately, in a projects, declare(strict_types=1) cannot be set globally for the whole project It only works per file and should be placed at the top of every PHP file.
echo 'Welcome to the PHP core OOP Project!':
Show this string text on the browser screen.

Result

If the local server and domain hosting configured properly, then it is time to check the result of your first code. Let’s say your local domain is http://localhost:8000. So, browse this URL, expected result is Welcome to the PHP core OOP Project!. If there is an exception, look at the error code number and debug accordingly. And if necessary, you can view the server log.

💡 Tip : Local Server Setup

You can use any of LAMP, MAMP, WAMP or XAMPP Stack as a local server. I've used PHP's built in server to develop this project.

Open terminal/shell then run commands:

> cd <project-root> 
> php -S localhost:8000 -t public/

Now browse: http://localhost:8000

Learn More

Page controller:
While the Front Controller pattern provides a single, centralized entry point for all requests in an application, the Page Controller is an architectural approach where each individual page request has its own controller and this controller is primary handler for its request. It is responsible for handling the logic associated with that particular page or request.
Advantages of front controller against page controller
In addition to the PHP application, the front controller needs to be configured on the server end as well.

⬇SOURCE CODE: Chapter 02

Part 01 - Directory Structure of the Application

Johirul Islam — Sat, 26 Sep 2026 06:13:19 +0000

Source Code Files of this Chapter

project-root/
│── public/
│
└── app/

See the final project directory structure


project-root
├── app/
│   ├── Controllers/
│   │   ├── Api/
│   │   │   └── UserController.php
│   │   ├── AuthController.php
│   │   ├── EmailVerificationController.php
│   │   ├── HomeController.php
│   │   └── UserController.php
│   ├── Core/
│   │   ├── Abstract/
│   │   │   ├── Migration.php
│   │   │   ├── Model.php
│   │   │   └── Seeder.php
│   │   ├── App.php
│   │   ├── Bootstrap.php
│   │   ├── Config.php
│   │   ├── Database.php
│   │   ├── Env.php
│   │   ├── ExceptionHandler.php
│   │   ├── Mailer.php
│   │   ├── Request.php
│   │   ├── Response.php
│   │   ├── Router.php
│   │   └── Validator.php
│   ├── Helpers/
│   │   └── helpers.php
│   ├── Models/
│   │   ├── EmailQueue.php
│   │   ├── EmailVerification.php
│   │   └── User.php
│   ├── Queue/
│   │   └── MailQueue.php
│   └── Services/
│       └── EmailVerificationService.php
├── composer.json
├── composer.lock
├── config/
│   ├── app.php
│   ├── database.php
│   └── mail.php
├── database/
│   ├── Migrations/
│   │   ├── 2026_01_10_create_users_table.php
│   │   ├── 2026_01_18_create_email_queue_table.php
│   │   ├── 2026_01_18_create_email_verifications_table.php
│   │   ├── 2026_01_19_add_password_to_users_table.php
│   │   └── 2026_01_19_add_verified_column_to_users_table.php
│   └── Seeders/
│       └── UserSeeder.php
├── .env
├── .env.testing
├── .gitignore
├── migration.php
├── .phpunit.result.cache
├── phpunit.xml
├── public/
│   ├── adminer.php
│   ├── css/
│   │   └── style.css
│   ├── images/
│   │   └── welcome.png
│   ├── index.php
│   └── scripts/
│       └── app.js
├── queue.php
├── routes/
│   ├── api.php
│   └── web.php
├── seeder.php
├── server.php
├── tests/
│   ├── Bootstrap.php
│   ├── Database/
│   │   ├── DatabaseConnectionTest.php
│   │   ├── MigrationTest.php
│   │   ├── Seeders/
│   │   │   └── UserSeeder.php
│   │   ├── SeederTest.php
│   │   └── UserModelTest.php
│   ├── DatabaseTestCase.php
│   ├── Feature/
│   │   └── HomePageTest.php
│   └── Unit/
│       ├── ConfigTest.php
│       ├── EnvTest.php
│       ├── RequestTest.php
│       ├── RouterTest.php
│       └── ValidatorTest.php
├── vendor/
└── views/
    ├── auth/
    │   └── login.php
    ├── home.php
    ├── layout.php
    └── user/
        ├── edit.php
        ├── register.php
        └── show.php

The directory structure is the skeleton of the project. So the more standardized and understandable it can be, the project will be in terms of extensible, maintainable, and testable.

MVC-inspired Directory Structure

On this project, the directory structure is flexible and conventional. Which means you can create it the way you want. But since the PHP community has been using different directory structures in web development for a long time, some conventions have become well-known regarding the names and patterns of files and directories. For example, src, config, .env, public, index.php etc.

Our project will be like MVC and we will use PSR-4 through Composer for class autoloader.

Init Coding

So, let’s start to build the project-root directory first, then create public and app directory inside the project-root directory.

> mkdir <PROJECT_NAME>
> cd <PROJECT_NAME>
> mkdir public app

<PROJECT_NAME>: your project name, it will be the project-root directory.

public: the default accessible file of the project

app: all project related class will go here

⬇SOURCE CODE: Chapter 01

Introduction

Johirul Islam — Sat, 26 Sep 2026 06:11:57 +0000

Over the time, PHP and its various tools have become more advanced and easier to use. As a result, you can create your own framework even using core PHP. Although there are many reputable, well-known, secure, updated and well-documented open source PHP frameworks that can be easily installed and used with Git or Composer commands. But as a PHP learner, if you want to understand how things like function classes, namespace objects, and so on work together within a framework, there is no substitute for hands-on learning.

So let's start by building a simple framework from scratch.

Please keep in mind that we are not inventing anything new. We will just use various functions and features of PHP.

Disclaimer:

This framework is for learning purposes only. It is not intended for professional use or use on production server.

This tutorial is not for novice in PHP. You should have at least an understanding of object-oriented programming concepts. It is also recommended to have a grasp of MVC and Solid Design Patterns.

Highly recommend to get clear knowledge about git and composer.

DEV Community: Johirul Islam

How does #PHP automatically find your classes without endless require() statements? In Part 05 of my “Build Your Own PHP Framework from Scratch” series, I’m exploring #Composer, #PSR-4 #autoloading, controllers, and unified error/exception handling.

Part 05 - Composer

Part 05 - Composer

Using Composer

Configure Composer

Install Dependency and Generate Autoload File

Integrate the autoload.php File into the Application

Load a Controller Class Using Composer Autoload

Unified Error and Exception Handler

Result

Git : Add .gitignore File and Push Changes to Remote

Learn More

Part 04 - Configure Git for Collaboration

Using Git

Configure Git on Local

Configure Git on Remote

Push Changes to GitHub

⚠️ Important

Result

Learn More

[Boost]

Part 03 - Bootstrap

Part 03 - Bootstrap

Prepare Runnable Environment by Loading Common Dependencies

Create Bootstrap.php File

Inject Bootstrap into Front Controller

Result

Learn More

Part 02 - Front Controller (index.php) File

Front Controller Design Pattern

Create Front Controller

Result

💡 Tip : Local Server Setup

Learn More

Part 01 - Directory Structure of the Application

MVC-inspired Directory Structure

Init Coding

Introduction

Integrate the `autoload.php` File into the Application

Git : Add `.gitignore` File and Push Changes to Remote

Create `Bootstrap.php` File