Forem: Tamilselvan K

Building a Full Stack User Authentication System using React, Spring Boot, and PostgreSQL

Tamilselvan K — Tue, 31 Mar 2026 11:07:24 +0000

Introduction

In this blog, I will walk through how I built a full-stack User Authentication System using React for the frontend, Spring Boot for the backend, and PostgreSQL for the database.

This project demonstrates a complete flow of user registration, login, and dashboard display, along with validation and login activity tracking.

Tech Stack

Frontend

React
React Router
Axios
CSS

Backend

Java
Spring Boot
Spring Data JPA

Database

PostgreSQL

Features

User Registration
User Login Authentication
Dashboard with User Details
Client-side Form Validation
REST API Integration
Login Activity Tracking (Status and Timestamp)

Application Flow

User registers with username, password, name, and email
Data is sent to Spring Boot backend and stored in PostgreSQL
User logs in with credentials
Backend validates user and records login attempt
On success, frontend fetches user details
Dashboard displays user information

Frontend Implementation (React)

Form Handling

I used React’s useState hook to manage form inputs and errors. Each input field is a controlled component.

const [data, setData] = useState({
  username: "",
  password: ""
});

Validation

Client-side validation ensures that users cannot submit empty fields or invalid data.

if (!data.username || !data.password) {
  setErrors({ message: "All fields are required" });
}

API Integration

Axios is used to communicate with the backend.

const response = await axios.post(
  "http://localhost:8080/api/login",
  new URLSearchParams(data)
);

Navigation

React Router is used to navigate between pages like Register, Login, and Dashboard.

Backend Implementation (Spring Boot)

Layered Architecture

The backend follows a layered structure:

Controller → Handles HTTP requests
Service → Contains business logic
Repository → Interacts with database

User Registration

public String register(String username, String password, String name, String email) {
    UserEntity user = new UserEntity();
    user.setUsername(username);
    user.setPassword(password);
    user.setName(name);
    user.setEmail(email);

    userRepo.save(user);
    return "User Registered";
}

Login Logic

public String login(String username, String password) {
    UserEntity user = userRepo.findByUsername(username);

    String status;

    if (user != null && user.getPassword().equals(password)) {
        status = "SUCCESS";
    } else {
        status = "FAILED";
    }

    LoginEntity attempt = new LoginEntity();
    attempt.setUsername(username);
    attempt.setStatus(status);
    attempt.setTime(LocalDateTime.now());

    loginRepo.save(attempt);

    return status;
}

Login Tracking

Each login attempt is stored with:

Username
Status (SUCCESS / FAILED)
Timestamp

This helps in tracking user activity.

Database Design

UserEntity

id
username
password
name
email

LoginEntity

id
username
status
time

Challenges Faced

Managing state and validation in React
Handling API communication between frontend and backend
Designing clean backend architecture

Limitations

Passwords are stored in plain text
No authentication mechanism like JWT
No route protection

Future Improvements

Add JWT-based authentication
Encrypt passwords using BCrypt
Implement protected routes
Improve error handling

Conclusion

This project helped me understand how frontend and backend systems work together in a full-stack application. It also improved my knowledge of API integration, state management, and backend architecture.

If you are learning full-stack development, building an authentication system like this is a great way to understand real-world application flow.

GitHub Repository

Tamilselvan1812 / 37-UserAuthenticationSystem

Full Stack User Authentication System using React, Spring Boot, and PostgreSQL

User Authentication System (React + Spring Boot + PostgreSQL)

Overview

This is a full-stack User Authentication System that allows users to register, log in, and view their profile on a dashboard. The application is built using React for the frontend, Spring Boot for the backend, and PostgreSQL for database management.

Features

✅ User Registration
✅ User Login Authentication
✅ Dashboard with User Details
✅ Client-side Form Validation
✅ REST API Integration
✅ Login Activity Tracking (Status + Timestamp)
✅ Responsive UI with modern CSS

Tech Stack

Frontend

React
React Router
Axios
CSS

Backend

Java
Spring Boot
Spring Data JPA

Database

PostgreSQL

Application Flow

User registers with username, password, name, and email
Data is stored in PostgreSQL via Spring Boot APIs
User logs in with credentials
Backend validates user and records login attempt
On success, user is redirected to dashboard
Dashboard displays user details

