Spring Boot Annotations You Must Know for REST APIs

Spring Boot Annotations Explained for Freshers (REST API Focus)

Before the era of Spring Boot, Java developers spent hours wrestling with massive XML configuration files just to get a simple web application running. Spring Boot completely revolutionized this process by adopting an annotation-driven approach. Today, annotations are the steering wheel of your application—they dictate how your application bootstraps, how it routes HTTP traffic, how it manages memory through dependency injection, and how it communicates with your database.

For freshers and junior developers, memorizing a list of annotations is not enough to pass a technical interview. Senior engineers want to know that you understand the mechanics behind the annotations. This guide breaks down the most critical annotations by their architectural layers, explaining exactly what happens under the hood when the Spring container starts up.

What You Will Learn in This Guide:

• The exact internal composition of the application bootstrapping process.
• How REST annotations seamlessly convert Java objects into JSON payloads.
• Why certain Dependency Injection annotations are considered anti-patterns in modern enterprise applications.
• How to avoid the most common conceptual mistakes during technical interviews.

---

1️⃣ Application Bootstrapping and Configuration

@SpringBootApplication

Every Spring Boot application requires a starting point, traditionally housing the public static void main method. However, placing @SpringBootApplication at the top of this class does much more than simply start the program. It is actually a "meta-annotation" that silently combines three crucial Spring framework instructions into one:

• @Configuration: This tells the Spring container that this class can be used as a source of bean definitions. It allows you to declare @Bean methods that the application context will manage.
• @EnableAutoConfiguration: This is the magic engine of Spring Boot. It inspects your pom.xml or build.gradle classpath. If it sees Tomcat and Spring MVC on the classpath, it automatically configures a web server for you. If it sees Hibernate, it automatically configures a database connection pool.
• @ComponentScan: This instructs Spring to look for other components, configurations, and services starting from the package where this main class resides, and scanning recursively downwards through all sub-packages.

@SpringBootApplication
public class EmployeeManagementApplication {
  public static void main(String[] args) {
    SpringApplication.run(EmployeeManagementApplication.class, args);
  }
}

Interview Tip: A common interview question is, "Why isn't my Controller being detected by Spring?" The answer is almost always related to @ComponentScan. If your controller is located in a package that is structurally above or outside the package containing your @SpringBootApplication class, Spring will not scan it.

To deeply understand how Spring exposes these auto-configured beans at runtime for monitoring, check out our guide on Spring Boot Actuator explained.

---

2️⃣ The Web Layer: REST Controller Annotations

@RestController

In modern web development, backend systems are typically decoupled from the frontend (like Angular, React, or mobile apps). These frontends do not want HTML pages; they want raw data, usually formatted as JSON.

The @RestController annotation is specifically designed for this architecture. It is a convenience meta-annotation that combines @Controller and @ResponseBody. When you annotate a class with @RestController, you are telling Spring's DispatcherServlet that every single method inside this class will bypass the traditional ViewResolver (which looks for HTML/JSP templates). Instead, the returned Java object will be passed directly to an HttpMessageConverter (typically Jackson), serialized into JSON, and written straight into the HTTP response body.

@RestController
@RequestMapping("/api/v1/employees")
public class EmployeeController {

  private final EmployeeService service;

  public EmployeeController(EmployeeService service) {
    this.service = service;
  }

  @GetMapping
  public List<Employee> getAllEmployees() {
    // Jackson automatically converts this Java List into a JSON Array
    return service.getAll();
  }
}

---

HTTP Request Mapping: @GetMapping vs @PostMapping

REST APIs rely on standard HTTP verbs to determine the intent of a request. Spring provides specialized annotations to map these HTTP verbs to specific Java methods cleanly.

Annotation	HTTP Method	RESTful Purpose
@GetMapping	GET	Retrieve data without modifying the server state (Read).
@PostMapping	POST	Submit new data to be processed and stored (Create).
@PutMapping	PUT	Completely replace an existing resource with a new payload (Update).
@DeleteMapping	DELETE	Remove a resource from the server (Delete).

While you can technically use the older @RequestMapping(method = RequestMethod.GET), the shortcut annotations listed above drastically improve code readability and are the established standard in enterprise development.

---

Extracting Data: @PathVariable & @RequestBody

When a client sends a request to your API, they usually pass data along with it. Spring Boot provides annotations to seamlessly extract this data and bind it to Java variables.

@GetMapping("/{id}")
public Employee getEmployeeById(@PathVariable Long id) {
  // Extracts the 'id' directly from the URI path (e.g., /api/employees/101)
  return service.get(id);
}

@PostMapping
public Employee createEmployee(@RequestBody Employee employee) {
  // Deserializes the incoming JSON payload into the Employee Java object
  return service.save(employee);
}

To learn how to wrap these returned objects in proper HTTP status codes, read our comprehensive guide on Returning JSON responses in Spring Boot.

---

3️⃣ The Core Layer: Dependency Injection Annotations

The Evolution of @Autowired

Dependency Injection is the heart of the Spring Framework (Inversion of Control). When one class needs another to function (e.g., a Controller needing a Service), Spring injects it automatically. Historically, developers used @Autowired directly on the fields.

// ANTI-PATTERN: Field Injection
@Autowired
private EmployeeService service;

