org.internate 를 선택합니다.Mapping Exception:java.util의 유형을 확인할 수 없습니다.표: College의 [org.hibernate.mapping]열 목록:열(학생)]

org.internate 를 선택합니다.Mapping Exception:java.util의 유형을 확인할 수 없습니다.표: College의 [org.hibernate.mapping]열 목록:열(학생)]

프로젝트의 모든 CRUD 작업에 Hibernate를 사용하고 있습니다.일대다와 다대일 관계에는 효과가 없습니다.아래와 같은 에러가 발생합니다.

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)]

인터넷에서 검색을 몇 개 실행했는데, 휴지 상태에서의 버그에 대해 말하는 사람도 있고, @Genecreated Value를 추가하면 이 에러는 클리어되지만, 나에게는 동작하지 않는 사람도 있습니다.

대학.자바

@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

@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:

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();
  }


}

콘솔:

 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)

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>

필드 액세스 전략(@Id 주석으로 결정)을 사용하고 있습니다.getter 속성 대신 각 필드 바로 위에 JPA 관련 주석을 배치합니다.

@OneToMany(targetEntity=Student.class, mappedBy="college", fetch=FetchType.EAGER)
private List<Student> students;

의 추가@ElementCollection[)]로 이했습니다.

    @Column
    @ElementCollection(targetClass=Integer.class)
    private List<Integer> countries;

액세스 전략의 문제

Hibernate는 JPA 프로바이더로서 엔티티 속성(인스턴스 필드) 또는 액세스자(인스턴스 속성)를 모두 조사할 수 있습니다." " " 의 입니다.@Id이치필드에 배치된 경우 휴지 상태는 필드 기반 액세스를 가정합니다.식별자 getter에 배치된 휴지 상태에서는 속성 기반 액세스가 사용됩니다.

필드 기반 액세스

필드 기반 액세스를 사용할 때 다른 엔티티 수준의 메서드를 추가하는 것이 훨씬 유연합니다. 왜냐하면 휴지 상태에서는 이러한 엔티티 수준의 메서드는 고려되지 않기 때문입니다.

@Entity
public class Simple {

@Id
private Integer id;

@OneToMany(targetEntity=Student.class, mappedBy="college", 
fetch=FetchType.EAGER)
private List<Student> students;

//getter +setter
}

속성 기반 액세스

속성 기반 액세스를 사용하는 경우 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;
}

}

그러나 필드 기반 액세스와 속성 기반 액세스를 동시에 사용할 수는 없습니다.이 오류와 같은 오류가 표시됩니다.

자세한 내용은 다음을 참조하십시오.

다음과 같이 배열 목록 변수 위에 @ElementCollection 주석을 삽입합니다.

@ElementCollection
private List<Price> prices = new ArrayList<Price>();

이게 도움이 됐으면 좋겠다

@Access(AccessType.PROPERTY)
@OneToOne(cascade = CascadeType.ALL, fetch = FetchType.EAGER)
@JoinColumn(name="userId")
public User getUser() {
    return user;
}

나도 같은 문제가 있어 추가해서 해결했어@Access(AccessType.PROPERTY)

내 경우 @OneToOne 주석이 없는 것이 바보같아서 @MapsId를 설정했습니다.

휴지기는 처음이지만 연구(시행착오라고 할 수 있음)가 거의 없기 때문에 메서드/필드에 주석을 다는 데 일관성이 없기 때문이라는 것을 알게 되었습니다.

변수에 @ID 주석을 다는 경우 다른 모든 주석도 변수에 대해서만 수행되도록 하고 getter 메서드에 주석을 다는 경우 해당 변수가 아닌 다른 모든 getter 메서드에만 주석을 달도록 하십시오.

걱정하지 마세요!이 문제는 주석 때문에 발생합니다.필드 기반 액세스 대신 속성 기반 액세스로 이 문제를 해결합니다.코드는 다음과 같습니다.

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;
}

}

내가 마주친 것과 같은 문제로 다른 누군가가 이곳에 도착할 경우를 대비해서.위와 같은 오류가 발생하였습니다.

init 메서드를 호출하지 못했습니다. 중첩된 예외는 org.hibernate입니다.Mapping Exception:java.util의 유형을 확인할 수 없습니다.컬렉션, 테이블:

휴지 상태에서는 반사를 사용하여 엔티티에 있는 열을 판별합니다.'get'으로 시작하는 개인 메서드를 사용하여 휴지 상태 엔티티이기도 한 개체를 반환했습니다.휴지 상태로 하고 싶은 프라이빗게터도 @Transient로 주석을 달아야 합니다.일단 @Transient 주석을 추가하자 모든 것이 작동했습니다.

@Transient 
private List<AHibernateEntity> getHibernateEntities() {
   ....
}

스키마 이름을 엔티티에 추가하면 엔티티가 검색합니다.날 위해 일했다!

여기에 나와 있는 솔루션 모두 효과가 없었습니다.그 이유는 다음과 같습니다.저는 자산 액세스 전략과 함께 엔티티 상속을 사용하고 있기 때문입니다.

@Entity(name = "spec")
@Inheritance(strategy = InheritanceType.SINGLE_TABLE)
@DiscriminatorFormula(value = "type")
public abstract class Spec extends BasicEntity { ... }

두 명의 상속인은 슈퍼클래스에 제시되지 않은 재산을 가지고 있다.상속자 중 한 명이 다음을 가지고 있습니다.JoinColumn그리고.OneToOne통합할 주석Basicattribute type usage (실제로 Intelij IDEA는 getter가 적절하지 않은 경우 필드를 강조 표시합니다)JoinColumn주석)을 클릭합니다.

@Data
@Entity
@DiscriminatorValue("data")
public class DataSpec extends Spec {

    private Payload payload;

    @OneToOne
    @NotFound(action = NotFoundAction.IGNORE)
    @JoinColumn(name = "payload_id")
    public Payload getPayload() {
        return payload;
    }

그러나 두 번째 상속자는 이 새 속성에 대한 주석이 없으며, IDEA는 이 문제에 대해 경고하기 위해 해당 속성을 강조 표시하지 않습니다.

@Data
@Entity
@DiscriminatorValue("blob")
public class BlobSpec extends Spec {

    private Payload payload;
  //^^^^^^^^^^^^^^^^^^^^^^^^ No getter with @JoinColumn! Should be highlighted with static code check!

휴지 상태 클래스를 디버깅하는 것만으로 문제를 분류할 수 있었습니다.엔티티가 검증에 합격하지 않은 것을 알게 되었습니다.MetadataImpl.validate방법.예외는 그것에 대해 말해주지 않는다.에러만 출력됩니다.spec자세한 내용은 아닙니다.

제거만 하면 됩니다.

@OneToMany(targetEntity=College.class, mappedBy="college", fetch=CollegeType의 mappedBy="college"입니다.열심)

이것으로 내 문제는 해결되었다.;)

같은 문제가 있었는데 id 필드에 @Id 주석을 지정하지 않은 것이 문제였습니다.

주석을 달자 모든 것이 순조롭게 진행되었다.

언급URL : https://stackoverflow.com/questions/3774198/org-hibernate-mappingexception-could-not-determine-type-for-java-util-list-at