Project Structure

Frontend (React)

src/
 ├── App.jsx

…

View on GitHub

7 Days of Java Coding Practice – My Structured Preparation Plan

Tamilselvan K — Thu, 19 Feb 2026 06:01:06 +0000

Recently, I decided to strengthen my core Java problem-solving skills by practicing fundamental coding problems for seven days. Instead of randomly solving questions, I followed a structured approach covering numbers, recursion, arrays, and strings.

Day 1 – Basic Number Problems

I started with simple number-based logic building.

Reverse a Number
Extract digits using % 10 and rebuild the number using rev * 10.
Time Complexity: O(d)
Space Complexity: O(1)
Palindrome Number
Reverse the number and compare it with the original.
Sum of Digits
Extract each digit and add them until the number becomes zero.

These problems helped me understand digit extraction and number manipulation clearly.

Day 2 – Recursion and Mathematical Concepts

Count Digits
Keep dividing the number by 10 until it becomes zero.
Fibonacci Series

Iterative approach – efficient, O(n)
Recursive approach – simple logic but exponential complexity

This helped me understand the difference between optimized and non-optimized solutions.

Factorial
Practiced both iterative and recursive approaches.
Armstrong Number
Checked whether the sum of cubes of digits equals the original number (for 3-digit numbers).
Sum of Digits Until Single Digit
Repeatedly calculated digit sum until a single digit remains (digital root concept).

Day 3 – Prime and Special Numbers

Check Prime Number
Initially used O(n) approach. Later learned it can be optimized to check until square root of n.
Print Prime Numbers from 1 to 50
Applied nested loops for prime checking.
Strong Number
Example: 145 = 1! + 4! + 5!

These problems improved my mathematical thinking and loop control.

Day 4 – Array Basics

Bubble Sort
Understood how comparison-based sorting works.
Time Complexity: O(n²)
Maximum Element in Array
Traverse and update max value.
Second Largest Element
Maintain two variables to track first and second largest.
Reverse an Array
Printed in reverse order and also practiced swapping method.
Adding Element in Array
Inserted element at end and at specific position.

These strengthened my array traversal and indexing logic.

Day 5 – Array Rotations and Duplicates

Remove Duplicates (Sorted Array)
Used two-pointer technique.
Left Rotate by 1
Right Rotate by 1
Left Rotate by K

Understood how shifting works internally and how to improve performance.

Day 6 – String Basics

Reverse a String
Initially used string concatenation (O(n²)).
Later understood why StringBuilder is more efficient.
Palindrome String
Reverse and compare using equals().
Count Vowels
Traversed each character and checked conditions.
Character Frequency
Used frequency array of size 256.

This day helped me understand string immutability and character handling.

Day 7 – Advanced String Problems

Anagram
Incremented frequency for first string and decremented for second.
First Non-Repeating Character
Used frequency count and scanned again.
Check Unique Characters
Ensured no character appears more than once.
Reverse Each Word in a Sentence
Split sentence and reversed each word individually.

These problems improved my confidence in solving string-based interview questions.

What I Learned

Improved logical thinking
Better understanding of time and space complexity
Learned difference between brute force and optimized approach
Strengthened recursion basics
Practiced two-pointer technique
Improved confidence in writing clean Java code

Instead of solving hundreds of random problems, I focused on mastering around 30 fundamental problems deeply. That gave me much more clarity and confidence.

What I Covered in the Last Two Months After My First Full-Stack Project

Tamilselvan K — Wed, 04 Feb 2026 05:19:54 +0000

Two months ago, I published a blog about my Student Management System, which was my first complete full-stack project. After completing that project, I continued learning consistently and focused on improving my understanding of both frontend and backend development.

This post is a summary of what I covered during the last two months and how my learning progressed after building my first full-stack application.

Frontend Development

During the last two months, I spent time strengthening my frontend fundamentals and improving my React skills.

Topics covered

HTML for semantic structure and better readability
CSS for layouts, responsiveness, and UI improvements
JavaScript for logic building and DOM manipulation
React for component-based UI development
Small React practice programs to apply concepts

Backend Development

