Understanding Models and Views in Laravel

Understanding models and views is essential if you’re looking to build dynamic, data-driven applications with Laravel. These two powerful components work together to structure your data and display it elegantly, bridging the gap between your backend logic and frontend design.

Models in Laravel serve as the link between your application and your database, making data handling much more straightforward, On the other hand, Views in Laravel manage the user-facing side of the application.

In this guide, we’ll explore models and views in depth, uncovering how they streamline database interactions and transform raw data into stunning web pages.

Let’s get started.

What Are Models in Laravel?

Models in Laravel are the core of the framework’s MVC architecture, and they manage how data is used and organized throughout your application.

Laravel models represent tables in your database, enabling you to perform essential operations—like querying, updating, and deleting data—through expressive, human-readable code.

Beyond basic database interaction, Laravel models empower you to add business logic directly to your models, making your code more modular and organized.

What Is the Purpose of Creating a Model in Laravel?

Models in Laravel are the powerhouse behind managing and organizing your app’s data, making it easy to interact with your database effortlessly.

Here’s why creating a model is so valuable:

• Direct Database Interaction: Models bridge your database tables, allowing you to retrieve, create, update, and delete data easily without writing raw SQL.
• Logical Data Organization: Each model represents a specific table, like User or Order, giving your data a clear, meaningful structure that matches your app’s needs.
• Simplified Relationships: Models allow you to define relationships, like “one-to-many” or “many-to-many,” which lets you access related data (like a user’s posts) with minimal code.
• Built-in Data Security: Models include features like mass-assignment protection and attribute casting, making it easier to handle data securely and prevent common vulnerabilities.

How to Create a Model in Laravel?

Creating a model in Laravel involves a few clear steps, each handled by specific commands and file modifications.

Here’s how to create a model in Laravel, step by step, with code and explanations:

Step 1: Use Artisan Command

To create a model in Laravel, use the Artisan command-line tool in your SSH terminal with the following command:

php artisan make:model Post

This command generates a new model file. We’re creating a Post model. By default, the model file is created in the app/Models directory.

Step 2: Define Model Properties

Once the model file is created, you can add properties to define how it interacts with the database.

Add the following line of code in app/Models/Post.php that you just created in the previous step.

namespace App\Models;

use Illuminate\Database\Eloquent\Factories\HasFactory;
use Illuminate\Database\Eloquent\Model;

class Post extends Model
{
    use HasFactory;

    // Add fillable properties
    protected $fillable = ['title', 'content', 'author'];

    // Specify the table name if it's different from 'posts'
    // protected $table = 'my_custom_table';
}

• Here, title, content, and author are fields that can be filled by the application.
• You can also specify custom table names or add relationships to other models if needed.

Step 3: Database Migration

To create the actual table in the database, generate a migration file and define the columns.

php artisan make:migration create_posts_table

This command creates a new migration file in the database/migrations folder.

Add the following line of code inside the new migration file in the database/migrations.

<?php

use Illuminate\Database\Migrations\Migration;
use Illuminate\Database\Schema\Blueprint;
use Illuminate\Support\Facades\Schema;

return new class extends Migration
{
    public function up()
    {
        Schema::create('posts', function (Blueprint $table) {
            $table->id();
            $table->string('title');
            $table->text('content');
            $table->string('author');
            $table->timestamps();
        });
    }

    public function down()
    {
        Schema::dropIfExists('posts');
    }
};

This migration file defines the structure of the posts table, including its columns.

Each field specified here (title, content, author) corresponds to a column in the database. The timestamps() method automatically adds created_at and updated_at columns.

After defining the migration, run it with:

php artisan migrate

Till now, you have created a basic model in Laravel for managing Post records in a posts database table.

This includes defining the model (Post) and a migration file to create the table with columns like title, content, and author.

Running the migration with php artisan migrate creates the posts table in the database.

Step 4: Using Models With Eloquent ORM

After setting up this model, you can use Eloquent ORM to interact with the database, such as:

// Create a new Post record
Post::create(['title' => 'First Post', 'content' => 'This is the content.', 'author' => 'Author Name']);

// Retrieve all posts
$posts = Post::all();

