Hello! In this course, we will understand the code of Spring Boot 3 and learn in detail about backend development methodologies. Spring Boot is a Java-based framework that helps you build web applications quickly and easily. Through this course, we will cover a wide range of topics from the basic concepts of Spring Boot to advanced features.<\/p>\n
Spring Boot is an extension of the Spring Framework and is a tool that makes it easier to set up and deploy traditional Spring applications. Typically, setting up a Spring application requires many configuration files and XML setups, but Spring Boot simplifies this process through Auto Configuration and Starter Dependencies.<\/p>\n
To use Spring Boot, you first need to set up the development environment. In this section, we will learn how to create a Spring Boot project.<\/p>\n
To start a Spring Boot project, you can use Spring Initializr. This web-based tool allows you to set up all the necessary dependencies.<\/p>\n
https:\/\/start.spring.io<\/code><\/pre>\nBy entering the project’s metadata and adding the required dependencies at the above link, you can download the basic skeleton of a Spring Boot project.<\/p>\n
3.2. IDE setup<\/h3>\n
Load the downloaded project into an IDE (Integrated Development Environment, e.g., IntelliJ IDEA or Eclipse). This process will automatically set up dependency management through Maven or Gradle.<\/p>\n
4. Spring Boot application structure<\/h2>\n
A Spring Boot project has the following structure:<\/p>\n
\ncom.example.demo\n\u251c\u2500\u2500 DemoApplication.java\n\u251c\u2500\u2500 controller\n\u2502 \u251c\u2500\u2500 HelloController.java\n\u251c\u2500\u2500 service\n\u2502 \u251c\u2500\u2500 HelloService.java\n\u2514\u2500\u2500 repository\n \u251c\u2500\u2500 HelloRepository.java\n<\/code><\/pre>\nEach folder serves the following roles:<\/p>\n
\n- controller<\/strong>: Contains controllers that handle client requests.<\/li>\n
- service<\/strong>: Contains service classes that handle business logic.<\/li>\n
- repository<\/strong>: Contains repositories that manage interactions with the database.<\/li>\n<\/ul>\n
5. Creating a basic web application<\/h2>\n
Now, let’s create a simple web application. This application will create a REST API that returns a “Hello, World!” message.<\/p>\n
5.1. HelloController.java<\/h3>\n
Write the controller class as follows:<\/p>\n
\npackage com.example.demo.controller;\n\nimport org.springframework.web.bind.annotation.GetMapping;\nimport org.springframework.web.bind.annotation.RestController;\n\n@RestController\npublic class HelloController {\n @GetMapping(\"\/hello\")\n public String sayHello() {\n return \"Hello, World!\";\n }\n}\n<\/code><\/pre>\n5.2. DemoApplication.java<\/h3>\n
The main application class is as follows:<\/p>\n
\npackage com.example.demo;\n\nimport org.springframework.boot.SpringApplication;\nimport org.springframework.boot.autoconfigure.SpringBootApplication;\n\n@SpringBootApplication\npublic class DemoApplication {\n public static void main(String[] args) {\n SpringApplication.run(DemoApplication.class, args);\n }\n}\n<\/code><\/pre>\n5.3. Running the application<\/h3>\n
Now run the application and enter http:\/\/localhost:8080\/hello<\/code> in your web browser to see the “Hello, World!” message.<\/p>\n6. Dependency management in Spring Boot<\/h2>\n
Spring Boot manages dependencies through Maven or Gradle. We will use Maven by default.<\/p>\n
6.1. Modifying pom.xml<\/h3>\n
Add the necessary dependencies to the project’s pom.xml<\/code> file. Below are the basic dependencies for a RESTful service:<\/p>\n\n<project xmlns=\"http:\/\/maven.apache.org\/POM\/4.0.0\"\n xmlns:xsi=\"http:\/\/www.w3.org\/2001\/XMLSchema-instance\"\n xsi:schemaLocation=\"http:\/\/maven.apache.org\/POM\/4.0.0 http:\/\/maven.apache.org\/xsd\/maven-4.0.0.xsd\">\n <modelVersion>4.0.0<\/modelVersion>\n\n <groupId>com.example<\/groupId>\n <artifactId>demo<\/artifactId>\n <version>0.0.1-SNAPSHOT<\/version>\n <packaging>jar<\/packaging>\n\n <name>demo<\/name>\n <description>Demo project for Spring Boot<\/description>\n\n <parent>\n <groupId>org.springframework.boot<\/groupId>\n <artifactId>spring-boot-starter-parent<\/artifactId>\n <version>3.0.0<\/version>\n <relativePath\/> <!-- lookup parent from repository -->\n <\/parent>\n\n <properties>\n <jdk.version>17<\/jdk.version>\n <\/properties>\n\n <dependencies>\n <dependency>\n <groupId>org.springframework.boot<\/groupId>\n <artifactId>spring-boot-starter-web<\/artifactId>\n <\/dependency>\n <\/dependencies>\n\n <build>\n <plugins>\n <plugin>\n <groupId>org.springframework.boot<\/groupId>\n <artifactId>spring-boot-maven-plugin<\/artifactId>\n <\/plugin>\n <\/plugins>\n <\/build>\n<\/project>\n<\/code><\/pre>\n7. Integrating with a database<\/h2>\n
You can implement simple CRUD (Create, Read, Update, Delete) functionality using Spring Boot. In this section, we will explain how to integrate with a database using H2.<\/p>\n
7.1. Adding H2 database dependency<\/h3>\n
The H2 database is an in-memory database suitable for testing and development. Add the following dependency to pom.xml<\/code>:<\/p>\n\n<dependency>\n <groupId>com.h2database<\/groupId>\n <artifactId>h2<\/artifactId>\n <scope>runtime<\/scope>\n<\/dependency>\n<\/code><\/pre>\n7.2. Database configuration<\/h3>\n
Now modify the application.properties<\/code> file to add the database configuration:<\/p>\n\nspring.h2.console.enabled=true\nspring.datasource.url=jdbc:h2:mem:testdb\nspring.datasource.driverClassName=org.h2.Driver\nspring.datasource.username=sa\nspring.datasource.password=\n<\/code><\/pre>\n7.3. Defining the entity class<\/h3>\n
Next, create a User entity class that can store simple user information:<\/p>\n
\npackage com.example.demo.model;\n\nimport jakarta.persistence.Entity;\nimport jakarta.persistence.GeneratedValue;\nimport jakarta.persistence.GenerationType;\nimport jakarta.persistence.Id;\n\n@Entity\npublic class User {\n @Id\n @GeneratedValue(strategy = GenerationType.IDENTITY)\n private Long id;\n\n private String name;\n\n private String email;\n\n \/\/ getters and setters\n}\n<\/code><\/pre>\n7.4. Creating the repository<\/h3>\n
Now define the UserRepository interface that provides CRUD functionality for the User entity:<\/p>\n
\npackage com.example.demo.repository;\n\nimport com.example.demo.model.User;\nimport org.springframework.data.jpa.repository.JpaRepository;\n\npublic interface UserRepository extends JpaRepository {\n}\n<\/code><\/pre>\n8. Implementing the RESTful API<\/h2>\n
Finally, let’s implement the CRUD API for the User entity.<\/p>\n
8.1. UserController.java<\/h3>\n
Write the controller that provides the RESTful API as follows:<\/p>\n
\npackage com.example.demo.controller;\n\nimport com.example.demo.model.User;\nimport com.example.demo.repository.UserRepository;\nimport org.springframework.beans.factory.annotation.Autowired;\nimport org.springframework.http.HttpStatus;\nimport org.springframework.http.ResponseEntity;\nimport org.springframework.web.bind.annotation.*;\n\nimport java.util.List;\n\n@RestController\n@RequestMapping(\"\/api\/users\")\npublic class UserController {\n\n @Autowired\n private UserRepository userRepository;\n\n @GetMapping\n public List getAllUsers() {\n return userRepository.findAll();\n }\n\n @PostMapping\n public ResponseEntity createUser(@RequestBody User user) {\n return new ResponseEntity<>(userRepository.save(user), HttpStatus.CREATED);\n }\n\n @GetMapping(\"\/{id}\")\n public ResponseEntity getUserById(@PathVariable(value = \"id\") Long userId) {\n return userRepository.findById(userId)\n .map(user -> new ResponseEntity<>(user, HttpStatus.OK))\n .orElse(new ResponseEntity<>(HttpStatus.NOT_FOUND));\n }\n\n @PutMapping(\"\/{id}\")\n public ResponseEntity updateUser(@PathVariable(value = \"id\") Long userId, @RequestBody User userDetails) {\n return userRepository.findById(userId)\n .map(user -> {\n user.setName(userDetails.getName());\n user.setEmail(userDetails.getEmail());\n return new ResponseEntity<>(userRepository.save(user), HttpStatus.OK);\n })\n .orElse(new ResponseEntity<>(HttpStatus.NOT_FOUND));\n }\n\n @DeleteMapping(\"\/{id}\")\n public ResponseEntity deleteUser(@PathVariable(value = \"id\") Long userId) {\n return userRepository.findById(userId)\n .map(user -> {\n userRepository.delete(user);\n return new ResponseEntity(HttpStatus.NO_CONTENT);\n })\n .orElse(new ResponseEntity<>(HttpStatus.NOT_FOUND));\n }\n}\n<\/Void><\/void><\/User><\/User><\/User><\/User><\/code><\/pre>\n9. Testing and deployment<\/h2>\n
Spring Boot allows you to perform tests using JUnit. Efficiently writing tests can enhance the quality of the application.<\/p>\n
9.1. Writing test code<\/h3>\n
Let’s write some simple test code:<\/p>\n
\npackage com.example.demo;\n\nimport com.example.demo.controller.UserController;\nimport com.example.demo.model.User;\nimport com.example.demo.repository.UserRepository;\nimport org.junit.jupiter.api.BeforeEach;\nimport org.junit.jupiter.api.Test;\nimport org.mockito.InjectMocks;\nimport org.mockito.Mock;\nimport org.mockito.MockitoAnnotations;\n\nimport static org.mockito.Mockito.*;\n\npublic class UserControllerTest {\n\n @InjectMocks\n private UserController userController;\n\n @Mock\n private UserRepository userRepository;\n\n @BeforeEach\n void setUp() {\n MockitoAnnotations.openMocks(this);\n }\n\n @Test\n void getAllUsers() {\n userController.getAllUsers();\n verify(userRepository, times(1)).findAll();\n }\n\n @Test\n void createUser() {\n User user = new User();\n user.setName(\"Test User\");\n when(userRepository.save(user)).thenReturn(user);\n\n userController.createUser(user);\n verify(userRepository, times(1)).save(user);\n }\n}\n<\/code><\/pre>\n9.2. Application deployment<\/h3>\n
Spring Boot applications can be packaged and deployed as standalone JAR files. You can build it using Maven:<\/p>\n
mvn clean package<\/code><\/pre>\nThen you can start the server by running the created JAR file located in the target<\/code> directory:<\/p>\njava -jar demo-0.0.1-SNAPSHOT.jar<\/code><\/pre>\n10. Spring Boot microservices architecture<\/h2>\n
Spring Boot is very useful for building a microservices architecture. You can build multiple independent services and configure them to communicate with each other.<\/p>\n
10.1. Advantages of microservices<\/h3>\n