Along with frontend learning, I continued working on backend development using Java and Spring Boot.

Topics covered

Core Java concepts and object-oriented programming
Spring Boot for building RESTful APIs
PostgreSQL for database connectivity and queries
Backend practice projects and API testing

Full-Stack Learning Beyond My First Project

After completing the Student Management System, I worked on another full-stack project:

Hotel Management System

This project helped reinforce concepts such as CRUD operations, frontend-backend integration, and database handling. Building another full-stack application gave me more confidence in structuring applications from start to finish.

Coding Practice and Consistency

To improve my problem-solving skills, I practiced coding regularly alongside project work.

React practice programs: 5
Java practice programs: 25

What I Plan to Do Next

In the coming months, I plan to:

Build more real-world full-stack projects
Improve my React and Spring Boot skills further
Focus on interview preparation
Continue documenting my learning through blog posts

Day-105 Building a Full-Stack Student Management System with React, Spring Boot, and PostgreSQL

Tamilselvan K — Fri, 17 Oct 2025 11:25:27 +0000

Managing student records manually can be time-consuming — from adding new students to updating and deleting their details. This project demonstrates how to build a Student Management Web Application using React for the frontend, Spring Boot for the backend, and PostgreSQL as the database.

The application performs complete CRUD operations (Create, Read, Update, Delete) with persistent data storage.

Tech Stack Used

Frontend : React (JavaScript)
Backend : Spring Boot (Java)
Database : PostgreSQL
API Communication: REST API (Axios)

Project Goal

To create a simple, user-friendly web app that allows:

Adding new student details
Viewing all students in a table
Editing student details
Deleting student by name
Storing data permanently in PostgreSQL

Project Structure

StudentManagement/
│── demo/         → Spring Boot backend
│── my-app/       → React frontend

Backend – Spring Boot + PostgreSQL

The backend handles all data operations — fetching, adding, updating, and deleting student records.

1. Student Model

@Entity
public class Student {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String name;
    private int age;
    private int marks;
}

2. Repository Layer

public interface StudentRepository extends JpaRepository<Student, Long> {

    Student findByName(String name);
}

3. Controller Layer

@RestController
@CrossOrigin(origins = "http://localhost:3000")
public class StudentController {

    @Autowired
    private StudentRepository repo;

    @GetMapping("/")
    public List<Student> getAllStudents() {
        return repo.findAll();
    }

    @PostMapping("/students")
    public Student addStudent(@RequestBody Student student) {
        return repo.save(student);
    }

    @PutMapping("/students/byName/{name}")
    public Student updateStudent(@PathVariable String name, @RequestBody Student updated) {
        Student s = repo.findByName(name);
        s.setName(updated.getName());
        s.setAge(updated.getAge());
        s.setMarks(updated.getMarks());
        return repo.save(s);
    }

    @DeleteMapping("/students/byName/{name}")
    public String deleteStudent(@PathVariable String name) {
        repo.deleteByName(name);
        return "Deleted successfully";
    }
}

4. Database Configuration

In application.properties:

spring.jpa.properties.hibernate.dialect = org.hibernate.dialect.PostgreSQLDialect
spring.jpa.hibernate.ddl-auto=update
spring.jpa.hibernate.show-sql=true
spring.datasource.url=jdbc:postgresql://localhost:5432/studentdb
spring.datasource.username=postgres
spring.datasource.password=your password

Frontend – React

The React frontend provides a clean interface for managing students and interacts with the backend using Axios.

1. StudentTable Component

Displays the list of students and allows editing or deleting.

