DEV Community: Piyush Kulkarni

Spring boot learning by doing

Piyush Kulkarni — Sat, 26 Sep 2026 07:00:54 +0000

In a previous post, I used a linked list to create a CRUD application. However, to save data permanently, a linked list is not sufficient; you need to utilize a database, which will allow data to persist even after closing the application.

As a beginner, I opted for the H2 in-memory database. This choice was made to avoid the need to download and configure a full relational database like MySQL or PostgreSQL, making the setup easier. I plan to switch to a more robust database in the future.

Configuring the H2 In-memory Database

In the application.properties file, you will add three grouped configurations:

H2 Database Configuration: This setup creates an in-memory database, meaning the database resides in your RAM.
JPA Configuration: What is JPA (Jakarta Persistence API)? Instead of writing SQL queries manually, you can write Java code, and JPA will translate it into SQL queries to be executed on the database.
H2 Database Console Configuration: This provides a visual representation of your in-memory database, accessible via a web browser, typically at http://localhost:8080/h2-console.

Here are the configurations you would include in the application.properties file:

spring.application.name=demo
server.port=8080

# H2 Database Configuration
spring.datasource.url=jdbc:h2:mem:taskdb
spring.datasource.driverClassName=org.h2.Driver
spring.datasource.username=sa
spring.datasource.password=password

# JPA Configuration
spring.jpa.database-platform=org.hibernate.dialect.H2Dialect
spring.jpa.hibernate.ddl-auto=update
spring.jpa.show-sql=true

# H2 Console Configuration
spring.h2.console.enabled=true
spring.h2.console.path=/h2-console

The URL is used to create the database for you, while the driver class connects your application to the database. The username and password are the credentials required to access the database.

The "dialect" varies for each relational DBMS (Database Management System). Although they all use SQL, the syntax can differ slightly among different DBMS software. Thus, while the language remains the same, the dialect is different, which is why it's essential to specify the particular dialect for which JPA (Java Persistence API) will generate queries.

Setting ddl-auto=update allows your database to be updated according to the entity classes defined in your application. The show-sql option lets you view the SQL queries generated by JPA in the terminal.

This configuration will allow you to work with an H2 in-memory database effectively, providing both ease of use and accessibility for development purposes. Please remember to add the Spring Data JPA dependency in the pom.xml file.

Spring Boot Learning by doing

Piyush Kulkarni — Mon, 21 Sep 2026 17:12:04 +0000

Learning Spring by doing. In this post, I'll share the steps I took to create my first Spring Boot application. There's less theory in this guide (you can find that elsewhere); instead, I'll focus on the steps to take, how to do them, and the reasoning behind those steps.

In my previous blog post, I created a controller with one request-handling method. It simply returned the string "Hello, World!" when you accessed the endpoint localhost:8081/hello, as the request-handling method was mapped to that endpoint. In Java, everything is an object, so the next thing we need is a simple POJO (Plain Old Java Object) class to carry our data. This could be a class like Student, Car, Employee, etc. In this case, we created a Task POJO class.

Next, we will create more request-handling methods that perform some logic on that data and return the output. To manipulate the data and save the results (for future retrieval), you typically need a database. However, as a beginner, I decided to use a simple list of Tasks and return its results instead.

List<Task> tasks = new ArrayList<>();

CRUD Operations:

Create (HTTP POST Request): -

For the Create operation, I annotated the request-handling method with the @PostMapping annotation to map it to an endpoint. In this method, we fetch the JSON data sent by the client from the HTTP request body and create a Task object using that data. We do this with the @RequestBody annotation, which allows us to receive a pre-made object directly from Spring Boot. We then add this object to the list of tasks we created.

Read ( HTTP GET Request): -

For the Read operation, I annotated the request-handling method with the @GetMapping annotation to map it to an endpoint. In this method, we just return the list of tasks that we created and added some task objects.

Update (HTTP PUT Request): -

For the Create operation, I annotated the request-handling method with the @PutMapping annotation to map it to an endpoint. In this method, we fetch the JSON data sent by the client from the HTTP request body and create a Task object using that data. We do this with the @RequestBody annotation, which allows us to receive a pre-made object directly from Spring Boot. We also fetch the ID of the object to be updated from the request URL path variable. We use the @PathVariable annotation to get that ID. Then we replace the details of the existing object with the new object provided by Spring Boot, which was made using data from the client PUT request that came in.

Delete (HTTP DELETE Request): -

For the Delete operation, I annotated the request-handling method with the @DeleteMapping annotation to map it to an endpoint. In this method, we fetch the ID of the object to be deleted from the request URL path variable. We use the @PathVariable annotation to get that ID. Then we delete that object from the list.

Code snippet: -

package com.example.demo.controllers;


import com.example.demo.entity.Task;
import org.springframework.web.bind.annotation.*;

import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.List;

@RestController
@RequestMapping("/tasks")
public class TaskController {

    List<Task> tasks = new ArrayList<>();
    int id = 1;

    @GetMapping("/getTasks")
    public List<Task> getAllTasks(){
       return tasks;
    }

    @PostMapping("/addTask")
    public List<Task> addTask(@RequestBody Task task){

        task.setId(id++);
        task.setCreatedAt(LocalDateTime.now());
        task.setCompleted(false);


        tasks.add(task);
        return tasks;
    }

