如何在JVM中实现基于内容的唯一对象管理

Book b = new Book(123456, "Effective Java");
Book c = new Book(123456, "Effective Java");

// 假设Book是一个不可变记录（record）
record Book(int isbn, String title) {}

class BookFactory {
    private static final Map<Integer, Book> bookCache = new ConcurrentHashMap<>();

    // 私有构造函数防止外部实例化
    private BookFactory() {}

    public static Book getOrCreateBook(int isbn, String title) {
        // computeIfAbsent 是线程安全的，如果键不存在则原子性地计算并插入值
        return bookCache.computeIfAbsent(isbn, k -> new Book(k, title));
    }

    public static Optional<Book> getBook(int isbn) {
        return Optional.ofNullable(bookCache.get(isbn));
    }
}

Book book1 = BookFactory.getOrCreateBook(123456, "Effective Java");
Book book2 = BookFactory.getOrCreateBook(123456, "Effective Java"); // 会返回book1的引用

System.out.println(book1 == book2); // 输出 true

import java.lang.ref.WeakReference;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

// 假设Book是一个不可变记录（record）
record Book(int isbn, String title) {}

// 使用WeakReference的工厂模式
class BookWeakRefFactory {
    private static final Map<Integer, WeakReference<Book>> bookCache = new ConcurrentHashMap<>();

    private BookWeakRefFactory() {}

    public static Book getOrCreateBook(int isbn, String title) {
        WeakReference<Book> ref = bookCache.get(isbn);
        Book existingBook = (ref != null) ? ref.get() : null;

        if (existingBook != null) {
            return existingBook;
        } else {
            // 如果不存在或已被GC，则创建新对象
            Book newBook = new Book(isbn, title);
            bookCache.put(isbn, new WeakReference<>(newBook));
            return newBook;
        }
    }

    public static Optional<Book> getBook(int isbn) {
        WeakReference<Book> ref = bookCache.get(isbn);
        return Optional.ofNullable(ref != null ? ref.get() : null);
    }
}

import java.util.Optional;
import java.util.concurrent.ConcurrentHashMap;

// Book record 保持不变
record Book(int isbn, String title) {}

/**
 * BookSession 类，管理其生命周期内的唯一 Book 对象集合。
 * 避免了全局内存泄漏，并将唯一性约束限制在会话范围内。
 */
class BookSession {
    private final ConcurrentHashMap<Integer, Book> books = new ConcurrentHashMap<>();

    /**
     * 根据 ISBN 获取一个 Book 对象。
     *
     * @param isbn 书籍的国际标准书号。
     * @return 包含 Book 对象的 Optional，如果不存在则为 Optional.empty()。
     */
    public Optional<Book> get(int isbn) {
        return Optional.ofNullable(books.get(isbn));
    }

    /**
     * 根据 ISBN 获取或创建一个 Book 对象。
     * 如果已存在相同 ISBN 的 Book，则返回现有对象；否则创建新对象并存储。
     *
     * @param isbn 书籍的国际标准书号。
     * @param title 书籍标题。
     * @return 唯一且与给定 ISBN 匹配的 Book 对象。
     */
    public Book getOrCreate(int isbn, String title) {
        // computeIfAbsent 是线程安全的，如果键不存在则原子性地计算并插入值
        return books.computeIfAbsent(isbn, (i) -> new Book(i, title));
    }

    // 可以添加其他方法，例如 findByTitle 等
    // public Optional<Book> findByTitle(String title) { /* ... */ }
}

BookSession session1 = new BookSession();
Book bookA = session1.getOrCreate(123, "Title A");
Book bookB = session1.getOrCreate(123, "Title A"); // 返回 bookA

System.out.println(bookA == bookB); // 输出 true

BookSession session2 = new BookSession();
Book bookC = session2.getOrCreate(123, "Title A"); // 这是session2中的新对象

System.out.println(bookA == bookC); // 输出 false (因为它们属于不同的会话)