1. Overview
In this short tutorial, we’ll shed light on how to fix the Hibernate exception: “AnnotationException: field is a @ManyToOne association and may not use @Column to specify column mappings (use @JoinColumn instead)”.
First, we’ll explain the root cause behind the exception. Then, we’ll illustrate using practical examples how to reproduce it and finally, how to fix it.
2. Understanding AnnotationException
Before jumping to the solution, let’s first break down the exception and its stack trace to understand what’s going on.
Hibernate relies on annotations to do all the heavy lifting of mapping Java classes to database tables. Typically, AnnotationException occurs when Hibernate has trouble understanding these annotations.
Furthermore, the message “is a @ManyToOne association and May Not Use @Column” signals that the @Column annotation is used where it doesn’t make sense. A common cause of this exception is decorating a field that is already mapped with @ManyToOne with @Column.
3. Reproducing AnnotationException
Now that we understand what triggers Hibernate’s AnnotationException, let’s dive in and recreate the exception ourselves.
First, let’s create the University JPA entity class:
@Entity
public class University {
@Id
private int id;
@Column(name = "university_name")
private String name;
// standard getters and setters
}
In a nutshell, each university has an identifier and a name. The @Entity annotation marks the University class as a JPA entity, and @Id specifies its primary key. Additionally, the @Column annotation maps the field name to its corresponding database column.
Next, we’ll create another entity class, Student:
@Entity
public class Student {
@Id
private int id;
@Column(name = "full_name")
private String fullName;
@ManyToOne
@Column(name = "university")
private University university;
// standard getters and setters
}
As we can see, the Student class shares a many-to-one association with the University class. Here, we pretend to use the @Column annotation alongside @ManyToOne. Now, let’s reproduce the exception using a test case:
@Test
void whenUsingColumnAnnotationWithManyToOneAnnotation_thenThrowAnnotationException() {
assertThatThrownBy(() -> {
HibernateUtil.getSessionFactory()
.openSession();
}).isInstanceOf(AnnotationException.class)
.hasMessageContaining("university' is a '@ManyToOne' association and may not use '@Column'");
}
As shown above, Hibernate fails with AnnotationException because we used @Column on a field that is marked with @ManyToOne, which is incorrect. This is because Hibernate requires a different annotation than @Column when describing columns related to joins.
4. Solution
As we saw earlier, AnnotationException occurs when we incorrectly try to use @Column on a field that denotes a @ManyToOne relationship. So, the simplest fix would be to use the @JoinColumn annotation instead.
First, let’s update the Student class to replace @Column with @JoinColumn:
@ManyToOne
@JoinColumn(name = "university_id")
private University university;
That way, we ensure that Hibernate properly maps the foreign key relationship, rather than treating it as a simple column. Next, let’s write another test case to verify that everything works correctly:
@Test
void whenNotUsingColumnAnnotationWithManyToOneAnnotation_thenCorrect() {
Session session = HibernateUtil.getSessionFactory()
.openSession();
Query<Student> query = session.createQuery("FROM Student", Student.class);
assertThat(query.list()).isEmpty();
session.close();
}
As expected, the test executes without issues, confirming our fix prevents the AnnotationException.
5. Conclusion
In this short article, we discussed what causes Hibernate to fail with the error: “AnnotationException: field is a @ManyToOne association and may not use @Column to specify column mappings (use @JoinColumn instead)”. Along the way, we demonstrated how to reproduce the exception in practice and how to solve it.
