Fixing Hibernate AnnotationException: Field Is a @ManyToOne Association and May Not Use @Column

Last updated: August 24, 2025

Written by: Abderrahim Azhrioun

Reviewed by: Josh Cummings

Persistence

Refactor Java code safely — and automatically — with OpenRewrite.

Refactoring big codebases by hand is slow, risky, and easy to put off. That’s where OpenRewrite comes in. The open-source framework for large-scale, automated code transformations helps teams modernize safely and consistently.

Each month, the creators and maintainers of OpenRewrite at Moderne run live, hands-on training sessions — one for newcomers and one for experienced users. You’ll see how recipes work, how to apply them across projects, and how to modernize code with confidence.

Join the next session, bring your questions, and learn how to automate the kind of work that usually eats your sprint time.

Regression testing is an important step in the release process, to ensure that new code doesn't break the existing functionality. As the codebase evolves, we want to run these tests frequently to help catch any issues early on.

The best way to ensure these tests run frequently on an automated basis is, of course, to include them in the CI/CD pipeline. This way, the regression tests will execute automatically whenever we commit code to the repository.

In this tutorial, we'll see how to create regression tests using Selenium, and then include them in our pipeline using GitHub Actions:, to be run on the LambdaTest cloud grid:

>> How to Run Selenium Regression Tests With GitHub Actions

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.