function StudentTable() {
  const [students, setStudents] = useState([]);
  const navigate = useNavigate();

  const fetchStudents = () => {
    axios.get("http://localhost:8080/")
      .then((res) => setStudents(res.data))
      .catch((err) => console.log("Error fetching students", err));
  };

  useEffect(() => {
    fetchStudents();
  }, []);

  const handleDeleteByName = (name) => {
    axios.delete(`http://localhost:8080/students/byName/${name}`)
      .then(() => fetchStudents())
      .catch((err) => console.log("Error deleting student", err));
  };

  const handleEditByName = (student) => {

    navigate("/addStudent", { state: { student } });                   // Navigate to StudentForm and pass student object as state
  };

  return (
    <div>
      <h2>Student List</h2>
      <button type="button" onClick={() => navigate("/addStudent")}>Add Student</button>

      <table border="1">
        <thead>
          <tr>

            <th>Name</th>
             <th>Age</th>
            <th>Marks</th>
            <th>Action</th>
          </tr>
        </thead>
        <tbody>
          {students.map((s) => (
            <tr key={s.id}>

              <td>{s.name}</td>
              <td>{s.age}</td>
              <td>{s.marks}</td>
              <td>
                <button type="button" onClick={() => handleDeleteByName(s.name)}>Delete</button>
                <button type="button" onClick={() => handleEditByName(s)}>Edit</button>
              </td>
            </tr>
          ))}
        </tbody>
      </table>
    </div>
  );
}

2. StudentForm Component

Used to add or edit a student record.

function StudentForm() {
  const [name, setName] = useState("");
  const [age, setAge] = useState("");
  const [marks, setMarks] = useState("");
  const navigate = useNavigate();
  const location = useLocation();
  const [oldName, setOldName] = useState(null);

  useEffect(() => {
    if (location.state?.student) {
      const { student } = location.state;
      setName(student.name);
      setAge(student.age);
      setMarks(student.marks);
      setOldName(student.name);
    }
  }, [location]);

  const handleSubmit = (e) => {
    e.preventDefault();
    const data = { name, age: parseInt(age), marks: parseInt(marks) };

    if (oldName)
      axios.put(`http://localhost:8080/students/byName/${oldName}`, data)
        .then(() => navigate("/"));
    else
      axios.post("http://localhost:8080/students", data)
        .then(() => navigate("/"));
  };

  return (
    <div>
      <h2>{oldName ? "Edit Student" : "Add Student"}</h2>
      <form onSubmit={handleSubmit}>
        <input value={name} onChange={(e) => setName(e.target.value)} placeholder="Name" required />
        <input value={age} onChange={(e) => setAge(e.target.value)} placeholder="Age" required />
        <input value={marks} onChange={(e) => setMarks(e.target.value)} placeholder="Marks" required />
        <button type="submit">Save</button>
        <button type="button" onClick={() => navigate("/")}>Cancel</button>
      </form>
    </div>
  );
}

How Frontend and Backend Communicate

React uses Axios to send HTTP requests (GET, POST, PUT, DELETE).
Spring Boot exposes REST endpoints for each CRUD operation.
JPA handles all database operations with PostgreSQL.

Example endpoints:

POST /students → Adds a new student
GET / → Fetches all students
PUT /students/byName/{name} → Updates student details
DELETE /students/byName/{name} → Deletes student

What I Learned

Connecting React with Spring Boot using Axios
Integrating PostgreSQL with JPA
Implementing complete CRUD operations
Understanding how REST APIs link frontend and backend
Designing a clean and responsive React interface

Day-104 Understanding JPA, Hibernate, and JpaRepository in Spring Boot

Tamilselvan K — Sat, 11 Oct 2025 03:27:55 +0000

When working with databases in Java-based applications, managing data persistence efficiently is important. Spring Boot simplifies this process using JPA and Hibernate, making CRUD operations seamless with minimal boilerplate code.

What is JPA?

JPA (Java Persistence API) is a standard specification provided by Java for Object Relational Mapping (ORM).
It allows developers to map Java objects to database tables and perform database operations using Java code instead of SQL queries.

Key Features of JPA:

Defines how Java objects are stored and retrieved from relational databases.
Provides annotations to map classes and fields to database tables and columns.
Simplifies data access through high-level APIs.
Works with different ORM providers like Hibernate, EclipseLink, etc.

Common JPA Annotations:

@Entity – Marks a class as a JPA entity.
@Id – Defines the primary key.
@Table – Maps the class to a specific database table.
@Column – Maps a field to a table column.

What is Hibernate?

Hibernate is the implementation of the JPA specification.
While JPA defines the rules, Hibernate provides the actual functionality to interact with the database.

Hibernate Features:

Implements all JPA features.
Provides advanced ORM capabilities like:
- Caching – Improves performance by reducing database hits.
- Lazy Loading – Loads related data only when required.
Allows writing queries using:
- JPQL (Java Persistence Query Language)
- Native SQL

