Nella lezione precedente abbiamo visto come PHP moderno abbia introdotto un sistema di tipizzazione molto più rigoroso e affidabile. In questa lezione faremo un passo ulteriore: capiremo quali sono le novità, tecniche ma anche concettuali, che possiamo utilizzare per costruire software robusto ed estendibile.
Dalle classi di servizio al dominio
Finora abbiamo visto con una certa frequenza classi come questa:
<?php
class CalciatoreManager
{
public function saveCalciatore() {}
public function deleteCalciatore() {}
public function getCalciatore() {}
}
<?php
class Calciatore
{
private string $email;
private bool $active;
public function activate(): void
{
$this->active = true;
}
public function changeEmail(string $email): void
{
$this->email = $email;
}
}
Possiamo dire addio a classi come questa
<?php
class UserManager
{
public function saveUser() {}
public function sendEmail() {}
public function generatePdf() {}
public function calculateDiscount() {}
}
- UserRepository
- MailService
- PdfGenerator
- DiscountCalculator
Meno ereditarietà, più composition
PHP, da sempre, non ha volutamente offerto la possibilità di utilizzare l’ereditarietà multipla, scelta applicata a suo tempo anche nel mondo Java ma non in C++.
L’ereditarietà multipla può portare diversi problemi. Ipotizziamo per un attimo che PHP la supporti:
<?php
class MailSender
{
public function sendMail() {}
}
class Logger
{
public function log() {}
}
class UserService extends MailSender, Logger
{
}
Con un approccio sempre più tipizzato, PHP 8 spalanca le porte a soluzioni come questa
<?php
class MailSender
{
public function sendMail(): void
{
echo "Mail sent";
}
}
class Logger
{
public function log(string $message): void
{
echo $message;
}
}
class UserService
{
public function __construct(
private MailSender $mailer,
private Logger $logger
) {
}
public function register(): void
{
$this->logger->log("User registration");
$this->mailer->sendMail();
}
}
Non va intesa come un semplice modo per riutilizzare codice, ma piuttosto come una soluzione per gestire reali relazioni.
Dependency Injection: oggetti tipizzati
Un classico esempio di come vengono passati oggetti all'interno di una classe è questo
<?php
class UserService
{
private Logger $logger;
public function __construct()
{
$this->logger = new Logger();
}
}
<?php
class UserService
{
public function __construct(
private LoggerInterface $logger
) {
}
}
<?php
$service = new UserService(
new FileLogger()
);
Che differenza c’è tra un’interfaccia ed una classe astratta?
Chiaramente questa non è una differenza introdotta da PHP 8, ma viene da se che, alla luce di quanto abbiamo detto finora, l’utilizzo di classi astratte ed interfacce diventa sempre più rilevante.
Un’interfaccia si limita a determinare “lo scheletro” di una classe, dichiarandone tutti i metodi ma lasciando l’implementazione degli stessi alle classi che la utilizzeranno. In pratica rappresentano il contratto che definisce il comportamento delle classi.
Anche una classe astratta dichiara i metodi, ma può definirne il codice. Classico esempio, quello dei corrieri in un sistema di e-commerce dove torna comodo definire il metodo getName() (che verosimilmente per quasi tutti ritornerà “return $this-> name”) dichiarando abstract e lasciando vuoti i vari setWeight(), setTax(), getPrice() ecc. ecc.
La comodità delle interfacce/classi astratte appare evidente quando le passiamo come parametri, sfruttando così il cosiddetto "polimorfismo"
class OrderService
{
public function __construct(
private LoggerInterface $logger
) {
}
}
In questo caso OrderService potrà essere istanziata sia con un logger di File che con uno di Database, senza alcuna modifica.
Cosa sono i trait?
I trait rappresentano una sorta di “snippet” che aggiunge le proprie funzioni alle classi in cui viene usato:
<?php
trait Timestampable
{
private DateTime $createdAt;
public function date2Mysql(): string
{
$dt = new \DateTime();
return $dt->format("Y-m-d H:i:s");
}
}
class Allenatore
{
use Timestampable;
}
class Calciatore
{
use Timestampable;
}
$allenatore = new Allenatore();
$calciatore = new Calciatore();
echo 'Allenatore inserito in data '.$allenatore->date2Mysql();
echo "\n";
echo 'Calciatore inserito in data '.$calciatore->date2Mysql();
Alcune modifiche sintattiche aggiunte in PHP 8
Proprietà e classi readonly
<?php
class User
{
public function __construct(
public readonly string $email
) {
}
}
A partire da PHP 8.2 è possibile usare il readonly direttamente nella dichiarazione della classe:
<?php
readonly class User
{
public function __construct(
public string $email,
public string $name
) {
}
}
Attenzione: “readonly” non significa che la variabile è in sola lettura in senso assoluto (sarebbe inutile!); diventa tale dopo che è stata valorizzata una prima volta, nel costruttore o in un metodo successivo.
constructor property promotion
<?php
class User
{
public function __construct(
private string $name
) {
}
}
<?php
class User
{
private string $name;
public function __construct(string $name)
{
$this->name = $name;
}
}
"La vera efficienza si trova nella serenità." (Henry David Thoreau)
Questo sito rispetta gli utenti:
