Laravel applications take after the customary Model-View-Controller configuration design, where you utilize:
Connecting your database with Models to get your product or item data
Perspectives to render pages
So…
An ask for is made — say, when a client enters a URL related with your application.
A course connected with that URL maps the URL to a controller activity.
That controller activity use the vital model(s) to recover data from the database, and after that passes fthat information off to a view.
Furthermore, that view renders the last page Laravel Programmer Building an example application
For exhibit, I will walk you through the way toward building the beginning of an example Laravel 5 application with all the MVC parts — a model, a view, and a controller.
In this way, suppose you needed to fabricate an application managing autos…
The Model
We’ll begin by making a model, to speak to a Car.
Laravel accompanies an awesome, worked in charge line interface, the Artisan CLI, which furnishes you with a group of valuable orders to enable you to assemble your application.
Along these lines, start up your charge line (and associate with your Homestead virtual machine, in case you’re utilizing Laravel Homestead), move into your application’s fundamental index, and run the accompanying summon to create another Car display:
$ php craftsman make:model Car – movement
Models are altogether put away in the primary application registry, so charge will produce an application/Car.php demonstrate record with the accompanying code:
<?php
namespace App;
utilize Illuminate\Database\Eloquent\Model;
class Car expands Model
{
/
}
Because of Laravel’s worked in display usefulness, just by making a vacant model class, Laravel will accept that this model is related with a database table named autos.
Furthermore, really, by providing that – movement choice while producing the model, Laravel likewise produced a database relocation petition for making that autos database table. The relocation document is situated at [timestamp]_create_cars_table.php and contains the accompanying code:
<?php
utilize Illuminate\Database\Schema\Blueprint;
utilize Illuminate\Database\Migrations\Migration;
class CreateCarsTable broadens Migration
{
/**
* Run the relocations.
*
* @return void
*/
open capacity up()
{
Schema::create(‘cars’, work (Blueprint $table) {
$table->increments(‘id’);
$table->timestamps();
});
}
/**
* Reverse the relocations.
*
* @return void
*/
open capacity down()
{
Schema::drop(‘cars’);
}
}
(In case you’re new to the idea of database movements, read more about how Laravel utilizes database relocations to enable you to deal with your database from specifically inside your application. It’s great.)
All you need to do currently is utilize Laravel’s Schema manufacturer documentation to finish the relocation record. So you could characterize a couple of extra sections to, say, store the autos’ make, model, and generation date:
.
.
.
Schema::create(‘cars’, work (Blueprint $table) {
$table->increments(‘id’);
$table->string(‘make’);
$table->string(‘model’);
$table->date(‘produced_on’);
$table->timestamps();
});
.
.
.
And afterward you can run the relocation to make the autos table utilizing the accompanying Artisan charge:
$ php craftsman move
With the database-related things tended to, we would now be able to proceed onward to make a controller.
Note: for the sole purpose of testing, now, I just physically added a section to the autos database table.
The Controller
In Laravel, a sort of question —, for example, a Car, for this situation — is alluded to as an asset.
Since it’s so normal to assemble applications around assets, you can produce an asset controller — a controller to deal with all solicitations identified with an asset — utilizing another straightforward Artisan order:
$ php craftsman make:controller CarController
That will produce an application/Http/Controllers/CarController.php controller document with the accompanying code:
<?php
namespace App\Http\Controllers;
utilize Illuminate\Http\Request;
utilize App\Http\Requests;
utilize App\Http\Controllers\Controller;
class CarController broadens Controller
{
/**
* Display a posting of the asset.
*
* @return Response
*/
open capacity file()
{
/
}
/**
* Show the shape for making another asset.
*
* @return Response
*/
open capacity make()
{
/
}
/**
* Store a recently made asset away.
*
* @return Response
*/
open capacity store()
{
/
}
/**
* Display the predetermined asset.
*
* @param int $id
* @return Response
*/
open capacity show($id)
{
/
}
/**
* Show the shape for altering the predetermined asset.
*
* @param int $id
* @return Response
*/
open capacity edit($id)
{
/
}
/**
* Update the predetermined asset away.
*
* @param int $id
* @return Response
*/
open capacity update($id)
{
/
}
/**
* Remove the predetermined asset from capacity.
*
* @param int $id
* @return Response
*/
open capacity destroy($id)
{
/
}
}
