Detailed explanation of the responsive interface provided in Laravel 5.5 for responding to requests

This article mainly introduces you to the relevant information about the responsive interface provided in Laravel 5.5 for responding to requests. The article introduces it in great detail through sample code. It has certain reference learning value for everyone's study or work. It needs Friends, please follow the editor to learn together.

Preface

Laravel 5.5 will also be the next LTS (long-term support) version. That means it has two years of fixes and three years of security updates. The same goes for Laravel 5.1, although its two years of bug-fix support will end this year.

Laravel 5.5 adds a new return type to routing: Responsable interface. This interface allows objects to be automatically converted into a standard HTTP response interface when returned from a controller or closure route. Any object that implements the Responsable interface must implement a method named toResponse(), which converts the object into an HTTP response object.

Look at the example:

use Illuminate\Contracts\Support\Responsable;

class ExampleObject implements Responsable
{
 public function __construct($name = null)
 {
  $this->name = $name ?? 'Teapot'; 
 }

 public function status()
 {
  switch(strtolower($this->name)) {
   case 'teapot':
    return 418;
   default:
    return 200;
  }
 }

 public function toResponse()
 {
  return response(
   "Hello {$this->name}",
   $this->status(),
   ['X-Person' => $this->name]
  );
 }
}

When using this ExampleObject in routing, you can do this:

Route::get('/hello', function() {
 return new ExampleObject(request('name'));
});

In the Laravel framework, the Route class can now check for this type (that implements the Responsable interface) when preparing the response content:

if ($response instanceof Responsable) {
 $response = $response->toResponse();
}

If you use multiple response types to organize your response content under the App\Http\Responses namespace, you can refer to the following example. This example demonstrates how to support Posts (a Collection of multiple instances):

posts = $posts;
 }

 public function toResponse()
 {
  return response()->json($this->transformPosts());
 }

 protected function transformPosts()
 {
  return $this->posts->map(function ($post) {
   return [
    'title' => $post->title,
    'description' => $post->description,
    'body' => $post->body,
    'published_date' => $post->published_at->toIso8601String(),
    'created' => $post->created_at->toIso8601String(),
   ];
  });
 }
}

The above is just a basic example to simulate a simple application scenario: return a JSON response , but you hope that the response layer will not simply use the built-in implementation to JSONize the object, but do some content processing. The above examples also assume that the App\Http\Responses\Response class can provide some basic functions. Of course, the response layer can also contain some conversion code (similar to Fractal) instead of doing such conversion directly in the controller.

The controller code that cooperates with the PostIndexResponse class in the above example is similar to the following:

If you want to know more details about this interface, you can view the commit of the relevant code in the project.

Summary

Articles you may be interested in:

php operation zip in Explanation on displaying the pictures in the compressed package without decompressing the package

Detailed explanation of the example analysis of the method of php implementing the sign-in function

Detailed explanation of solving the problem of memory exhaustion caused by too many php-fpm processes under Linux

The above is the detailed content of Detailed explanation of the responsive interface provided in Laravel 5.5 for responding to requests. For more information, please follow other related articles on the PHP Chinese website!