相关疑难解决方法(0)

我有这个问题:

org.hibernate.LazyInitializationException:懒得初始化角色集合:mvc3.model.Topic.comments,没有会话或会话被关闭

这是模型:

@Entity
@Table(name = "T_TOPIC")
public class Topic {

    @Id
    @GeneratedValue(strategy=GenerationType.AUTO)
    private int id;

    @ManyToOne
    @JoinColumn(name="USER_ID")
    private User author;

    @Enumerated(EnumType.STRING)    
    private Tag topicTag;

    private String name;
    private String text;

    @OneToMany(mappedBy = "topic", cascade = CascadeType.ALL)
    private Collection<Comment> comments = new LinkedHashSet<Comment>();

    ...

    public Collection<Comment> getComments() {
           return comments;
    }

}

调用模型的控制器如下所示:

@Controller
@RequestMapping(value = "/topic")
public class TopicController {

    @Autowired
    private TopicService service;

    private static final Logger logger = LoggerFactory.getLogger(TopicController.class);


    @RequestMapping(value = "/details/{topicId}", method = RequestMethod.GET)
    public ModelAndView …

hibernate映射中的默认提取类型是什么？

探索之后我才知道的是:

• 一对一,它是渴望.
• 对于一对多它是懒惰的.

但是在Eclipse中测试之后,它渴望所有人.

这取决于我使用的是JPA还是Hibernate？

我的代码:

    @Test
public void testAddRoleAndAddUser() {

    Role r = roleDao.findByProperty("name", "admin");
    if(r == null) {
        r = new Role();
        r.setName("admin");
        r.setDescription("Just administrator.");
        roleDao.save(r);
    }

    User u = dao.get(1l);
    Set<Role> roles = u.getRoleSet();
    logger.debug("Roles is null: " + (roles == null));
    roles.add(r);
    dao.save(u);
}

13:39:41041 ERROR:org.hibernate.LazyInitializationException未能懒洋洋地初始化角色的集合:xxx.entity.core.User.roleSet,没有会议或会议是封闭org.hibernate.LazyInitializationException:未能初始化懒洋洋的集合作用:xxx.entity.core.User.roleSet,没有会议或会议收于org.hibernate.collection.AbstractPersistentCollection.throwLazyInitializationException(AbstractPersistentCollection.java:380)在org.hibernate.collection.AbstractPersistentCollection.throwLazyInitializationExceptionIfNotConnected(AbstractPersistentCollection.java: 372)在org.hibernate.collection.AbstractPersistentCollection.initialize(AbstractPersistentCollection.java:365)在org.hibernate.collection.PersistentSet.add(PersistentSet.java:212)在sg.com.junglemedia.test.dao.impl.hibernate.UserDaoTest.testAddRoleAndAddUser(UserDaoTest.java:40)at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:39)at sun.reflect.DelegatingMethodAccessorImpl.在org.junit的org.junit.runners.model.FrameworkMethod $ 1.runReflectiveCall(FrameworkMethod.java:44)的java.lang.reflect.Method.invoke(Method.java:597)中调用(DelegatingMethodAccessorImpl.java:25). org.junit.runners.runners.statements.InvokeMethod.evaluate上的org.junit.runners.model.FrameworkMethod.invokeExplosively(FrameworkMethod.java:41)中的internal.runners.model.ReflectiveCallable.run(ReflectiveCallable.java:15) InvokeMethod.java:20)在org.junit.internal.runners.statements.RunBefores.evaluate(RunBefores.java:28)在org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:76)org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:50)org.junit.runners.ParentRunner $ 3.run(ParentRunner.java:193)at org.在org.junit.runners.ParentRunner.access $ 000(ParentRunner.java:42)的org.junit.runners.ParentRunner.runChildren(ParentRunner.java:191)上的junit.runners.ParentRunner $ 1.schedule(ParentRunner.java:52) org.junit.runners.ParentRunner $ 2.evaluate(ParentRunner.java:184)位于org.eclipse.jdt.internal.junit4.runner.JUnit4TestReference的org.junit.runners.ParentRunner.run(ParentRunner.java:236).在运行org.eclipse.jdt.internal.junit.runner.RemoteTestRunner(JUnit4TestReference.java:46)在org.eclipse.jdt.internal.junit.runner.TestExecution.run(TestExecution.java:38).runTests(RemoteTestRunner.java:467)位于org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.runTests(RemoteTestRunner.java:683)org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.run(RemoteTestRunner.的java:390)在org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.main(RemoteTestRunner.java:197)

有人帮吗？

我相信只有两种使用Hibernate加载对象的方法,即延迟加载,一种是急切加载.延迟加载有其自身的优点,它不会加载大量对象,只有在需要时才加载.我还了解到,如果你想强制加载一个对象的所有子项,你可以简单地调用parent.getChildren().size().所以我们假设我们有以下对象

@Entity
public class Customer{
public Set<Order> order;
}

@Entity
public class Order{
}

让我们假设我们的客户在我们的系统中有订单,它可能不止一个甚至是空的.所以我的问题是在这种情况下总是使用急切加载不是更好吗？我们需要与客户相关的订单的大小或一些信息.在这种情况下使用延迟加载有什么好处,有什么好处吗？

我试图了解在何处使用延迟加载以及在哪里使用预先加载,非常感谢您的洞察力.

