Laravel: architecture MVC et meilleures pratiques

L'architecture MVC de Laravel améliore la structure et la maintenabilité du code à travers des modèles, des vues et des contrôleurs pour la séparation de la logique des données, de la présentation et du traitement des affaires. 1) Le modèle traite les données, 2) La vue est responsable de l'affichage, 3) le contrôleur traite la saisie des utilisateurs et la logique métier. Cette architecture permet aux développeurs de se concentrer sur la logique métier et d'éviter de tomber dans le bourbier de code.

introduction

Salut les gars! Aujourd'hui, nous parlerons de l'artefact de Laravel, en particulier de son architecture MVC et de quelques meilleures pratiques. Cet article vous donnera non seulement une compréhension claire du MVC de Laravel, mais partagera également une certaine expérience et suggestions pratiques pour vous sentir à l'aise pendant le processus de développement. Après avoir lu cet article, vous apprendrez à créer efficacement des applications avec l'architecture MVC de Laravel et comment éviter certains pièges courants.

Examen des connaissances de base

Laravel est un cadre basé sur PHP qui suit l'architecture MVC (modèle-View-Controller). L'architecture MVC nous aide à diviser l'application en trois éléments principaux: le modèle gère la logique des données, la vue gère l'affichage et le contrôleur gère l'entrée utilisateur et la logique métier. Ces trois fonctionnent en étroite collaboration, mais chacun remplit ses propres tâches, rendant notre code plus structuré et maintenable.

Dans Laravel, le modèle est généralement une instance d'ORM éloquent, la vue peut être un modèle de lame et le contrôleur est une classe qui gère les demandes HTTP. La relation entre ces trois est comme une Trinité, et aucune n'est manquante.

Analyse du concept de base ou de la fonction

La définition et le rôle de MVC dans Laravel

Dans Laravel, l'architecture MVC n'est pas seulement un moyen d'organiser le code, mais aussi une philosophie de développement. Il permet aux développeurs de se concentrer sur la logique métier plutôt que de rester coincé dans le bourbier du code. Le modèle est responsable des opérations de données, telles que la lecture ou l'enregistrement des données de la base de données; La vue est responsable de l'affichage des données à l'utilisateur; Et le contrôleur agit comme un intermédiaire, accepte les demandes des utilisateurs, appelle le modèle pour traiter les données, puis transmet le résultat à la vue.

Regardons un exemple simple:

 // L'utilisateur de la classe du modèle étend le modèle {
    fonction publique getfullNameAtTribute () {
        return "{$ this-> first_name} {$ this-> last_name}";
    }
}

// classe de contrôleur UserController étend le contrôleur {
    Fonction publique Show ($ id) {
        $ user = user :: find ($ id);
        return View ('user.show', ['utilisateur' => $ utilisateur]);
    }
}

// View (user / show.blade.php)
<h1 id="user-full-name"> {{$ user-> full_name}} </h1>

Dans cet exemple, le modèle User définit un attribut full_name , et UserController obtient des données utilisateur de la base de données et la transmet à la vue, et la vue est responsable de l'affichage du nom complet de l'utilisateur.

Comment fonctionne MVC

Le principe de travail de l'architecture MVC peut être simplement décrit comme: l'utilisateur initie une demande, la demande atteint le contrôleur, le contrôleur appelle le modèle pour obtenir ou mettre à jour les données, puis transmet les données à la vue et renvoie la vue à l'utilisateur après les avoir rendues. L'ensemble du processus est comme une opération de chaîne de montage, chaque lien effectue ses propres tâches.

Dans Laravel, les demandes sont acheminées vers le contrôleur, qui interagit avec la base de données via Eloquent ORM, acquiert ou met à jour les données et injecte les données dans le modèle de lame, qui est responsable du rendu de la sortie HTML finale.

L'avantage de cette architecture est qu'il rend le code plus modulaire et testable. Par exemple, vous pouvez tester la logique métier du modèle séparément sans vous soucier de l'affichage de la vue.

Exemple d'utilisation

Utilisation de base

Dans Laravel, il est très intuitif de créer une application CRUD simple. Supposons que nous voulons gérer les informations des utilisateurs, nous pouvons le faire:

 // L'utilisateur de la classe du modèle étend le modèle {
    protégé $ fillable = ['name', 'e-mail', 'mot de passe'];
}

// classe de contrôleur UserController étend le contrôleur {
    Index de fonction publique () {
        $ utilisateurs = utilisateur :: all ();
        return View ('users.index', ['utilisateurs' => $ utilisateurs]);
    }

    fonction publique create () {
        return View ('Users.Create');
    }

    Public Function Store (demande $ demande) {
        $ validedData = $ request-> valider ([
            'name' => 'requis',
            'e-mail' => 'requis | e-mail | Unique: utilisateurs',
            'mot de passe' => 'requis | min: 8',
        ]));

        $ user = user :: create ($ validedData);
        return redirect ('/ use') -> avec ('succès', 'utilisateur créé avec succès.');
    }

    // ... Autres méthodes telles que Show, Edit, Update, Destring
}

