What’s New in Laravel 5

The PHP community has recently been blessed with a new release of one of its most loved frameworks, Laravel. Version 5.0.1 is a major release, so not only are there some great new features available, but the architectural foundations of the framework have also been altered to some extent. So, without any further ado, I am going to dive right into the framework and show you all the good things the latest release has to offer.

1. Directory Structure

The folder structure of a Laravel project has gone through a major overhaul. Laravel 5 implements the PSR-4 autoloading standard, which means all your classes are completely namespaced. The default namespace for your web application is app, which you can change using the php artisan app:name <your-app-name> command.

Your models fall under the default app namespace and are inside the app folder. Your application's assets, views, and language files are in the resources folder. The vendor, public, and bootstrap directories retain their place as in the older versions of the framework, while the config, storage, database, and tests directories have been moved to the root of the project.

If you peek inside the app folder, you will notice a lot of classes, but don't worry about them for now—we are going to get into that during the course of this article.

Environment detection has been vastly improved. Instead of all the complex nested configuration directories, you have a .env file at the root of your project to take care of the application environment and all the environment variables. Also, the php artisan tinker command now utilizes the Psysh package instead of Boris.

2. Method Injection

Method injection has been greatly simplified. Until version 4.2, you had to request the Inversion of Control (IoC) container to provide a class instance or create it in your controller's constructor to make it accessible under the class scope. Now, you can declare the type hinted class instance in the controller method's signature and the IoC container will take care of it, even if there are multiple parameters in your controller function's signature.

<?php
// your class at "app/Classes/your_class.php"

namespace App\Classes

class YourClass
{
    // your class implementation
}

// somewhere in one of your controller actions
public function myAction(\App\Classes\YourClass $MyObject)
{
	// use $MyObject just like any other object
}
?>

3. Contracts

Contracts are actually interface classes in disguise. Interfaces are a tried and tested method for removing class dependency and developing loosely coupled software components. They generally help you follow the "depend on abstractions, not concretions" rule.

Laravel buys into the same philosophy. Most of the major core components make use of these contracts to keep the framework loosely coupled. You can also utilize them in your package development.

For example, if your package requires caching, then instead of using a concrete cache class, you can implement the Illuminate\Contracts\Cache interface and you will be free to plug the cache implementation in and out without changing much of your package code.

You might ask how Laravel goes about figuring out the implementation for a specific contract. All that magic happens inside the Illuminate\Foundation\Application.php file.

4. Route Caching

Artisan has a new route caching feature. Route caching tremendously speeds up your application's route registration, with clearly visible performance benefits. However, if your application deals in a small number of routes, you might not see the impact route caching is supposed to have, which means it is more suited to cases where your application has a large number of routes.

The commands php artisan route:cache and php artisan route:clear turn route caching on and off respectively. Once route caching is turned on, any modifications you make to the application routes will not take effect. Route caching would generally be implemented as part of your deployment process.

5. Route Middleware

Middleware can be used to add extra layers to your HTTP routes. If you want code to execute before every route or before specific routes in your application, then such a piece of code is a good fit for a middleware class.

For example, let's say you want to block out a certain range of IPs from your application to make your application unavailable in that region. In such a case, you will need to check the client IP before every request and allow/disallow them entry to your application. This will be a lot to do in your controller actions, so you will use middleware instead. Generate a middleware class at app/Http/Middleware/RegionMiddleware.php by using php artisan make:middleware "RegionMiddleware".

<?php 
namespace app\Http\Middleware;

use Closure;

class RegionMiddleware {

    /**
	 * Handle an incoming request.
	 *
	 * @param  \Illuminate\Http\Request  $request
	 * @param  \Closure  $next
	 * @return mixed
	 */
	public function handle($request, Closure $next)
	{
		// perform some IP logic on $request
		// and redirect to appropriate
		// page based on results

		// everything went well
		// this will resume normal flow
		return $next($request);
	}

}
?>

You can then register your middleware in the app/Http/Kernel.php file by appending it to the $middleware array. You can also attach middleware to specific routes by adding it to the $routeMiddleware array and then passing it in the route options.

6. Authentication

Authentication is part of almost all the web applications you develop, and a lot of time is spent writing the authentication boilerplate. This is not the case any more with Laravel 5. The database migrations, models, controllers, and views just need to be configured to make it all work. Laravel 5 has a Registrar service, which is a crucial part of this out of the box, ready to use authentication system.