Using Eloquent ORM, you can use the User Interface to Post records in your database. You can access them with Post::all() or find specific records by ID using Post::find(1).

What are Views in Laravel?

In Laravel, views are like the front end of your application. They display the information that your application generates.

Views are typically written in Blade, a templating engine provided by Laravel. Blade allows you to create dynamic and reusable HTML templates. You can embed PHP code within your HTML to generate content dynamically.

To use a view, you typically return it from a controller. The controller collects the necessary data and passes it to the view, which then renders the HTML with the given data. This separation of content helps keep your code organized and maintainable.

What Is the Purpose of Using Views in Laravel?

Views in Laravel are the key to making your data secure and manageable. Laravel views let you keep your code clean, separate, and organized. Here’s why they’re essential:

• Effortless Content Display: Views are the templates that display your application’s data, making it easy to show dynamic content on web pages without cluttering your backend code.
• Separation of Logic and Design: Views keep your HTML and CSS separate from your business logic, making your code cleaner and easier to maintain. This structure also simplifies updates since the logic and design don’t overlap.
• Reusable Layouts: You can create reusable layouts, such as headers, footers, and sidebars, that appear across multiple pages with a consistent design, saving you time and effort.
• Dynamic User Experience: By passing data to views, you can create interactive and dynamic pages that enhance the user experience, all while keeping your code streamlined.

How to Create a Views in Laravel?

Creating and rendering views in Laravel is a fundamental task for web applications. Here’s how to achieve it step by step, including code examples and explanations for each part:

Step 1: Creating and Rendering Views

To create a view, place the HTML template file in the resources/views directory.

Create a new file with a .blade.php extension. This extension tells Laravel to use the Blade template engine to parse the view.

In the view file, add the HTML, PHP, and/or Blade templates that define the page’s structure and layout. You can use placeholders for dynamic content.

Save the view file.

<!-- resources/views/greeting.blade.php -->
<h1>Step 1 output</h1>
<h1>Hello, world!</h1>

To render this view, use the view() helper in a controller or route:

// In a route (routes/web.php)
Route::get('/', function () {
    return view('welcome');
});

Output

Step 2: Nested View Directories

You can organize views into subdirectories to keep them organized.

<!-- resources/views/posts/index.blade.php -->
<!DOCTYPE html>
<html>
<head>
    <title>Posts</title>
</head>
<body>
    <h1>All Posts</h1>
</body>
</html>

To render a nested view, use dot notation:

// In a route (routes/web.php)
Route::get('/posts', function () {
    return view('posts.index');
});

The view posts.index uses dot notation to access the nested directory.

Step 3: Creating the First Available View

Use View::first() to render the first available view from various options.

use Illuminate\Support\Facades\View;

// In a route (routes/web.php)
Route::get('/landing', function () {
    return View::first(['custom.landing', 'default.landing']);
});

If resources/views/custom/landing.blade.php exists, it loads that view. Otherwise, it will return to resources/views/default/landing.blade.php.

Step 4: Determining if a View Exists

Checks if a view exists before trying to render it.

use Illuminate\Support\Facades\View;

// In a route (routes/web.php)
Route::get('/check-view', function () {
    if (View::exists('posts.index')) {
        return view('posts.index');
    } else {
        return 'View does not exist';
    }
});

Step 5: Passing Data to Views

You can pass data directly to a view using an array.

Route::get('/post', function () {
    $post = [
        'title' => 'My First Post',
        'content' => 'This is the content of my first post.',
    ];
    return view('posts.show', compact('post'));
});

Also, update the view in resources/views/posts/show.blade.php:

<!-- resources/views/posts/show.blade.php -->
<!DOCTYPE html>
<html>
<head>
    <title>{{ $post['title'] }}</title>
</head>
<body>
    <h1>{{ $post['title'] }}</h1>
    <p>{{ $post['content'] }}</p>
</body>
</html>

Step 6: Sharing Data with All Views

You can share data globally in your application with all views using the View::share() method.

use Illuminate\Support\Facades\View;

// In App\Providers\AppServiceProvider.php
public function boot()
{
    View::share('appName', 'My Laravel App');
}