JpaRepository in Spring Boot

Spring Data JPA provides the JpaRepository interface, which extends CrudRepository and PagingAndSortingRepository.
It comes with built-in methods for CRUD and query operations — no need to write SQL manually.

Common JpaRepository Built-in Methods

Method	Description
`save()`	Insert or update an entity.
`findById()`	Find an entity by its primary key.
`findAll()`	Retrieve all entities.
`deleteById()`	Delete an entity using its primary key.
`delete()`	Delete a specific entity.
`count()`	Get total number of records.
`existsById()`	Check if an entity exists by its primary key.

Custom Query Methods

Apart from built-in methods, Spring Data JPA also allows custom query methods by following a simple naming convention.

Examples:

List<Student> findByName(String name);
List<Student> findByAge(int age);
List<Student> findByNameAndMarks(String name, int marks);

Spring Boot automatically generates the SQL queries for these methods based on their names.

Day-102,103 Connecting Spring Boot with PostgreSQL Database

Tamilselvan K — Wed, 01 Oct 2025 06:47:00 +0000

1. Add Dependencies for PostgreSQL and JPA

In pom.xml, add the following dependencies. If you use Spring Initializr, you can directly select Spring Data JPA, PostgreSQL Driver, and Spring Web.

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

<dependency>
    <groupId>org.postgresql</groupId>
    <artifactId>postgresql</artifactId>
    <scope>runtime</scope>
</dependency>

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

2. Configure Database Connection in application.properties

Provide database connection details in the application.properties file.

spring.datasource.url=jdbc:postgresql://localhost:5432/mydb
spring.datasource.username=postgres
spring.datasource.password=yourpassword

spring.jpa.hibernate.ddl-auto=update
spring.jpa.show-sql=true
spring.jpa.database-platform=org.hibernate.dialect.PostgreSQLDialect

Replace mydb, postgres, and yourpassword with your actual PostgreSQL database name, username, and password.

3. Create an Entity Class

Entities in JPA represent tables in the database. Below is a simple Student entity.

package com.payilagam.DB_connection.entity;

import jakarta.persistence.Entity;
import jakarta.persistence.Id;

@Entity
public class Student {

    @Id
    private int id;
    private String name;
    private int age;
    private int marks;

    public Student() {}

    public Student(int id, String name, int age, int marks) {
        this.id = id;
        this.name = name;
        this.age = age;
        this.marks = marks;
    }

    public int getId() { return id; }
    public void setId(int id) { this.id = id; }

    public String getName() { return name; }
    public void setName(String name) { this.name = name; }

    public int getAge() { return age; }
    public void setAge(int age) { this.age = age; }

    public int getMarks() { return marks; }
    public void setMarks(int marks) { this.marks = marks; }
}

4. Create a Repository Interface

Spring Data JPA provides CRUD operations by extending jpaRepository.

package com.payilagam.DB_connection.repository;

import org.springframework.data.jpa.repository.JpaRepository;
import com.payilagam.DB_connection.entity.Student;

public interface StudentRepo extends JpaRepository<Student, Integer> {
}

5. Insert Data Automatically Using a Controller

In this example, instead of exposing REST APIs, we will insert data automatically at startup using @PostConstruct.

package com.payilagam.DB_connection.controller;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import com.payilagam.DB_connection.entity.Student;
import com.payilagam.DB_connection.repository.StudentRepo;

import jakarta.annotation.PostConstruct;

@Component
public class StudentController {

    @Autowired
    private StudentRepo studentRepo;

    @PostConstruct
    public void display() {
        Student s = new Student(1, "Tamil", 30, 95);
        studentRepo.save(s);
        System.out.println("Student saved into PostgreSQL database.");
    }
}

When the Spring Boot application starts, the display() method executes automatically, creates a Student object, and saves it into the PostgreSQL database.

6. Run and Verify

Start PostgreSQL and ensure the database exists.
Run the Spring Boot application.
Check the console logs. Hibernate will generate an SQL insert statement similar to the one below:

insert into student (age, marks, name, id) values (30, 95, 'Tamil', 1)