// Affichage (utilisateurs / index.blade.php)
@Foreach ($ utilisateurs en tant qu'utilisateur)
    <p> {{$ user-> name}} - {{$ user-> email}} </p>
@endforeach

Cet exemple montre comment utiliser des modèles, des contrôleurs et des vues pour implémenter la fonctionnalité CRUD de base.

Utilisation avancée

Parfois, nous devons faire face à une logique commerciale plus complexe, comme la gestion de la permission des utilisateurs. Pour le moment, nous pouvons utiliser le middleware et les politiques de Laravel à mettre en œuvre:

 // middleware (app / http / middleware / checkrole.php)
Poignée de fonction publique ($ demande, fermeture $ suivant, Role $) {
    if (! $ request-> user () -> Hasrole ($ role)) {
        retour rediriger («maison»);
    }

    retourner $ suivant ($ demande);
}

// classe de contrôleur AdminController étend le contrôleur {
    fonction publique __construct () {
        $ this-> middleware ('role: admin');
    }

    Index de fonction publique () {
        // seuls les administrateurs peuvent accéder à cette vue de retour de méthode ('admin.index');
    }
}

// stratégie (app / stratégies / userpolicy.php)
Mise à jour de la fonction publique (utilisateur de l'utilisateur, utilisateur de l'utilisateur $) {
    return $ user-> id === $ modèle-> id || $ user-> hasrole ('admin');
}

// classe de contrôleur UserController étend le contrôleur {
    fonction publique __construct () {
        $ this-> AutorizerEreSource (utilisateur :: class, 'utilisateur');
    }

    Mise à jour de la fonction publique (demande $ demande, utilisateur User $) {
        // Appelez automatiquement la méthode de mise à jour de l'utilisateur Policy pour l'autorisation CHECK $ USER-> Update ($ request-> valided ());
        return redirect ('/ use') -> avec ('succès', 'l'utilisateur mis à jour avec succès.');
    }
}

Cet exemple montre comment utiliser les middleware et les politiques pour implémenter une gestion complexe des autorisations.

Erreurs courantes et conseils de débogage

Les erreurs courantes lors de l'utilisation de l'architecture MVC de Laravel comprennent:

• Le modèle ne correspond pas au nom de la table de la base de données : assurez-vous que la propriété $table dans le modèle est correctement définie ou suivez la convention de dénomination de Laravel.
• La méthode du contrôleur n'est pas définie : vérifiez si la définition de l'itinéraire est correcte pour vous assurer que la méthode du contrôleur existe et que la signature est correcte.
• Fichier Affichage INCORDÉ : Vérifiez si le chemin du fichier Afficher est correct et assurez-vous que le fichier de modèle de lame existe.

Conseils de débogage:

• Utilisez le système de journalisation de Laravel pour enregistrer les messages d'erreur pour aider à localiser les problèmes.
• Utilisez l'outil de ligne de commande Tinker de Laravel pour un débogage rapide.
• Utilisez la fonction dd() pour produire des valeurs de variable dans le code pour aider à comprendre le flux de données.

Optimisation des performances et meilleures pratiques

Dans les applications pratiques, comment optimiser l'architecture MVC de Laravel? Voici quelques suggestions:

• Utilisez un chargement avide : évitez les problèmes de requête n 1 et chargez les données associées à la fois par le chargement avide.

 // Évitez n 1 query $ utilisateurs = utilisateur :: avec ('Posts') -> get ();

// au lieu de $ utilisateurs = utilisateur :: all ();
foreach ($ utilisateurs comme $ utilisateur) {
    $ user-> publications; // déclenchent n 1 requête}

• Résultats de la requête du cache : Pour les résultats de requête fréquemment utilisés, vous pouvez utiliser le système de cache de Laravel pour améliorer les performances.

 $ utilisateurs = Cache :: Remember ('Users', 3600, function () {
    RETOUR UTILISATEUR :: All ();
});

• CODE LICIBILITÉ ET MAINTENANCE : Gardez le code concis, suivez le principe sec (ne vous répétez pas) et utilisez raisonnablement les commentaires et les documents.

• Développement basé sur les tests (TDD) : Écrivez des tests unitaires et des tests d'intégration pour assurer la fiabilité et la maintenabilité du code.

 // Exemple de test unitaire TestUserCanBeCreated () {
    $ user = user :: factory () -> create ();
    $ this-> assertDatabaseHas ('utilisateurs', ['id' => $ user-> id]);
}

En général, l'architecture MVC de Laravel nous fournit un cadre de développement puissant, mais pour vraiment exercer sa puissance, nous devons toujours l'explorer et l'optimiser constamment dans la pratique. J'espère que cet article vous donnera une inspiration et vous permettra d'aller plus loin sur la route du développement de Laravel.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!