Spring Boot is a framework that allows for fast and easy development of web applications based on Java. In this course, we will build a backend server using Spring Boot and implement a RESTful API through a blog creation example. Finally, we will also learn how to test the API execution.<\/p>\n
Spring Boot is a technology that enables easy and rapid application development based on the Spring Framework. Using Spring Boot reduces complex configurations and allows for easy testing through an embedded server.<\/p>\n
To use Spring Boot, you need a Java Development Kit (JDK) and a build tool like Maven or Gradle. Below are the installation methods for JDK and Maven.<\/p>\n
Install JDK version 8 or higher. You can download it from Oracle’s official website. After installation, check the installed version using the command below:<\/p>\n
java -version<\/code><\/pre>\n2.2 Installing Maven<\/h3>\n
Maven is used to manage the dependencies of Spring Boot projects. Download and install it from the official Apache Maven website. After installation, check the installed version using the command below:<\/p>\n
mvn -version<\/code><\/pre>\n2.3 Choosing an IDE<\/h3>\n
You can use IDEs such as IntelliJ IDEA, Eclipse, or Spring Tool Suite (STS). This course will explain using IntelliJ IDEA as the basis.<\/p>\n
3. Creating a Spring Boot Project<\/h2>\n
A Spring Boot project can be easily created using Spring Initializr. Spring Initializr is a web application that automatically generates the basic structure of a Spring Boot application.<\/p>\n
3.1 Accessing Spring Initializr<\/h3>\n
Access Spring Initializr through the link below:
\nSpring Initializr<\/a><\/p>\n3.2 Project Configuration<\/h3>\n\n- Project: Maven Project<\/li>\n
- Language: Java<\/li>\n
- Spring Boot: Select the latest version<\/li>\n
- Group: com.example<\/li>\n
- Artifact: blog-api<\/li>\n
- Name: blog-api<\/li>\n
- Description: Blog API example<\/li>\n
- Package name: com.example.blogapi<\/li>\n
- Packaging: Jar<\/li>\n
- Java: Select 11<\/li>\n<\/ul>\n
3.3 Adding Dependencies<\/h3>\n
Add the necessary dependencies. Add the following dependencies:<\/p>\n
\n- Spring Web<\/li>\n
- Spring Data JPA<\/li>\n
- H2 Database (or MySQL can be selected)<\/li>\n<\/ul>\n
After setting up, click the GENERATE<\/strong> button to download the ZIP file and unzip it in your desired location.<\/p>\n4. Understanding the Project Structure<\/h2>\n
The generated project folder structure is as follows:<\/p>\n
\nblog-api\n \u251c\u2500\u2500 src\n \u2502 \u251c\u2500\u2500 main\n \u2502 \u2502 \u251c\u2500\u2500 java\n \u2502 \u2502 \u2502 \u2514\u2500\u2500 com\n \u2502 \u2502 \u2502 \u2514\u2500\u2500 example\n \u2502 \u2502 \u2502 \u2514\u2500\u2500 blogapi\n \u2502 \u2502 \u2502 \u2514\u2500\u2500 BlogApiApplication.java\n \u2502 \u2502 \u2514\u2500\u2500 resources\n \u2502 \u2502 \u251c\u2500\u2500 application.properties\n \u2502 \u2502 \u2514\u2500\u2500 static\n \u2502 \u2514\u2500\u2500 test\n \u251c\u2500\u2500 pom.xml\n<\/code><\/pre>\n5. Creating a Domain Object<\/h2>\n
Now, let’s create a domain object to represent a blog post. We will create a Post<\/code> class to define the attributes of the blog post.<\/p>\n5.1 Creating the Post Class<\/h3>\n
Create a Post.java<\/code> file in the src\/main\/java\/com\/example\/blogapi<\/code> folder:<\/p>\n\npackage com.example.blogapi;\n\nimport javax.persistence.Entity;\nimport javax.persistence.GeneratedValue;\nimport javax.persistence.GenerationType;\nimport javax.persistence.Id;\n\n@Entity\npublic class Post {\n @Id\n @GeneratedValue(strategy = GenerationType.IDENTITY)\n private Long id;\n private String title;\n private String content;\n\n \/\/ getters and setters\n}\n<\/code><\/pre>\n6. Creating a Repository Interface<\/h2>\n
To interact with the database, we will use a JPA repository. Create a PostRepository<\/code> interface to implement CRUD functionality.<\/p>\n6.1 Creating the PostRepository Interface<\/h3>\n
Create a PostRepository.java<\/code> file in the src\/main\/java\/com\/example\/blogapi<\/code> folder:<\/p>\n\npackage com.example.blogapi;\n\nimport org.springframework.data.jpa.repository.JpaRepository;\n\npublic interface PostRepository extends JpaRepository {\n}\n<\/code><\/pre>\n7. Creating a Service Class<\/h2>\n
Create a service class to handle business logic. We will create a PostService<\/code> class to implement CRUD functionality for blog posts.<\/p>\n7.1 Creating the PostService Class<\/h3>\n
Create a PostService.java<\/code> file in the src\/main\/java\/com\/example\/blogapi<\/code> folder:<\/p>\n\npackage com.example.blogapi;\n\nimport org.springframework.beans.factory.annotation.Autowired;\nimport org.springframework.stereotype.Service;\nimport java.util.List;\n\n@Service\npublic class PostService {\n @Autowired\n private PostRepository postRepository;\n\n public List getAllPosts() {\n return postRepository.findAll();\n }\n\n public Post getPostById(Long id) {\n return postRepository.findById(id).orElse(null);\n }\n\n public Post createPost(Post post) {\n return postRepository.save(post);\n }\n\n public Post updatePost(Long id, Post post) {\n Post existingPost = postRepository.findById(id).orElse(null);\n if (existingPost != null) {\n existingPost.setTitle(post.getTitle());\n existingPost.setContent(post.getContent());\n return postRepository.save(existingPost);\n }\n return null;\n }\n\n public void deletePost(Long id) {\n postRepository.deleteById(id);\n }\n}\n<\/code><\/pre>\n8. Creating a Controller Class<\/h2>\n
To handle requests from clients, we write a controller class to create a RESTful API.<\/p>\n
8.1 Creating the PostController Class<\/h3>\n
Create a PostController.java<\/code> file in the src\/main\/java\/com\/example\/blogapi<\/code> folder:<\/p>\n\npackage com.example.blogapi;\n\nimport org.springframework.beans.factory.annotation.Autowired;\nimport org.springframework.http.HttpStatus;\nimport org.springframework.web.bind.annotation.*;\n\nimport java.util.List;\n\n@RestController\n@RequestMapping(\"\/api\/posts\")\npublic class PostController {\n @Autowired\n private PostService postService;\n\n @GetMapping\n public List getAllPosts() {\n return postService.getAllPosts();\n }\n\n @GetMapping(\"\/{id}\")\n public Post getPostById(@PathVariable Long id) {\n return postService.getPostById(id);\n }\n\n @PostMapping\n public Post createPost(@RequestBody Post post) {\n return postService.createPost(post);\n }\n\n @PutMapping(\"\/{id}\")\n public Post updatePost(@PathVariable Long id, @RequestBody Post post) {\n return postService.updatePost(id, post);\n }\n\n @DeleteMapping(\"\/{id}\")\n @ResponseStatus(HttpStatus.NO_CONTENT)\n public void deletePost(@PathVariable Long id) {\n postService.deletePost(id);\n }\n}\n<\/code><\/pre>\n9. Configuring Application Properties<\/h2>\n
Edit the application.properties<\/code> file to configure database connection and other settings.<\/p>\n9.1 H2 Database Configuration<\/h3>\n
Edit the src\/main\/resources\/application.properties<\/code> file as follows:<\/p>\n\n# H2 Database\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=\nspring.jpa.database-platform=org.hibernate.dialect.H2Dialect\n<\/code><\/pre>\n10. Running the Application<\/h2>\n
Now that all configurations are complete, run the BlogApiApplication.java<\/code> class in your IDE to start the application.<\/p>\n10.1 Accessing the H2 Console<\/h3>\n
If the application is running successfully, you can access the H2 console to check the database:<\/p>\n
\n- Access http:\/\/localhost:8080\/h2-console<\/a> in your web browser.<\/li>\n
- Enter JDBC URL:
jdbc:h2:mem:testdb<\/code> and click the Connect<\/strong> button.<\/li>\n<\/ul>\n11. Testing the API<\/h2>\n
Now let’s test the API using Postman or cURL.<\/p>\n
11.1 Installing Postman<\/h3>\n
Postman is a useful tool for testing APIs. After installing Postman, you can send requests as shown below.<\/p>\n
11.2 API Request Examples<\/h3>\n\n- GET \/api\/posts<\/strong>: Retrieve all posts<\/li>\n
- GET \/api\/posts\/{id}<\/strong>: Retrieve a specific post<\/li>\n
- POST \/api\/posts<\/strong>: Create a post<\/li>\n
- PUT \/api\/posts\/{id}<\/strong>: Update a post<\/li>\n
- DELETE \/api\/posts\/{id}<\/strong>: Delete a post<\/li>\n<\/ul>\n
11.2.1 Example of a POST Request:<\/h4>\n\nPOST \/api\/posts\nContent-Type: application\/json\n\n{\n \"title\": \"First Post\",\n \"content\": \"Hello, this is the first post.\"\n}\n<\/code><\/pre>\n11.2.2 Example of a GET Request:<\/h4>\n\nGET \/api\/posts\n<\/code><\/pre>\n12. Conclusion<\/h2>\n
In this course, we learned how to implement a simple blog API using Spring Boot. We set up domain objects, repositories, services, and controllers, and examined the process of testing the API using Postman.<\/p>\n
Now you have laid the foundation to create a blog API using Spring Boot. You can expand your knowledge by implementing more features, transitioning to different databases, learning about deployment methods, and more.<\/p>\n
References<\/h2>\n