Create Spring Boot Project in Intellij | Create Spring Boot Project with Spring Initializr

Creating a Spring Boot Project in IntelliJ

Introduction to Spring Boot and IntelliJ

• The video focuses on creating a Spring Boot project using IntelliJ, following an overview of Spring Boot's basics from the previous video.

• The presenter prefers IntelliJ due to its active development team and smooth user interface.

Using Spring Initializer

• Spring Initializer is introduced as a convenient web tool for configuring and creating Spring Boot projects.

• Maven is selected as the build tool, which automates tasks like compiling, testing, and packaging applications into JAR or WAR files.

Project Configuration

• Key project metadata includes group name (e.g., eDigest), artifact name (e.g., My first project), description, and Java version (Java 8).

• Dependencies are explained as pre-written code that can be added to avoid manual coding; for example, adding Spring Web for API creation.

Understanding Packaging Options

• The difference between JAR (Java Archive) and WAR (Web Application Archive) is clarified; JAR files run directly while WAR files require deployment on an external server.

• After configuration, generating the project results in downloading a zip file that needs extraction before being imported into IntelliJ.

Importing the Project into IntelliJ

• Once extracted, the folder can be dragged into IntelliJ. Potential errors may arise upon import requiring adjustments in project settings.

• It's important to ensure that the Java version selected matches or exceeds what was set during project creation.

Running the Application

• The application is run successfully with logs indicating that it has started correctly along with displaying the selected Spring Boot version.

Starting the Application and Understanding PID

Initial Setup

• The application has successfully started, indicating it is running on Java 11 with a Process ID (PID) of 18873. This PID helps identify the specific process within the operating system.

• The speaker notes that there are multiple processes running on the operating system, highlighting the complexity of managing applications.

Exploring Tomcat and Spring Boot Context Path

Tomcat Version and Project Creation

• The absence of active profiles is acknowledged, but it's not seen as an issue at this stage. Tomcat's version is confirmed to be operational, which is essential for running Spring Boot applications.

• The context path will be examined later; however, it’s established that a Spring Boot project has been created successfully.

Creating an API Endpoint in Spring Boot

Developing a Simple Controller

• A new class is being created to serve as an API endpoint using minimal code—just two lines are needed to set up a basic structure for an API.

• The @RestController annotation is introduced, which designates the class as a RESTful controller in Spring Boot applications. This annotation allows handling HTTP requests effectively.

Implementing Method and Mapping

Defining Functionality

• A method named sayHello is defined within the controller, returning a simple string "hello." This demonstrates how to create basic functionality in an API endpoint.

• The @GetMapping annotation is applied to specify that this method responds to GET requests at a designated URL path (e.g., /hello or /ABC). Running this setup confirms that it works correctly when accessed via localhost on port 8080.

Understanding Context Path in Detail

Clarifying Context Path Usage

• It’s explained that accessing localhost:8080/ABC returns "hello," showcasing how APIs can be structured under different paths without needing additional context paths initially set up in this case.