4.Verify in PostgreSQL using a query:

select * from student;

You should see the inserted student record.

Conclusion

Add dependencies for PostgreSQL and JPA
Configure database connection in application.properties
Create an entity class
Create a repository interface
Insert data automatically using @PostConstruct in a controller

Day-100,101 19-Essential Spring Boot Annotations

Tamilselvan K — Wed, 24 Sep 2025 07:18:58 +0000

1.@SpringBootApplication

Marks the main class of a Spring Boot application.
Enables auto-configuration,component scanning, and configuration setup.

@SpringBootApplication
public class MyApp {
    public static void main(String[] args) {
        SpringApplication.run(MyApp.class, args);
    }
}

2.@RestController

Marks a class as a REST API controller.
Combines @Controller + @ResponseBody, so responses are returned as JSON.

@RestController
public class HelloController {
    @GetMapping("/hello")
    public String hello() {
        return "Hello Spring Boot!";
    }
}

3.@Controller

Marks a class as a Spring MVC controller.
Used for serving web pages or templates (like Thymeleaf).

@Controller
public class PageController {
    @GetMapping("/home")
    public String homePage() {
        return "home"; // returns home.html
    }
}

4.@GetMapping

Maps HTTP GET requests to a controller method.

@GetMapping("/users")
public List<User> getUsers() { ... }

5.@PostMapping

Maps HTTP POST requests to a method.

@PostMapping("/users")
public User createUser(@RequestBody User user) { ... }

6.@PutMapping

Maps HTTP PUT requests to a method for updating resources.

@PutMapping("/users/{id}")
public User updateUser(@PathVariable Long id, @RequestBody User user) { ... }

7.@DeleteMapping

Maps HTTP DELETE requests to a method for deleting resources.

@DeleteMapping("/users/{id}")
public void deleteUser(@PathVariable Long id) { ... }

8.@Autowired

Automatically injects Spring-managed beans.

@Autowired
private UserService userService;

9.@Service

Marks a class as a service layer bean containing business logic.

@Service
public class UserService { ... }

10.@Repository

Marks a class as a data access layer (DAO).
Supports exception translation for database operations.

@Repository
public interface UserRepository extends JpaRepository<User, Long> { }

11.@Component

Generic annotation for any Spring-managed bean.

@Component
public class Utility { ... }

12.@entity

Marks a class as a JPA entity mapping to a database table.

@Entity
public class User { ... }

13.@ Id

Marks the primary key in a JPA entity.

@Id
private Long id;

14.@GeneratedValue

Configures automatic generation of primary key values (e.g., auto-increment).

@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;

15.@Configuration

Marks a class as a source of bean definitions.

@Configuration
public class AppConfig { ... }

16.@ Bean

Declares a bean inside a configuration class; managed by Spring.

@Bean
public RestTemplate restTemplate() {
    return new RestTemplate();
}

17.@RequestBody

Binds HTTP request body (JSON) to a Java object.

@PostMapping("/users")
public User createUser(@RequestBody User user) { ... }

18.@PathVariable

Binds a URI path variable to a method parameter.

@GetMapping("/users/{id}")
public User getUser(@PathVariable Long id) { ... }

19.@RequestParam

Binds query parameters or form data to a method parameter.

@GetMapping("/users")
public List<User> getUsers(@RequestParam int page, @RequestParam int size) { ... }

Conclusion

For freshers, mastering these 19 annotations is enough to handle most Spring Boot interview questions. They cover:

Application setup
REST controllers
Dependency injection
Service & repository layers
JPA / database mapping
Request handling

Day-99 Multithreading in Java

Tamilselvan K — Tue, 23 Sep 2025 09:19:35 +0000

Multithreading is the process of executing multiple threads simultaneously.

A thread is the smallest unit of execution.
Java provides strong multithreading support via the Thread class and Runnable interface.
It helps in better CPU utilization and improved application performance.

Ways to Create a Thread

There are two main ways to create a thread in Java:

a) Extending the Thread Class

class MyThread extends Thread {
    public void run() {
        System.out.println("Thread running using Thread class!");
    }
}

public class ThreadDemo {
    public static void main(String[] args) {
        MyThread t1 = new MyThread();
        t1.start(); // Start the thread
    }
}

