@GetMapping Spring Boot Example

In this tutorial, we will learn how to use @GetMapping annotation in a Spring Boot application to handle HTTP GET requests.

@GETMapping Annotation Overview

The GET HTTP method is used to get a single resource or multiple resources and @GetMapping annotation for mapping HTTP GET requests onto specific handler methods. 

Specifically, @GetMapping is a composed annotation that acts as a shortcut for @RequestMapping(method = RequestMethod.GET).

@GetMapping annotation takes the following optional elements 

consumes – Narrows the primary mapping by media types that can be consumed by the mapped handler.

headers – The headers of the mapped request, narrowing the primary mapping. 

name – Assign a name to this mapping. 

params – The parameters of the mapped request, narrowing the primary mapping. 

path – The primary mapping expressed by this annotation. 

produces – Narrows the primary mapping by media types that can be produced by the mapped handler. 

value – The primary mapping expressed by this annotation.

@GetMapping Annotation Example

Let's build a simple Spring Boot project using IntelliJ IDEA to demonstrate the usage of @GetMapping annotation. 

We will use Spring Data JPA to develop a repository layer and MySQL database at the backend. We will use the Postman client to test the REST API.

1. Create a Spring boot application

Spring Boot provides a web tool called Spring Initializer to bootstrap an application quickly. Just go to https://start.spring.io/ and generate a new spring boot project.

While generating the Spring Boot Project, make sure that you have added the following Maven dependencies:

		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-data-jpa</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-web</artifactId>
		</dependency>

		<dependency>
			<groupId>com.mysql</groupId>
			<artifactId>mysql-connector-j</artifactId>
			<scope>runtime</scope>
		</dependency>
		<dependency>
			<groupId>org.projectlombok</groupId>
			<artifactId>lombok</artifactId>
			<optional>true</optional>
		</dependency>

Download the Spring Boot project as a zip file, unzip it, and import it into IntelliJ IDEA.

2. Configure MySQL Database

Since we’re using MySQL as our database, we need to configure the database URL, username, and password so that Spring can establish a connection with the database on startup. 

Open the src/main/resources/application.properties file and add the following properties to it:

spring.datasource.url=jdbc:mysql://localhost:3306/todo_management
spring.datasource.username=root
spring.datasource.password=Mysql@123

spring.jpa.properties.hibernate.dialect = org.hibernate.dialect.MySQLDialect

spring.jpa.hibernate.ddl-auto = update

Don’t forget to change the spring.datasource.username and spring.datasource.password as per your MySQL installation. Also, create a database named todo_management in MySQL before proceeding to the next section.

You don’t need to create any tables. The tables will automatically be created by Hibernate from the Todo entity that we will define in the next step. This is made possible by the property spring.jpa.hibernate.ddl-auto = update.

3. Create Model Layer - Todo JPA Entity

Let's create a class named Todo and add the following content to it:

import jakarta.persistence.*;
import lombok.AllArgsConstructor;
import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.Setter;

@Setter
@Getter
@NoArgsConstructor
@AllArgsConstructor
@Entity
@Table(name = "todos")
public class Todo {

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

    @Column(nullable = false)
    private String title;

    @Column(nullable = false)
    private String description;
    private boolean completed;
}

@Setter, @Getter, @NoArgsConstructor, and @AllArgsConstructor annotations are provided by the Lombok library and are used to generate getter and setter methods, a no-argument constructor, and an all-arguments constructor for the class.

The @Entity annotation indicates that the class is an entity in JPA, representing a table in a relational database. 

The @Table annotation specifies the name of the table that corresponds to this entity. In this case, the table name is "todos".

The @Id annotation marks the field id as the primary key for the entity. 

The @GeneratedValue annotation specifies the strategy for generating the primary key values. In this case, the GenerationType.IDENTITY strategy is used, which indicates that the database will automatically assign a unique identifier to each new entity.

The @Column annotation is used to specify the mapping of the field title to a column in the database table.

4. Create Repository Layer - TodoRepository

Now, we gonna create a Spring Data JPA repository to talk with the MySQL database. Let's create the following TodoRepository interface and add the following content to it:

import net.javaguides.todo.entity.Todo;
import org.springframework.data.jpa.repository.JpaRepository;

public interface TodoRepository extends JpaRepository<Todo, Long> {
}

5. Create DTO Class - TodoDto

Let's create TodoDto class to transfer the data between the client and server:

import lombok.AllArgsConstructor;
import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.Setter;

@Setter
@Getter
@NoArgsConstructor
@AllArgsConstructor
public class TodoDto {

    private Long id;
    private String title;
    private String description;
    private boolean completed;
}

Note that we will be using TodoDto class in the request and response of the REST APIs.

6. Custom Exception - ResourceNotFoundException

Let's create ResourceNotFoundException that we will create and throw whenever a resource with a given id does not exist in the database.

import org.springframework.http.HttpStatus;
import org.springframework.web.bind.annotation.ResponseStatus;

@ResponseStatus(value = HttpStatus.NOT_FOUND)
public class ResourceNotFoundException extends RuntimeException{

    public ResourceNotFoundException(String message) {
        super(message);
    }
}

7. Create Service Layer - TodoService interface and TodoServiceImpl class

