Controller CodeIgniter 4 : Le Guide ultime pour tout savoir

Lorsque l’on débute avec le framework PHP CodeIgniter 4, l’un des premiers concepts que l’on rencontre est le controller CodeIgniter. C’est un élément central dans l’architecture MVC (Model-View-Controller) utilisée par CodeIgniter.

Dans ce tutoriel, nous allons décortiquer le rôle du controller CodeIgniter, expliquer comment en créer un, et présenter des exemples concrets d’utilisation. Que vous soyez totalement débutant ou déjà un peu à l’aise avec le framework, ce guide est fait pour vous.

Qu’est-ce qu’un controller CodeIgniter ?

Un controller CodeIgniter (ou contrôleur) est une classe PHP qui sert d’intermédiaire entre les vues et les modèles. Il reçoit les requêtes HTTP, traite les données si besoin (via des modèles), puis charge une vue pour afficher le résultat à l’utilisateur.

Dans une application construite avec CodeIgniter 4, chaque action (afficher une page, traiter un formulaire, etc.) est généralement gérée par une méthode d’un controller.

Si vous débutez, je vous conseille cet article : Route, Controller et Vue : Les principes généraux.

Structure de base d’un controller CodeIgniter

Tous les contrôleurs dans CodeIgniter 4 doivent hériter de la classe CodeIgniter\Controller. Voici un exemple simple de controller CodeIgniter :

<?php

namespace App\Controllers;

use CodeIgniter\Controller;

class Home extends Controller
{
    public function index()
    {
        return view('welcome_message');
    }
}

Dans cet exemple :

• Le fichier Home.php est situé dans le dossier app/Controllers/.
• La méthode index() est celle appelée par défaut lorsque vous accédez à l’URL de base du site.
• La fonction view() permet d’afficher une vue HTML (ici welcome_message.php).

Où sont stockés les controller CodeIgniter ?

Par convention, tous les controllers CodeIgniter se trouvent dans le dossier :

app/Controllers/

Vous pouvez organiser vos contrôleurs dans des sous-dossiers pour plus de clarté (notamment dans des projets de grande taille). Si vous faites cela, pensez à bien définir les namespaces.

Comment créer un controller CodeIgniter personnalisé

Voici un exemple de controller CodeIgniter nommé Blog qui affiche une liste d’articles.

<?php

namespace App\Controllers;

use CodeIgniter\Controller;

class Blog extends Controller
{
    public function index()
    {
        $data = [
            'titre' => 'Bienvenue sur mon blog',
            'articles' => [
                'Apprendre CodeIgniter 4',
                'Créer une API REST',
                'Comprendre MVC',
            ]
        ];

        return view('blog/index', $data);
    }
}

Vue associée (fichier app/Views/blog/index.php) :

<h1><?= esc($titre) ?></h1>

<ul>
<?php foreach($articles as $article): ?>
    <li><?= esc($article) ?></li>
<?php endforeach; ?>
</ul>

Ce simple controller CodeIgniter montre comment :

• passer des données à la vue ;
• organiser proprement les éléments ;
• afficher dynamiquement du contenu.

Utiliser un controller CodeIgniter pour traiter un formulaire

Un autre usage courant d’un controller CodeIgniter est le traitement des formulaires. Voici un exemple d’inscription utilisateur.

Vue : app/Views/user/form.php

<form action="/user/register" method="post">
    <label for="name">Nom :</label>
    <input type="text" name="name" id="name" required>

    <label for="email">Email :</label>
    <input type="email" name="email" id="email" required>

    <button type="submit">S'inscrire</button>
</form>

Controller : app/Controllers/User.php

<?php

namespace App\Controllers;

class User extends BaseController
{
    public function register()
    {
        $name = $this->request->getPost('name');
        $email = $this->request->getPost('email');

        // Ici, vous pouvez valider ou sauvegarder les données
        return "Merci $name, votre email $email a été enregistré.";
    }
}

Le controller CodeIgniter ici :

• récupère les données du formulaire ;
• les traite ;
• renvoie une réponse personnalisée.

Utiliser un controller CodeIgniter avec un modèle

L’intérêt de CodeIgniter repose aussi sur l’utilisation de modèles pour interagir avec la base de données. Voici comment un controller CodeIgniter peut appeler un modèle pour enregistrer un utilisateur.

Modèle : app/Models/UserModel.php

<?php

namespace App\Models;

use CodeIgniter\Model;

class UserModel extends Model
{
    protected $table = 'users';
    protected $allowedFields = ['name', 'email'];
}

