Service providers

Cleaner code through facades and the container

• The container is an awesome tool that powers most of the helpers of the framework:
  • Constructor injection
  • Method injection
  • Facades
  • and much more...

The container

What is a dependency inversion container?

• Registry of classes, interfaces and simple names bound to other classes or instances

What you might have done

public function myMethod() {

    Mail::send('template', function(MailMessage $message) {

        $message->setSubject(Request::get('subject');

        $message->to(Request::get('to'));

    });

}

Facade usage

Using the container

Constructor injection

public function __construct(Mail $mail) {

    $this->mail = $mail;

}

Using the container

public function myMethod(Request $request) {

    $this->mail->send('template', function() use ($request) {

        $this->setSubject($request->get('subject');

        $this->to($request->get('to'));

    });

}

Method injection

• Less static binding to a specific class name / alias
• Know exactly where each dependency you use comes from
• Easier for code insight, relies less on magic and alias scanning
• Easier versionning of classes through the container's "when, on, give" methods

Why is it better?

app::when(Controller::Class)
    ->needs('SomeName')
    ->give(SomeClassV2::class);

app::when(AnOldController::Class)
    ->needs('SomeName')
    ->give(SomeClassV1::class);

Not at all, just less direct.

So facades are bad?

Why use them then?

They are a simpler and cleaner approach to accessing globally available libraries.

They are much better than singletons

or static bindings!

Facade vs singleton

class MySingleton {
    
    public static function myAwesomeStaticFunction() { ... }

}

MySingleton::myAwesomeStaticFunction();

• Stuck to using your class name
• Induces static context
• Induces static binding resolution in your code

Facade vs singleton

• Uses aliases (Core concept of facades) which diminishes static binding resolution in your code
• Calls are non static and are made against an instance of your class. (Good for testing)

• It's just a module of code that:
  • binds classes in the container
  • offers configuration support
  • usually provides a facade to make quick and easy access in your code

So what is a service provider?

Example

'aliases' => [

        'Riddles' => App\ServicesProviders\RiddlesServiceProvider
                        \Facades\Riddles::class,

]

class Riddles extends Facade
{
    /**
     * Get the registered name of the component.
     *
     * @return string
     */
    protected static function getFacadeAccessor()
    {
        return 'Riddles';
    }
}

Example

class RiddlesServiceProvider extends ServiceProvider
{

    /**
     * Register bindings in the container.
     *
     * @return void
     */
    public function register()
    {
        $this->app->bind('Riddles', function ($app) {
            return new RiddleRepository();
        });
    }

}

Example

class RiddleRepository {
    
    public function getARiddle() : Riddle { ... }

}

$riddle = Riddle::getARiddle();

• Decouples modules in your code
• Allows cleaner access to resources in your code through dependency inversion and facades
• Less static context compared to singletons
• Better testability

Advantages

• Do manual bindings to override usage of a class

Other uses for the container

$this->app->bind(
    EmailAggregatorInterface::class, ReviewerIDBasedEmailAggregator::class
);

$this->app->bind(
    EmailTargetInterface::class, LessonReviewCreatorEmailTarget::class
);

$this->app->bind(
    EmailDeciderInterface::class, ImmediatelySentEmailDecider::class
);

• Use tagging to index important classes together

Other uses for the container

$this->app->tag(
    JiraSummaryConsoleCommand::class, ['ConsoleCommand']
);

$this->app->tag(
    JiraSprintsConsoleCommand::class, ['ConsoleCommand']
);

$this->app->tag(
    JiraBugsConsoleCommand::class, ['ConsoleCommand']
);

You can use the container outside of laravel

Hint !!!

composer require illuminate/container

$ioc = new Illuminate\Container\Container();

The queues

Or distributing workload

What is the problem here?

// Send an email for each user that asked for news

foreach($users as $user) {

    Mail::send('template', function() use ($user) {

        $this->setTo($user->email);

        $this->setSubject(Request::get('subject');

    });

}

• Instead, you should leverage queuing capabilities :
  • Easy with Laravel's queue api
  • Makes your app more responsive
  • Allows you to distribute workload to different servers
  • Adds value to your app (delay, job isolation, priority)

Why use queues?

How do i use it?

Mail::queue('template', function(MailMessage $message){

    $message->to('someone@else.com');

});

dispatch(new UploadProcessingJob(
    $fileToProcess,
    $uploadingUser
));

Service container can define jobs and can even queue their own jobs...

What does a job look like?

class SendReminderEmail extends Job implements ShouldQueue
{
    use InteractsWithQueue, SerializesModels;

    protected $user;

    public function __construct(User $user)
    {
        $this->user = $user;
    }

    public function handle(Mailer $mailer)
    {
        $mailer->send(/* ... */);

        $this->user->reminders()->create(...);
    }

}

Distribute to many servers

php artisan queue:work --queue=emails
php artisan queue:work redis --queue=jobs
php artisan queue:work sqs --queue=emails
php artisan queue:work --sleep 3

Server 1

Server 2

Server 3

Runs web requests

Runs the email queue

Runs the upload processing job queue

Priorizing/classifying jobs

$job->onQueue('low');

$job->onConnection('slow-queues');

• Prioritize your jobs by running multiple daemons
• Run more daemons on one queue to make it more responsive
• Queue slow jobs or customers with free accounts on one connection and the paying customers on another

Delaying jobs

$checkTranscodingJobIsDone->delay(Carbon::now()->addMinutes(10));

$sendAppreciationEmail->delay(Carbon::now()->addDays(5));

• Delays are useful to queue stuff to happen in the future or to prevent overload on a queue
• AWS SQS doesn't support more than 15m delays, you have to use a different service if you want to queue emails on a daily basis

• Media transcoding job
• Caching system update jobs
• Heavy calculation or processing job
• Web scanner that crawls a site
• etc

Types of jobs you could use

You can use the queue outside of laravel

Hint !!!

composer require illuminate/queue

Note: Not an easy thing to do though!

Event dispatching

Programming reactively instead of sequentialy

• Events are small code pieces describing something happening in your application
• Dispatching an event triggers listeners which execute more code related to that event
• Listeners don't run sequentialy nor run immediately

What is an event

• Creates smaller units of code
• Disconnects different parts of your app
• Makes testing easier as everything is a small unit
• Create magical effects
• Can lead to many different classes

Good and Bad

First you need to create event objects

How to use them

<?php
namespace App\Events;

class AnswerCreatedEvent extends Event
{

    use Illuminate\Queue\SerializesModels;

    public $answer;

    public function __construct(App\Answer $answer)
    {

        $this->answer = $answer;
    }

}

Then you need to create event listeners

How to use them

<?php
namespace App\Listeners;

class NotifyClubOwnerOnAnswerCreatedListener {}

class NotifyRiddleOwnerOnAnswerCreatedListener {}

class AwardEarlyBirdBadgeOnEarlyAnswersListener {}

class AwardProcrastinatorBadgeOnLateAnswersListener {}

/**
 * Each class implements
 */
public function handle(App/Events/AnswerCreatedEvent $event) {
    
    // Do something

}

Finaly, you need to bind events and listeners

How to use them

class EventServiceProvider extends ServiceProvider
{
    
    protected $listen = [
        AnswerCreatedEvent::class => [
            NotifyClubOwnerOnAnswerCreatedListener::class,
            NotifyRiddleOwnerOnAnswerCreatedListener::class,
            AwardEarlyBirdBadgeOnEarlyAnswersListener::class,
            AwardProcrastinatorBadgeOnLateAnswersListener::class,
        ],
    ];

}

Once all is bounded, you can fire events away!

Triggering events

<?php

$answer = Answer::create([
    'answer'         => $answer,
    'club_riddle_id' => $clubRiddle->id,
    'user_id'        => $user->id,
]);

Event::fire(new AnswerCreatedEvent($answer));

This will fire the handle method of all 4 listeners in no specific order and not necessarily now...

Listeners can be queued

• In a production environment, listeners are queued if they implement ShouldQueue

class NotifyOwnerThatAnswerWasPosted implements ShouldQueue {}

• If a listeners is queued, it means it could get delayed

Do not assume that a listener has run at any moment unless you have data backing this decision.

You can use the events outside of laravel

Hint !!!

composer require illuminate/events

Note: Not an easy thing to do though!

Eloquent

Deeper down the
rabbit hole

Supercharging a scope

public function scopeWithoutActiveRiddleFor($query, Carbon $date)
{
    
    $query
        ->select('clubs')
        ->leftJoin('clubs_riddles', function (JoinClause $on) use ($date) {
            
            $on->on('clubs_riddles.club_id', '=', 'clubs.id');
            $on->where('clubs_riddles.opens_at', '>=', $date->copy()->startOfDay()->tz('UTC'));
            $on->where('clubs_riddles.opens_at', '<=', $date->copy()->endOfDay()->tz('UTC'));
        })
        ->whereNull('clubs_riddles.riddle_id');
}

• You can use complex query elements in scopes
• Remember to ::select if you add tables which create duplicate fields

M:M Pivots

public function achievements()
{
    return $this->belongsToMany(Achievement::class)->withPivot(['current']);
}

public function badges()
{
    return $this->belongsToMany(Badge::class)->withPivot('amount');
}

• When using a M:M relationship, you can use "withPivot" to get information from the M:M table

M:M Pivots

$value = $record->pivot->column;

• Extract pivot values

$riddle->creator->badges()->updateExistingPivot(
    $badge->id,
    ['amount' => $record->pivot->amount + 1]
);

• Update/Create a pivot

$riddle->creator->badges()->attach(
    $badge,
    ['amount' => 1]
);

Supercharging a relation

public function currentAchievement()
{
    return $this->belongsToMany(Achievement::class)
                ->where('current', 1);
}

• All relationship methods actually return a query, thus you can add as many things as you want in there such as joins, wheres, etc

Model events

class Answer
{
    use Notifiable;

    protected $events = [
        'created' => AnswerCreatedEvent::class,
    ];
}

$answer = Answer::create([
    'answer'         => $answer,
    'club_riddle_id' => $clubRiddle->id,
    'user_id'        => $user->id,
]);

Event::fire(new AnswerCreatedEvent($answer));

Accessors

public function getScoreAttribute($score)
{
    return $score * 100
}

public function getFirstNameAttribute($value)
{
    return ucfirst($value);
}

• Accessors transform existing values on get
• You can call the accesor using the original name of the property without changing a thing

Mutators

public function setFirstNameAttribute($value)
{
    $this->attributes['first_name'] = strtolower($value);
}

• Modifies the value being set into the attribute
• You can also modify more than one value with this

Virtual properties

protected $appends = array('availability');

public function getAvailabilityAttribute()
{
    return $this->calculateAvailability();  
}

public function setAvailabilityAttribute($value)
{
    $this->attributes['availability'] = $value;  
}

• Not a real property but you can now use it with
  $obj->availability
• $appends is used to provide more data when serializing, if you don't, the value is lost and never serialized.

• Returning an object instead of a response will JSON serialize that object.

Serialization

protected $appends = ['someVirtualProperty'];
protected $hidden = ['password'];

• This will prevent returning the hashed password
• This will return the virtual property