Aprende Laravel
Aprende Laravel
Aprende Laravel
Este es un libro de Leanpub. Leanpub anima a los autores y publicadoras con el proceso de
publicación. Lean Publishing es el acto de publicar un libro en progreso usando herramientas
sencillas y muchas iteraciones para obtener feedback del lector hasta conseguir tener el libro
adecuado.
Introducción . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1
Prerequisitos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1
¿Qué es Laravel? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1
Características principales . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
Ecosistema Laravel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
Práctica 7 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
Práctica 8 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
Autenticación . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
Práctica 9 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
Manejo de sesiones . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
Práctica 10 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
Próximos pasos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
Introducción
Es importante que antes de comenzar a leer este libro, comprendas dos cosas fundamentales acerca
del mismo:
• Este libro no pretende ser una extensa guía de referencia que profundice en cada uno de los
aspectos de Laravel. Su objetivo es el de mostrarte los aspectos más importantes de Laravel y
enseñarte paso a paso y de forma práctica a desarrollar aplicaciones web.
• El libro está en constante mejora y actualización. Toda contribución es bienvenida, ya sea en
forma de corrección de errores, sugerencias sobre el contenido, difusión entre conocidos o redes
sociales o cualquier otro tipo de colaboración que se te pueda ocurrir. Puedes hacerlo de forma
sencilla escribiendo un mensaje directo en Twitter a @JonVadillo.
Prerequisitos
Para seguir esta guía únicamente necesitarás conocimientos básicos/medios de PHP y motivación
para aprender. Si todavía no dispones de estos conocimientos, puedes utilizar el material gratuito
disponible en http://jonvadillo.com/learn para comenzar tu aprendizaje.
Cualquier editor de texto te servirá también para programar. No obstante, te recomiendo PhpStorm
de JetBrains, el cual considero sin duda alguna uno de los editores para PHP más potentes en la
actualidad.
¡Comencemos!
¿Qué es Laravel?
Tal y como dice la guía oficial, Laravel es un framework de desarrollo de aplicaciones web con
una sintaxis elegante que nos permitirá desarrollar aplicaciones web de forma rápida y segura.
El objetivo de Laravel es permitir a los desarrolladores crear aplicaciones web robustas y profesio-
nales, de forma ágil y con una estructura adecuada. Laravel facilita la implentación de cualquier
funcionalidad que toda aplicación profesional pueda necesitar (interacción con bases de datos,
seguridad, servicios web, etc.).
En este libro aprenderás a crear aplicaciones web con Laravel desde cero, desde lo más básico
hasta funcionalidades más complejas que incluyan aspectos como la seguridad o control de acceso.
Introducción 2
Características principales
Algunas de las características de Laravel son:
Ecosistema Laravel
Es importante conocer bien los actores principales del ecosistema Laravel:
• Router: recibe todas las peticiones y las envía al controlador adecuado (también puede ejecutar
algún middleware específico antes de llamar al controlador).
• Controladores (Controllers): contienen toda la lógica para reaccionar a las peticiones entran-
tes.
• Vistas (Views): contienen el código HTML y separan la presentación de la lógica de la
aplicación (controlador).
• Modelos (Models): se utilizan para interactuar con la base de datos y aplicar la lógica de
negocio.
Laravel diagram
Introducción 3
Tal y como muestra la imagen anterior, el flujo de una petición en una aplicación de Laravel sería
el siguiente:
2. Instalar Vagrant.
Descarga e instala Vagrant tal y como lo indica la documentación de la página web oficial
https://www.vagrantup.com⁶.
Una Vagrant box es una imagen base utilizada para clonar de forma rápida y sencilla una máquina
virtual. Ejecuta el siguiente comando para descargar e instalar la Vagrant box the Larabel y así poder
utilizarla para crear tantos entornos como quieras.
Puedes comprobar que se ha añadido correctamente utilizando el comando vagrant box list.
4. Instalar Homestead
Ejecuta el comando init.sh en un terminal dentro del directorio donde clonaste Homestead. Este
comando creará el archivo de configuración Homestead.yaml.
1 // Mac / Linux...
2 bash init.sh
3
4 // Windows...
5 init.bat
1 ip: "192.168.10.10"
2 memory: 2048
3 cpus: 2
4 provider: virtualbox
5
6 authorize: ~/.ssh/id_rsa.pub
7
8 keys:
9 - ~/.ssh/id_rsa
10
11 folders:
12 - map: ~/code
13 to: /home/vagrant/code
14
15 sites:
16 - map: homestead.test
17 to: /home/vagrant/code/public
18
19 databases:
20 - homestead
Si no dispones de unas clasves ssh en el sistema necesitarás generarlas desde un terminal. Para saber
si ya dispones de ellas, intanta encontrar el directorio .ssh en tu sistema operativo (normalmente
suele encontrarse en C:UsersUSER_NAME en Windows y el el directorio raíz ∼ en Linux/Mac ) y
busca dos archivos llamados id_rsa y id_rsa.pub. Si los has encontrado, puedes saltarte este paso.
En caso contrario, lanza el siguiente comando desde la consola:
Preparar el entorno de desarrollo 6
El script te realizará algunas preguntas, simplemente pulsa ENTER y te creará los archivos id_rsa
y id_rsa.pub en un directorio con nombre .ssh.
7. Configurar Homestead
En esta instalación no tendrás que tocar el archivo Vagrantfile (probablemente estés familiarizado
con él ya que es típicamente el utilizado para configurar el entorno). Homestead delega la
configuración en el archivo Homestead.yaml, por lo que a continuación te mostraremos las opciones
más importantes que tendrás que configurar:
1 authorize: c:/Users/USER_NAME/.ssh/id_rsa.pub
2
3 keys:
4 - c:/Users/USER_NAME/.ssh/id_rsa
• Shared folders: en este apartado se indican los directorios de la máquina local que se
mantendrán sincronizados con la máquina virtual creada. Modifica el valor de ‘map’ y
escribe la carpeta de tu proyecto (p.ej. /Users/USER_NAME/dev/my-project en Linux/Mac o
c:/dev/my-project en Windows).
1 folders:
2 - map: ~/code/project1
3 to: /home/vagrant/project1
4
5 - map: ~/code/project2
6 to: /home/vagrant/project2
• Sites: La propiedad sites permite mapear fácilmente un dominio con un directorio de nuestro
entorno virtual. De este forma podremos utilizar el dominio indicado para acceder a nuestra
aplicación desde el navegador:
Preparar el entorno de desarrollo 7
1 sites:
2 - map: homestead.test
3 to: /home/vagrant/project1/public
4 - map: miapp.test
5 to: /home/vagrant/project2/public
Es probable que vayas a utilizar el entorno virtual creado para múltiples proyectos o aplicaciones, por
lo que necesitarás añadir los dominios indicados en el anterior apartado de ‘sites’ al archivo hosts
de tu ordenador. De esta forma puedes redirigir las peticiones a dominios concretos a aplicaciones
de tu entorno virtual Homestead.
Modifica el archivo hosts (lo encontrarás en /etc/hosts en Mac/Linux y en C:\Windows\System32\drivers\etc\hos
en Windows):
1 192.168.10.10 homestead.test
2 192.168.10.10 miapp.test
Para evitar otro tipo de problemas, la recomendación general es utilizar dominios de tipo “.localhost”,
“.invalid”, “.test”, or “.example”.
1 vagrant up
1 vagrant ssh
¡Enhorabuena! Ya estás preparado para comenzar a crear tu primera aplicación web con Laravel.
Puedes detener la máquina virtual con el comando vagrant halt.
Tu primera aplicación en 8 pasos
Ahora que ya tenemos nuestro entorno de desarrollo preparado, crearemos una aplicación web con
Laravel paso por paso. Al finalizar los 8 pasos que encontrarás en este capítulo, obtendremos como
resultado una revista online a la que hemos llamado RevistApp. Esta aplicación mostrará los artículos
de una revista almacenados en una base de datos. ¿Comenzamos ya?
Si recibes un error, probablemente sea porque todavía no tienes Composer instalado en tu máquina
virtual. Para ello, ejecuta el siguiente comando:
Una vez instalado vuelve a ejecutar el comando create-project de Composer. Este comando
inicializará un nuevo proyecto creado en el directorio revistapp. Puedes acceder a la aplicación
entrando a http://homestead.test (o el dominio que hayas indicado en la configuración) desde tu
navegador favorito.
De forma alternativa también puedes utilizar el comando laravel new que también creará un nuevo
proyecto de Laravel en la carpeta especificada:
Puedes entrar a ver los archivos que se han creado en la nueva carpeta del proyecto. A partir de
ahora siempre trabajaremos dentro de este directorio.
Laravel utiliza una clave para securizar tu aplicación. La clave de aplicación es un string de 32
caracteres utilizado para encriptar datos como la sesión de usuario. Cuando se instala Laravel
utilizando Composer o el instalador de Laravel, la clave se genera automáticamente, por lo que no
es necesario hacer nada. Comprueba que existe un valor para APP_KEY en el fichero de configuración
.env. En caso de no tener una clave generada, créala utilizando el siguiente comando:
Tu primera aplicación en 8 pasos 9
Homestead realiza este paso por nosotros, por lo que si estás utilizando Homestead los permisos
deberían estar correctamente establecidos. Si no estás utilizando Homestead o quieres desplegar tu
aplicación en un servidor, no olvides establecer permisos de escritura para el servidor web en los
directorios storage y bootstrap/cache.
1 Route::get('/articulos', function () {
2 return '¡Vamos a leer unos articulos!';
3 });
El código anterior muestra cómo se define una ruta básica. En este caso, cuando el usuario realice
una petición sobre /articulos, nuestra aplicación enviará una respuesta al usuario con el string
‘¡Vamos a leer unos articulos!’.
Aparte de ejecutar las acciones definidas para cada ruta, Laravel ejecutará el middlewere específico
en función del Router utilizado (por ejemplo, el middlewere relacionado con las peticiones web
proveerá de funcionalidades como el estado de la sesión o la protección CSRF⁷.
Artisan incluye un comando para mostrar todas las rutas de una aplicación de forma rápida. Basta
con ejecutar el siguiente comando en la consola:
Devolver un JSON
También es posible devolver un JSON. Laravel convertirá automáticamente cualquier array a JSON:
⁷https://es.wikipedia.org/wiki/Cross-site_request_forgery
Tu primera aplicación en 8 pasos 10
1 Route::get('/articulos', function () {
2 return ['foo' => 'bar'];
3 });
Parámetros en la ruta
Una URL puede contener información de nuestro interés. Laravel permite acceder a esta información
de forma sencilla utilizando los parámetros de ruta:
Los parámetros de ruta vienen definidos entre llaves {} y se inyectan automáticamente en las
callbacks. Es posible utilizar más de un parámetro de ruta:
También es posible acceder a la información enviada en la petición. Por ejemplo, el siguiente código
devolverá el valor enviado para el parámetro ‘fecha’ de la URL /articulos?fecha=hoy:
1 Route::get('/articulos', function () {
2 $date = request('fecha');
3 return $date;
4 });
Las vistas contienen el HTML que sirve nuestra aplicación a los usuarios. Se almacenan en el
directorio resources/views de nuestro proyecto.
Tu primera aplicación en 8 pasos 11
Cargar y devolver una vista al usuario es tan sencillo como utilizar la función global (helper) view():
1 Route::get('/articulos', function () {
2 return view('articulos');
3 });
Laravel utiliza el motor de plantillas Blade⁸ por defecto. Un motor de plantillas permite crear vistas
empleando código HTML junto con código específico del motor empleado. De esta forma podremos
mostrar información almacenada en variables, crear condiciones if/else, estructuras repetitivas, etc.
En Blade mostrar datos almacenados en variables es muy sencillo:
1 <html>
2 <body>
3 <h1>Vamos a leer al escritor {{ $nombre }}</h1>
4 </ul>
5 </body>
6 </html>
Tal y como se puede ver en el ejemplo anterior, basta con escribir el nombre de la variable entre
llaves {{ }}.
También es posible iterar por los datos de una colección o array. El siguiente ejemplo muestra como
iterar por un array de strings de forma rápida:
⁸https://laravel.com/docs/6.x/blade
Tu primera aplicación en 8 pasos 12
Para que la vista pueda acceder a los datos, es necesario proporcionárselos en la llamada al método
view():
1 Route::get('/articulos', function () {
2 $articulos = array('Primero', 'Segundo','Tercero', 'Último');
3 return view('articulos', [
4 'nombre' => 'Ane Aranceta',
5 'articulos' => $articulos
6 ]);
7 });
Creando un Controller
• Crear manualmente una clase que extienda de la clase Controller de Laravel dentro del
directorio app/Http/Controllers.
• Utilizar el comando de Artisan make:controller. Artisan es una herramienta que nos provee
Laravel para interactuar con la aplicación y ejecutar instrucciones.
⁹https://laravel.com/docs/6.x/blade
Tu primera aplicación en 8 pasos 14
1 <?php
2
3 namespace App\Http\Controllers;
4
5 use App\Http\Controllers\Controller;
6 use App\User;
7
8 class ArticuloController extends Controller
9 {
10 /**
11 * Show the profile for the given user.
12 *
13 * @param int $id
14 * @return View
15 */
16 public function show($id)
17 {
18 return view('show', ['articulo' => 'Mi primer artículo de Laravel');
19 }
20 }
Añadiendo --resource al comando anterior, Artisan añadirá al controlador creado los siete métodos
más comunes: index(), create(), store(), show(), edit(), update(), destroy().
Enrutar el Controlador
1 Route::get('articulos/', 'ArticuloController@index');
2 Route::get('articulos/{id}', 'ArticuloController@show');
3 Route::get('articulos/{id}/create', 'ArticuloController@create');
4 Route::post('articulos/', 'ArticuloController@store');
El fichero .env de Laravel contiene la configuración relacionada con la aplicación y el entorno, como
por ejemplo la configuración de la base de datos. Abre el fichero .env con un editor y modifica las
siguientes credenciales de la base de datos:
1 DB_CONNECTION=mysql
2 DB_HOST=127.0.0.1
3 DB_PORT=3306
4 DB_DATABASE=nombre de la base de datos(revistapp)
5 DB_USERNAME=nombre de usuario de la base de datos(root)
6 DB_PASSWORD=contraseña del usuario(root)
1 mysql -u root
1 <?php
2
3 use Illuminate\Support\Facades\Schema;
4 use Illuminate\Database\Schema\Blueprint;
5 use Illuminate\Database\Migrations\Migration;
6
7 class CreateArticulosTable extends Migration
8
9 {
10 /**
11 * Run the migrations.
12 *
13 * @return void
14 */
15 public function up()
16 {
17 Schema::create('articulos', function (Blueprint $table) {
18 $table->increments('id');
19 $table->string('titulo');
20 $table->text('contenido');
21 $table->timestamps();
22 });
23 }
24
25
26
27 /**
28 * Reverse the migrations.
29 *
30 * @return void
31 */
32 public function down()
33 {
34 Schema::dropIfExists('articulos');
35 }
36 }
Tal y como puedes deducir del código anterior, una migración contiene 2 métodos:
• up(): se utiliza para crear nuevas tablas, columnas o índices a la base de datos.
• down(): se utiliza para revertir operaciones realizadas por el método up().
Existen una gran variedad de tipos de columnas disponibles para definir las tablas. Puedes
Tu primera aplicación en 8 pasos 17
Es recomendable utilizar un usuario de base de datos diferente a root. Para ello, desde MySQL
ejecuta lo siguiente:
El comando anterior crea el usuario con la contraseña indicada. El siguiente paso es otorgar permisos
al usuario:
1 FLUSH PRIVILEGES;
No olvides actualizar los datos de acceso a base de datos en el fichero de configuración .env.
Each database table has a corresponding “Model” which is used to interact with that table.
Models allow you to query for data in your tables, as well as insert new records into the
table.
En otras palabras, cada tabla de la base de datos corresponde a un Modelo, el cual permite ejecutar
operaciones sobre esa tabla (insertar o leer registros por ejemplo).
Creando un Modelo
El comando anterior ha creado una clase llamada Articulo en el directorio app (es el directorio por
defecto para los modelos de Eloquent).
1 <?php
2
3 namespace App;
4
5 use Illuminate\Database\Eloquent\Model;
6
7 class Articulo extends Model
8 {
9 //
10 }
Por defecto un modelo de Eloquent almacena los registros en una tabla con el mismo nombre pero
en plural. En este caso, Articulo interactuará con la tabla llamada ‘articulos’.
Los modelos de Eloquent se utilizan para recuperar información de las tablas relacionadas con el
modelo. Proporcionan métodos como los siguientes:
El siguiente controlador contiene toda la lógica para insertar, actualizar y borrar modelos:
1 <?php
2
3 namespace App\Http\Controllers;
4
5 use App\Articulo;
6 use Illuminate\Http\Request;
7 use Redirect;
8
9 class ArticuloController extends Controller
10 {
11
12 /**
13 * Create a new articulo instance.
14 *
15 * @param Request $request
16 * @return Response
17 */
18 public function store(Request $request)
19 {
20 // Validar la petición...
21
22 $articulo = new Articulo;
23
24 $articulo->titulo = request('titulo');
25
26 $articulo->save();
27 }
28
29 /**
30 * Update the specified resource in storage.
31 *
32 */
33 public function update(Request $request, $id)
34 {
35 $articulo = App\Articulo::find(1);
36
37 $articulo->titulo = request('titulo');
38 $articulo->contenido = request('contenido');
39
Tu primera aplicación en 8 pasos 20
40 $articulo->save();
41 }
42
43 /**
44 * Remove the specified resource from storage.
45 *
46 */
47 public function destroy($id)
48 {
49 // Encuentra el artículo por ID y lo elimina
50 $articulo = App\Articulo::find($id);
51 $articulo->delete();
52
53 // Alternativa
54 App\Articulo::destroy($id);
55
56 //Borrar modelos por consulta (borra todos los que encuentre en la consulta)
57 Articulo::where('id',$id)->delete();
58 }
59
60 }
Laravel proporciona alternativas para realizar operaciones más complejas, como creaciones en
“masa” o crear un modelo solo si no existe:
Tinker es un potente REPL¹² o consola interactiva que viene por defecto en Laravel. Resulta muy
útil durante el desarrollo ya que permite interactuar con nuestra aplicación Laravel y probar cantidad
de cosas: eventos, acceso a datos, etc.
Para iniciar Tinker hay que ejecutar el siguiente comando:
A partir de ese momento se puede comenzar a interactuar con nuestra aplicación, como muestra el
ejemplo a continuación:
¹¹https://laravel.com/docs/6.x/eloquent
¹²https://es.wikipedia.org/wiki/REPL
Tu primera aplicación en 8 pasos 21
Práctica 1
Crea una aplicación Laravel que muestre un listado de artículos de la base de datos.
Práctica 2
Añade a la aplicación anterior una nueva vista que muestre el detalle de un artículo. Se accederá
desde la vista del listado de artículos.
Level up: Laravel nivel intermedio
Borrado de registros
El borrado de registros es un tema que suele traer complicaciones, debido a que desde una página
HTML solo es posible enviar peticiones GET y POST (desde formularios). Por lo tanto, las alternativas
son las siguientes:
• Crear una ruta GET específica para el borrado. Por ejemplo: /removeArticulo/{id}
• Hacer la petición utilizando AJAx y especificando en la llamada el tipo de método: 'type':
'DELETE'
• Emular la llamada DELETE mediante el campo oculto _method. Para ello podemos utilizar los
helpers o directivas de Laravel en un formulario para notificar que se trata de una petición de
tipo DELETE:
1 <form method="POST">
2 {{ csrf_field()}}
3 {{ method_field("DELETE")}}
4 <!-- ... -->
5 </form>
1 <form method="POST">
2 @csrf
3 @method("DELETE")
4 <!-- ... -->
5 </form>
Práctica 3
Añade la posibilidad de eliminar artículos mediante un enlace o botón en cada uno de los registros
mostrados.
Level up: Laravel nivel intermedio 24
Formularios
Los formularios HTML son la forma más habitual de recoger datos introducidos por los usuarios y
enviarlos a la aplicación.
Para este cometido necesitaremos crear dos nuevas rutas en nuestro Router: una para mostrar al
usuario el formulario de recogida de datos y otra para recibir y tratar los datos introducidos por el
usuario.
1 Route::get('articulos/create', 'ArticuloController@create');
2 Route::post('articulos/', 'ArticuloController@store');
De igual forma que hemos necesitado dos nuevas rutas, también necesitaremos dos nuevos métodos
en nuestro Controller:
28
29 $articulo->save();
30
31 return redirect('/articulos');
32 }
33 }
El último paso es crear la vista que contenga el formulario HTML y que será mostrada al usuario al
invocar el método create() del controlador:
Práctica 4
Añade la posibilidad de añadir nuevos artículos mediante un formulario ubicado en una nueva vista.
Construir layouts
Las aplicaciones siempre contienen varias parte de la interfaz que son comunes en todas las páginas
(la cabecera, menú de navegación, footer, etc.). Blade permite el uso de Layouts, los cuales permiten
de forma muy sencilla compartir entre distintas vistas las partes que tienen en común y así evitar
repetir lo mismo múltiples veces. La idea consiste en separar en un archivo distinto la parte común
Level up: Laravel nivel intermedio 26
de nuestras vistas y especificar en ella las zonas que albergarán los contenidos específicos de cada
vista (lo que no es común).
Empecemos por definir un layout básico:
1 <html>
2 <head>
3 <title>App Name - @yield('titulo')</title>
4 </head>
5 <body>
6 <div class="container">
7 @yield('content')
8 </div>
9 <div class="big-footer">
10 @yield('footer')
11 </div>
12 </body>
13 </html>
La directiva @yield se utiliza para especificar el lugar donde se mostrarán los contenidos de cada
sección.
Ahora crearemos la vista concreta que especificará el contenido a introducir en el layout. Es por esto
que decimos que la vista extiende (extends) del layout, es decir, la vista heredará toda la estructura
definida en el layout y sobreescribirá las partes concretas que defina (las secciones).
1 @extends('layouts.master')
2
3 @section('titulo', 'Page Title')
4
5 @section('content')
6 <h1>Hello World!</h1>
7 <p>This is my body content.</p>
8 @endsection
9
10 @section('footer')
11 <p>Built by @JonVadillo.</p>
12 @endsection
@section indica la sección del padre donde será introducido el contenido especificado entre las
etiquetas @section y @endsection.
Práctica 5
Crea un layout que englobe la parte común que contienen todas las vistas de la aplicación.
Level up: Laravel nivel intermedio 27
1 Route::get('articulos/', 'ArticuloController@index')->name('articulos.index');
2 Route::get('articulos/create', 'ArticuloController@index')->name('articulos.create');
3 Route::get('articulos/{id}', 'ArticuloController@show')->name('articulos.show');
Como se puede deducir del ejemplo anterior, utlizamos el método name() para definir el nombre que
queremos establecer para cada ruta.
De este modo, podremos cargar las rutas utilizando el método global route():
En ocasiones necesitaremos indicar al método route los parámetros que necesitará insertar:
Es posible comprobar las todas las rutas y sus nombres mediante el comande Artisan php artisan
route:list.
A continuación describiremos los pasos a seguir para incluir Bootstrap mediante la última opción
descrita.
1 npm install
En ocasiones puede haber problemas si la máquina virtual se ejecuta en un host con Windows 10,
por lo que en ese caso lanzar:
1 <html>
2 <head>
3 <meta charset="utf-8">
4 <title>Mi aplicación</title>
5 <link href="{{ asset('css/app.css') }}" rel="stylesheet" type="text/css" />
6 </head>
7 <body>
8 <h1>Bienvenido a mi app</h1>
9 <div class="content">
10 @yield('content')
11 </div>
12 <script src="{{ asset('js/app.js') }}" type="text/js"></script>
13 </body>
14 </html>
El método asset() generará una URL a nuestros recursos en la carpeta public/. Si cambiamos la
ubicación de nuestros recursos lo tendremos que especificar en la variable ASSET_URL del fichero
.env.
Level up: Laravel nivel intermedio 29
Relaciones One-to-Many
Las relaciones en Eloquent ORM se definen como métodos. Supongamos que tenemos dos entidades,
User y Articulo. Podríamos decir que un User tiene (‘has’) varios Articulo o que un Articulo
pertenece a (‘belongs to’) un User. Por lo tanto, podemos definir la relación en cualquiera de los dos
modelos, incluso en los dos.
Por defecto, si no indicamos lo contrario, Eloquent utilizará como foreign key el nombre del modelo
que contiene la colección añadiendo el sufijo '_id'. Es decir, en el caso anterior la tabla de Articulo
deberá contener una columna llamada 'user_id'.
Laravel también permite la creación de las restricciones de claves foráneas a nivel de base de datos.
De esta forma podemos asegurarnos la integridad referencial en nuestra base de datos relacional. El
siguiente ejemplo muestra cómo hacerlo de forma sencilla:
Además, en función de la base de datos utilizada, también podemos especificar qué acciones llevar
a cabo cuando borremos un registro cuyo ID es utilizado como FK en otros registros. Siguiendo el
ejemplo anterior, cuando eliminemos un usuario, podremos especificar el comportamiento de la base
de datos:
• Indicando que también se eliminen automáticamente todos sus artículos (conocido como
‘borrado en cascada’).
• Impidiendo que se realice el borrado del usuario si tiene artículos asociados (evitando así una
inconsistencia referencial).
• Actualizar el valor user_id a NULL en los artículos que tengan como FK el usuario que será
eliminado.
1 $table->foreign('user_id')
2 ->references('id')->on('users')
3 ->onDelete('cascade');
4
5 // O por ejemplo:
6 $table->foreign('user_id')
7 ->references('id')->on('users')
8 ->onDelete('set null');
• Estamos desarrollando una nueva aplicación y no nos importa borrar los datos existentes.
• Tenemos una aplicación en uso y queremos añadir columnas sin perder ningún registro.
Este comando eliminará todas las tablas de la base de datos y volverá a crearlas desde cero.
Para el segundo caso (modificar una tabla sin perder datos), lo recomendable es crear una nueva
migración y ejecutar el comando php artisan migrate para lanzar los cambios. Normalmente se
incluyen los cambios en el propio nombre de la migración, por ejemplo:
Level up: Laravel nivel intermedio 32
Una vez creado nuestro Seeder es probable que necesites regenerar el fichero autoload.php:
1 composer dump-autoload
Si lo que quieres es lanzar el proceso de creación de base de datos y el de seeding a la vez, puedes
utilizar el siguiente comando:
Es recomendable crear un seeder específico por cada entidad. Para ello, puedes utilizar el siguiente
comando:
php artisan make:seeder UsersTableSeeder
Por último, tendrás que modificar la clase DatabaseSeeder para que lance nuestros Seeders:
1 **
2 * Run the database seeds.
3 *
4 * @return void
5 */
6 public function run()
7 {
8 $this->call([
9 UsersTableSeeder::class,
10 PostsTableSeeder::class,
11 CommentsTableSeeder::class,
12 ]);
13 }
Level up: Laravel nivel intermedio 34
Práctica 6
La vista de detalle de artículo mostrará los comentarios del artículo e incluirá la posibilidad de añadir
nuevos comentarios.
Práctica 7
Asigna nombres a las rutas y utilízalos desde los controladores y vistas de la aplicación.
Práctica 8
Añade estilo a la aplicación mediante Bootstrap 4.
Autenticación
La autenticación es una funcionalidad presente en la gran mayoría de aplicaciones. Básicamente se
trata de asegurar que un usuario es quién dice ser mediante un control de acceso a la aplicación.
Laravel 6 nos trae de serie los elementos necesarios para implementar la autenticación en nuestras
aplicaciones y no tener que preocuparnos de hacer todas las tareas por nosotros mismos (login,
registro, recuperación de contraseña, validación de usuario, etc.).
En concreto necesitaremos lo siguiente:
• Generar las vistas (login, registro, etc.), rutas y sus respectivas implementaciones.
• Especificar las partes de nuestra web (rutas) que queramos proteger.
Este paquete nos permitirá generar de forma automática todo lo relacionado con la interfaz de
usuario: vistas, rutas y un nuevo controlador llamado HomeController. Para ello utilizaremos el
siguiente comando:
Puesto que las vistas autogeneradas utilizan bootstrap, debemos o bien añadir manualmente
bootstrap al layout generado app.blade.php:
Level up: Laravel nivel intermedio 35
1 Auth::routes();
2
3 Route::get('/home', 'HomeController@index')->name('home');
La primera genera de forma automática las rutas necesarias para el proceso de autenticación (prueba
a acceder a /login o /register para comprobarlo). Las vistas que se cargan son las autogeneradas
en resources/views/auth (también se ha creado un layout).
La segunda es simplemente un nuevo controlador autogenerado como ejemplo. Si intentas acceder
a la ruta creada /home verás como la aplicación nos lleva a la página de login. Esto es porque
el controlador HomeController está definido como ‘seguro’ y solo usuarios autenticados podrán
acceder.
¡Felicidades! Ya tienes la estructura básica de la aplicación creada. Puedes probar a registrar nuevos
usuarios y realizar las acciones de login o logout con ellos.
Una de las cosas que tendrás que configurar es la ruta a la que se envía al usuario tras autenticarse.
Esto puede especificarse mediante la variable HOME del archivo RouteServiceProvider:
Laravel utiliza por defecto el campo email para identificar a los usuarios. Puedes cambiar esto
creando un método username() en el controlador LoginController.
Level up: Laravel nivel intermedio 36
Otro aspecto que podremos configurar es la ruta a la que enviaremos al usuario cuando intente acce-
der a una ruta protegida sin autenticarse. Por defecto Laravel le enviará a /login, pero podemos cam-
biar esto modificando el método redirectTo() del archivo app/Http/Middleware/Authenticate.php:
Indicaremos las rutas que queramos proteger directamente en nuestro ruter web.php:
1 Route::get('profile', function () {
2 // Solo podrán acceder usuarios autenticados.
3 })->middleware('auth');
Existen distintas formas de acceder al objeto del usuario autenticado. Desde cualquier punto de la
aplicación podremos acceder utilizado la facade Auth:
Level up: Laravel nivel intermedio 37
1 use Illuminate\Support\Facades\Auth;
2
3 // Conseguir el usuario autenticado:
4 $user = Auth::user();
5
6 // Conseguir el ID del usuario autenticado:
7 $id = Auth::id();
1 use Illuminate\Support\Facades\Auth;
2
3 if (Auth::check()) {
4 // El usuario está autenticado.
5 }
Práctica 9
• Añade las funciones de login, registro y logout a la aplicación.
• Protege la ruta empleada para escribir un nuevo artículo (solo usuarios autenticados podrán
acceder).
• La opción de borrar un artículo únicamente estará visible para usuarios autenticados.
• Muestra los comentarios de los artículos únicamente a usuarios autenticados. A los usuarios
no identificados muéstrales un mensaje con un enlace a la página de login.
Manejo de sesiones
HTTP es un protocolo sin estado (stateless), es decir, no guarda ninguna información sobre
conexiones anteriores. Esto quiere decir que nuestra aplicación no tiene “memoria”, y cada petición
realizada por un usuario es nueva para la aplicación. Las sesiones permiten afrontar este problema,
ya que son un mecanismo para almacenar información entre las peticiones que realiza un usuario al
navegar por nuestra aplicación. Laravel implementa las sesiones de forma que su uso es muy sencillo
para los desarrolladores.
Level up: Laravel nivel intermedio 38
Configuración
Laravel soporta el manejo de sesiones con distintos backends (bases de datos, ficheros, etc.). Esta
configuración se indica en el fichero config/session.php, en le que podemos indicar el driver a
utilizar (“file”, “cookie”, “database”, “apc”, “memcached”, “redis”, “dynamodb” o “array”). La opción
utilizada por defecto es “cookie”, la cual es suficiente para la mayoría de aplicaciones.
Más información sobre la configuración en la documentación oficial¹⁵.
Práctica 10
Añade las siguientes funcionalidades a la aplicación:
¹⁵https://laravel.com/docs/6.x/session
Level up: Laravel nivel intermedio 39
• Guardar en sesión los artículos leídos: cuando un usuario entre a ver un artículo, se almacenará
en sesión que ya lo ha leído.
• Guardar en sesión los artículos favoritos de un usuario: el usuario podrá hacer click en un
enlace/botón que guarde en sesión ese artículo como favorito.
Los artículos marcados como favoritos se podrán distinguir visualmente (mediante un icono, texto
en negrita o similar). Igualmente, los artículos leídos se mostrarán también de forma especial.
Próximos pasos
Si has llegado a este punto, te doy mi más sincera enhorabuena. Ya eres capaz de crear aplicaciones
web profesionales con uno de los frameworks más potentes de la actualidad como Laravel. Si algo
puedo asegurarte, es que el desarrollo de aplicaciones web es un bonito camino en el que nunca
dejarás de aprender y siempre tendrás nuevas cosas por explorar. En el punto en el que te encuentras
ahora mismo, son muchas las opciones por las que puedes decantarte y que dependerán únicamente
de lo que te motive aprender. Algunas ideas son:
• Aprender JavaScript para dar potenciar en tus aplicaciones las interacciones con el usuario. Si
ya conoces este lenguaje, quizá sea una buena oportunidad para aprender potentes frameworks
como Vue.js¹⁶, React¹⁷ o Angular¹⁸.
• Explorar nuevas bases de datos, como por ejemplo las no relacionales. Algunas por las que
puedes empezar son MongoDB¹⁹, Redis²⁰ o Cassandra²¹.
• Adentrarte en el ecosistema Laravel aprendiendo Vapor²², Envoyer²³ o Forge²⁴.
• Explorar nuevas formas de autenticación con Passport²⁵ o Socialite²⁶.
• Ampliar tu conocimiento de otros lenguajes de programación como Python mediante el libro
gratuito Aprende Python: desde cero a experto²⁷.
Recuerda, lo único que necesitas saber es que tú puedes aprender cualquier cosa.
¹⁶https://vuejs.org/
¹⁷https://es.reactjs.org/
¹⁸https://angular.io/
¹⁹https://www.mongodb.com/es
²⁰https://redis.io/
²¹http://cassandra.apache.org/
²²https://vapor.laravel.com/
²³https://envoyer.io/
²⁴https://forge.laravel.com/
²⁵https://laravel.com/docs/6.x/passport
²⁶https://laravel.com/docs/6.x/socialite
²⁷https://leanpub.com/aprende-python/