7. Events

Gone are the old days when you used to declare your application events as strings, because the event object is now available. You can create event objects using php artisan make:event <event-name> and event handler objects using php artisan handler:event <handler-name>. All your event and handler classes go inside the app/Events and app/Handlers/Events folder respectively.

Once you have created your events, you can fire them by Event::fire(new Event(params)). To attach listeners to your events, you need to edit the $listen array in the app/Providers/EventServiceProvider.php file.

8. Commands

Laravel 5 allows you to encapsulate your complex business logic into simple command objects.

For example, let's say you have an online shop where users register and buy electronic items. The registration process may involve verifying the user's email address and credit card.

It might be tempting to dump all this code in a controller action, but it is not a good idea to have code that will work only under the HTTP request context, be hard to unit test because of HTTP requests, and bloat the controller actions.

Doing this using commands will give you several advantages. First, your self-contained code will be modular and a breeze to unit test. Second, since Laravel allows you to queue commands, your business logic can be run asynchronously in the background, which is impossible to do with controller actions.

9. Queue and Task Scheduling

A ready to use queue is provided by default with the framework, so you don't need to use any third party packages. All you need to do is configure the queue and you should be good to go. All your queueable jobs are kept in the app/Commands folder. Once you have created your queueable commands, you can simply push them to the queue using Queue::push(new Command($params)).

Task scheduling has also been improved a lot. Previously, you had to set up a cron for each console command, but not any more. You will only need a single cron entry and you can schedule your tasks within the application using a lot of syntax sugar.

10. Multiple File Systems

Laravel 5 has native support for multiple filesystems using the third party package Flysystem. Your application can use local or cloud storage by means of simple configuration. You will only need to work with the filesystem facade, and the underlying storage operations will be taken care of automatically. You can configure your storage options in the config/filesystems.php file. In case you need access to all the available storage options in your project, you can bypass the filesystem facade and work with the disk facade directly.

11. Request Object

The request object helps you inject authentication/authorization and data validation logic into your requests. Once you have implemented your business logic in the request object, you need to type hint it into a controller's action, just as in the case of method injection.

Let's decrypt this using a code example. Execute php artisan make:request TutsPlusRequest to generate a request class at app/Http/Requests/TutsPlusRequest.php. Looking into the contents of that file, you will notice that artisan has generated a rules method and an authorize method. You are going to add some validation rules in your rules method.

<?php
namespace App\Http\Requests;

use App\Http\Requests\Request;

class TutsPlusRequest extends Request {
    
    /**
	 * Determine if the user is authorized to make this request.
	 *
	 * @return bool
	 */
	public function authorize()
	{
		return true;
	}

	/**
	 * Get the validation rules that apply to the request.
	 *
	 * @return array
	 */
	public function rules()
	{
		return [
			'email' => 'required|email',
			'password' => 'required|min:8'
		];
	}

}

// in your controller action
public function postLogin(\App\Http\Requests\TutsPlusRequest $request)
{
	// code here will not fire
	// if the validation rules
	// in the request fail
}
?>

You want the email to be a valid email and the password to be at least eight characters. Both of the fields are required. If any of these validation rules fail, your controller action will not be executed and the user will be redirected to the form page.

12. Elixir

Elixir is a GulpJS API for Laravel that helps you define gulp tasks for your applications. Diving into GulpJS is beyond the scope of this article, but you can take a look at its official site and Elixir for more information.

A typical use case for GulpJS is to minify/concatenate your CSS/JS files. Your gulp packages reside in the package.json file at the root of your project, whereas the tasks that need to be run are specified in the gulpfile.js file. For those of you who are already familiar with the GulpJS workflow, this would make more sense, since Elixir only helps you integrate GulpJS into your Laravel apps.

13. Laravel Socialite

Socialite is a first party package that makes integration of third party authentication into your web applications a cinch. Since it is not included by default, you need to pull it in using composer. Once that's done, you need to configure the providers you wish to use in your application. Currently, Socialite supports Twitter, GitHub, Google, and Facebook.

Curtains!

I hope you enjoyed looking into the specifics of Laravel 5. From an architectural perspective, I think the framework has taken giant leaps forward, which will go a long way in keeping your web application code organized and freeing you from the nightmare that is maintenance.

If you want to find some useful Laravel plugins and scripts, check out the selection on Envato Market.

HIGHLIGHTS OF THE DAY