Understanding MVC in Laravel: A Comprehensive Guide - Day 3 Lecture Notes

 


Understanding MVC in Laravel

A Comprehensive Guide - Day 3 Lecture Notes


Objective:

By the end of this session, students will understand the Model-View-Controller (MVC) design pattern in Laravel. They will be able to identify the roles of Models, Views, and Controllers in a Laravel application and create a simple controller using Laravel's Artisan command.

What is MVC?

MVC stands for Model-View-Controller, a software architectural pattern used for developing web applications. It separates the application into three main components, each with a distinct role:

1.  Model – Represents the data and the logic of the application.

2.  View – Handles the display (user interface), usually in the form of HTML, CSS, and JavaScript.

3.  Controller – Contains the logic that connects the Model and View, handling user input and interactions.

Why use MVC?

The MVC pattern helps organize code in a way that is easy to maintain, test, and scale. It separates the concerns of the application:

  • Model manages the business logic and database interaction.
  • View handles the presentation and UI.
  • Controller serves as a mediator between the Model and the View, handling requests and controlling the flow of data.

Roles of MVC Components in Laravel

1. Model

  • The Model in Laravel represents the data structure of the application, typically interacting with the database. It contains the application's business logic, database queries, and validation rules.
  • Role of Model:
    • It manages the data (retrieves, stores, and updates it in the database).
    • It often includes methods for interacting with specific tables or performing operations (CRUD - Create, Read, Update, Delete).
  • Creating a Model: You can create a model using the Artisan command like this:

php artisan make:model Post

This will generate a model file located in the app/Models/Post.php file.

  • Example of a Simple Model (Post.php):

namespace App\Models;

use Illuminate\Database\Eloquent\Model;

class Post extends Model

{

    protected $fillable = ['title', 'body']; // Define the columns we can insert data into

}

2. View

  • The View is responsible for presenting data to the user in a readable and interactive format. In Laravel, views are generally written in Blade, a simple and powerful templating engine that allows you to mix HTML with PHP logic.
  • Role of View:
    • It manages the UI components like forms, buttons, images, and text.
    • It is responsible for the layout and display of data passed from the Controller.
  • Creating a View: Views are stored in the resources/views directory. For example, creating a post.blade.php file to display a post's title and body might look like this:

<!DOCTYPE html>

<html lang="en">

<head>

    <meta charset="UTF-8">

    <title>Post</title>

</head>

<body>

    <h1>{{ $post->title }}</h1>

    <p>{{ $post->body }}</p>

</body>

</html>

  • Passing Data from Controller to View: In Laravel, you can pass data to a view using the with method:

public function show($id)

{

    $post = Post::find($id);

    return view('post')->with('post', $post);

}

3. Controller

  • The Controller is the intermediary between the Model and the View. It handles the logic of retrieving data from the Model and passing it to the View. The Controller also processes user input (like form submissions), performs necessary operations on the data, and redirects the user accordingly.
  • Role of Controller:
    • It defines how the application responds to user requests.
    • It processes data from the user (forms, URL inputs, etc.) and interacts with the Model to fetch or update the data.
    • It decides which View should be shown and passes necessary data to it.
  • Creating a Controller: You can create a new controller using the Artisan command:

php artisan make:controller ExampleController

This creates a controller file in app/Http/Controllers/ExampleController.php.

  • Example of a Simple Controller (ExampleController.php):

namespace App\Http\Controllers;

use App\Models\Post;

use Illuminate\Http\Request;

class ExampleController extends Controller

{

    // Method to show a post by ID

    public function show($id)

    {

        $post = Post::find($id); // Fetch the post from the database

        return view('post')->with('post', $post); // Return view with the post data

    }

}

In this example, the show method fetches a specific post from the Post model and passes it to the post view.

How MVC Works Together in Laravel

1.  The Request: A user sends a request to the Laravel application, typically through the browser (e.g., by visiting a URL).

2.  Routing: Laravel routes the request to a specific Controller method (defined in routes/web.php).

3.  Controller: The Controller handles the request, interacts with the Model (to fetch or update data), and then returns a response (usually a View).

