在Java中序列化具有多對多關系的兩個對象

Question

我在Java中有“書籍”類和“作者”類。書籍與作者之間存在多對多關系。

書類：

public class Book
{
    int ISPN;
    String title;
    String description;
    int pageCount;
    public ArrayList<Author> Authors;
}

作者類別：

public class Author 
{
    int authorID;
    String firstName;
    String lastName;
    ArrayList<Book> books;
}

我想序列化Book或Author的對象，但是會有無限遞歸，因為每本Book都有其關聯作者的列表，他們的關聯書籍等都無限。 那么如何處理這種情況呢？

對不起，我的英語不好。

Answer 1

就您與多對多的關系而言，您需要一些存儲空間才能存儲所有數據（例如數據庫）。 恕我直言，最好的方法是讓您在恢復序列化文件時列出此存儲的暫態和恢復項目。 如果您的情況確實是數據庫，則可以使用一些內存中的緩存以使其更快。

[編輯]：

這是存儲的替代實現：

Storage.java ：

public class Storage implements Serializable {
    private final HashMap<Integer, Book> books;
    private final HashMap<Integer, Author> authors;

    public Storage() {
        books = new HashMap<>();
        authors = new HashMap<>();
    }

    public void addBook(Book book) {
        books.put(book.ISPN, book);
    }

    public void removeBook(Book book) {
        books.remove(book.ISPN);
    }

    public void addAuthor(Author author) {
        authors.put(author.authorID, author);
    }

    public void removeAuthor(Author author) {
        authors.remove(author.authorID);
    }

    public Author getAuthor(Integer authorId) {
        return authors.get(authorId);
    }

    public Book getBook(Integer bookId) {
        return books.get(bookId);
    }
}

Book.java ：

public class Book implements Serializable {
    int ISPN;
    String title;
    String description;
    int pageCount;
    ArrayList<Integer> AuthorIds;
    Storage storage;

    public Book(Storage storage) {
        this.storage = storage;
    }

    public void addAuthor(Author author) {
        storage.addAuthor(author);
        AuthorIds.add(author.authorID);
    }

    public List<Author> createAuthorsList() {
        List<Author> authorList = new ArrayList<>();
        for (Integer authorId : AuthorIds) {
            authorList.add(storage.getAuthor(authorId));
        }
        return authorList;
    }
}

Author.java ：

public class Author {
    int authorID;
    String firstName;
    String lastName;
    ArrayList<Integer> bookIds;
    Storage storage;

    public Author(Storage storage) {
        this.storage = storage;
    }

    public void addBook(Book book) {
        storage.addBook(book);
        bookIds.add(book.ISPN);
    }

    public List<Book> createBooksList() {
        List<Book> bookList = new ArrayList<>();
        for (Integer bookId : bookIds) {
            bookList.add(storage.getBook(bookId));
        }
        return bookList;
    }
}

使用此實現的唯一（但很大）缺點是，在反序列化之后，您將擁有具有相同數據的多個Storage類實例。 為了優化此功能，我建議您將存儲條目作為臨時成員進行創建，並分別對其進行序列化。