Spring Boot / Controllers

We have developed an application which can connect to db and performs crud operations so far. While inserting new records to db, we used a listener to understand if the app is up and running. As soon as app is ready, we inserted new records automatically. Is this a proper way to insert the data to db? For some purposes, we can use this approach like inserting predefined config data or testing data etc. If we are planning this app to be interacted with a user, all apps have some users, we need to develop a mechanism to interact with user.

I am planning to drive our application to be a web application. We have some design patterns for application development in the market and some of them are widely accepted, named MVC. MVC stands for Model-View-Controller. We will see how to create the most basic controller in spring boot, then you can have a look this post to understand mvc.

In order to interact with our application, we will develop a controller using Spring Web Starter.

Version Update

Before starting application application I decided to update my code base and Spring version. I updated the Spring parent project to be 3.0.0 and apparently we have some major changes.

I simply changed the following part of pom file.

<parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>3.0.0</version>
        <relativePath /> <!-- lookup parent from repository -->
    </parent>

For the following packages which are based on javax.persistance.* we need to update the packages to jakarta.persistence.*

import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.ManyToOne;

import jakarta.persistence.Entity;
import jakarta.persistence.FetchType;
import jakarta.persistence.GeneratedValue;
import jakarta.persistence.GenerationType;
import jakarta.persistence.Id;
import jakarta.persistence.JoinColumn;
import jakarta.persistence.ManyToOne;

You can follow the instructions that your IDE gives you.

Start Developing

First, since we are developing a web application we need spring-boot-strater-web to add to our maven dependency in pom file.

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

Next step is creating a class file named FlightController in the controller package of our application.

Sure, I’d be happy to help you write an article about Spring Boot controllers for APIs.

Why use a controller in a Spring Boot API?

At its core, a Spring Boot application is a collection of classes that work together to handle incoming requests and generate responses. Controllers are a critical part of this process, as they are responsible for receiving requests from clients and returning appropriate responses.

There are a number of reasons why controllers are an essential component of any Spring Boot API. For one, they help to organize and structure your code in a way that makes it easy to maintain and modify. By encapsulating request handling logic in a separate controller class, you can keep your code modular and easy to work with.

Another key benefit of using controllers in a Spring Boot API is that they allow you to define clear and consistent API endpoints. By mapping incoming requests to specific controller methods, you can ensure that clients know exactly how to interact with your API, and you can make it easy to add new endpoints as your application evolves.

Example: Creating a simple Spring Boot controller

To demonstrate how controllers work in a Spring Boot API, let’s walk through an example of how to create a simple controller that handles HTTP requests.

Now, we’ll create a new Java class called HelloController. This class will be responsible for handling incoming requests and generating responses. Here’s what the class should look like:

@RestController
public class HelloController {

    @GetMapping("/hello")
    public String sayHello() {
        return "Hello, world!";
    }
}

In this example, we’ve defined a new controller class that handles GET requests to the “/hello” endpoint. When a client sends a GET request to this endpoint, the sayHello() method will be called, which simply returns the string “Hello, world!”.

Note that we’ve annotated our class with @RestController. This tells Spring Boot that this class should be treated as a controller and that its methods should be used to handle incoming requests.

To test our new controller, we can start up our Spring Boot application and navigate to http://localhost:8080/hello in our web browser. We should see the message “Hello, world!” displayed on the screen.

Conclusion

In this article, we’ve explored the role of controllers in a Spring Boot API and walked through an example of how to create a simple controller to handle HTTP requests. By using controllers to organize your code and define clear API endpoints, you can create a well-structured and maintainable API that’s easy to work with.

Of course, this is just a basic example of what you can do with Spring Boot controllers. There are many other features and capabilities you can explore, such as handling request parameters, working with JSON data, and more.

By leveraging the power of Spring Boot and its built-in support for controllers, you can create powerful and scalable APIs with ease. Whether you’re building a small prototype or a large-scale enterprise application, Spring Boot provides the tools and features you need to get the job done.