    @DeleteMapping("/deleteTask/{id}")
    public List<Task> deleteTask(@PathVariable int id){

        tasks.removeIf(task -> task.getId() == id);

        return tasks;
    }

    @PutMapping("/updateTask/{id}")
    public List<Task> updateTask(@PathVariable int id, @RequestBody Task updatedTask){

        for(int i =0; i<tasks.size();i++){
            if(tasks.get(i).getId() == id){
                tasks.get(i).setTitle(updatedTask.getTitle());
                tasks.get((i)).setCompleted(updatedTask.getCompleted());
                tasks.get(i).setDescription(updatedTask.getDescription());
            }
        }
        return tasks;
    }
}

Spring Boot Learning by Doing

Piyush Kulkarni — Sat, 19 Sep 2026 06:12:43 +0000

So I'm a beginner of spring boot learning it by doing. Here will be only steps (not much theory) of creating spring boot app. Even though I've read theory of spring boot I rarely know what to do next when I actually start making spring boot app.

So in this I'll write what to do, how to do and why we do it? With very little Theory. Now as most beginners do, I'm going to create simple web app and these steps are based on it.

1.Application class (@SpringBootApplication): -
When you first create a project, you automatically get this class generated. It's mostly your application name+ Application (eg, For Taskmanager its TaskmanagerApplication).

It is annotated with @SpringBootApllication annotation which I've talked about in previous blog.

This app is starting point of your application. It has main method in it Springapplication.run() method which bootstraps and launches your app.

2.Controller -
Second thing you create is most of the time is a controller class. A Java class annotated with @Controller/@RestController. This class contains handler methods which receives client request performs some action and returns the response.

Make sure you create a package named Controller inside the package in which your main class with @SpringBootApplication is.

3.Request Handling Methods -
These are annotated with @GetMapping and similar annotations with url path mapped in it. Any request coming from that url is handled by this method.

For starting, we will just return "Hello, World!" and it'll be sent back as response and displayed in browser.

Now Spring boot automatically configures your server which is tomcat and it runs on port 8080 so go on http://localhost:8080/hello or any endpoint you have created and you'll see the hello world message.

Because your application class is annotated with @SpringBootApplication it includes component-scan, which checks for components inside the current package and its sub packages by help of annotations. @Controller is also one of those components annotations. So Springboot creates the TaskController object and registers it inside context so spring can manage it.

Thats it for today. You can check theory of few things like application context/contianer, SpringApplication.run() method, how spring configures application, web MVC, request response rendering, client-server communication etc.

Learning Spring Boot By Doing

Piyush Kulkarni — Thu, 17 Sep 2026 21:37:18 +0000

This is my first post. I just wanted to write something and start. So it is here.

I am a theory person. I like learning the mental theory or use case theory about any development concepts. I don't usually code unless I understand theory perfectly.

Which I think is very big drawback. So even though I know some theory about spring boot I never made apps using it.

So today my goal was to initialize simple spring app and remember next time how to do the same.

So this might feel dumb, but this is how I remember it:

Spring Intializer

1.First, you go to spring initializer (https://start.spring.io/), add project name, domain name, choose dependency management tool-Maven, Java version 21, configuration- properties and most important - add dependencies like Spring web, Spring Data JPA etc. Download the jar file and open it in either IntelliJ IDE or STS (Spring tool suite).

Project Structure

2.After that you get simple spring app project structure with dependencies you added while creating project jar file. You get the application. properties file which contains nothing but project name. You get pom.xml file in which project related dependencies are mentioned there with version and what not. When you use spring initializer it fetches the correct names of these dependencies and their matching versions.

3.Structure is simple as well, 'src/main/java' -> 'com/example/pk/project_name' (for ex com/ex/pk/TaskManager and then coding part- ProjectNameApplication (for ex, TaskManagerApplication) java class with spring boot annotation @SpringBootApplication above it.

@SpringBootApplication

4.@SpringBootApplication annotation is combination of three other annotations: -

@Configuration means this class contains bean definitions, methods that returns bean object
@EnableAutoConfiguration this annotation tells Spring boot to check the dependencies downloaded and configure things according to it. Like if web dependencies are downloaded configure the tomcat server, configure database etc.
@ComponentScan - scan the packages and subpackages in which this class is and register the components you find into spring context. Means it'll check for components annotated with @Controller/@RestController, @Service, @Repositories etc., creates their bean and adds it into Spring context. (Context is like a box inside which beans lives and spring manages them) 4.Run the app, nothing happens mostly. If you added web dependency, go check on localhost:8080 port which is where configured tomcat server is running. You will see the white page with some error page means your app is running.

Inclusion

I know this is very basic stuff, and I've not explained everything perfectly but I'm not focusing on theory, learn by doing and escape the tutorial hell which keeps throwing me back to basics.
But I just wanted to write my first blog. I'll try to be consistent with it. I'm very lazy person with lot of distractions and I'll try to change through this.
Also, I'm not good writer either, but I saw other people's (especially senior Dev's) old blog on their personal websites like Julia Evans (https://jvns.ca/) or Jeff Atwood(https://blog.codinghorror.com/) and thought it's so great and cool. Their dedication, their love, their exploration, their journey and learning everything else was really great. So I wanted to start too.

You should share your experience too. Let me know how you escaped tutorial hell in comments below!