AuthorRepository repo = new JdbcAuthorRepository(cm);

UUID tarasId = taras.getId();

// Перший виклик — SELECT з БД
Author author1 = repo.findById(tarasId).orElseThrow();

// ... кілька рядків бізнес-логіки ...

// Другий виклик — знову SELECT з БД
Author author2 = repo.findById(tarasId).orElseThrow();

// Здається, це один автор — але Java каже інакше
System.out.println(author1 == author2);           // false — різні об'єкти в пам'яті
System.out.println(author1.equals(author2));       // true — якщо equals через id

// Оновлюємо через перший об'єкт
author1.setFirstName("Тарас");
repo.update(author1);

// Другий об'єкт — застарілий! Він досі зберігає старе ім'я.
System.out.println(author2.getFirstName()); // ← старе значення

package com.example.audiobook.persistence;

import java.util.HashMap;
import java.util.Map;
import java.util.Optional;

/**
 * Identity Map — реєстр завантажених об'єктів, індексований за первинним ключем.
 * <p>
 * Гарантує, що для кожного значення ключа {@code ID} у пам'яті існує
 * не більше одного екземпляра типу {@code T}. При повторному запиті
 * з тим самим ключем повертає той самий об'єкт (не копію), що:
 * <ul>
 *   <li>усуває зайві SELECT-запити до БД;</li>
 *   <li>підтримує узгодженість стану у рамках сесії;</li>
 *   <li>вирівнює семантику ідентичності Java та реляційної БД.</li>
 * </ul>
 *
 * <p><b>Область видимості:</b> один екземпляр Identity Map повинен
 * існувати в межах однієї логічної одиниці роботи (запит, транзакція
 * або сесія). Він <em>не є</em> глобальним або thread-safe кешем.
 *
 * @param <ID> тип первинного ключа (наприклад, {@code UUID})
 * @param <T>  тип доменної сутності (наприклад, {@code Author})
 */
public class IdentityMap<ID, T> {

    /**
     * Внутрішнє сховище: первинний ключ → екземпляр сутності.
     * <p>
     * Використовуємо {@link HashMap} (не {@link java.util.concurrent.ConcurrentHashMap}),
     * оскільки Identity Map призначений для однопотокового використання
     * у рамках однієї сесії/транзакції.
     */
    private final Map<ID, T> store = new HashMap<>();

    /**
     * Шукає об'єкт у кеші за первинним ключем.
     *
     * @param id первинний ключ
     * @return {@link Optional} з об'єктом, якщо він раніше був завантажений;
     *         {@link Optional#empty()} якщо cache miss
     */
    public Optional<T> get(ID id) {
        return Optional.ofNullable(store.get(id));
    }

    /**
     * Реєструє об'єкт у кеші після завантаження з БД.
     * <p>
     * Якщо об'єкт з таким {@code id} вже зареєстрований — він буде замінений.
     * Зазвичай це не має відбуватися у нормальному потоці роботи.
     *
     * @param id     первинний ключ
     * @param entity завантажений об'єкт
     */
    public void put(ID id, T entity) {
        store.put(id, entity);
    }

    /**
     * Видаляє об'єкт із кешу.
     * <p>
     * Викликається після успішного {@code DELETE} або при явній інвалідації
     * (наприклад, у {@link com.example.audiobook.repository.CachedJdbcRepository#deleteById}).
     *
     * @param id первинний ключ
     */
    public void remove(ID id) {
        store.remove(id);
    }

    /**
     * Перевіряє, чи об'єкт з даним ключем зареєстрований у кеші.
     *
     * @param id первинний ключ
     * @return {@code true} якщо cache hit
     */
    public boolean contains(ID id) {
        return store.containsKey(id);
    }

    /**
     * Очищає весь кеш.
     * <p>
     * Викликається в кінці сесії або при явному скиданні стану.
     * Після виклику наступний {@code findById} знову звернеться до БД.
     */
    public void clear() {
        store.clear();
    }

    /**
     * Повертає кількість об'єктів у кеші.
     * Корисно для діагностики та тестів.
     */
    public int size() {
        return store.size();
    }
}

package com.example.audiobook.repository;

import com.example.audiobook.persistence.IdentityMap;

import java.util.List;
import java.util.Optional;

/**
 * Декоратор для будь-якого {@link Repository}, що додає кешування
 * через {@link IdentityMap}.
 * <p>
 * Реалізує патерн Decorator (GoF): делегує всі операції wrapped-репозиторію,
 * перехоплюючи {@code findById} і {@code save/update/delete} для підтримки
 * кешу в актуальному стані.
 * <p>
 * <b>Контракт:</b>
 * <ul>
 *   <li>{@code findById} — спочатку кеш, потім БД;</li>
 *   <li>{@code findAll} — завжди БД (наповнює кеш результатами);</li>
 *   <li>{@code save} — зберігає в БД і додає у кеш;</li>
 *   <li>{@code update} — оновлює в БД і інвалідує (оновлює) кеш;</li>
 *   <li>{@code deleteById} — видаляє з БД і з кешу.</li>
 * </ul>
 *
 * @param <T>  тип доменної сутності
 * @param <ID> тип первинного ключа
 */