b) Implementing the Runnable Interface

class MyRunnable implements Runnable {
    public void run() {
        System.out.println("Thread running using Runnable interface!");
    }
}

public class RunnableDemo {
    public static void main(String[] args) {
        Thread t1 = new Thread(new MyRunnable());
        t1.start();
    }
}

Thread Lifecycle

A thread passes through these states:

New → Runnable → Running → Waiting → Terminated

New: Thread object created but not started.
Runnable: Thread is ready to run but waiting for CPU scheduling.
Running: Thread is currently executing.
Waiting/Timed Waiting: Thread is paused temporarily.
Terminated: Thread has finished execution.

Common Thread Methods

start() → begin thread execution
run() → contains the logic of the thread
sleep(ms) → pause thread for given milliseconds
join() → wait for a thread to finish
isAlive() → check if thread is running

Synchronization

When multiple threads access a shared resource, race conditions may occur.

synchronized keyword ensures that only one thread can access a resource at a time.

Conclusion

Threads allow concurrent execution.
Two ways to create threads: Thread class & Runnable interface.
Use synchronization to prevent race conditions.
Multithreading is widely used in games, web servers, and real-time applications.

Day-98 Java 8 Features – Functional Interfaces, Lambda Expressions & Streams

Tamilselvan K — Tue, 23 Sep 2025 09:15:34 +0000

Java 8 introduced functional programming concepts to the language, making code more concise, readable, and powerful. Three of the most important features are:

Functional Interfaces
Lambda Expressions
Streams API

Functional Interfaces

A functional interface is an interface with a single abstract method (SAM).

They enable lambda expressions and method references.
Common functional interfaces:
- Predicate → test a condition
- Consumer → consume input
- Function → transform input
- Supplier → provide values

Example Code – Functional Interface

public class FunctionalInterfaceDemo {

    public static void main(String[] args) {

        Predicate<Integer> isEven = n -> n % 2 == 0;

        System.out.println(isEven.test(10));        // true
        System.out.println(isEven.test(15));        // false
    }
}

Lambda Expressions

A lambda expression is a short way to represent an anonymous function.

It reduces boilerplate code.
Syntax:

  (parameters) -> expression  
  (parameters) -> { statements }

Example Code – Lambda Expression

public class LambdaDemo {
    public static void main(String[] args) {
           List<String> names = new ArrayList<>();
           names.add("Alice");
           names.add("Bob");
           names.add("Charlie");

           System.out.println(names); 


      names.forEach(name -> System.out.println(name.toUpperCase()));   // Iterate using forEach and lambda
       }
}

Streams API

A Stream is a sequence of elements supporting functional-style operations.

Used for filtering, mapping, reducing, and collecting data.
Works with collections easily.

Common Methods:

filter() – filter elements by condition
map() – transform elements
forEach() – iterate elements
collect() – gather results into List/Set/Map
reduce() – combine into a single result

Example Code – Streams

public class StreamsDemo {
    public static void main(String[] args) {

        List<Integer> numbers = new ArrayList<>();
        numbers.add(1);
        numbers.add(2);
        numbers.add(3);
        numbers.add(4);
        numbers.add(5);
        numbers.add(6);


        List<Integer> result = numbers.stream()
                                      .filter(n -> n % 2 == 0)           // Filter even numbers
                                      .map(n -> n * 2)                   //  double them
                                      .collect(Collectors.toList());     // collect to a new list

        System.out.println(result); 
    }
}

Conclusion

Functional Interfaces allow concise coding patterns.
Lambdas replace anonymous classes with cleaner syntax.
Streams bring the power of functional programming to data processing.

Day-97 Stack & Queue in Java

Tamilselvan K — Tue, 23 Sep 2025 09:10:23 +0000

1. Stack (LIFO – Last In, First Out)

A Stack follows the principle of Last In, First Out (LIFO).
Think of a stack of plates: the last plate placed on top is the first one to be removed.

Common Methods in Stack:

push() – add an element
pop() – remove top element
peek() – see top element without removing
isEmpty() – check if stack is empty

Example Code (Stack Demo):

import java.util.Stack;

