我是否必须为双向关系设置双方？

Question

@Entity
public class A {
    @GeneratedValue
    @Id
    private long id;

    public long getId() {
        return id;
    }

    public void setId(final long id) {
        this.id = id;
    }

    @OneToMany(mappedBy = "a")
    List<B> bs;

    public List<B> getBs() {
        return bs;
    }

    public void setBs(final List<B> bs) {
        this.bs = bs;
    }
}
@Entity
public class B {
    @GeneratedValue
    @Id
    private long id;

    public long getId() {
        return id;
    }

    public void setId(final long id) {
        this.id = id;
    }

    @ManyToOne
    @JoinTable
    A a;

    public A getA() {
        return a;
    }

    public void setA(final A a) {
        this.a = a;
    }
}

为了建立关系，我必须打电话

b.setA(a);
a.getBs().add(b);

为什么两者都需要，为什么只做还不够

b.setA(a);

或者

a.getBs().add(b);

?

该关系存储在连接表中，b.setA(a)并将更新该连接表。

但是当我之后进行查询时，它a.getBs()是空的。这是为什么？

这是一个说明问题的测试用例。请注意，最后一个断言失败。

public class QuickTestAB2 {

    private static String dbUrlBase = "jdbc:derby:testData/db/test.db";

    private static String dbUrlCreate = dbUrlBase + ";create=true";

    private static String dbUrlDrop = dbUrlBase + ";drop=true";

    private EntityManagerFactory factory;

    private EntityManager em;

    public Map<String, String> createPersistenceMap(final String dbUrl) {
        final Map<String, String> persistenceMap = new HashMap<>();
        persistenceMap.put("javax.persistence.jdbc.url", dbUrl);
        return persistenceMap;
    }

    public void dropDatabase() throws Exception {
        if (em != null && em.isOpen()) {
            em.close();
        }
        if (factory != null && factory.isOpen()) {
            factory.close();
        }
        try (Connection conn = DriverManager.getConnection(dbUrlDrop)) {

        } catch (final SQLException e) {
            // always

        }
    }

    public void deleteDatabase() throws Exception {
        dropDatabase();
        final File file = new File("testData/db/test.db");
        if (file.exists()) {
            FileUtils.forceDelete(file);
        }
    }

    public void createNewDatabase() throws SQLException, IOException {

        FileUtils.forceMkdir(new File("testData/db"));
        try (Connection conn = DriverManager.getConnection(dbUrlCreate)) {

        }
    }

    @BeforeClass
    public static void setUpBeforeClass01() throws Exception {
        Tests.enableLog4J();
        JPATests.enableJPA();

    }

    @AfterClass
    public static void tearDownAfterClass01() throws Exception {

    }

    @Before
    public void setUp01() throws Exception {

        deleteDatabase();
        createNewDatabase();
        final Map<String, String> map = createPersistenceMap(dbUrlCreate);
        factory = Persistence.createEntityManagerFactory("pu", map);

    }

    @After
    public void tearDown01() throws Exception {
        if (em != null && em.isOpen()) {
            em.close();
        }
        em = null;
        if (factory != null && factory.isOpen()) {
            factory.close();
        }
        factory = null;
    }

    @Test
    public void test01() throws Exception {
        em = factory.createEntityManager();
        final A a = new A();
        final B b = new B();
        b.setA(a);
        try {
            em.getTransaction().begin();
            em.persist(a);
            em.persist(b);
            em.getTransaction().commit();
        } finally {
            em.close();
        }
        em = factory.createEntityManager();
        B b2;
        A a2;
        try {
            em.getTransaction().begin();
            Query q = em.createQuery("SELECT b FROM B b");
            b2 = (B) q.getSingleResult();
            q = em.createQuery("SELECT a FROM A a");
            a2 = (A) q.getSingleResult();
            em.getTransaction().commit();
        } finally {
            em.close();
        }
        assertThat(a2, is(not(nullValue())));
        assertThat(b2, is(not(nullValue())));

        assertThat(b2.getA(), is(not(nullValue())));
        assertThat(a2.getBs().isEmpty(), is(false));

    }

}

动机：当数量a.Bs变大时，通过更改“仅一侧”来更改双向关系会很有用。在这种情况下，UPDATE SELECT拥有方的查询比调用a.getBs().remove(b) See also here快得多。

Answer 1

问题中有两个“方面”：Java 方面和 JPA 方面。

Java端

更完整的代码清单可能是：

@Entity
class A {
    @OneToMany(mappedBy = "a")
    @JoinTable
    List<B> bs;

    public List<B> getBs() {
        return bs;
    }
    public void setBs(List<B> bs) {
        this.bs = bs;
    }
}

@Entity
class B {
    @ManyToOne
    @JoinTable
    A a;

    public A getA() {
        return a;
    }
    public void setA(A a) {
        this.a = a;
    }
}

JPA 实体仍然是 Java 对象。如果您确实明确指示 Java ，例如“将 B 添加到 B 的集合中，当它的a属性被设置时”，它没有理由自动执行此操作。话虽如此，我经常看到这样的模式（为了简洁而跳过空检查）：

@Entity
class A {
    ...

    public void addB(B b) {
        bs.add(b);
        b.setA(this);
    }
    public void removeB(B b) {
        if( bs.remove(b) ) {
            b.setA(null);
        }
    }
}

JPA端

JPA 2.1。规格，通道 2.9 “实体关系”：

双向关系既有拥有方，也有反向（非拥有）方。单向关系只有拥有方。关系的拥有方决定了对数据库中关系的更新，如第 3.2.4 节所述。

• 双向关系的反面必须通过使用mappedBy元素来引用它的拥有方

在问题的设置中，B.a拥有方是因为A.bs指定mappedBy="a". 规范说只有在更新拥有方时才会更新关系（即，将插入连接表中的条目）。这就是为什么做b.setA(a)更新连接表。

做好以上后，成功地更新数据库，阅读相关的目的从DB新鲜应取的正确bs集合。可以肯定的是，首先尝试合并 B，提交事务，然后在不同的事务中获取 A（或刷新它）。如果您希望Java 对象的状态立即反映在同一个事务中，您别无选择，只能同时设置b.a和a.getBs().add(b)。

Answer 2

正如下面 Nikos Paraskevopoulos 的回答中所述，JPA 和 java 对象要求您设置关系的双方。只要你设置了拥有方，数据库就会随着关系的变化而更新，但是如果你手动设置它，或者你强制刷新或重新加载，非拥有方只会反映数据库中的内容。从单独的上下文中读取实体不会强制重新加载，因为您的 JPA 提供程序可以使用二级缓存；这是EclipseLink 中的默认设置。您的另一个读取是从共享缓存返回 A，与您的原始对象一样，它没有将 B 添加到其 B 列表中。

最简单的解决方案是预先将 B 设置到 A 的列表中。不过这里的其他选项是使用 em.refresh(a) 或使用查询提示强制刷新 A，或者禁用共享缓存。