Facades in Laravel. Why and How?

If you have worked with laravel, then you might be aware that there are some classes or helper function which we just call in our controller or anywhere for that matter in our application, without even importing the class.

For example, you might have used view() function in laravel. It can be called in two ways:

1. view('home'); , this is the helper function in laravel, and
2. View::make('home'); , this is the direct class reference that we can use, still without importing it.

So, What is happening here?

There is a little magic behind the scene which is the laravel service container(IoC). It loads all the classes before loading the application, so at run time, they are available for us to use. You can assume how many classes you have to import if you were using core PHP to run something like Laravel. There has to be a way around this.

So, Facades are at rescue.

What are Facades?

Facades are a way to register your class and its functions with the Laravel Container, so they are available everywhere after getting resolved by Reflection.

The official documentation says:

Laravel facades serve as “static proxies” to underlying classes in the service container, providing the benefit of a terse, expressive syntax while maintaining more testability and flexibility than traditional static methods.

Why to use Facades?

Facades have many benefits like you don’t have to remember long class names, which needs to be imported or injected before using them.

Another advantage is, it gives more testability to the application, as you don’t have to inject them everywhere while creating test cases.

How To Make Use of Facades or probably create your own?

First we need a class with some function, create MyFacade.php class, in app folder.

<?php
namespace App;
class MyFacade
{
    public function getName()
    {
        return 'Facades are awesome';
    }
}

Now we will make a route to call this function (routes/web.php):

use App\MyFacade;
Route::get('/', function () {
    $facade = new MyFacade();
    return $facade->getName();
});

This is how you can call it normally, first by using the class and making an object of it and then calling the function with that object.

Now, we have to bind the class MyFacade with the service container.

<?php
namespace App\Facades;
use \Illuminate\Support\Facades\Facade;
class MyFacade extends Facade
{
    public static function getFacadeAccessor()
    {
        return 'myfacade';
    }
}

Every Facade in Laravel has to extend base Facade class: Illuminate\Support\Facades\Facade . In this class we are overriding the base function getFacadeAccessor. The purpose of this function is when accessing this Facade, get the responsible object from this name in the container and pass the data to this object.

In one of our Provider classes that ships with laravel, we can bind this name with our service container. Personally, I prefer to use different Provider class for this, but it is easy this way for the demonstration.

You can edit AppServiceProvider class in app/providers in your laravel installation. In the register method of this class,

/**
 * Register any application services.
 *
 * @return void
 */
public function register()
{
    app()->bind('myfacade', function() {
        return new \App\MyFacade;
    });
}

Now, you can use the facade you just made. So recalling what we did in routes/web.php, we can rewrite that as,

//use App\MyFacade; Do not need to import the class
Route::get('/', function () {
    //$facade = new MyFacade(); Do not need to make object
    return MyFacade::getName(); //See the magic, in your browser.
});

Isn’t it fantastic, how things work sometimes. It’s so simple.

Don’t forget to tell me how you wrote your first Facade in your application.