Best Practice & Interview Gold: Field injection is now widely considered an anti-pattern. It prevents you from declaring fields as final, making your beans mutable. It also makes unit testing difficult because you cannot instantiate the class without using a dependency injection framework or complex reflection.

The Modern Solution: Constructor Injection. If a class has only one constructor, Spring Boot automatically injects the dependencies without even needing the @Autowired annotation. This allows you to mark your fields as final, ensuring immutability and thread safety.

// INDUSTRY STANDARD: Constructor Injection
@RestController
public class EmployeeController {
    
  private final EmployeeService service;

  // @Autowired is optional here in modern Spring Boot
  public EmployeeController(EmployeeService service) {
    this.service = service;
  }
}

---

Layered Stereotypes: @Component, @Service, @Repository

Spring uses "stereotype" annotations to categorize beans based on their architectural role. While they all technically register a bean in the Application Context just like @Component, using the specific semantic annotation is crucial for clarity and advanced framework features.

Annotation	Architectural Layer	Under-the-Hood Behavior
@Component	Generic/Utility	Registers a standard, generic Spring-managed bean.
@Service	Business Logic	Acts as a marker for domain logic; often the layer where @Transactional boundaries are defined.
@Repository	Data Access (DAO)	Automatically translates raw, vendor-specific database exceptions (like an Oracle SQL error) into Spring's unified DataAccessException hierarchy.

---

4️⃣ The Persistence Layer: JPA & Database Annotations

When interacting with databases, Spring Boot typically utilizes Spring Data JPA and Hibernate. Annotations in this layer dictate how Java objects map to relational database tables.

@Entity
@Table(name = "corporate_employees")
public class Employee {

  @Id
  @GeneratedValue(strategy = GenerationType.IDENTITY)
  private Long id;

  @Column(nullable = false, length = 100)
  private String name;
  
  @Column(unique = true)
  private String email;
}

In this snippet, @Entity marks the class as a JPA manageable entity, while @Table allows you to specify exact database configurations. @Id denotes the primary key, and @GeneratedValue instructs the database to handle the auto-incrementing of that key.

If you are new to Object-Relational Mapping, read our beginner-friendly guide: Spring Boot + JPA Basics for Freshers.

---

5️⃣ Architectural Request Flow

To truly master Spring Boot, you must understand how these annotations hand off data to one another during a live HTTP request. When a user requests data, the flow looks like this:

1. HTTP GET Request arrives at Tomcat server.
2. DispatcherServlet routes it to the matching @RestController method.
3. Controller extracts data using @PathVariable / @RequestBody.
4. Controller delegates business logic to the @Service layer via Constructor Injection.
5. @Service layer calls the @Repository layer.
6. @Repository translates the request into an SQL query via @Entity mappings.
7. Data flows back up, and the @RestController uses Jackson to serialize the response into JSON.

---

6️⃣ Common Fresher Mistakes to Avoid in Interviews

• Overusing @Component: Do not use @Component for your DAOs or Services. Always use the semantically correct @Repository and @Service so the framework applies the correct proxy behaviors (like exception translation).
• Bypassing the Service Layer: Never inject a @Repository directly into a @RestController. The controller should only handle HTTP routing; business logic and transaction management belong strictly in the @Service.
• Exposing Entities: Do not return @Entity objects directly from your REST API. This exposes your database schema to the client and can cause infinite recursion issues with JSON serialization. Always map Entities to Data Transfer Objects (DTOs) before returning them.
• Ignoring Global Exception Handling: Relying on standard try-catch blocks in every controller method is an anti-pattern. Use @ControllerAdvice for robust error management. (See: Global Exception Handling in Spring Boot).

---

Final Summary

• Annotations define the fundamental behavior, routing, and memory management of Spring Boot applications.
• Understanding why an annotation is used (e.g., avoiding field injection, understanding Jackson serialization) proves senior-level comprehension.
• Maintaining a strict separation of concerns through layered annotations (Controller → Service → Repository) is the key to passing enterprise technical interviews.

By mastering the architecture behind these annotations, you transition from someone who just writes code to someone who designs robust, scalable backend systems.

🏷️ Master REST API Annotations in Spring Boot

Spring Boot REST annotations define how HTTP requests are mapped, validated, and converted into JSON responses. Strengthen your understanding of REST API development by exploring these closely related interview topics.

🌐 Controller vs RestController

Deep dive into the ViewResolver mechanism and understand exactly when to use @Controller vs @RestController in production.

🔄 Returning JSON Responses

Learn how REST annotations interact with HttpMessageConverters to enable automatic JSON serialization.

✅ REST API Validation Annotations

Protect your database by validating request bodies, path variables, and query parameters before they hit your service layer.

🧩 Custom Validation Annotations

Create reusable, robust custom validation annotations for clean and maintainable API architectures.

🚨 Global Exception Handling

Handle REST API errors gracefully and consistently across your entire application using @ControllerAdvice.

🧩 Spring Boot CRUD API Example

See all of these core REST annotations utilized together in a real-world, end-to-end CRUD application.

🎓 Interview Questions (Freshers)

Review the 50 most frequently asked technical interview questions surrounding basic REST annotations and architecture.

💼 Interview Questions (2–5 Years)

Transition from fresher to intermediate with real-world interview discussions on REST API design and architectural trade-offs.