Difference Between @Size, @Length, and @Column(length=value)

Last updated: February 20, 2026

Written by: baeldung

Reviewed by: Josh Cummings

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.

Distributed systems often come with complex challenges such as service-to-service communication, state management, asynchronous messaging, security, and more.

Dapr (Distributed Application Runtime) provides a set of APIs and building blocks to address these challenges, abstracting away infrastructure so we can focus on business logic.

In this tutorial, we'll focus on Dapr's pub/sub API for message brokering. Using its Spring Boot integration, we'll simplify the creation of a loosely coupled, portable, and easily testable pub/sub messaging system:

>> Flexible Pub/Sub Messaging With Spring Boot and Dapr

1. Overview

In this quick tutorial, we’ll take a look at JSR-330‘s @Size annotation, Hibernate‘s @Length annotation, and JPA‘s @Column‘s length attribute.

At first blush, these may seem the same, but they perform different functions.

2. Origins

Simply put, all of these annotations are meant to communicate the size of a field.

@Size and @Length are similar. We can use either annotation to validate the size of a field. The former is a Java-standard annotation, while the latter is specific to Hibernate.

@Column, though, is a JPA annotation that we use to control DDL statements.

Now let’s go through each of them in detail.

3. @Size

For validations, we’ll use @Size, a bean validation annotation. We’ll use the property middleName annotated with @Size to validate its value between the attributes min and max:

public class User {

    // ...

    @Size(min = 3, max = 15)
    private String middleName;

    // ...

}

Most importantly, @Size makes the bean independent of JPA and its vendors, such as Hibernate. As a result, it’s more portable than @Length.

4. @Length

As we previously mentioned, @Length is the Hibernate-specific version of @Size. We’ll enforce the range for lastName using @Length:

@Entity
public class User {

    // ...
      
    @Length(min = 3, max = 15)
    private String lastName;

    // ...

}

5. @Column(length=value)

@Column is quite different from the previous two annotations.

We’ll use @Column to indicate specific characteristics of the physical database column. We’ll use the length attribute of the @Column annotation to specify the string-valued column length:

@Entity
public class User {

    @Column(length = 3)
    private String firstName;

    // ...

}

The resulting column will be generated as a VARCHAR(3), and trying to insert a longer string will result in an SQL error.

Note that we’ll use @Column only to specify table column properties, as it doesn’t provide validations.

Of course, we can use @Column together with @Size to specify database column properties with bean validation:

@Entity
public class User {

    // ... 
    
    @Column(length = 5)
    @Size(min = 3, max = 5)
    private String city;

    // ...

}

6. Conclusion

In this article, we learned about the differences between the @Size annotation, @Length annotation, and @Column‘s length attribute. Then we examined each separately within the areas of their use.

The code backing this article is available on GitHub. Once you're logged in as a Baeldung Pro Member, start learning and coding on the project.