Mise à jour du controller :

<?php

namespace App\Controllers;

use App\Models\UserModel;

class User extends BaseController
{
    public function register()
    {
        $name = $this->request->getPost('name');
        $email = $this->request->getPost('email');

        $model = new UserModel();
        $model->save([
            'name' => $name,
            'email' => $email
        ]);

        return "Inscription réussie pour $name.";
    }
}

Ce controller CodeIgniter montre comment :

• utiliser un modèle ;
• enregistrer des données dans la base ;
• garder un code lisible et structuré.

L’importance des routes dans les controller CodeIgniter

Les controllers CodeIgniter sont liés aux URL via les routes. Par défaut, CodeIgniter utilise les conventions suivantes :

http://votresite.com/nom_du_controller/nom_de_la_methode

Exemple :

http://localhost/blog/index

Appelle :

• le fichier Blog.php dans app/Controllers/
• la méthode index()

Mais vous pouvez personnaliser les routes dans le fichier :

app/Config/Routes.php

Exemple :

$routes->get('accueil', 'Home::index');
$routes->post('inscription', 'User::register');

Consultez notre guide pour Tout savoir sur les Routes avec CodeIgniter 4.

Des formations informatique pour tous !

Débutant ou curieux ? Apprenez le développement web, le référencement, le webmarketing, la bureautique, à maîtriser vos appareils Apple et bien plus encore…

Formateur indépendant, professionnel du web depuis 2006, je vous accompagne pas à pas et en cours particulier, que vous soyez débutant ou que vous souhaitiez progresser. En visio, à votre rythme, et toujours avec pédagogie.

Découvrez mes formations Qui suis-je ?

Bonnes pratiques avec les Controller CodeIgniter

1. Séparer les responsabilités : évitez de tout faire dans le controller. Déléguez à des modèles ou des services.
2. Nommer clairement les méthodes : par exemple show(), create(), edit(), etc.
3. Limiter le nombre de lignes par méthode : un controller CodeIgniter clair et lisible est plus facile à maintenir.
4. Sécuriser les entrées utilisateur : toujours valider les données reçues dans le controller.
5. Utiliser BaseController : il est déjà configuré avec les helpers, le gestionnaire de requêtes, etc.

Organiser les controller CodeIgniter avec des sous-dossiers et des namespaces

Maintenant que nous avons découvert les bases du controller CodeIgniter : création, rôle, interactions avec les vues et les modèles, ainsi que les bonnes pratiques, nous allons explorer des fonctionnalités plus avancées du controller CodeIgniter. Notamment l’organisation avec des namespaces, l’utilisation de filtres, les méthodes REST, les tests unitaires, et un projet final pour bien ancrer les concepts.

Lorsque votre application grandit, vous aurez besoin de structurer vos controllers CodeIgniter dans des sous-dossiers pour plus de clarté.

Exemple :

app/
└── Controllers/
    ├── Admin/
    │   └── Dashboard.php
    └── User/
        └── Profile.php

Controller : app/Controllers/Admin/Dashboard.php

<?php

namespace App\Controllers\Admin;

use App\Controllers\BaseController;

class Dashboard extends BaseController
{
    public function index()
    {
        return view('admin/dashboard');
    }
}

Pour y accéder, vous devez ajuster votre route :

$routes->get('admin/dashboard', 'Admin\Dashboard::index');

✅ Organiser les controllers CodeIgniter en modules (Admin, User, API…) améliore la lisibilité du projet.

Les filtres dans un controller CodeIgniter

Les filters permettent d’exécuter des actions avant ou après un controller CodeIgniter, comme vérifier si un utilisateur est connecté, ou logger une activité.

Consultez notre chapitre dédié à La connexion et l’accès sécurisé via CodeIgniter.

Exemple de filtre : app/Filters/AuthFilter.php

<?php

namespace App\Filters;

use CodeIgniter\HTTP\RequestInterface;
use CodeIgniter\HTTP\ResponseInterface;
use CodeIgniter\Filters\FilterInterface;

class AuthFilter implements FilterInterface
{
    public function before(RequestInterface $request, $arguments = null)
    {
        if (! session()->get('logged_in')) {
            return redirect()->to('/login');
        }
    }

    public function after(RequestInterface $request, ResponseInterface $response, $arguments = null)
    {
        // rien ici pour l'instant
    }
}

Activation dans app/Config/Filters.php

public $aliases = [
    'auth' => \App\Filters\AuthFilter::class,
];

