Column mapping with @Column in Spring Boot - Step-by-Step Execution

Concept Flow - Column mapping with @Column

Define Entity Class

↓

Add @Entity Annotation

↓

Add Fields

↓

Annotate Fields with @Column

↓

Set Column Properties (name, length, nullable, etc.)

↓

Spring Boot Maps Fields to DB Columns

↓

Use Repository to Save/Retrieve Data

This flow shows how you define a Java class as an entity, annotate its fields with @Column to map to database columns, and then Spring Boot uses this mapping to interact with the database.

Execution Sample

Spring Boot

import jakarta.persistence.*;

@Entity
public class User {
  @Id
  @GeneratedValue(strategy = GenerationType.IDENTITY)
  private Long id;

  @Column(name = "user_name", length = 50, nullable = false)
  private String username;
}

Defines a User entity with a username field mapped to the 'user_name' column in the database with specific constraints.

Execution Table

Step	Action	Field	@Column Properties	Effect on DB Mapping
1	Read class User	-	-	Prepare entity mapping
2	Read field id	id	@Id, @GeneratedValue	Primary key, auto-generated
3	Read field username	username	name='user_name', length=50, nullable=false	Maps to 'user_name' column, max 50 chars, not null
4	Spring Boot creates DB schema	-	-	Creates table with columns 'id' and 'user_name' with constraints
5	Save User instance	username='alice'	-	Stores 'alice' in 'user_name' column
6	Retrieve User	-	-	Fetches data from 'user_name' column into username field
7	End	-	-	Mapping complete

💡 All fields mapped and database operations use these mappings

Variable Tracker

Variable	Start	After Step 3	After Step 5	Final
id	null	null	auto-generated (e.g., 1)	1
username	null	null	'alice'	'alice'

Key Moments - 3 Insights

Why do we use @Column(name = "user_name") instead of just naming the field 'user_name'?

The field name in Java can differ from the database column name. @Column(name = "user_name") tells Spring Boot exactly which DB column to map to, as shown in execution_table step 3.

What happens if we omit @Column on a field?

Spring Boot uses the field name as the column name by default. But you lose control over properties like length or nullability, which @Column lets you specify (see step 3).

How does nullable=false affect the database?

It adds a NOT NULL constraint to the column in the database, preventing null values. This is shown in step 4 where the schema is created with constraints.

Visual Quiz - 3 Questions

Look at the execution_table, what is the effect of @Column on the 'username' field at step 3?

A Makes the field optional and nullable

B Maps to 'username' column with default settings

C Maps to 'user_name' column with max 50 chars and not null

D Generates the primary key

💡 Hint

Check the '@Column Properties' and 'Effect on DB Mapping' columns at step 3

At which step does Spring Boot create the database schema with column constraints?

A Step 2

B Step 4

C Step 5

D Step 6

💡 Hint

Look for the step mentioning 'creates table with columns' in the execution_table

If we remove 'nullable=false' from @Column, what changes in the execution?

A The column will allow null values in the database

B The column name changes to 'username'

C The field becomes the primary key

D The length of the column is unlimited

💡 Hint

Refer to key_moments about nullable property and step 4 in execution_table

Concept Snapshot

Use @Column to map Java fields to DB columns.
Specify properties like name, length, nullable.
If omitted, defaults apply (field name as column).
Spring Boot uses these mappings to create schema and handle data.
Example: @Column(name="user_name", length=50, nullable=false)

Full Transcript

This visual execution shows how Spring Boot maps Java entity fields to database columns using the @Column annotation. First, the entity class is defined and annotated with @Entity. Each field can be annotated with @Column to specify the database column name and constraints like length and nullability. Spring Boot reads these annotations to create the database schema with the correct columns and constraints. When saving or retrieving data, Spring Boot uses this mapping to store and fetch values correctly. Key points include that @Column allows customizing the column name and constraints, and if omitted, defaults are used. The execution table traces each step from reading the class and fields, applying @Column properties, creating the schema, and performing data operations. This helps beginners see how the annotation controls database mapping in a clear step-by-step way.