public class StackDemo {
    public static void main(String[] args) {
        Stack<Integer> stack = new Stack<>();

        stack.push(10);
        stack.push(20);
        stack.push(30);

        System.out.println("Top element: " + stack.peek()); // 30
        System.out.println("Removed: " + stack.pop()); // 30
        System.out.println("Is stack empty? " + stack.isEmpty());
    }
}

2. Queue (FIFO – First In, First Out)

A Queue follows the principle of First In, First Out (FIFO).
Think of a ticket counter queue: the first person in line is the first to be served.

Common Methods in Queue:

offer() – add element
poll() – remove front element
peek() – see front element
isEmpty() – check if queue is empty

Example Code (Queue Demo):

import java.util.LinkedList;
import java.util.Queue;

public class QueueDemo {
    public static void main(String[] args) {
        Queue<Integer> queue = new LinkedList<>();

        queue.offer(10);
        queue.offer(20);
        queue.offer(30);

        System.out.println("Front element: " + queue.peek()); // 10
        System.out.println("Removed: " + queue.poll()); // 10
        System.out.println("Is queue empty? " + queue.isEmpty());
    }
}

Conclusion

Stack is best when you need reverse order processing (Undo operations, DFS, expression evaluation).
Queue is best when you need sequential order processing (Task scheduling, BFS, request handling).

Day-96 Inversion of control(IOC) and Dependency Injection in Spring

Tamilselvan K — Sat, 20 Sep 2025 11:07:47 +0000

What is Inversion of Control (IoC)?

Inversion of Control is a design principle where the control of object creation and dependency management is transferred from the application code to a container or framework.

In Spring, this container is called the IoC Container, which comes in two forms:

BeanFactory (basic)
ApplicationContext (advanced, with additional features)

What is Dependency Injection (DI)?

Dependency Injection is one way of implementing IoC.

Instead of objects creating their own dependencies, the Spring container injects the required dependencies into them.

This makes the code:

Loosely Coupled → Easier to maintain and extend.
Testable → Since dependencies can be mocked or swapped easily.

Types of Dependency Injection in Spring

Spring provides three main types of DI:

Constructor Injection

Dependencies are provided through a class constructor. Best for mandatory dependencies.

Setter Injection

Dependencies are set through setter methods. Useful for optional dependencies.

Field Injection

Dependencies are injected directly into class fields using annotations like @Autowired. Convenient, but less preferred in large applications.

Benefits of Using DI

Reduces boilerplate code for object creation.
Promotes loose coupling.
Simplifies unit testing with mock dependencies.
Improves maintainability and readability.

Day-94,95 Understanding Servlets, JSP, Annotations and CORS

Tamilselvan K — Thu, 18 Sep 2025 07:11:57 +0000

Servlets: Backend Logic and Request Handling

A Servlet is a Java program that runs on a server and handles HTTP requests and responses. Servlets are part of the Java EE (Jakarta EE) ecosystem and are primarily responsible for backend logic.

Definition: A Servlet is a Java class that processes requests and generates responses.
Role: Manages business logic and request handling.

JSP (Java Server Pages): Presentation Layer

JSP is used for the presentation layer of an application.

Definition: JSP combines HTML and Java code.
Role: Used to display dynamic content (UI part).
Difference from Servlets: While Servlets usually handle business logic, JSP focuses on presentation.

Annotations

Java Annotations provide metadata (example: @override).
Spring Boot Annotations reduce boilerplate code, handle Dependency Injection (DI), configure REST APIs, ORM, security, and more.

CORS (Cross-Origin Resource Sharing)

CORS is a security feature in browsers that controls cross-origin requests.

Same-Origin Policy: By default, browsers block requests from different origins.
Cross-Origin Requests: If your React app runs on port 3000 and Spring Boot backend runs on 8080, the browser blocks the request without CORS configuration.
Solution: Add @CrossOrigin annotation in your Spring Boot REST controller.
Prevents malicious cross-site data access.
Allows safe communication between frontend (React) and backend (Spring Boot).

Example Workflow: React + Spring Boot

React app runs at localhost:3000.
Spring Boot backend runs at localhost:8080.
Without CORS, the browser blocks the request.
Adding @CrossOrigin allows cross-origin communication.