1

将我的实体视为 CPU 和 PROCESSOR 与共享主键具有一对一的关系。一个 CPU 有一个处理器。

CPU.java

@Entity
@Table(name = "PKJoin_CPUt")
public class CPU {


    private int id;
    private String name;
    private Processor processor;

    @OneToOne(cascade = CascadeType.PERSIST, mappedBy = "cpu", optional = true,fetch=FetchType.LAZY)
    public Processor getProcessor() {
        return processor;
    }
    public void setProcessor(Processor processor) {
        this.processor = processor;
        if (null != processor) {
            processor.setCpu(this);
        }
    }
    private Processor2 processor2;

    @OneToOne(cascade = CascadeType.PERSIST, mappedBy = "cpu", optional = true,fetch=FetchType.LAZY)
    public Processor2 getProcessor2() {
        return processor2;
    }

    public void setProcessor2(Processor2 processor2) {
        this.processor2 = processor2;
        if (null != processor2) {
            processor2.setCpu(this);
        }
    }

    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
        if (null != processor) {
            processor.setId(id);
        }
        if (null != processor2) {
            processor2.setId(id);
        }
    }

    public String getName() {
        return name;
    }

    public void setName(String deptName) {
        this.name = deptName;
    }

}

处理器.java

@Entity
@Table(name = "PKJoin_Processor")
public class Processor {

    private int id;
    private String name;

    private CPU cpu;

    @OneToOne(fetch=FetchType.LAZY)
    @PrimaryKeyJoinColumn
    public CPU getCpu() {
        return cpu;
    }

    public void setCpu(CPU cpu) {
        this.cpu = cpu;
    }
    @Id
    public int getId() {
        return id;
    }

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

主.java

public class Main {
  static EntityManagerFactory emf = Persistence.createEntityManagerFactory("Hello");
  static EntityManager em = emf.createEntityManager();

  public static void main(String[] a) throws Exception {
    em.getTransaction().begin();

    new Main().findData();
   // new Main().persistData();

    em.getTransaction().commit();
    em.close();
    emf.close();    

  }

 public void findData(){      

    CPU cpu = em.find(CPU.class, 449);
    System.out.println(cpu.getProcessor().getName());   


  }
}

这是这样执行的::

    Hibernate: select cpu0_.id as id11_0_, cpu0_.name as name11_0_ from PKJoin_CPUt cpu0_ where cpu0_.id=?
    Hibernate: select processor0_.id as id38_0_, processor0_.name as name38_0_ from  PKJoin_Processor processor0_ where processor0_.id=?
    Hibernate: select processor2x0_.id as id19_0_, processor2x0_.name as name19_0_ from PKJoin_Processor222 processor2x0_ where processor2x0_.id=?

乔

我不希望在仅获取 CPUName 属性时执行这三个查询。我也不想加入。每当我尝试获取 CPU 属性时，我只想执行第一个查询。需要解决方案吗？

4

2 回答 2

1

问题在于，由于关联是可选的，Hibernate 无法仅通过加载 CPU 来知道它是否具有关联的处理器。因此，为了将处理器字段设置为空，或者将其设置为处理器的实例，它必须使用 CPU 的主键检查处理器是否存在。

为避免这种情况，最简单的方法是使用 CPU 中指向处理器的连接列来映射关联。这样，如果连接列为空，Hibernate 就知道没有关联的 CPU。如果它不为空，它可以将 procssor 字段设置为惰性代理。

另一种方法，AFAIK，是使用@LazyToOne(NO_PROXY), 并检测 bytecode。但是我过去在这种设置方面有过不好的经历。也许它已经有所改善。

于 2013-01-02T14:39:53.463 回答
0

在您的 findData() 中，您执行 cpu.getProcessor().getName()，因此您得到第一个处理器的查询是合乎逻辑的。

您在 CPU.setId() 函数中做了一些奇怪的事情，也许这就是加载处理器的原因。

你不应该这样做，你应该让hibernate来处理这个。对于基于主键的双向一对一关系，我认为您需要以下内容：

public class CPU { 
    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    private int id;


    @OneToOne(cascade = CascadeType.ALL, mappedBy = "cpu", fetch=FetchType.LAZY)
    private Processor processor; 

    ...
}

public class Processor {  
    @Id @OneToOne 
    @JoinColumn("id")
    private CPU cpu;  //combine @Id and @OneToOne, no int id needed.

    protected Processor(){}    

    public Processor(CPU cpu){
       this.cpu = cpu;
       cpu.setProcessor(this);
    }    
    ...
}

现在如果你保存一个带有 CPU 的处理器，它的 id 会神奇地用 CPU 的 id 填充。确保以正确的顺序保存它们：

CPU cpu = new CPU();
em.save(cpu);
Processor p = new Processor(cpu);
em.save(p);
于 2013-01-02T14:47:04.217 回答