相关疑难解决方法(0)

我想在不加载整个对象的情况下获取一对一关系的id.我以为我可以使用延迟加载执行此操作,如下所示:

class Foo { 
    @OneToOne(fetch = FetchType.LAZY, optional = false)
    private Bar bar; 
}


Foo f = session.get(Foo.class, fooId);  // Hibernate fetches Foo 

f.getBar();  // Hibernate fetches full Bar object

f.getBar().getId();  // No further fetch, returns id

我希望f.getBar()不会触发另一个提取.我希望hibernate给我一个代理对象,允许我调用.getId()而不实际获取Bar对象.

我究竟做错了什么？

我只是想知道所有这些注释之间的区别.我们为什么要使用这些...意味着它们没有影响,尤其是字段级别和属性级别.

使用混合级注释的目的是什么:

@Entity
@Access(AccessType.FIELD)
class Employee {
    // why their is a field level access 
    private int id;

    // whats the purpose of transient here
    @Transient                               
    private String phnnumber;

    // why its a property level access
    @Access(AccessType.property)             
    public String getPhnnumber() {
        return "1234556";
    }

}

这堂课到底是什么意思？

目前,Hibernate允许我直接加载由*-to-one关系定义的对象

entity1.getEntity2()

是否可以获取外键而不是对象？

我看到的当前方法是对我的映射添加addint:

@JoinColumn(name="message_key")
@ManyToOne(targetEntity=Message.class,fetch=FetchType.LAZY)
private Message message;  //these lines currently exist

@Column(name="message_key")
private Long message_fk; //the idea is to add those 2 lines

是否有更好的方法来获取外键,或者这是唯一的？

主题说明了一切......到目前为止,我认为人们没有在吸气剂和/或制定者上声明注释的优势.对我来说,这只会带来在类上传播注释的缺点,这会使类更难以理解.

将注释放在字段上会明显减少需要帮助时要发布的代码量.这只是一个很小的优势.但是对方法进行注释对我没有任何意义.

我有一个关于Hibernate使用的简单问题.我一直通过注释类的字段以及通过在相应的bean上注释get方法,以两种方式之一看到人们使用JPA注释.

我的问题如下:注释字段和bean方法与JPA annoations(如@Id)之间是否存在差异.

例:

@Entity
public class User
{

**@ID**
private int id;

public int getId(){
return this.id;
}

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

}

- - - - - -要么 - - - - - -

@Entity
public class User
{


private int id;

**@ID**
public int getId(){
return this.id;
}

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

}

我认为这是一个简单的问题.我已经看过两种方式的例子.问题是 - "为什么我不能把我的注释放在场上？".让我给你举个例子....

@Entity
@Table(name="widget")
public class Widget {
 private Integer id;

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

上面的代码工作正常(假设那里没有拼写错误).当注释被放置在物业的吸气剂上时,一切都是完美的.

然而,这对我来说似乎很尴尬.在我看来,将注释放在场上比较清晰,就像这样 -

@Entity
@Table(name="widget")
public class Widget {
 @Id
 @GeneratedValue(strategy=GenerationType.AUTO)
 private Integer id;

 public Integer getId() { return this.id; }
 public Integer setId(Integer Id) { this.id = id;}
}

我见过两种方式的例子.但是,当我运行第二个例子时,我得到以下内容......

java.lang.NullPointerException
    at com.widget.util.hibernate.HibernateSessionFactory$ThreadLocalSession.initialValue(HibernateSessionFactory.java:25)
    at com.widget.util.hibernate.HibernateSessionFactory$ThreadLocalSession.initialValue(HibernateSessionFactory.java:1)
    at java.lang.ThreadLocal$ThreadLocalMap.getAfterMiss(Unknown Source)
    at java.lang.ThreadLocal$ThreadLocalMap.get(Unknown Source)
    at java.lang.ThreadLocal$ThreadLocalMap.access$000(Unknown Source)
    at java.lang.ThreadLocal.get(Unknown Source)
    at com.widget.util.hibernate.HibernateSessionFactory.get(HibernateSessionFactory.java:33) …

我把hibernate注释放在哪里？

它是我的实例变量之上的行吗？或者在吸气器之前？或者在二传手之前？或者它真的不重要吗？

非常感谢

我目前正在学习Hibernate和Java Persistence API.

我有一个@Entity类,需要将注释应用于各个字段.我已经在下面的代码中包含了他们可以去的所有三个地方.

我应该将它们应用于场地本身,吸气剂还是定位器？这三个选项之间的语义差异(如果有的话)是什么.

import javax.persistence.Entity;
import javax.persistence.Table;
import javax.persistence.Id;

@Entity
@Table(name = "song")
public class Song { 
    // Annotations should only be applied to one of the below

    @Id 
    @Column(name="id", unique=true, nullable=false)
    private int    id;

    @Id
    @Column(name="id", unique=true, nullable=false)
    public int getId() {
        return id;
    }

    @Id
    @Column(name="id", unique=true, nullable=false)
    public void setId(int id) {
        this.id = id;
    }
}

我有Hibernate Entities看起来像这样(getters和setter被遗漏):

@Entity
public class EntityA {
    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn(name = "parent_id")
    private EntityB parent;
}

@Entity
public class EntityB extends SuperEntity {
    @OneToMany(mappedBy = "parent")
    @Fetch(FetchMode.SUBSELECT)
    @JoinColumn(name = "parent_id")
    private Set<EntityA> children;
}

@MappedSuperclass
public class SuperEntity {
    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    @Column(name = "id")
    private long itemId;
}

当我查询EntityA时,它加载正常,父关联被Hibernate代理替换(因为它是Lazy).如果我想访问父母的id,我执行以下调用:

EntityA entityA = queryForEntityA();
long parentId = entityA.getParent().getItemId();

据我所知,调用不应该向数据库进行往返,因为Id存储在EntityA表中,并且代理应该只返回该值.但是,在我的情况下,这将生成一个SQL语句,该语句提取EntityB,然后才返回Id.

我该如何调查这个问题？导致这种错误行为的可能原因是什么？

我有一个查询工厂,它将列名作为属性,以便搜索该列.现在我将列的名称作为字符串传递,因此它是硬编码的.如果列的名称在实体的注释中发生更改,则"隐藏的依赖项"会中断.

在jpa中是否有一种方法可以检索列的真实名称并在编译时将其提供,因此我可以在查询中使用它？