Solving org.hibernate.AnnotationException: Illegal Attempt to Map a Non Collection

Last updated: July 19, 2026

Written by: Andrei Branza

Reviewed by: David Martinez

Persistence

Hibernate

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.

1. Introduction

When we map entity relationships with Hibernate, a small mistake in a field declaration can prevent our application from booting up. A common example is the “org.hibernate.AnnotationException: Illegal attempt to map a non collection as a @OneToMany, @ManyToMany or @CollectionOfElements” error.

In this tutorial, we’ll look at why Hibernate throws this exception. Next, we’ll reproduce it with a simple mapping and walk through a couple of ways to fix it.

2. Understanding the Exception

Hibernate expects any field annotated with @OneToMany, @ManyToMany or @ElementCollection to be a collection-valued association. In practice, this means we must declare the field using one of the collection interfaces it recognizes:

Collection or List: an ordered group that allows duplicate elements
Set: a group that contains only unique elements
Map: a set of key-value pairs, useful for associations based on keys

The reason for this requirement is that Hibernate manages these collections with its own implementation. When we persist an entity, Hibernate replaces that field value with a proxy that supports lazy loading and dirty checking. It can only do that if the field type is an interface it controls.

As such, when the annotation is used on a field that isn’t one of these interfaces, Hibernate can’t build that proxy. Therefore, it fails fast during startup and throws the AnnotationException.

3. Reproducing the Exception

Let’s reproduce the problem with a classic parent-child mapping. First, let’s define a Comment entity:

@Entity
public class Comment {
    @Id
    @GeneratedValue
    private Long id;
    private String text;

    // getters and setters
}

Now, let’s create a Post entity that owns many comments. Here, purposely declare the field with the concrete ArrayList type:

@Entity
public class Post {
    @Id
    @GeneratedValue
    private Long id;

    @OneToMany
    private ArrayList<Comment> comments = new ArrayList<>();

    // getters and setters
}

When Hibernate scans this mapping during building of the metadata at startup, it throws: org.hibernate.AnnotationException: Illegal attempt to map a non collection as a @OneToMany, @ManyToMany or @CollectionOfElements: com.baeldung.Post.comments

Note that newer Hibernate versions phrase the same message with @ElementCollection instead of the legacy @CollectionOfElements, but the cause is identical.

Even though ArrayList is technically a list, Hibernate rejects it because it’s a concrete class rather than a collection interface.

4. Fixing the Mapping

The fix is straightforward: we declare the field using a collection interface instead of the implementation. So, let’s change the type from ArrayList to List:

@Entity
public class Post {
    @Id
    @GeneratedValue
    private Long id;

    @OneToMany
    private List<Comment> comments = new ArrayList<>();

    // getters and setters
}

We should notice that we still initialize the field with new ArrayList<>(). That’s not a problem, because only the type of the declared field needs to be an interface. Hibernate will switch the value for its own implementation once the entity becomes managed.

We can apply the same rule to the other annotations. For instance, a Set pairs well with @ManyToMany when we want to avoid duplicates. @ElementCollection accepts any of the standard collection interfaces. The thing to remember is that the compile time type of the field must be an interface, not the class we assign to it.

Now, when it comes to which interface to pick, a List is the common default when order or duplicates matter, while a Set is a good fit when each element must be unique. Either way, the mapping stays valid as long as the field type remains an interface.

We can encounter the same exception when we place a collection annotation on a single-valued field. For instance, a comment belongs to exactly one post, so we might mistakenly write:

@Entity
public class Comment {
    @Id
    @GeneratedValue
    private Long id;

    @OneToMany
    private Post post;
}

In this case, post holds a single Post, not a collection, so Hibernate throws the same AnnotationException. However, in this case, switching to an interface type won’t help, since the relationship itself is incorrectly modeled.

Instead, we should choose the annotation that matches the cardinality. Considering that many comments map to a single post, @ManyToOne is the correct choice:

@Entity
public class Comment {
    @Id
    @GeneratedValue
    private Long id;

    @ManyToOne
    private Post post;
}

Similarly, if the field represents a one-to-one association, we’d choose @OneToOne instead.

This also ties together the two fixes we’ve seen. In a bidirectional relationship, the @ManyToOne side is the owner of the association, while the Post entity maps the inverse side with @OneToMany(mappedBy = “post”). Here, the @OneToMany field is still a List, and the @ManyToOne field is still a single reference. As such, each annotation matches the type it is assigned to and Hibernate build the mapping without complaints.

6. Conclusion

In this article, we’ve looked at the Hibernate AnnotationException that warns us about mapping an improper type.

The root of the problem is a mismatch between an annotation and a field type. When we use @OneToMany, @ManyToMany, or @ElementCollection, the field must be a collection interface like List or Set, and not a concrete class such as ArrayList. And when the field actually holds a single reference, we should reach for @ManyToOne or @OneToOne instead.

By matching the annotation to the field’s cardinality and always declaring collections through their interface, we keep our mappings valid and let Hibernate deal with their management.

As always, the code is available over on Github.