public class CachedJdbcRepository<T, ID> implements Repository<T, ID> {

    /** Обгорнутий репозиторій: виконує реальні SQL-операції. */
    private final Repository<T, ID> delegate;

    /** Кеш завантажених об'єктів у межах поточної сесії. */
    private final IdentityMap<ID, T> identityMap;

    /** Функція отримання ID з сутності — потрібна для put/remove у кеш. */
    private final java.util.function.Function<T, ID> idExtractor;

    /**
     * @param delegate    реальний репозиторій (наприклад, JdbcAuthorRepository)
     * @param idExtractor функція для отримання ID з сутності (Author::getId)
     */
    public CachedJdbcRepository(
            Repository<T, ID> delegate,
            java.util.function.Function<T, ID> idExtractor) {
        this.delegate = delegate;
        this.idExtractor = idExtractor;
        this.identityMap = new IdentityMap<>();
    }

    /**
     * Знаходить сутність за ID.
     * <p>
     * <b>Логіка:</b>
     * <ol>
     *   <li>Перевірити Identity Map — cache hit? Повернути об'єкт.</li>
     *   <li>Cache miss → делегувати у wrapped repository (SQL SELECT).</li>
     *   <li>Зареєструвати знайдений об'єкт у Identity Map.</li>
     * </ol>
     */
    @Override
    public Optional<T> findById(ID id) {
        // Крок 1: перевірка кешу
        Optional<T> cached = identityMap.get(id);
        if (cached.isPresent()) {
            return cached;  // cache hit — SELECT не виконується
        }

        // Крок 2: cache miss — завантажити з БД
        Optional<T> fromDb = delegate.findById(id);

        // Крок 3: зареєструвати у кеші (якщо знайдено)
        fromDb.ifPresent(entity -> identityMap.put(id, entity));

        return fromDb;
    }

    /**
     * Повертає всі сутності.
     * <p>
     * <b>Стратегія:</b> завжди звертається до БД (не можна знати, чи кеш
     * є повним). Заповнює кеш усіма завантаженими об'єктами — наступні
     * {@code findById} будуть cache hit.
     */
    @Override
    public List<T> findAll() {
        // Завжди звертаємось до БД: не знаємо, чи всі записи вже у кеші
        List<T> all = delegate.findAll();

        // Наповнюємо кеш: наступний findById вже не піде в БД
        all.forEach(entity -> identityMap.put(idExtractor.apply(entity), entity));

        return all;
    }

    /**
     * Зберігає нову сутність.
     * <p>
     * Делегує в БД, потім реєструє сутність у кеші.
     */
    @Override
    public void save(T entity) {
        delegate.save(entity);
        // Після успішного INSERT реєструємо у кеші
        identityMap.put(idExtractor.apply(entity), entity);
    }

    /**
     * Оновлює існуючу сутність.
     * <p>
     * Делегує в БД, потім оновлює кеш — замінює старий об'єкт новим.
     * Це гарантує, що наступний {@code findById} поверне актуальний стан.
     */
    @Override
    public void update(T entity) {
        delegate.update(entity);
        // Інвалідуємо і оновлюємо кеш: кладемо новий об'єкт
        identityMap.put(idExtractor.apply(entity), entity);
    }

    /**
     * Видаляє сутність за ID.
     * <p>
     * Делегує в БД, потім видаляє з кешу.
     * Без цього кроку {@code findById} після видалення знайшов би
     * об'єкт у кеші і повернув би його — навіть якщо рядку вже немає у БД.
     */
    @Override
    public boolean deleteById(ID id) {
        boolean deleted = delegate.deleteById(id);
        if (deleted) {
            identityMap.remove(id);  // обов'язкова інвалідація
        }
        return deleted;
    }

    @Override
    public long count() {
        return delegate.count();  // делегуємо без кешування
    }

    @Override
    public boolean existsById(ID id) {
        // Якщо є у кеші — точно існує; якщо немає — запитуємо БД
        return identityMap.contains(id) || delegate.existsById(id);
    }

    /**
     * Повертає Identity Map для доступу до метаданих кешу.
     * Корисно для тестів та діагностики.
     */
    public IdentityMap<ID, T> getIdentityMap() {
        return identityMap;
    }
}

package com.example.audiobook;

