Skip to content

Instantly share code, notes, and snippets.

@satoblacksato

satoblacksato/LARAVEL_lumen.md

Forked from juanlopezdev/LARAVEL_lumen.md
Created April 15, 2021 18:25
Show Gist options
  • Star 1 You must be signed in to star a gist
  • Fork 1 You must be signed in to fork a gist
  • Save satoblacksato/a193ae9ec7c041b2139da403689f1352 to your computer and use it in GitHub Desktop.
Save satoblacksato/a193ae9ec7c041b2139da403689f1352 to your computer and use it in GitHub Desktop.
Download ZIP
Apuntes y primeros pasos con LUMEN (Microframework de Laravel)
Raw
LARAVEL_lumen.md

Lumen

Lumen es un micro-framework para PHP.

Lumen es una versión más liviana de Laravel y orientado más a la creación de APIs y microservicios, aunque también puedes usarlo para crear sitios web o lo que quieras.

Si es posible migrar de Lumen a Laravel

Microservicios:

Son procesos independientes que generalmente se encargan de una sola tarea (por ejemplo un cron-job para hacer un respaldo de la base de datos) y están por lo general desacoplados del resto de la aplicación.

Instalación

Crear un proyecto Lumen via composer

composer create-project laravel/lumen NOMBRE_DE_TU_PROYECTO --prefer-dist

Levantar proyecto lumen

php -S localhost:8000 -t public

Lo Básico

Enrutamiento Básico

Ruta del archivo app/Http/routes.php

$app->get('foo', function () {
    return 'Hola mundo';
});

$app->post('foo', function () {
    return 'Hola mundo POST'
});

Parámetros de ruta

// Un solo parámetro
$app->get('user/{id}', function ($id) {
    return 'User '.$id;
});

// Varios parámetros
$app->get('posts/{post}/comments/{comment}', function ($postId, $commentId) {
    //
});

// Expresiones regulares
$app->get('user/{name:[A-Za-z]+}', function ($name) {
    //
});

Nota: Los parametros de la ruta {post} no pueden contener "-", utilizar "_"

Grupos de ruta

Permite compartir atributos de ruta como "middleware" o "namespaces"

// Middleware
$app->group(['middleware' => 'auth'], function () use ($app) {
    $app->get('/', function ()    {
        // Uses Auth Middleware
    });

    $app->get('user/profile', function () {
        // Uses Auth Middleware
    });
});

// Namespaces
$app->group(['namespace' => 'Admin'], function() use ($app) {
    // Using The "App\Http\Controllers\Admin" Namespace...

    $app->group(['namespace' => 'User'], function() use ($app) {
        // Using The "App\Http\Controllers\Admin\User" Namespace...
    });
});

Prefijos de ruta:

// Prefijo
$app->group(['prefix' => 'admin'], function () use ($app) {
    $app->get('users', function ()    {
        // Matches The "/admin/users" URL
    });
});

// Prefijo con parametros
$app->group(['prefix' => 'accounts/{account_id}'], function () use ($app) {
    $app->get('detail', function ($accountId)    {
        // Matches The "/accounts/{account_id}/detail" URL
    });
});

Middleware

Los middleware HTTP proporcionan un mecanismo para filtrar peticiones HTTP que ingresan a su aplicación.

Por ejemplo, Lumen incluye un middleware que verifica que el usuario de su aplicación está autenticado. Si el usuario no está autenticado, el middleware redirigirá al usuario a la pantalla de inicio de sesión. Sin embargo, si el usuario es autenticado, el middleware permitirá que la solicitud continúe en la aplicación.

// Middleware que permite el acceso a la ruta si la edad suministrada es superior a 200. 
// De lo contrario, redirigiremos a los usuarios de nuevo al URI de "inicio".

namespace App\Http\Middleware;

use Closure;

class OldMiddleware {

    /**
     * Run the request filter.
     *
     * @param  \Illuminate\Http\Request  $request
     * @param  \Closure  $next
     * @return mixed
     */
    public function handle($request, Closure $next) {
        if ($request->input('age') <= 200) {
            return redirect('home');
        }

        return $next($request);
    }

}

Registro de middleware

Global: Si desea que un middleware se ejecute durante cada solicitud HTTP a su aplicación, simplemente liste la clase middleware en la llamada al método $app->middleware() en su archivo bootstrap/app.php

$app->middleware([
   App\Http\Middleware\OldMiddleware::class
]);

Asignación de Middleware a las rutas: Si desea asignar middleware a rutas específicas, primero debe asignar al middleware una clave corta en la llamada del archivo bootstrap/app.php al método $app->routeMiddleware()