4.  Model: If necessary, the Model retrieves or updates data from the database, which is then passed to the View.

5.  View: The View displays the data to the user in a readable format (HTML).

Creating a Controller with Artisan Command

  • Step 1: Open the terminal (command line interface).
  • Step 2: Run the following command to create a controller:

php artisan make:controller ExampleController

  • Step 3: This command will create a controller in the app/Http/Controllers directory. Open the ExampleController.php file and add methods to handle requests.

Example:

namespace App\Http\Controllers;

use Illuminate\Http\Request;

class ExampleController extends Controller

{

    public function index()

    {

        return "Hello from ExampleController";

    }

}

  • Step 4: Define a route in routes/web.php to link a URL to this controller method:

use App\Http\Controllers\ExampleController;

Route::get('/example', [ExampleController::class, 'index']);

  • Step 5: Visit http://your-app-url/example to see the response from the controller.

Summary of Key Points

  • Model: Manages data, interacts with the database, and performs business logic.
  • View: Handles the display and UI using Blade templates.
  • Controller: Contains logic that connects Models and Views and processes user input.

Exercise for Students

1.  Create a controller called PostController.

2.  Create a model called Post with fields title and body.

3.  Create a view to display a post's title and body.

4.  Define routes to display a post by its ID.


Comments

Post a Comment

Popular posts from this blog

MCQs Of Day CRUD 8 Operations with Eloquent

MCQs Of Day 8 CRUD  Operations with Eloquent   CRUD Operations with Eloquent - MCQs 1. What does CRUD stand for in database management? a) Create, Read, Update, Delete b) Connect, Retrieve, Update, Delete c) Create, Return, Update, Delete d) Collect, Read, Update, Delete Answer:  a) Create, Read, Update, Delete Explanation:  CRUD is a set of operations that stand for Create, Read, Update, and Delete, which are basic functions used in databases to manage records. 2. Which Laravel method is used to create a new record in a database? a) create() b) store() c) insert() d) add() Answer:  a) create() Explanation:  The create() method is used in Laravel's Eloquent ORM to create a new record in the database. 3. Which of the following is true about Eloquent ORM in Laravel? a) It allows only raw SQL queries. b) It does not support relationships between models. c) It provides an active record implementation for working with the database. d) It is used only for Read op...
Read more

Lecture Notes Of Day 24: Laravel Policies

  Lecture Notes Of Day 24: Laravel Policies Objective: To implement policies for authorization, ensuring that different users can perform only the actions they are authorized to do. This will help students understand how to manage user permissions effectively for different actions in Laravel applications. Outcome: By the end of this class, students will be able to create, register, and use policies to manage user permissions for various actions in a Laravel application. They will also learn how to secure resources and actions based on user roles or other attributes. What are Policies in Laravel? In Laravel, policies provide a convenient way to authorize user actions on certain resources. A policy is essentially a class that organizes authorization logic for a particular model. For example, if you have a Post model, you might have a PostPolicy class that defines who can view, update, or delete a post. Why use Policies? Policies centralize authorization ...
Read more

MCQs of Day 7 Eloquent ORM Basics

  MCQs of Day 7 Eloquent ORM Basics 1. Which command is used to create an Eloquent model in Laravel? A) php artisan create:model B) php artisan make:model C) php artisan model:create D) php artisan generate:model Answer: B) php artisan make:model Explanation: The php artisan make:model command is used to create a new Eloquent model in Laravel. 2. What is the purpose of the $fillable property in an Eloquent model? A) To define which fields can be mass-assigned B) To define the table name C) To store timestamps D) To define relationships between models Answer: A) To define which fields can be mass-assigned Explanation: The $fillable property in an Eloquent model defines which fields are allowed for mass-assignment to protect against mass-assignment vulnerabilities. 3. How do you retrieve a single record by its ID in Eloquent? A) Model::get(1) B) Model::find(1) C) Model::single(1) D) Model::first(1) Answer: B) Model::find(1) Explanation: The find() method retrieves a single record by ...
Read more