import com.example.audiobook.db.ConnectionManager;
import com.example.audiobook.domain.Author;
import com.example.audiobook.repository.AuthorRepository;
import com.example.audiobook.repository.CachedJdbcRepository;
import com.example.audiobook.repository.jdbc.JdbcAuthorRepository;

import java.util.UUID;

public class Main {

    public static void main(String[] args) {

        ConnectionManager cm = ConnectionManager.forH2("./data/audiobook_db");

        // Підклад: реальний JDBC-репозиторій
        JdbcAuthorRepository jdbcRepo = new JdbcAuthorRepository(cm);

        // Обгортка: той самий AuthorRepository, але з Identity Map
        // Author::getId — функція вилучення ID для put/remove у кеш
        AuthorRepository repo = new CachedJdbcRepository<>(jdbcRepo, Author::getId);

        // Зберегти автора
        Author shevchenko = new Author("Тарас", "Шевченко");
        repo.save(shevchenko);
        UUID id = shevchenko.getId();

        System.out.println("=== Перший findById ===");
        Author a1 = repo.findById(id).orElseThrow();
        // → cache miss: виконується SELECT
        // → об'єкт кладеться у Identity Map

        System.out.println("=== Другий findById (той самий id) ===");
        Author a2 = repo.findById(id).orElseThrow();
        // → cache hit: SELECT НЕ виконується

        // Перевірка семантики ідентичності
        System.out.println("a1 == a2: " + (a1 == a2));   // true — ОДИН і той самий об'єкт
        System.out.println("a1 id:    " + System.identityHashCode(a1));
        System.out.println("a2 id:    " + System.identityHashCode(a2));
        // Обидва System.identityHashCode однакові — це буквально той самий об'єкт

        System.out.println("=== Зміна через a1, читання через a2 ===");
        a1.setFirstName("Тарасик");   // змінюємо через перше посилання
        System.out.println("a2.getFirstName() = " + a2.getFirstName());
        // "Тарасик" — бо a1 і a2 — це той самий об'єкт у пам'яті!

        System.out.println("=== Оновлення в БД та інвалідація кешу ===");
        a1.setFirstName("Тарас");      // повернули правильне ім'я
        repo.update(a1);               // UPDATE в БД + оновлення кешу

        System.out.println("=== Видалення та перевірка кешу ===");
        boolean deleted = repo.deleteById(id);
        System.out.println("Видалено: " + deleted);

        // Після deleteById об'єкт вилучений з кешу
        // Наступний findById знову піде в БД — і не знайде запис
        Author a3 = repo.findById(id).orElse(null);
        System.out.println("Знайдено після видалення: " + a3);  // null

        cm.close();
    }
}

// Псевдокод HTTP-обробника (Spring-стиль без Spring)
public Response handleGetAudiobook(UUID audiobookId) {
    // Новий CachedJdbcRepository = новий IdentityMap для цього запиту
    AuthorRepository authorRepo =
        new CachedJdbcRepository<>(new JdbcAuthorRepository(cm), Author::getId);

    // Навіть якщо логіка тричі завантажує автора — SELECT виконається один раз
    Audiobook book = buildAudiobookResponse(audiobookId, authorRepo);
    return Response.ok(book);
    // CachedJdbcRepository виходить зі scope → Identity Map знищується
}

// Усі операції в межах однієї транзакції використовують один IM
try (Connection conn = cm.getConnection()) {
    conn.setAutoCommit(false);

    CachedJdbcRepository<Author, UUID> authorRepo =
        new CachedJdbcRepository<>(new JdbcAuthorRepository(cm), Author::getId);

    Author author = authorRepo.findById(id1).orElseThrow(); // SELECT
    Author same   = authorRepo.findById(id1).orElseThrow(); // cache hit!

    author.setBio("Оновлена біографія");
    authorRepo.update(author);

    conn.commit();
    // IdentityMap виходить зі scope разом із транзакцією
}

Потік A:  findById(42) → cache miss → SELECT → author{name="Тарас"} → кеш
Потік B:  findById(42) → cache miss → SELECT → author{name="Тарас"} → кеш

Потік A:  author.setName("Тарас Григорович") → update() → UPDATE у БД → кеш A оновлено
Потік B:  findById(42) → cache hit → повертає author{name="Тарас"} ← ЗАСТАРІЛІ ДАНІ!

// Варіант з WeakHashMap — автоматичне звільнення при GC
private final Map<ID, T> store = new java.util.WeakHashMap<>();
// Увага: не підходить якщо є тільки посилання через кеш — об'єкт може зникнути!

// Неправильна оптимізація (не робимо):
@Override
public List<T> findAll() {
    if (allLoaded) {
        return new ArrayList<>(identityMap.values()); // небезпечно!
    }
    // ...
}
// Чому небезпечно: інша транзакція могла додати запис після нашого findAll.
// Флаг allLoaded = true → ми пропустили новий запис.