TodoService interface

Let's create a TodoService interface and add the following code to it:

import net.javaguides.todo.dto.TodoDto;

import java.util.List;

public interface TodoService {

    TodoDto getTodo(Long id);

    List<TodoDto> getAllTodos();
}

TodoServiceImpl class

Let's create a TodoServiceImpl class that implements the TodoService interface and its method:

import lombok.AllArgsConstructor;
import net.javaguides.todo.dto.TodoDto;
import net.javaguides.todo.entity.Todo;
import net.javaguides.todo.exception.ResourceNotFoundException;
import net.javaguides.todo.repository.TodoRepository;
import net.javaguides.todo.service.TodoService;

import org.springframework.stereotype.Service;

import java.util.List;
import java.util.stream.Collectors;

@Service
@AllArgsConstructor
public class TodoServiceImpl implements TodoService {

    private TodoRepository todoRepository;

    @Override
    public TodoDto getTodo(Long id) {

        Todo todo = todoRepository.findById(id)
                .orElseThrow(() -> new ResourceNotFoundException("Todo not found with id:" + id));

        return mapToTodoDto(todo);
    }

    @Override
    public List<TodoDto> getAllTodos() {

        List<Todo> todos = todoRepository.findAll();

        return todos.stream().map((todo) -> mapToTodoDto(todo))
                .collect(Collectors.toList());
    }

    private TodoDto mapToTodoDto(Todo todo){
        TodoDto todoDto = new TodoDto();
        todoDto.setId(todo.getId());
        todoDto.setTitle(todo.getTitle());
        todoDto.setDescription(todo.getDescription());
        todoDto.setCompleted(todo.isCompleted());
        return todoDto;
    }
}

8. Controller Layer - TodoController

Let's create TodoController class and build GET REST APIs that handle HTTP GET requests:

import lombok.AllArgsConstructor;
import net.javaguides.todo.dto.TodoDto;
import net.javaguides.todo.service.TodoService;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;

import java.util.List;

@RestController
@RequestMapping("api/todos")
@AllArgsConstructor
public class TodoController {

    private TodoService todoService;

    // Build Get Todo REST API
    @GetMapping("{id}")
    public ResponseEntity<TodoDto> getTodo(@PathVariable("id") Long todoId){
        TodoDto todoDto = todoService.getTodo(todoId);
        return new ResponseEntity<>(todoDto, HttpStatus.OK);
    }

    // Build Get All Todos REST API
    @GetMapping
    public ResponseEntity<List<TodoDto>> getAllTodos(){
        List<TodoDto> todos = todoService.getAllTodos();
        //return new ResponseEntity<>(todos, HttpStatus.OK);
        return ResponseEntity.ok(todos);
    }
}

The @RestController annotation is used to indicate that this class is a REST controller, which means it handles incoming HTTP requests and returns the corresponding responses. 

The @RequestMapping annotation specifies the base URL path for all the request mappings defined within this controller.

The @AllArgsConstructor annotation is provided by the Lombok library and generates a constructor with arguments for the class.

The @GetMapping annotation is used to HTTP GET requests to specific handler methods.

9. Start Spring Boot Application and Test GET REST APIs

Test Get Todo REST API:

Let's use Get Todo REST API to get a single Todo object from the database:

Test Get All Todos REST API:

Let's use Get All Todos REST API to get a all Todos from the database:

10. Conclusion

In summary, this blog post showcased an example of using the @GetMapping annotation in a Spring Boot application. The @GetMapping annotation is used to handle HTTP GET requests and retrieve data from RESTful APIs. 

By leveraging the power of the @GetMapping annotation, the Spring Boot application was able to handle GET requests efficiently and provide the requested data as a response. 

Related Spring and Spring Boot Annotations

• Spring Boot @Bean Annotation Example
• Spring @Qualifier Annotation Example
• Spring @Autowired Annotation with Example
• Spring @Bean Annotation with Example
• Spring @Configuration Annotation with Example
• Spring @PropertySource Annotation with Example
• Spring @Import Annotation with Example
• Spring @ImportResource Annotation Example
• Spring - @Lazy Annotation Example
• Spring - @Primary Annotation Example
• Spring @PostConstruct and @PreDestroy Example
• Spring @Repository Annotation
• Spring @Service Annotation 
• The Spring @Controller and @RestController Annotations
• Spring Boot @Component, @Controller, @Repository and @Service
• Spring @Scope annotation with Prototype Scope Example
• Spring @Scope annotation with Singleton Scope Example
• Spring Boot @PathVariable
• Spring Boot @ResponseBody
• Spring @RequestBody - Binding Method Parameters to Request Body
• Spring Boot @ResponseStatus Annotation
• Spring Boot - Creating Asynchronous Methods using @Async Annotation
• @SpringBootTest Spring Boot Example
• @SpringBootTest vs @WebMvcTest
• @DataJpaTest Spring Boot Example
• Spring @PostConstruct and @PreDestroy Example
• Spring @GetMapping, @PostMapping, @PutMapping, @DeleteMapping and @PatchMapping
• Spring Boot @EnableAutoConfiguration Annotation with Example
• Spring Boot @SpringBootApplication Annotation with Example