org.hibernate.MappingException：无法确定类型：java.util.List，在表：大学，列：[org.hibernate.mapping.Column(students)]
声明：本页面是StackOverFlow热门问题的中英对照翻译，遵循CC BY-SA 4.0协议，如果您需要使用它，必须同样遵循CC BY-SA许可，注明原文地址和作者信息，同时你必须将它归于原作者（不是我）：StackOverFlow
原文地址: http://stackoverflow.com/questions/3774198/
Warning: these are provided under cc-by-sa 4.0 license. You are free to use/share it, But you must attribute it to the original authors (not me):
StackOverFlow
org.hibernate.MappingException: Could not determine type for: java.util.List, at table: College, for columns: [org.hibernate.mapping.Column(students)]
提问by
I'm using Hibernate for all CRUD operations in my project. It doesn't work for One-To-Many and Many-To-One relationships. It gives me the below error.
我正在将 Hibernate 用于我项目中的所有 CRUD 操作。它不适用于一对多和多对一关系。它给了我以下错误。
org.hibernate.MappingException: Could not determine type for: java.util.List, at table: College, for columns: [org.hibernate.mapping.Column(students)]
org.hibernate.MappingException: Could not determine type for: java.util.List, at table: College, for columns: [org.hibernate.mapping.Column(students)]
Then again i went through this video tutorial. It is very simple to me, in the beginning. But, i cant make it work. It also now, says
然后我又看了这个视频教程。一开始对我来说很简单。但是，我不能让它工作。它现在也说
org.hibernate.MappingException: Could not determine type for: java.util.List, at table: College, for columns: [org.hibernate.mapping.Column(students)]
org.hibernate.MappingException: Could not determine type for: java.util.List, at table: College, for columns: [org.hibernate.mapping.Column(students)]
I have ran some searches in the internet, there someone telling its a bug in Hibernate, and some says, by adding @GenereatedValuethis error ll be cleared, but it doesn't work for me.
我在互联网上进行了一些搜索，有人告诉它 Hibernate 中的一个错误，有人说，通过添加@GenereatedValue这个错误将被清除，但它对我不起作用。
College.java
大学.java
@Entity
public class College {
@Id
@GeneratedValue(strategy=GenerationType.AUTO)
private int collegeId;
private String collegeName;
private List<Student> students;
@OneToMany(targetEntity=Student.class, mappedBy="college", fetch=FetchType.EAGER)
public List<Student> getStudents() {
return students;
}
public void setStudents(List<Student> students) {
this.students = students;
}//Other gettters & setters omitted
Student.java
学生.java
@Entity
public class Student {
@Id
@GeneratedValue(strategy=GenerationType.AUTO)
private int studentId;
private String studentName;
private College college;
@ManyToOne
@JoinColumn(name="collegeId")
public College getCollege() {
return college;
}
public void setCollege(College college) {
this.college = college;
}//Other gettters & setters omitted
Main.java:
主.java：
public class Main {
private static org.hibernate.SessionFactory sessionFactory;
public static SessionFactory getSessionFactory() {
if (sessionFactory == null) {
initSessionFactory();
}
return sessionFactory;
}
private static synchronized void initSessionFactory() {
sessionFactory = new AnnotationConfiguration().configure().buildSessionFactory();
}
public static Session getSession() {
return getSessionFactory().openSession();
}
public static void main (String[] args) {
Session session = getSession();
Transaction transaction = session.beginTransaction();
College college = new College();
college.setCollegeName("Dr.MCET");
Student student1 = new Student();
student1.setStudentName("Peter");
Student student2 = new Student();
student2.setStudentName("John");
student1.setCollege(college);
student2.setCollege(college);
session.save(student1);
session.save(student2);
transaction.commit();
}
}
Console:
安慰：
Exception in thread "main" org.hibernate.MappingException: Could not determine type for: java.util.List, at table: College, for columns: [org.hibernate.mapping.Column(students)]
at org.hibernate.mapping.SimpleValue.getType(SimpleValue.java:306)
at org.hibernate.mapping.SimpleValue.isValid(SimpleValue.java:290)
at org.hibernate.mapping.Property.isValid(Property.java:217)
at org.hibernate.mapping.PersistentClass.validate(PersistentClass.java:463)
at org.hibernate.mapping.RootClass.validate(RootClass.java:235)
at org.hibernate.cfg.Configuration.validate(Configuration.java:1330)
at org.hibernate.cfg.Configuration.buildSessionFactory(Configuration.java:1833)
at test.hibernate.Main.initSessionFactory(Main.java:22)
at test.hibernate.Main.getSessionFactory(Main.java:16)
at test.hibernate.Main.getSession(Main.java:27)
at test.hibernate.Main.main(Main.java:43)
The XML:
XML：
<?xml version='1.0' encoding='utf-8'?>
<!DOCTYPE hibernate-configuration PUBLIC
"-//Hibernate/Hibernate Configuration DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
<session-factory>
<!-- Database connection settings -->
<property name="connection.driver_class">com.mysql.jdbc.Driver</property>
<property name="connection.url">jdbc:mysql://localhost:3306/dummy</property>
<property name="connection.username">root</property>
<property name="connection.password">1234</property>
<!-- JDBC connection pool (use the built-in) -->
<property name="connection.pool_size">1</property>
<!-- SQL dialect -->
<property name="dialect">org.hibernate.dialect.MySQLDialect</property>
<!-- Enable Hibernate's automatic session context management -->
<property name="current_session_context_class">thread</property>
<!-- Disable the second-level cache -->
<property name="cache.provider_class">org.hibernate.cache.NoCacheProvider</property>
<!-- Echo all executed SQL to stdout -->
<property name="show_sql">true</property>
<!-- Drop and re-create the database schema on startup -->
<property name="hbm2ddl.auto">update</property>
<mapping class="test.hibernate.Student" />
<mapping class="test.hibernate.College" />
</session-factory>
采纳答案by Arthur Ronald
You are using field access strategy(determined by @Id annotation). Put any JPA related annotation right above each field instead of getter property
您正在使用字段访问策略（由 @Id 注释确定）。将任何与 JPA 相关的注释放在每个字段的正上方，而不是 getter 属性
@OneToMany(targetEntity=Student.class, mappedBy="college", fetch=FetchType.EAGER)
private List<Student> students;
回答by Biggy_java2
Adding the @ElementCollectionto the List field solved this issue:
添加@ElementCollection到列表字段解决了这个问题：
@Column
@ElementCollection(targetClass=Integer.class)
private List<Integer> countries;
回答by user2406031
@Access(AccessType.PROPERTY)
@OneToOne(cascade = CascadeType.ALL, fetch = FetchType.EAGER)
@JoinColumn(name="userId")
public User getUser() {
return user;
}
I have the same problems, I solved it by add @Access(AccessType.PROPERTY)
我有同样的问题，我通过添加解决了它 @Access(AccessType.PROPERTY)
回答by aaron stone
Don't worry! This problem occurs because of the annotation. Instead of Field based access, Property based access solves this problem. The code as follows:
别担心！出现此问题的原因是注释。代替基于字段的访问，基于属性的访问解决了这个问题。代码如下：
package onetomanymapping;
import java.util.List;
import javax.persistence.*;
@Entity
public class College {
private int collegeId;
private String collegeName;
private List<Student> students;
@OneToMany(targetEntity = Student.class, mappedBy = "college",
cascade = CascadeType.ALL, fetch = FetchType.EAGER)
public List<Student> getStudents() {
return students;
}
public void setStudents(List<Student> students) {
this.students = students;
}
@Id
@GeneratedValue
public int getCollegeId() {
return collegeId;
}
public void setCollegeId(int collegeId) {
this.collegeId = collegeId;
}
public String getCollegeName() {
return collegeName;
}
public void setCollegeName(String collegeName) {
this.collegeName = collegeName;
}
}
}
回答by JustCode
Problem with Access strategies
访问策略的问题
As a JPA provider, Hibernate can introspect both the entity attributes (instance fields) or the accessors (instance properties). By default, the placement of the
@Idannotation gives the default access strategy. When placed on a field, Hibernate will assume field-based access. Placed on the identifier getter, Hibernate will use property-based access.
作为 JPA 提供者，Hibernate 可以内省实体属性（实例字段）或访问器（实例属性）。默认情况下，
@Id注释的位置给出了默认的访问策略。当放置在一个字段上时，Hibernate 将承担基于字段的访问。放置在标识符 getter 上，Hibernate 将使用基于属性的访问。
Field-based access
基于字段的访问
When using field-based access, adding other entity-level methods is much more flexible because Hibernate won't consider those part of the persistence state
使用基于字段的访问时，添加其他实体级方法要灵活得多，因为 Hibernate 不会考虑持久状态的那些部分
@Entity
public class Simple {
@Id
private Integer id;
@OneToMany(targetEntity=Student.class, mappedBy="college",
fetch=FetchType.EAGER)
private List<Student> students;
//getter +setter
}
Property-based access
基于属性的访问
When using property-based access, Hibernate uses the accessors for both reading and writing the entity state
当使用基于属性的访问时，Hibernate 使用访问器来读取和写入实体状态
@Entity
public class Simple {
private Integer id;
private List<Student> students;
@Id
public Integer getId() {
return id;
}
public void setId( Integer id ) {
this.id = id;
}
@OneToMany(targetEntity=Student.class, mappedBy="college",
fetch=FetchType.EAGER)
public List<Student> getStudents() {
return students;
}
public void setStudents(List<Student> students) {
this.students = students;
}
}
But you can't use both Field-based and Property-based access at the same time. It will show like that error for you
但是您不能同时使用基于字段和基于属性的访问。它会为你显示类似的错误
For more idea follow this
有关更多想法，请遵循此
回答by sid
Though I am new to hibernate but with little research (trial and error we can say) I found out that it is due to inconsistency in annotating the methods/fileds.
虽然我是 hibernate 的新手，但经过很少的研究（我们可以说是反复试验），我发现这是由于注释方法/文件的不一致造成的。
when you are annotating @ID on variable make sure all other annotations are also done on variable only and when you are annotating it on getter method same make sure you are annotating all other getter methods only and not their respective variables.
当你在变量上注释@ID 时，确保所有其他注释也只对变量进行，当你在 getter 方法上注释它时，确保你只注释所有其他 getter 方法而不是它们各自的变量。
回答by jbppsu
In case anyone else lands here with the same issue I encountered. I was getting the same error as above:
万一其他人遇到我遇到的同样问题。我遇到了与上面相同的错误：
Invocation of init method failed; nested exception is org.hibernate.MappingException: Could not determine type for: java.util.Collection, at table:
init 方法调用失败；嵌套异常是 org.hibernate.MappingException：无法确定类型：java.util.Collection，在表中：
Hibernate uses reflection to determine which columns are in an entity. I had a private method that started with 'get' and returned an object that was also a hibernate entity. Even private getters that you want hibernate to ignore have to be annotated with @Transient. Once I added the @Transient annotation everything worked.
Hibernate 使用反射来确定实体中的哪些列。我有一个以“get”开头的私有方法，并返回一个也是休眠实体的对象。即使您希望休眠忽略的私有 getter 也必须使用 @Transient 进行注释。添加 @Transient 注释后，一切正常。
@Transient
private List<AHibernateEntity> getHibernateEntities() {
....
}
回答by Renato Vasconcellos
Just insert the @ElementCollection annotation over your array list variable, as below:
只需在数组列表变量上插入 @ElementCollection 注释，如下所示：
@ElementCollection
private List<Price> prices = new ArrayList<Price>();
I hope this helps
我希望这有帮助
回答by S.Dayneko
In my case it was stupid missing of @OneToOne annotation, i set @MapsId without it
在我的情况下，@OneToOne 注释的缺失是愚蠢的，我设置了 @MapsId 没有它