$app->routeMiddleware([
    'auth' => App\Http\Middleware\Authenticate::class,
]);

Usar en la ruta

// Uso normal
$app->get('admin/profile', ['middleware' => 'auth', function () {
    //
}]);

// Utilice una matriz para asignar varios middleware a la ruta:
$app->get('/', ['middleware' => ['first', 'second'], function () {
    //
}]);

Parámetros de Middleware

Un Middleware también puede recibir parámetros personalizados adicionales.

Por ejemplo, si su aplicación necesita verificar que el usuario autenticado tiene un "rol" determinado antes de realizar una acción determinada, puede crear un RoleMiddleware que reciba un nombre de rol como argumento adicional.

namespace App\Http\Middleware;

use Closure;

class RoleMiddleware {

    /**
     * Run the request filter.
     *
     * @param  \Illuminate\Http\Request  $request
     * @param  \Closure  $next
     * @param  string  $role
     * @return mixed
     */
    public function handle($request, Closure $next, $role) {
        if (! $request->user()->hasRole($role)) {
            // Redirect...
        }

        return $next($request);
    }

}

Los parámetros de Middleware se pueden especificar al definir la ruta separando el nombre del middleware y los parámetros con a :. Los parámetros múltiples se deben delimitar por comas:

$app->put('post/{id}', ['middleware' => 'role:editor', function ($id) {
    //
}]);

Controladores

Los controladores pueden agrupar la lógica de manejo de solicitud HTTP relacionada en una clase. Los controladores se almacenan en el directorio app/Http/Controllers.

namespace App\Http\Controllers;

use App\User;

class UserController extends Controller {

    /**
     * Retrieve the user for the given ID.
     *
     * @param  int  $id
     * @return Response
     */
    public function show($id) {
        return User::findOrFail($id);
    }
}

Podemos encaminar a la acción del controlador así:

$app->get('user/{id}', 'UserController@show');

Request

Para obtener una instancia de la solicitud HTTP actual a través de la inyección de dependencia, debe escribir la sugerencia de la clase Illuminate\Http\Request en el constructor o método del controlador. La instancia de solicitud actual será inyectada automáticamente por el contenedor de servicio:

namespace App\Http\Controllers;

use Illuminate\Http\Request;

class UserController extends Controller {

    /**
     * Store a new user.
     *
     * @param  Request  $request
     * @return Response
     */
    public function store(Request $request) {
        $name = $request->input('name');
        //
    }
}

Response

Lumen proporciona varias formas diferentes de devolver las respuestas. La respuesta más básica es simplemente devolver una cadena de una ruta o controlador:

$app->get('/', function () {
    return 'Hello World';
});

Response Objects

$app->get('home', function () {
    return response($content, $status)
                  ->header('Content-Type', $value);
});

JSON Responses

El método json establecerá automáticamente el encabezado Content-Type en application / json, así como convertirá la matriz dada en JSON usando la función json_encode PHP:

return response()->json(['name' => 'Abigail', 'state' => 'CA']);

// Opcionalmente, puede proporcionar un código de estado y una matriz de encabezados adicionales:
return response()->json(['error' => 'Unauthorized'], 401, ['X-Header-One' => 'Header Value']);

Autenticación

Las solicitudes entrantes que desea autenticar deben estar autenticadas a través de un mecanismo sin estado, como los tokens API.

Nota: Antes de utilizar las funciones de autenticación de Lumen, se debe descomentar AuthServiceProvider en su archivo bootstrap/app.php.

Nota: Si desea usar Auth::user() para acceder al usuario actualmente autenticado, debe descomentar el método $app->withFacades() en su archivo bootstrap/app.php.

Creamos un campo mas en nuestra tabla usuario, llamada "api_token" Asignamos un valor de 50 carácteres a cada usuario. Por ejemplo: E6dlOYFq9CmLOVoW28LSdaaL4hQWfjwks6v9q7CZNNKFGAjwZZ

Para probarlo usamos lo siguiente en nuestro archivo route.php

$app->group(['middleware' => 'auth'], function () use ($app) {
  $app->get('auth', 'App\Http\Controllers\UserController@auth');
});

UserController.php

/**
 * Demo autenticación token
 */
public function auth() {
  echo 'Autorizado';
}

Lo usamos mediante la siguiente URL: http://local.lab.lumen/auth?api_token=E6dlOYFq9CmLOVoW28LSdaaL4hQWfjwks6v9q7CZNNKFGAjwZZ

Apuntes y Curiosidades

Para trabajar con Eloquent debemos descomentar la siguiente linea que esta ubicada en bootstrap/app

$app->withEloquent();

Referencias

Tutoriales y Ejemplos

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment