L - Liskov Substitution: подтипы без сюрпризов
LSP: объекты подкласса должны заменять объекты базового класса без поломки логики.
Если ты подставил наследника и всё сломалось - это нарушение LSP.
Классический провал: квадрат и прямоугольник
«Квадрат - это частный случай прямоугольника» - звучит математически безупречно. На бумаге Square идеально наследует Rectangle. На практике LSP ломается:
type Rectangle struct{ Width, Height int }
func (r *Rectangle) SetWidth(w int) { r.Width = w }
func (r *Rectangle) SetHeight(h int) { r.Height = h }
func (r *Rectangle) Area() int { return r.Width * r.Height }
type Square struct{ Rectangle } // встроили - методы Rectangle продвинуты в Square
// Чтобы сохранить инвариант «у квадрата стороны равны», объявляем свои методы:
func (s *Square) SetWidth(w int) { s.Width = w; s.Height = w }
func (s *Square) SetHeight(h int) { s.Width = h; s.Height = h }
// Embedding не делает Square подтипом Rectangle: *Square нельзя передать
// туда, где ждут *Rectangle. Подтипирование в Go - только через интерфейс:
type Shape interface {
SetWidth(w int)
SetHeight(h int)
Area() int
}
<?php
declare(strict_types=1);
class Rectangle
{
public function __construct(protected int $width, protected int $height) {}
public function setWidth(int $w): void { $this->width = $w; }
public function setHeight(int $h): void { $this->height = $h; }
public function area(): int { return $this->width * $this->height; }
}
final class Square extends Rectangle
{
// Чтобы сохранить инвариант «у квадрата стороны равны», переопределяем:
public function setWidth(int $w): void { $this->width = $w; $this->height = $w; }
public function setHeight(int $h): void { $this->width = $h; $this->height = $h; }
}
from dataclasses import dataclass
@dataclass
class Rectangle:
width: int
height: int
def set_width(self, w: int) -> None:
self.width = w
def set_height(self, h: int) -> None:
self.height = h
def area(self) -> int:
return self.width * self.height
class Square(Rectangle): # унаследовали - теперь Square имеет set_width/set_height
# Чтобы сохранить инвариант «у квадрата стороны равны», переопределяем:
def set_width(self, w: int) -> None:
self.width = w
self.height = w
def set_height(self, h: int) -> None:
self.width = h
self.height = h
А теперь функция, которая написана для Rectangle и не знает про Square:
func GrowToFit(r Shape, w, h int) int {
r.SetWidth(w)
r.SetHeight(h)
return r.Area() // ожидаем w*h
}
// GrowToFit(&Rectangle{}, 2, 3) == 6
// GrowToFit(&Square{}, 2, 3) == 9 - а ждали 6
<?php
declare(strict_types=1);
function growToFit(Rectangle $r, int $w, int $h): int
{
$r->setWidth($w);
$r->setHeight($h);
return $r->area(); // ожидаем w*h
}
def grow_to_fit(r: Rectangle, w: int, h: int) -> int:
r.set_width(w)
r.set_height(h)
return r.area() # ожидаем w*h
Подставляем Square вместо Rectangle - получаем h*h вместо w*h. Код, корректный для базового типа, ломается на подтипе. Это и есть нарушение LSP: подтип не сохранил наблюдаемое поведение базы.
Урок: наследование «is-a» в реальном мире и наследование контракта в коде - не одно и то же. В Go embedding выглядит как наследование, но лишь продвигает методы и не делает Square подтипом Rectangle. Подтипирование в Go возможно только через интерфейсы - и как только Square и Rectangle подставляются под общий интерфейс Shape, та же ловушка возвращается.
Практичный пример: «репозиторий» без сюрпризов
// Доменная ошибка - часть контракта UserRepo.
// Postgres-реализация оборачивает в неё sql.ErrNoRows, а не отдаёт ошибку драйвера наружу.
var ErrUserNotFound = errors.New("user not found")
type UserRepo interface {
Get(id int64) (User, error)
}
type PgUserRepo struct{}
func (PgUserRepo) Get(id int64) (User, error) { /* ok */ return User{}, nil }
type FakeUserRepo struct{}
func (FakeUserRepo) Get(id int64) (User, error) {
// Должно вести себя так же: либо User, либо ErrUserNotFound.
return User{}, ErrUserNotFound
}
interface UserRepo
{
public function get(int $id): array;
}
final class PgUserRepo implements UserRepo
{
public function get(int $id): array
{
return ['id' => $id];
}
}
final class FakeUserRepo implements UserRepo
{
public function get(int $id): array
{
// Контракт: либо массив пользователя, либо UserNotFoundException - придерживаемся.
throw new UserNotFoundException("user {$id} not found");
}
}
from dataclasses import dataclass
from typing import Protocol
@dataclass
class User:
id: int
class UserNotFoundError(Exception):
pass
# Контракт UserRepo: get() вернёт User или бросит UserNotFoundError.
# Protocol - структурная типизация: наследоваться от него не нужно,
# достаточно совпадения сигнатур (как с неявной реализацией интерфейса в Go).
class UserRepo(Protocol):
def get(self, user_id: int) -> User: ...
class PgUserRepo:
def get(self, user_id: int) -> User:
# ok - возвращает User
return User(id=user_id)
class FakeUserRepo:
def get(self, user_id: int) -> User:
# Должно вести себя так же: либо User, либо UserNotFoundError - не None, не другое исключение.
raise UserNotFoundError(f"user {user_id} not found")
⚠️ Пример нарушения LSP
Если
FakeUserRepo.Get()вдруг начнёт паниковать вместо ошибки/исключения - код, ожидающий стандартное поведение, развалится.
Контракт интерфейса = preconditions + postconditions + инварианты
LSP формализуется через design-by-contract:
- preconditions - что обязан гарантировать вызывающий код перед вызовом метода (валидный id, ненулевой контекст)
- postconditions - что обязан гарантировать метод после успешного выполнения (вернёт
Userилиerror, не оставит мусор в БД) - инварианты - что справедливо для типа в целом (
UserRepoне должен паниковать)
Правило Барбары Лисков: подтип может ослабить preconditions (принимать больше) и усилить postconditions (возвращать конкретнее), но никогда наоборот. Если фейк начинает требовать заполненный RequestID в контексте, а Postgres-реализация - нет, фейк ужесточил precondition и нарушил LSP.
LSP в Go: интерфейсы - это контракты
В Go нет наследования классов, и иногда возникает соблазн думать, что LSP здесь не нужен. Это заблуждение. LSP - это про подтипирование, а не про конкретный механизм наследования. В Go механизм подтипирования один - интерфейсы и их реализации:
type UserRepo interface { // базовый «тип» (контракт)
Get(ctx context.Context, id int64) (User, error)
}
// Каждая реализация - это «подтип» в смысле LSP
type PgUserRepo struct{ db *sql.DB } // реализация-подтип
type RedisUserRepo struct{ rdb *redis.Client } // ещё один подтип
type FakeUserRepo struct{ users map[int64]User } // и ещё один
<?php
declare(strict_types=1);
interface UserRepo // базовый «тип» (контракт)
{
public function get(int $id): User;
}
// Каждая реализация - это «подтип» в смысле LSP
final class PdoUserRepo implements UserRepo
{
public function __construct(private readonly PDO $db) {}
public function get(int $id): User { /* ... */ throw new LogicException(); }
}
final class RedisUserRepo implements UserRepo
{
public function __construct(private readonly Redis $redis) {}
public function get(int $id): User { /* ... */ throw new LogicException(); }
}
final class FakeUserRepo implements UserRepo
{
/** @var array<int, User> */
private array $users = [];
public function get(int $id): User { /* ... */ throw new LogicException(); }
}
from dataclasses import dataclass, field
from typing import Protocol
from psycopg import Connection
from redis import Redis
class UserRepo(Protocol): # базовый «тип» (контракт)
def get(self, user_id: int) -> User: ...
# Каждая реализация - это «подтип» в смысле LSP.
# Ни один класс не наследует UserRepo: Protocol сверяет форму, а не родословную.
class PgUserRepo: # реализация-подтип
def __init__(self, db: Connection) -> None:
self._db = db
def get(self, user_id: int) -> User: ...
class RedisUserRepo: # ещё один подтип
def __init__(self, rdb: Redis) -> None:
self._rdb = rdb
def get(self, user_id: int) -> User: ...
@dataclass
class FakeUserRepo: # и ещё один
users: dict[int, User] = field(default_factory=dict)
def get(self, user_id: int) -> User: ...
Любой код, написанный против UserRepo, должен корректно работать с любой из этих реализаций. Это и есть LSP, переведённый на язык Go: подтип = реализация интерфейса, контракт = интерфейс.
Поэтому LSP в Go проявляется везде, где есть полиморфизм через интерфейсы - а это практически весь идиоматический Go-код. Если фейк ведёт себя иначе, чем Postgres-реализация, клиентский код, написанный на тестах с фейком, рассыплется в проде. Это и есть нарушение принципа подстановки.
Embedding gotchas в Go
Go не имеет наследования, но embedding создаёт похожую иллюзию - и те же ловушки:
type Base struct{}
func (Base) Save(ctx context.Context) error { return nil }
type Cached struct {
Base
cache map[string]string
}
// Если переопределить Save и забыть про инвариант базового типа -
// код, который ожидал поведение Base, сломается на Cached.
func (c *Cached) Save(ctx context.Context) error {
c.cache = nil // делаем что-то ещё
return nil
}
<?php
declare(strict_types=1);
// В PHP та же ловушка возникает при extends + переопределении метода:
// если потомок ломает постусловие родителя, клиентский код, ожидающий
// поведение Base, развалится на Cached.
class Base
{
public function save(): void { /* persist */ }
}
final class Cached extends Base
{
/** @var array<string, string> */
private array $cache = [];
public function save(): void
{
$this->cache = []; // делаем что-то ещё
// забыли вызвать parent::save() - данные не сохранятся
}
}
class Base:
def save(self) -> None:
... # persist
class Cached(Base):
def __init__(self) -> None:
super().__init__()
self._cache: dict[str, str] = {}
# Если переопределить save и забыть про инвариант базового типа -
# код, который ожидал поведение Base, сломается на Cached.
def save(self) -> None:
self._cache.clear() # делаем что-то ещё
# забыли super().save() - данные не сохранятся
Это меньшая проблема, чем классическое наследование, потому что Go-код обычно работает с интерфейсами, а не с конкретными типами. Но как только клиент начинает делать type assertion (if cached, ok := r.(*Cached); ok) - иерархия даёт о себе знать.
Как проверить LSP
- прочитай контракт интерфейса (включая «как я веду себя при ошибке»)
- подставь каждую реализацию в уме: «а сломает ли это ожидающее поведение?»
- лучше - напиши общий тестовый пакет, прогоняющий один и тот же набор сценариев на всех реализациях
// Один тест на все реализации UserRepo - гарантия LSP по построению
func RunUserRepoContract(t *testing.T, makeRepo func() UserRepo) {
t.Run("Get несуществующего возвращает ErrUserNotFound", func(t *testing.T) {
repo := makeRepo()
_, err := repo.Get(context.Background(), -1)
if !errors.Is(err, ErrUserNotFound) {
t.Fatalf("want ErrUserNotFound, got %v", err)
}
})
// ... другие инварианты контракта
}
func TestPgUserRepo(t *testing.T) { RunUserRepoContract(t, func() UserRepo { return NewPgRepo(testDB) }) }
func TestFakeUserRepo(t *testing.T) { RunUserRepoContract(t, func() UserRepo { return NewFakeRepo() }) }
<?php
declare(strict_types=1);
// Один абстрактный тест на все реализации UserRepo - гарантия LSP по построению.
// В PHPUnit это базовый abstract класс с реальными тестами + потомки,
// возвращающие конкретную реализацию.
namespace App\Tests\User;
use App\User\UserNotFoundException;
use App\User\UserRepo;
use PHPUnit\Framework\TestCase;
abstract class UserRepoContractTest extends TestCase
{
abstract protected function makeRepo(): UserRepo;
public function testGetMissingThrowsUserNotFound(): void
{
$this->expectException(UserNotFoundException::class);
$this->makeRepo()->get(-1);
}
// ... другие инварианты контракта
}
final class PdoUserRepoTest extends UserRepoContractTest
{
protected function makeRepo(): UserRepo { return new PdoUserRepo(self::testPdo()); }
}
final class FakeUserRepoTest extends UserRepoContractTest
{
protected function makeRepo(): UserRepo { return new FakeUserRepo(); }
}
# Один набор тестов на все реализации UserRepo - гарантия LSP по построению.
# В pytest это класс-контракт с реальными тестами + потомки Test*,
# возвращающие конкретную реализацию (базовый класс без префикса Test не собирается).
import pytest
class UserRepoContract:
def make_repo(self) -> UserRepo:
raise NotImplementedError
def test_get_missing_raises_user_not_found(self) -> None:
repo = self.make_repo()
with pytest.raises(UserNotFoundError):
repo.get(-1)
# ... другие инварианты контракта
class TestPgUserRepo(UserRepoContract):
def make_repo(self) -> UserRepo:
return PgUserRepo(test_db)
class TestFakeUserRepo(UserRepoContract):
def make_repo(self) -> UserRepo:
return FakeUserRepo()
Если фейк перестаёт проходить контрактный тест, значит его клиенты тоже сломаются в реальной интеграции. Это самый дешёвый способ ловить LSP-нарушения автоматически.
Где LSP проявляется в реальном Go-коде
Самые частые места, где нарушается LSP в живых проектах:
- Фейковые репозитории, которые паникуют там, где Postgres-реализация возвращает ошибку
- Декорированные клиенты (например, кеширующая обёртка), которые молча проглатывают ошибки сети, считая «нет данных в кеше = нет данных вообще»
- Тестовые HTTP-клиенты, не соблюдающие тайм-ауты, которые гарантирует прод-реализация
- Адаптеры для разных БД, по-разному ведущие себя при race conditions (один блокирует, другой возвращает специфическую ошибку)
- «Гибкие» реализации, которые принимают
nilтам, где базовый контракт требовал ненулевой указатель - Кеширующие декораторы, у которых TTL ломает гарантии свежести данных, заявленные в основном интерфейсе
- In-memory имплементации, которые игнорируют контекст и не отменяют операции по
ctx.Done() - Метричные обёртки, которые добавляют побочные эффекты (записи в Prometheus) и блокируются, если метрик-сервер недоступен
В каждом случае подтип формально удовлетворяет интерфейсу (методы те же), но наблюдаемое поведение отличается - и это отличие проявляется только под нагрузкой или на граничных случаях.
Мини‑задание
- Проверь свои реализации интерфейсов: одинаково ли они ведут себя при ошибках?
- Заведи общий контрактный тест для одного интерфейса с двумя+ реализациями - все ли они его проходят?
- Найди случай embedding-а с переопределённым методом и оцени, не нарушает ли он ожидания базового типа