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的数量变大时，通过更改＆＃34;仅一侧＆＃34;来更改双向关系会很有用。在这种情况下，拥有方的UPDATE SELECT查询比调用a.getBs().remove(b)快得多另请参阅here。

Answer 1

有2＆＃34;方面＆＃34;在问题中：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 entites仍然是Java对象。如果你明确地指示Java ，例如＆＃34;在B的集合中添加B，当其a属性设置为＆＃34;它没有理由自动完成。话虽如此，我经常看到模式（跳过空检查以简洁）：

@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。规格，ch。 2.9＆＃34;实体关系＆＃34;：

双向关系具有拥有方和反向（非拥有方）。单向关系只有一个拥有方。关系的拥有方确定数据库中关系的更新，如3.2.4节所述。


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

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

执行上述并成功更新数据库后，从数据库中读取相关的A对象应获取正确的bs集合。可以肯定的是，首先尝试合并B，提交事务，并在另一个事务中获取A（或刷新它）。如果您希望 Java对象的状态立即反映在同一事务中，则除了设置b.a和a.getBs().add(b)之外别无选择。

Answer 2

如Nikos Paraskevopoulos' answer below中所述，JPA和java对象要求您设置关系的两侧。只要您设置了拥有方，数据库就会根据关系更改进行更新，但非拥有方只会反映数据库中的内容，如果您手动设置它，或者强制刷新或重新加载它。从单独的上下文中读取实体不会强制重新加载，因为您的JPA提供程序可以使用二级缓存;这是EclipseLink中的default。您的另一个读取是从共享缓存中返回A，与原始对象一样，没有B添加到其B列表中。

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

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

2 个答案:

Java方

JPA方