Application à un controller dans Routes.php :

$routes->get('admin/dashboard', 'Admin\Dashboard::index', ['filter' => 'auth']);

💡 Les filtres sécurisent vos controllers CodeIgniter sans polluer leur logique métier.

Créer une API REST avec un controller CodeIgniter

Un autre usage fréquent des controllers CodeIgniter est la création d’API RESTful. Pour cela, CodeIgniter 4 fournit la classe ResourceController.

Exemple : app/Controllers/Api/Users.php

<?php

namespace App\Controllers\Api;

use CodeIgniter\RESTful\ResourceController;

class Users extends ResourceController
{
    protected $modelName = 'App\Models\UserModel';
    protected $format    = 'json';

    public function index()
    {
        return $this->respond($this->model->findAll());
    }

    public function show($id = null)
    {
        $data = $this->model->find($id);
        if (!$data) return $this->failNotFound();
        return $this->respond($data);
    }
}

Ce controller CodeIgniter REST :

• utilise un modèle pour retourner des données JSON ;
• gère les requêtes GET /api/users et GET /api/users/1.

💡 En quelques lignes, vous avez une API JSON fonctionnelle !

Tester un controller CodeIgniter

CodeIgniter intègre un outil puissant pour tester vos controllers CodeIgniter.

Exemple de test : tests/app/Controllers/BlogTest.php

<?php

namespace Tests\Support\Controllers;

use CodeIgniter\Test\FeatureTestTrait;
use CodeIgniter\Test\CIUnitTestCase;

class BlogTest extends CIUnitTestCase
{
    use FeatureTestTrait;

    public function testBlogIndex()
    {
        $result = $this->call('get', 'blog');

        $result->assertStatus(200);
        $result->assertSee('Bienvenue sur mon blog');
    }
}

Grâce à ce test :

• vous vérifiez que le controller CodeIgniter retourne le bon contenu ;
• vous vous assurez que tout fonctionne après une mise à jour.

Projet final : Une mini application avec controller CodeIgniter

Voici un mini-projet combinant tout ce que vous avez appris.

Objectif :

Créer une application permettant de gérer une liste de contacts (CRUD).

Modèle : ContactModel.php

<?php

namespace App\Models;

use CodeIgniter\Model;

class ContactModel extends Model
{
    protected $table = 'contacts';
    protected $allowedFields = ['name', 'email', 'phone'];
}

Controller : Contact.php

<?php

namespace App\Controllers;

use App\Models\ContactModel;

class Contact extends BaseController
{
    public function index()
    {
        $model = new ContactModel();
        $data['contacts'] = $model->findAll();
        return view('contact/index', $data);
    }

    public function create()
    {
        return view('contact/create');
    }

    public function store()
    {
        $model = new ContactModel();
        $model->save([
            'name' => $this->request->getPost('name'),
            'email' => $this->request->getPost('email'),
            'phone' => $this->request->getPost('phone'),
        ]);
        return redirect()->to('/contact');
    }
}

Routes :

$routes->get('contact', 'Contact::index');
$routes->get('contact/create', 'Contact::create');
$routes->post('contact/store', 'Contact::store');

Et voilà ! En trois vues simples, un modèle, et un controller CodeIgniter, vous avez une vraie mini-application CRUD.

Conclusion

Le controller CodeIgniter est au cœur de toute application construite avec CodeIgniter 4. Il joue un rôle de chef d’orchestre, en reliant les vues, les modèles et les filtres. Dans cet article en deux parties, vous avez appris à :

• Créer des controllers CodeIgniter simples ;
• Gérer les routes et passer des données à des vues ;
• Traiter des formulaires ;
• Utiliser des modèles dans vos controllers CodeIgniter ;
• Organiser votre projet avec des sous-dossiers et des namespaces ;
• Ajouter des filtres pour sécuriser vos accès ;
• Créer des API REST ;
• Tester vos controllers CodeIgniter ;
• Réaliser une application CRUD fonctionnelle.

Avec ces bases solides, vous êtes maintenant capable de créer des projets professionnels avec CodeIgniter 4, tout en gardant une structure claire, sécurisée et évolutive.

Allez plus loin avec CodeIgniter :

• Le guide complet des Routes CodeIgniter
• Mise en place d’une Pagination
• Envoyé un mail automatiquement depuis CodeIgniter
• Gestion des Layout : Segmenter le Header, le Body et le Footer

Alban

Fondateur de l’agence Créa-troyes.
Intervenant en Freelance.
Contactez-moi

crea-troyes.fr