Sesiones

Introducción

Desde que las aplicaciones bajo HTTP son aplicaciones sin estado, las sesiones proveen un modo de almacenar información acerca del usuario a través de las peticiones. Laravel viene con gran variedad de soluciones de sesión disponibles para su uso a través de una clara y unificada API. Soporta soluciones populares de fábrica tales como Memcached, Redis, y Bases de Datos que son incluidas de fábrica.

Configuración

The session configuration file is stored at config/session.php. Asegúrese de revisar las opciones bien documentadas que están disponibles en este archivo. By default, Laravel is configured to use the file session driver, which will work well for many applications. In production applications, you may consider using the memcached or redis drivers for even faster session performance.

The session driver defines where session data will be stored for each request. Laravel ships with several great drivers out of the box:

  • file - sessions are stored in storage/framework/sessions.
  • cookie - sessions are stored in secure, encrypted cookies.
  • database - sessions are stored in a database used by your application.
  • memcached / redis - sessions are stored in one of these fast, cached based stores.
  • array - sessions are stored in a simple PHP array and will not be persisted across requests.

Note: The array driver is typically used for running tests to prevent session data from persisting.

Driver Prerequisites

Base de datos

Cuando usa el gestor de sesión database, deberá configurar una tabla que contenga los elementos de sesión. A continuación tiene un ejemplo de declaración del Schema para la tabla:

Schema::create('sessions', function ($table) {
    $table->string('id')->unique();
    $table->text('payload');
    $table->integer('last_activity');
});

You may use the session:table Artisan command to generate this migration for you!

php artisan session:table

composer dump-autoload

php artisan migrate

Redis

Antes de usar un sesiones Redis con Laravel, necesitará instalar el paquete predis/predis (~ 1.0) a través de Composer.

Other Session Considerations

El framework Laravel usa la llave de sesión flash internamente, por tanto no debería agregar un elemento de sesión con ese nombre.

If you need all stored session data to be encrypted, set the encrypt configuration option to true.

Uso básico

Accessing The Session

First, let's access the session. We can access the session instance via the HTTP request, which can be type-hinted on a controller method. Remember, controller method dependencies are injected via the Laravel service container:

<?php

namespace App\Http\Controllers;

use Illuminate\Http\Request;
use App\Http\Controllers\Controller;

class UserController extends Controller
{
    /**
     * Show the profile for the given user.
     *
     * @param  Request  $request
     * @param  int  $id
     * @return Response
     */
    public function showProfile(Request $request, $id)
    {
        $value = $request->session()->get('key');

        //
    }
}

When you retrieve a value from the session, you may also pass a default value as the second argument to the get method. This default value will be returned if the specified key does not exist in the session. If you pass a Closure as the default value to the get method, the Closure will be executed and its result returned:

$value = $request->session()->get('key', 'default');

$value = $request->session()->get('key', function() {
    return 'default';
});

If you would like to retrieve all data from the session, you may use the all method:

$data = $request->session()->all();

You may also use the global session PHP function to retrieve and store data in the session:

Route::get('home', function () {
    // Retrieve a piece of data from the session...
    $value = session('key');

    // Store a piece of data in the session...
    session(['key' => 'value']);
});

Determinando si un elemento existe en la sesión

The has method may be used to check if an item exists in the session. This method will return true if the item exists:

if ($request->session()->has('users')) {
    //
}

Storing Data In The Session

Once you have access to the session instance, you may call a variety of functions to interact with the underlying data. For example, the put method stores a new piece of data in the session:

$request->session()->put('key', 'value');

Pushing To Array Session Values

The push method may be used to push a new value onto a session value that is an array. For example, if the user.teams key contains an array of team names, you may push a new value onto the array like so:

$request->session()->push('user.teams', 'developers');

Retrieving And Deleting An Item

The pull method will retrieve and delete an item from the session:

$value = $request->session()->pull('key', 'default');

Deleting Items From The Session

The forget method will remove a piece of data from the session. If you would like to remove all data from the session, you may use the flush method:

$request->session()->forget('key');

$request->session()->flush();

Regenerando la ID de sesión

If you need to regenerate the session ID, you may use the regenerate method:

$request->session()->regenerate();

Datos volátiles

Sometimes you may wish to store items in the session only for the next request. You may do so using the flash method. Method stored in the session using this method will only be available during the subsequent HTTP request, and then will be deleted. Flash data is primarily useful for short-lived status messages:

$request->session()->flash('status', 'Task was successful!');

If you need to keep your flash data around for even more requests, you may use the reflash method, which will keep all of the flash data around for an additional request. If you only need to keep specific flash data around, you may use the keep method:

$request->session()->reflash();

$request->session()->keep(['username', 'email']);

Adding Custom Session Drivers

To add additional drivers to Laravel's session back-end, you may use the extend method on the Session facade. You can call the extend method from the boot method of a service provider:

<?php

namespace App\Providers;

use Session;
use App\Extensions\MongoSessionStore;
use Illuminate\Support\ServiceProvider;

class SessionServiceProvider extends ServiceProvider
{
    /**
     * Perform post-registration booting of services.
     *
     * @return void
     */
    public function boot()
    {
        Session::extend('mongo', function($app) {
            // Return implementation of SessionHandlerInterface...
            return new MongoSessionStore;
        });
    }

    /**
     * Register bindings in the container.
     *
     * @return void
     */
    public function register()
    {
        //
    }
}

Note that your custom session driver should implement the SessionHandlerInterface. Esta interfaz contiene unos pocos métodos sencillos que necesitamos implementar. A stubbed MongoDB implementation looks something like this:

<?php

namespace App\Extensions;

class MongoHandler implements SessionHandlerInterface
{
    public function open($savePath, $sessionName) {}
    public function close() {}
    public function read($sessionId) {}
    public function write($sessionId, $data) {}
    public function destroy($sessionId) {}
    public function gc($lifetime) {}
}

Puesto que estos métodos no son tan fácilmente comprensibles como la StoreInterface de caché, vamos rápidamente a cubrir lo que hacen cada uno de los métodos:

  • Normalmente se utilizaría el método open en sistemas de sesión basados en archivos. Debido a que Laravel viene con un controlador de sesión en archivos llamado file, casi nunca necesitarás poner algo en este método. Puedes dejarla como un stub vacío. Es simplemente por motivos de un diseño de interfaz pobre (el cual discutiremos más tarde) que PHP requiere que implementemos este método.
  • El método de close, como el método open, pueden ser ignorados. Para la mayoría de los controladores, no es necesario.
  • El método read debería retornar el texto del dato asociado al $sessionId dado. No hay ninguna necesidad de hacer ninguna serialización u otra codificación al recuperar o almacenar datos de sesión en tu controlador, Laravel realizará la serialización por ti.
  • El método write debe escribir la cadena $data dada asociada con el $sessionId a algún sistema de almacenamiento persistente, como MongoDB, Dynamo, etc.
  • El método de destroy debe eliminar los datos asociados con el $sessionId desde el almacenamiento persistente.
  • El método gc debe destruir todos los datos de sesión que sean mayores que el $lifetime dado, el cual es una marca de tiempo UNIX. Para sistemas de auto-expiración como Memcached y Redis, este método debe dejarse vacío.

Once the session driver has been registered, you may use the mongo driver in your config/session.php configuration file.