Now to access this view any view file, you can use appName:

<!-- Example in any view file -->
<h1>Step 6 output</h1>
<h1>Welcome to {{ $appName }}</h1>

Output

Using this code, you can build and display different pages in Laravel, organize those pages efficiently, handle missing views, and display dynamic data on the pages.

This structure is fundamental for building a functional, organized, and dynamic web application.

Laravel Model Tips

Here are some essential Laravel model tips to help you build secure and maintainable applications. Using these techniques, you can keep your code efficient and safe, ensuring better control over your models and data.

Let’s dive into each tip!

1. Spotting and Preventing N+1 Issues

The N+1 query problem happens when multiple queries are sent to the database for related data, causing slow performance. Avoid it by using Eager Loading with Laravel’s with() method in your queries.

This speeds up your queries by loading related data in a single call, preventing performance lags and unnecessary database calls.

// Instead of this (causes N+1 issue)
$posts = Post::all();
foreach ($posts as $post) {
    echo $post->author->name;
}

// Use this (solves N+1 issue)
$posts = Post::with('author')->get();
foreach ($posts as $post) {
    echo $post->author->name;
}

2. Prevent Accessing Missing Attributes

Accessing a non-existent attribute on a model can cause confusing bugs. Use $guarded or $fillable in your models to control which attributes are accessible.

By defining $fillable attributes, you ensure that only these specified fields can be accessed and mass-assigned, protecting your model from unexpected data.

class Post extends Model
{
    protected $fillable = ['title', 'content', 'author_id'];
}

3. Prevent Silently Discarding Attributes

Laravel can silently ignore attributes that aren’t in $fillable, causing confusion. To avoid this, enable guarded for fields you want to protect and strictly define only what’s allowed.

This approach helps prevent Laravel from discarding attributes without alerting you, keeping your data secure and your code clear.

class Post extends Model
{
    protected $guarded = ['id'];
}

4. Enable Strict Mode for Models

Laravel’s strict mode ensures errors are thrown for unrecognized attributes, making your app safer. Enable strict mode in your AppServiceProvider.

With strict mode enabled, Laravel alerts you when something unexpected happens, helping you catch issues early.

use Illuminate\Database\Eloquent\Model;

public function boot()
{
    Model::shouldBeStrict(true);
}

5. Using UUIDs

UUIDs are unique identifiers that make models more secure, especially in public-facing URLs. Add the Str::uuid() helper to generate UUIDs.

Using UUIDs hides your database’s numeric IDs, making your application’s data more secure and harder to predict.

use Illuminate\Support\Str;

class Post extends Model
{
    protected static function booted()
    {
        static::creating(function ($post) {
            $post->uuid = (string) Str::uuid();
        });
    }
}

6. Use UUIDs as the Primary Key

For an added layer of security, use UUIDs as your primary key. Override $primaryKey and $keyType in the model and set incrementing to false.

Using UUIDs as primary keys makes your database less predictable and enhances security by preventing sequential ID guessing.

class Post extends Model
{
    protected $primaryKey = 'uuid';
    protected $keyType = 'string';
    public $incrementing = false;
}

7. Using ULIDs

ULIDs are alternative unique identifiers that combine randomness with sequential sorting. You can generate ULIDs with Str::ulid().

In simple words, ULIDs offer a unique, sortable ID that’s great for use cases that require ordering but secure IDs in the URL.

use Illuminate\Support\Str;

class Post extends Model
{
    protected static function booted()
    {
        static::creating(function ($post) {
            $post->ulid = (string) Str::ulid();
        });
    }
}

8. Changing the Field Used for Route Model Binding

By default, Laravel binds models to routes using the primary key. You can change this to use a UUID or any other field by overriding getRouteKeyName().

This change makes your routes more flexible by allowing you to use unique fields like uuid instead of numeric IDs, adding both clarity and security.

class Post extends Model
{
    public function getRouteKeyName()
    {
        return 'uuid';
    }
}

9. Use Custom Model Collections

Laravel allows you to create custom collections for specific models, making it easier to add specialized methods for handling groups of models.