我的 Spring Data JPA 存储库有一个我不明白的问题。我有以下实体：

@Entity
public class Ability {
    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    private Integer id;
    private String name;
    private String color;
    private String image;

    @ManyToOne(
            fetch = FetchType.EAGER
    )
    private Subject subject;

    @OneToMany(
            mappedBy = "ability",
            cascade = CascadeType.ALL,
            orphanRemoval = true,
            fetch = FetchType.EAGER
    )
    private Set<Technology> technologies;

以及该实体的 JPA 存储库。我不明白的是，当我使用deleteByIdJpa 存储库的方法时，记录不会从数据库中删除。奇怪的是，它在我使用 InMemory 数据库的集成测试中运行良好。如果我deleteById用以下内容覆盖它，它就会起作用：

    @Modifying
    @Query("DELETE FROM Ability a WHERE a.id = :id")
    void deleteById(@Param("id") Integer id);

但我怀疑我不应该这样做。该方法有任何线索无法按预期工作吗？

编辑：添加端点源代码

@RestController
@RequestMapping("/subjects/{subjectId}/abilities")
public class …

我正在使用注释学习hibernate映射.我已经完成了一个部分.即我可以在保存父表时自动插入子类. 看到了.

但是当我获取主表时,我没有得到子表.也出错了

failed to lazily initialize a collection of role: com.pojo.one2many.unidirectional.Student.phonenos, no session or session was closed

我的代码已添加到此处以供您查看.请仔细阅读.并给我很好的建议.Student.java.(父类)

@Entity
    @Table(name="STUDENT")
    public class Student {
    private int studentid;
    private String studentName;
    private Set <Phone> phonenos;

    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    @Column(name="studenId")
    public int getStudentid() {
        return studentid;
    }
    public void setStudentid(int studentid) {
        this.studentid = studentid;
    }
    @Column(name="studenName")
    public String getStudentName() {
        return studentName;
    }
    public void setStudentName(String studentName) {
        this.studentName = studentName;
    }
    @OneToMany(fetch = FetchType.LAZY)
    @JoinColumn(name="studenId") 
    public Set<Phone> …

我对Hibernate很新.在这里我想比较两个选项.

第一种选择

我的hibernate pojo类如下.

Stock {
  @Id
  @GeneratedValue(strategy = GenerationType.AUTO)
  @Column(name = "stock_id")
  private Long stockId;

  @Column(name = "stock_name")
  private String stockName;

  @ManyToMany(fetch = FetchType.EAGER)
  @JoinTable(name = "stock_characteristics", joinColumns =  {@JoinColumn(name = "stock_id")}, inverseJoinColumns = {@JoinColumn(name = "ct_id")})
  private List<Characteristic> characteristics = new ArrayList<>();

  //constructor, getters and setters

}

Characteristics {
  @Id
  @GeneratedValue(strategy = GenerationType.AUTO)
  @Column(name = "ct_id", nullable = false)
  private Long id;

  @Column(name = "name", nullable = false, length = 32)
  private String name;

  //constructor, getters and setters …

请解释hibernate Eager fetching 和cascade-type all 之间的区别。

在这两种配置中，我们都可以加载与其父级关联的子对象，那么 in.

我正在使用 Spring Boot 开发 REST 应用程序，并且正在尝试优化查询的性能。我目前正在使用findAll导致性能问题的存储库。代码如下：

个人实体

@Entity
@Table(name = "cd_person")
@Data
@NoArgsConstructor
public class Person {
    ....
    @OneToOne(fetch = FetchType.EAGER, cascade = CascadeType.ALL)
    @JoinColumn(name = "password_id")
    @Fetch(FetchMode.JOIN)
    private Password password;
    ....
    @ManyToMany(fetch = FetchType.EAGER, cascade = {CascadeType.MERGE, CascadeType.PERSIST, CascadeType.REFRESH})
    @JoinTable(name = "cd_person_role",
        joinColumns = @JoinColumn(name = "person_id", referencedColumnName = "id"),
        inverseJoinColumns = @JoinColumn(name = "role_id", referencedColumnName = "id"))
    @Fetch(FetchMode.JOIN)
    private Set<Role> roles = new HashSet<>();
}

密码实体

@Entity
@Table(name = "cd_password")
@Data
@NoArgsConstructor
public class Password { …

我有三个实体，Session、Order 和 User（我的在线电影票项目的一部分）。在我的域模型中，Order 保留了 User 和 Session 的 fk。正如你在我的代码中看到的：

@Table(name="Orders")
@Entity

public class Order {
    @ManyToOne
    @JoinColumn(nullable = false)
    private User user;

    @ManyToOne
    private Session session;
    ...
}



@Entity 
@Table(name="Session")

public class Session {
    @OneToMany(fetch=FetchType.LAZY,
               cascade = CascadeType.ALL,
               mappedBy = "session")
    private List<Order> orders = new ArrayList<Order>();
    ...
}



@Table(name="User")
@Entity

public class User {
    @OneToMany(cascade = {  CascadeType.PERSIST,
                            CascadeType.MERGE,
                            CascadeType.REMOVE },
               mappedBy = "user")
    private @Getter Set<Order> orders = new HashSet<>();
    ...
}

我的问题是，我可以CascadeType.ALL在 Session 和 User …