Opprettelsesmønstre: Factory, Builder, Singleton
Styr objektopprettelsen på en ryddig måte med opprettelsesmønstre.
Opprettelsesmønstre: Factory, Builder, Singleton er en gratis leksjon i PHP Academy på CoddyKit. Dette er leksjon 2 av 4. Du kan lese hele leksjonen gratis nedenfor – og deretter øve praktisk i nettleseren med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Den er en del av læringsløpet i PHP Academy, og fremdriften din synkroniseres mellom nettet og CoddyKit-appen. Kurset i PHP Academy inneholder totalt 4 leksjoner.
Kontrollere opprettelse
Creational patterns kobler fra hva De trenger, og hvordan det bygges. Når opprettelsen er betinget, består av flere trinn eller må sentraliseres, knytter spredte new-uttrykk over hele kodebasen kallende kode til konkrete klasser. Her ser vi på Factory (og Factory Method), Builder for kompleks sammensetting og Singleton (med tilhørende forbehold).
Enkel Factory
En simple factory sentraliserer et opprettelsesvalg bak én metode. Kallende kode ber om en logisk type og mottar en konfigurert, konkret instans uten å kjenne klassenavnene.
<?php
interface Notifier { public function send(string $msg): string; }
final class EmailNotifier implements Notifier {
public function send(string $m): string { return "email: $m"; }
}
final class SmsNotifier implements Notifier {
public function send(string $m): string { return "sms: $m"; }
}
final class NotifierFactory {
public static function make(string $channel): Notifier {
return match ($channel) {
'email' => new EmailNotifier(),
'sms' => new SmsNotifier(),
default => throw new InvalidArgumentException($channel),
};
}
}
echo NotifierFactory::make('sms')->send('Hi'), PHP_EOL;
Factory Method
Mønsteret Factory Method utsetter instansieringen til underklasser. Basisklassen definerer en algoritme som kaller en abstrakt create(); hver underklasse bestemmer det konkrete produktet. Dette er OCP-vennlig: Legg til en ny oppretter uten å endre eksisterende opprettere.
<?php
abstract class ReportExporter {
abstract protected function create(): string;
public function export(): string {
return 'Exported as ' . $this->create();
}
}
final class PdfExporter extends ReportExporter {
protected function create(): string { return 'PDF'; }
}
final class CsvExporter extends ReportExporter {
protected function create(): string { return 'CSV'; }
}
echo (new PdfExporter())->export(), PHP_EOL;
echo (new CsvExporter())->export(), PHP_EOL;
Abstract Factory
En Abstract Factory produserer familier av relaterte objekter som må brukes sammen (for eksempel en MySqlConnection og en MySqlQueryBuilder). Den garanterer at delene er kompatible, fordi én factory leverer hele settet. Bruk den når en produktfamilie må være konsistent internt.
Builder: problemet
Når et objekt trenger mange valgfrie parametere, blir konstruktører til uleselige lister med posisjonsargumenter eller stadig lengre overlagrede konstruktører, noe PHP ikke engang har. Mønsteret Builder setter sammen et komplekst objekt trinn for trinn og returnerer til slutt et ferdig, gyldig produkt.
Fluent Builder
En fluent builder returnerer $this fra hver setter, og deretter produserer build() det uforanderlige resultatet. Dermed holdes selve produktet enkelt, mens logikken for sammensetting flyttes til builderen.
<?php
final class Query {
public function __construct(public readonly string $sql) {}
}
final class QueryBuilder {
private string $table = '';
private array $where = [];
public function from(string $t): self { $this->table = $t; return $this; }
public function where(string $c): self { $this->where[] = $c; return $this; }
public function build(): Query {
$sql = "SELECT * FROM {$this->table}";
if ($this->where) { $sql .= ' WHERE ' . implode(' AND ', $this->where); }
return new Query($sql);
}
}
echo (new QueryBuilder())->from('users')->where('age > 18')->build()->sql, PHP_EOL;
Builder sammenlignet med navngitte konstruktører
For enklere tilfeller er PHP 8-navngitte argumenter og named constructors (statiske factory-metoder) ofte et bedre valg enn en full builder.
- Bruk navngitte argumenter når alle dataene er tilgjengelige samtidig.
- Bruk en builder når sammensettingen skjer i flere trinn, er betinget eller gjenbrukes fra flere kallesteder.
<?php
final class Money {
private function __construct(public readonly int $cents, public readonly string $cur) {}
public static function fromDollars(float $d): self {
return new self((int) round($d * 100), 'USD');
}
public static function zero(string $cur = 'USD'): self {
return new self(0, $cur);
}
}
var_dump(Money::fromDollars(19.99)->cents); // int(1999)
Singleton
En Singleton garanterer én instans med et globalt tilgangspunkt. Implementer den med en privat konstruktør og en statisk tilgangsmetode. Den er faktisk nyttig for ting som virkelig må være unike innenfor én prosess, men den er også det mest misbrukte mønsteret.
<?php
final class Config {
private static ?self $instance = null;
private array $data = ['debug' => true];
private function __construct() {}
public static function instance(): self {
return self::$instance ??= new self();
}
public function get(string $k): mixed { return $this->data[$k] ?? null; }
}
var_dump(Config::instance()->get('debug'));
var_dump(Config::instance() === Config::instance()); // true
Hvorfor Singleton skaper problemer
Singletons introduserer skjult global tilstand: Kallende kode henter avhengigheten via Config::instance() i stedet for å deklarere den, noe som svekker testbarheten og støtten for parallell kjøring. I moderne PHP bør De heller registrere én delt instans i en DI container (livssyklus for «én instans») og injisere den. Da får De én instans uten den globale koblingen.
Velge riktig verktøy
- Simple/Factory Method: skjul konkrete klasser bak et opprettelsesvalg.
- Abstract Factory: produser kompatible produktfamilier.
- Builder: sett sammen komplekse objekter trinn for trinn.
- Singleton: siste utvei; foretrekk delte tjenester som administreres av en container.
Alle fire reduserer koblingen til konkrete konstruktører, slik at koden blir enklere å utvide og teste.
Registry-basert factory
En mer dynamisk factory slår opp opprettere i et register, slik at nye typer kan registrere seg selv uten at factoryen må endres (ekte OCP). Dette er slik plugin-systemer og serialisatorer ved kjøring finner konstruktøren for et typenavn.
<?php
interface Shape { public function name(): string; }
final class Circle implements Shape { public function name(): string { return 'circle'; } }
final class Square implements Shape { public function name(): string { return 'square'; } }
final class ShapeRegistry {
private array $creators = [];
public function register(string $key, callable $factory): void {
$this->creators[$key] = $factory;
}
public function create(string $key): Shape {
return ($this->creators[$key] ?? throw new InvalidArgumentException($key))();
}
}
$r = new ShapeRegistry();
$r->register('circle', fn() => new Circle());
$r->register('square', fn() => new Square());
echo $r->create('square')->name(), PHP_EOL; // square
Hurtigsjekk
Velg det beste verktøyet for opprettelse i scenarioet.
Oppsummering
De kontrollerte opprettelsen av objekter med creational patterns: factories for å skjule konkrete typer og velge produktfamilier, builders for å sette sammen komplekse objekter på en fluent måte, og Singleton med sine avveininger. Den moderne konklusjonen er å bruke factories og builders fritt, men erstatte Singleton med en delt instans-livssyklus i en DI container, slik at avhengighetene forblir eksplisitte og testbare.
Lær deg PHP med en AI-veileder – gratis
Skriv og kjør ekte kode i nettleseren, få umiddelbar hjelp fra en AI-veileder som er tilgjengelig døgnet rundt, og fortsett der du slapp – på nettet eller i appen.
- Kurs
- 49
- Leksjoner
- 195
Ofte stilte spørsmål
Er leksjonen «Opprettelsesmønstre: Factory, Builder, Singleton» gratis?
Ja – hele teksten i «Opprettelsesmønstre: Factory, Builder, Singleton» er gratis å lese her på nettet. For å øve interaktivt med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt, og for å låse opp resten av PHP Academy-kurset, kan du oppgradere til CoddyKit PRO. Kurset i PHP Academy inneholder totalt 4 leksjoner.
Hva lærer jeg i «Opprettelsesmønstre: Factory, Builder, Singleton»?
Styr objektopprettelsen på en ryddig måte med opprettelsesmønstre. Du øver på PHP Academy med praktisk kode som du kjører direkte i nettleseren, mens en AI-veileder som er tilgjengelig døgnet rundt, svarer på spørsmålene dine mens du jobber deg gjennom leksjonen.
Trenger jeg erfaring for å begynne med PHP Academy?
Ingen tidligere erfaring er nødvendig. PHP Academy på CoddyKit er lagt opp for både nybegynnere og viderekomne, så De kan begynne her eller helt fra start og lære i Deres eget tempo. Dette er leksjon 2 av 4.
Hvor lang tid tar leksjonen «Opprettelsesmønstre: Factory, Builder, Singleton»?
De fleste CoddyKit-leksjoner tar omtrent 5–10 minutter. Hver leksjon er kort og interaktiv, slik at De gjør jevne fremskritt og kan fortsette akkurat der De slapp – både på nettet og i appen.
Kan jeg skrive og kjøre kode i denne PHP Academy-leksjonen?
Ja. Alle PHP Academy-leksjoner har en innebygd kodeeditor, slik at De kan skrive og kjøre ekte kode direkte i nettleseren og få umiddelbar tilbakemelding fra AI – uten lokal konfigurering.
Alle leksjonene i dette kurset
- SOLID-prinsippene i praksis
- Opprettelsesmønstre: Factory, Builder, Singleton
- Strukturelle mønstre: Adapter, Decorator, Facade
- Atferdsmønstre: Strategy, Observer, Command