With custom collections, you can add methods like published() that filter your collection data, making it more readable and convenient.

use Illuminate\Database\Eloquent\Collection;

class PostCollection extends Collection
{
    public function published()
    {
        return $this->where('is_published', true);
    }
}

// In the Post model
class Post extends Model
{
    public function newCollection(array $models = [])
    {
        return new PostCollection($models);
    }
}

Using Models and Views together in Laravel?

Building dynamic web apps requires integrating Laravel’s Models and Views. In this part, we will learn how to use Models and Views together.

Let’s develop a basic application that retrieves and displays items or products from a database.

Here is a step-by-step guide on doing it:

Step 1: Database Setup

First, configure your database connection in the environment file. Once the database is set up, create a table for storing your products. Use the following Artisan command to create a products table:

php artisan make:migration create_products_table --create=products

Next, we will define the migration. To define the migration, locate the migration file created for the products table. You’ll find this file under database/migrations/, with a name similar to create_products_table. In our case, it’s named 2024_11_12_125426_create_products_table.php.

Once you locate the file, open it and define the schema as shown below:

public function up()
{
    Schema::create('products', function (Blueprint $table) {
        $table->id();
        $table->string('name');
        $table->text('description');
        $table->timestamps();
    });
}

Save the file, then run the migration to create the products table in the database. To do this, navigate to your project’s root directory and execute the following command:

php artisan migrate

Step 2: Creating a Model for Products

In this step, we will create a model for the products using the following Artisan command:

php artisan make:model Product

Once it’s done, we will define the fillable properties. We can achieve this by adding the code line shared below in the product.php file located under app/Models/Product.php.

You will need to add it under the product class, as shown in the screenshot below:

protected $fillable = ['name', 'description'];

Step 3: Creating Controller

Now we will create the Controller, which will be used to handle product-related requests. You will need to run the following command under the root directory:

php artisan make:controller ProductController

Now we need to define the Index Method by adding the following index code block under the file path app/Http/Controllers/ProductController.php.

Add the following code block to your ProductController.php file. Your ProductController.php should contain only this code:

<?php

namespace App\Http\Controllers;

use App\Models\Product; // Import the Product model
use Illuminate\Http\Request;

class ProductController extends Controller
{
    // Define the index method
    public function index()
    {
        // Fetch all products from the database
        $products = Product::all();
        // Pass the products data to the view
        return view('products.index', compact('products'));
    }
}

Step 4: Creating View and Layout

In this step, we will create a product and layout directory under resources/views/.

Now we will create a layout directory under views, the same as we did for the product directory.

Next, we will create a View File named index.blade.php under resources/views/products/ with the following code block and save it:

@extends('layouts.app')

@section('content')
    <h1>Our Products</h1>
    @foreach($products as $product)
        <div class="product">
            <h2>{{ $product->name }}</h2>
            <p>{{ $product->description }}</p>
        </div>
    @endforeach
@endsection

Now we will add the following code under the layout directory by creating a new file with the name app.blade.php and save it.

<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>My Laravel App</title>
    <link rel="stylesheet" href="{{ asset('css/app.css') }}"> <!-- Link to your CSS -->
</head>
<body>
    <div class="container">
        @yield('content') <!-- This is where your content will be injected -->
    </div>
</body>
</html>

Step 5: Defining Routes

Here we will open the Routes File under routes/web.php. We will add the Route for Products Index shared in the code block below:

use App\Http\Controllers\ProductController;
.
.
.
// Define route for products index
Route::get('/products', [ProductController::class, 'index']);

Following these steps has allowed you to successfully show products from your database using Laravel’s models and views. This method improves the user experience while maintaining your code’s organization by providing dynamic information in response to user queries.

A list of your items should now be appropriately displayed on your homepage when you visit /products. We added the following product details as samples—you can add your products to get your expected output.

Final Words.

In this guide, we explored the essential concepts of Models and Views in Laravel, helping you understand how data management and user interfaces are structured within this framework.

We looked at how Models simplify interactions with the database and how Views, using the Blade templating engine, allow for dynamic and flexible presentation of data.

Using these concepts, you can build applications that balance powerful back-end functionality with a responsive user experience.