Java中如何确保对象唯一性：工厂模式与会话管理实践

class Book {
    private int isbn;
    private String title;

    public Book(int isbn, String title) {
        this.isbn = isbn;
        this.title = title;
    }

    // getters, equals, hashCode
}

// 假设Book类已存在，且我们希望通过isbn确保唯一性
// 为了防止外部直接创建，可以考虑将Book的构造器设为包私有或通过其他方式限制
// 或者，如果Book是记录，则需要一个单独的工厂类来封装创建逻辑。

// 伪代码，存在内存泄漏问题
class BookFactory {
    private static final Map<Integer, Book> bookCache = new HashMap<>();

    public static Book getOrCreateBook(int isbn, String title) {
        if (bookCache.containsKey(isbn)) {
            return bookCache.get(isbn);
        } else {
            Book newBook = new Book(isbn, title); // 假设Book构造器可访问
            bookCache.put(isbn, newBook);
            return newBook;
        }
    }
}

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

// 假设Book类定义为 record 或具有合适的构造器
record Book(int isbn, String title) {}

class BookFactoryWithWeakRef {
    // 使用ConcurrentHashMap保证线程安全
    // 存储WeakReference，键为isbn
    private final ConcurrentHashMap<Integer, WeakReference<Book>> bookCache = new ConcurrentHashMap<>();

    public Optional<Book> get(int isbn) {
        WeakReference<Book> ref = bookCache.get(isbn);
        if (ref != null) {
            Book book = ref.get(); // 获取弱引用指向的实际对象
            if (book != null) {
                return Optional.of(book);
            } else {
                // 对象已被回收，从缓存中移除弱引用
                bookCache.remove(isbn, ref);
            }
        }
        return Optional.empty();
    }

    public Book getOrCreate(int isbn, String title) {
        // 尝试从缓存获取
        Optional<Book> existingBook = get(isbn);
        if (existingBook.isPresent()) {
            return existingBook.get();
        }

        // 如果不存在或已被回收，则创建新对象并放入缓存
        Book newBook = new Book(isbn, title);
        // 使用computeIfAbsent确保原子性，避免多线程冲突
        WeakReference<Book> newRef = new WeakReference<>(newBook);
        WeakReference<Book> oldRef = bookCache.computeIfAbsent(isbn, k -> newRef);

        // 检查是否有其他线程同时创建了，或者旧的引用仍然有效
        if (oldRef == newRef) { // 如果是当前线程成功放入
            return newBook;
        } else { // 如果其他线程先放入了，或者旧引用仍然有效
            Book existing = oldRef.get();
            if (existing != null) {
                return existing; // 返回已存在的对象
            } else {
                // 旧引用已失效，再次尝试放入
                // 这是一个简化，实际生产中可能需要更复杂的循环或重试逻辑
                // 或者直接依赖computeIfAbsent的原子性，但需要处理好WeakReference的生命周期
                return getOrCreate(isbn, title); // 递归调用，确保获取到有效的Book
            }
        }
    }
}

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

// Book类定义
record Book(int isbn, String title) {}

/**
 * BookSession 类用于在一个特定的会话中管理Book对象的唯一性。
 * 当BookSession实例不再被引用时，其内部管理的Book对象（如果没有其他强引用）
 * 也可以被垃圾回收。
 */
class BookSession {
    // 使用ConcurrentHashMap来存储Book对象，确保线程安全
    // 这里直接存储Book对象，而不是WeakReference，因为Session本身就是其管理的Book的强引用持有者
    // Session的生命周期决定了其内部Book对象的生命周期
    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 唯一且已存在的Book对象
     */
    public Book getOrCreate(int isbn, String title) {
        // computeIfAbsent 是原子操作，确保在多线程环境下只有一个Book会被创建并放入Map
        return books.computeIfAbsent(isbn, (key) -> new Book(key, title));
    }

    // 可以添加其他方法，例如 findByTitle, removeBook 等
}

public class UniqueObjectDemo {
    public static void main(String[] args) {
        // 创建一个BookSession实例
        BookSession session1 = new BookSession();

        // 在session1中获取或创建Book对象
        Book book1_1 = session1.getOrCreate(123456, "Effective Java");
        System.out.println("Book 1_1 (session1): " + book1_1);

        // 再次获取相同ISBN的Book，将返回同一个对象
        Book book1_2 = session1.getOrCreate(123456, "Effective Java");
        System.out.println("Book 1_2 (session1): " + book1_2);
        System.out.println("book1_1 == book1_2: " + (book1_1 == book1_2)); // true

        // 获取不同ISBN的Book
        Book book1_3 = session1.getOrCreate(789012, "Clean Code");
        System.out.println("Book 1_3 (session1): " + book1_3);

        System.out.println("\n--- New Session ---");
        // 创建另一个BookSession实例
        BookSession session2 = new BookSession();

        // 在session2中获取或创建相同ISBN的Book
        Book book2_1 = session2.getOrCreate(123456, "Effective Java");
        System.out.println("Book 2_1 (session2): " + book2_1);
        // 注意：book1_1 和 book2_1 是不同的对象实例，因为它们属于不同的Session
        System.out.println("book1_1 == book2_1: " + (book1_1 == book2_1)); // false

        // 验证session2内部的唯一性
        Book book2_2 = session2.getOrCreate(123456, "Effective Java");
        System.out.println("book2_1 == book2_2: " + (book2_1 == book2_2)); // true

        // 当session1不再被引用时，其内部的Book对象（如果无其他强引用）可被回收
        session1 = null; // 失去对session1的强引用
        System.gc(); // 提示JVM进行垃圾回收（不保证立即执行）
    }
}