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.
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
Ruta del archivo app/Http/routes.php
$app->get('foo', function () {
return 'Hola mundo';
});
$app->post('foo', function () {
return 'Hola mundo POST'
});
// 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 "_"
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
});
});
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);
}
}
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 () {
//
}]);
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) {
//
}]);
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');
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');
//
}
}
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';
});
$app->get('home', function () {
return response($content, $status)
->header('Content-Type', $value);
});
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']);
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 archivobootstrap/app.php
.
Nota: Si desea usar
Auth::user()
para acceder al usuario actualmente autenticado, debe descomentar el método$app->withFacades()
en su archivobootstrap/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
Para trabajar con Eloquent debemos descomentar la siguiente linea que esta ubicada en bootstrap/app
$app->withEloquent();
- https://styde.net/lumen-la-version-micro-framework-de-laravel-php/
- https://lumen.laravel.com/docs/5.4/installation
- https://lumen.laravel.com/docs/5.4/configuration
- https://lumen.laravel.com/docs/5.4/routing#basic-routing
- https://lumen.laravel.com/docs/5.4/routing#route-parameters
- https://lumen.laravel.com/docs/5.4/middleware
- https://lumen.laravel.com/docs/5.4/controllers
- https://lumen.laravel.com/docs/5.4/requests
- https://lumen.laravel.com/docs/5.4/authentication
- Mi Primera aplicación RESTful API en Lumen By juanlopezdev
- RESTful API en Lumen By Coderexample.com
- Autenticación por Token en Lumen By medium.com/@jpedraza
Gracias por la info. Muy interesante para comenzar.