Forem: Mohammed Quasim D A

Beginner’s Guide to Exception Handling in Spring Boot

Mohammed Quasim D A — Fri, 23 May 2025 02:33:32 +0000

This is continuation of Building a Student Management API with Spring Boot: A Step-by-Step Guide

github:https://github.com/mohammedQuasimDA/smart-campus
If you:

    Have doubts about any part of this guide
    Find something confusing or unclear
    Notice typos/errors

Please reach out in the comments/DMs—I’d be delighted to:

    Clarify concepts
    Fix mistakes promptly
    Improve this resource for everyone

Your feedback helps make this article more accurate and helpful for future readers!

Create an dir exception

Why Exception Handling Matters

When building REST APIs, you want to return meaningful and consistent error messages when something goes wrong (e.g., bad input, not found, duplicates). That’s where Spring Boot’s exception handling with @ControllerAdvice and @ExceptionHandler comes in

1. Define Custom Exceptions

Create custom exceptions for specific error cases. These extend RuntimeException

// Duplicate roll number
public class DuplicateRollNumberException extends RuntimeException {
    public DuplicateRollNumberException(String message) {
        super(message);
    }
}

// Invalid department code
public class InvalidDepartmentCodeException extends RuntimeException {
    public InvalidDepartmentCodeException(String code) {
        super("Invalid department code: " + code);
    }
}

// Student not found
public class StudentNotFoundException extends RuntimeException {
    public StudentNotFoundException(String rollNumber) {
        super("Student not found with roll number: " + rollNumber);
    }
}

2. Create a Standard Error Response Object

We want every error to return a consistent JSON structure.

public class ErrorResponse {
    private LocalDateTime timestamp;
    private int status;
    private String error;
    private String message;
    private String path;
    private Map<String, String> details; // Optional: for field validation errors

    // Constructor for general errors
    public ErrorResponse(HttpStatus status, String message) {
        this.timestamp = LocalDateTime.now();
        this.status = status.value();
        this.error = status.getReasonPhrase();
        this.message = message;
    }

    // Constructor for validation errors
    public ErrorResponse(HttpStatus status, String message, Map<String, String> details) {
        this(status, message);
        this.details = details;
    }

    // Getters and setters...
}

3. Build a Global Exception Handler with @ControllerAdvice

This class handles all exceptions in one place

@ControllerAdvice
public class GlobalExceptionHandler {

    private String extractPath(WebRequest request) {
        return request.getDescription(false).replace("uri=", "");
    }

    @ExceptionHandler(MethodArgumentNotValidException.class)
    public ResponseEntity<ErrorResponse> handleValidationErrors(
            MethodArgumentNotValidException ex, WebRequest request) {

        Map<String, String> errors = ex.getBindingResult()
                .getFieldErrors()
                .stream()
                .collect(Collectors.toMap(
                        FieldError::getField,
                        FieldError::getDefaultMessage,
                        (existing, replacement) -> existing
                ));

        ErrorResponse response = new ErrorResponse(
                HttpStatus.BAD_REQUEST,
                "Validation failed",
                errors
        );
        response.setPath(extractPath(request));
        return new ResponseEntity<>(response, HttpStatus.BAD_REQUEST);
    }

    @ExceptionHandler(DuplicateRollNumberException.class)
    public ResponseEntity<ErrorResponse> handleDuplicateRoll(
            DuplicateRollNumberException ex, WebRequest request) {
        ErrorResponse response = new ErrorResponse(HttpStatus.CONFLICT, ex.getMessage());
        response.setPath(extractPath(request));
        return new ResponseEntity<>(response, HttpStatus.CONFLICT);
    }

    @ExceptionHandler(StudentNotFoundException.class)
    public ResponseEntity<ErrorResponse> handleStudentNotFound(
            StudentNotFoundException ex, WebRequest request) {
        ErrorResponse response = new ErrorResponse(HttpStatus.NOT_FOUND, ex.getMessage());
        response.setPath(extractPath(request));
        return new ResponseEntity<>(response, HttpStatus.NOT_FOUND);
    }

    @ExceptionHandler(InvalidDepartmentCodeException.class)
    public ResponseEntity<ErrorResponse> handleInvalidDepartment(
            InvalidDepartmentCodeException ex, WebRequest request) {
        ErrorResponse response = new ErrorResponse(HttpStatus.BAD_REQUEST, ex.getMessage());
        response.setPath(extractPath(request));
        return new ResponseEntity<>(response, HttpStatus.BAD_REQUEST);
    }

    @ExceptionHandler(Exception.class)
    public ResponseEntity<ErrorResponse> handleOtherErrors(
            Exception ex, WebRequest request) {
        ErrorResponse response = new ErrorResponse(
                HttpStatus.INTERNAL_SERVER_ERROR,
                "An unexpected error occurred"
        );
        response.setPath(extractPath(request));
        return new ResponseEntity<>(response, HttpStatus.INTERNAL_SERVER_ERROR);
    }
}

4. Example Output (JSON)

When a user sends bad data, your API will respond like this

:
{
  "timestamp": "2025-05-23T12:45:00",
  "status": 400,
  "error": "Bad Request",
  "message": "Validation failed",
  "path": "/api/students",
  "details": {
    "name": "Name must not be blank",
    "email": "Invalid email format"
  }
}

{
  "timestamp": "2025-05-23T12:45:00",
  "status": 404,
  "error": "Not Found",
  "message": "Student not found with roll number: 23CS001",
  "path": "/api/students/23CS001"
}

Building a Student Management API with Spring Boot: A Step-by-Step Guide

Mohammed Quasim D A — Mon, 19 May 2025 10:05:55 +0000

github:https://github.com/mohammedQuasimDA/smart-campus
If you:

    Have doubts about any part of this guide
    Find something confusing or unclear
    Notice typos/errors

Please reach out in the comments/DMs—I’d be delighted to:

    Clarify concepts
    Fix mistakes promptly
    Improve this resource for everyone

Your feedback helps make this article more accurate and helpful for future readers!

This project is a Student Management System built as a RESTful API using Spring Boot. It allows you to perform CRUD (Create, Read, Update, Delete) operations on student records, such as:

Adding new students
Retrieving student details
Updating student information
Deleting student dent records

🚀 Getting Started
go to https://start.spring.io/ or search "spring initializr" in google


- project:maven
- language:java
- Spring boot:3.4.5 (or any version of your choice)
- Group: this is basically your company name in reverse order. like google.com-->com.google  if you are individual you can just com.your_name
- Artifact: give your project an artifact name, e.g., “demo.”
- Name: enter a name for your project, e.g., “SpringBootDemo.”
- Description: this field is optional.
- Package name: define your base package automatically generated you can also change it but it is combo of group and artifact , e.g., “com.learning.demo.”
- Packaging: choose “Jar” for a standalone JAR file.
- java:21

Dependencies:
1.     Spring Web
2.     Spring data JPA
3.     Mysql driver

Now click on Generate which will generate a zip ,extract it and open in IDE

My project name is smartcampus so it creates an folder with the same name
inside it you will find "src" folder under it "main" under it "java"

-->smartcampus
  |->src
    |->main
      |->java
         |->com.sc.smartcampus
      |->resources

1. Understanding the Model Layer

The Model layer represents the structure of data in your application. Think of it like blueprints for the data you store in the database.

Below is the folder struct we gonna create

-->smartcampus
  |->src
    |->main
      |->java
         |->com.sc.smartcampus
           |->model
               |->Student.java
               |->Department(enum)
           |->converter
               |->DepartmentConverter.java
      |->resources

package com.sc.smartcampus.model;

import java.time.LocalDate;

import com.sc.smartcampus.converter.DepartmentConverter;
import com.sc.smartcampus.validation.ValidRollNumber;
import jakarta.persistence.*;
import jakarta.validation.constraints.*;

@Entity
@Table(name = "students",indexes = @Index(columnList = "rollNumber",unique = true))
public class Student {

    @Id
    @Column(unique = true, length = 7) // Set to maximum possible length
    @ValidRollNumber
    private String rollNumber;

    @NotBlank(message = "Name is mandatory")
    @Size(min = 2, max = 50, message = "Name must be 2-50 characters")
    private String name;

    @Email(message = "Invalid email format")
    @Column(unique = true)
    private String email;

    @Column(name = "department")
    @Convert(converter = DepartmentConverter.class)
    private Department department;

    @NotNull(message = "Enrollment date is required")
    private LocalDate enrollmentDate;
    //getter setter , all args and no args construtor

}

• @Entity: Tells Spring Boot this class represents a database table.
• name = "students": Sets the name of the table in the database to students.
• indexes = @Index(...): Creates a database index on the rollNumber column to speed up search queries and enforce uniqueness.
• unique = true: Ensures that no two students can have the same roll number.
• @id: Marks this field as the primary key (unique identifier).
• @column: Configures the database column.
• unique = true: Ensures no two rows can have the same value.
• length = 7: Limits the max characters to 7 (for example, 22BCS01).
• @ValidRollNumber:custom validation annotation // will show
• @NotBlankEnsures that the field is not null or empty
• @Size:Ensures that the name is between 2 and 50 characters long
• @Email:Makes sure the email field is a valid email address (like test@example.com)
• @column(name = "department"): Creates a column named "department"
• @Convert(...): Uses a custom converter (here, DepartmentConverter) to convert the Department enum to a code like "CS" and vice versa.//will show

package com.sc.smartcampus.model;

public enum Department {
    // Core Engineering
    AEROSPACE("AE", "Aerospace Engineering"),
    AUTOMOBILE("AU", "Automobile Engineering"),
    BIOTECH("BT", "Biotechnology"),
    CHEMICAL("CH", "Chemical Engineering"),
    CIVIL("CE", "Civil Engineering"),
    COMPUTER_SCIENCE("CS", "Computer Science"),
    COMPUTER_ENGINEERING("CSE", "Computer Science Engineering"),
    ELECTRICAL("EE", "Electrical Engineering"),
    ELECTRONICS("EC", "Electronics Engineering"),
    ELECTRONICS_COMMUNICATION("ECE", "Electronics and Communication"),
    ENVIRONMENTAL("EN", "Environmental Engineering"),
    INDUSTRIAL("IE", "Industrial Engineering"),
    INFORMATION_TECH("IT", "Information Technology"),
    INSTRUMENTATION("IC", "Instrumentation and Control"),
    MECHANICAL("ME", "Mechanical Engineering"),
    MECHATRONICS("MT", "Mechatronics"),
    METALLURGY("ML", "Metallurgical Engineering"),
    MINING("MN", "Mining Engineering"),
    PETROLEUM("PE", "Petroleum Engineering"),
    PRODUCTION("PD", "Production Engineering"),
    ROBOTICS("RB", "Robotics Engineering"),
    TEXTILE("TE", "Textile Engineering"),
    ARTIFICIAL_INTELLIGENCE("AI", "Artificial Intelligence"),
    DATA_SCIENCE("DS", "Data Science"),
    CYBER_SECURITY("CY", "Cyber Security"),
    CLOUD_COMPUTING("CC", "Cloud Computing"),
    IOT("IO", "Internet of Things");

    private final String code;
    private final String fullName;

    Department(String code, String fullName) {
        this.code = code;
        this.fullName = fullName;
    }

    public String getCode() {
        return code;
    }

    public String getFullName() {
        return fullName;
    }

    // Helper method to get department from code
    public static Department fromCode(String code) {
        for (Department dept : values()) {
            if (dept.code.equalsIgnoreCase(code)) {
                return dept;
            }
        }
        throw new IllegalArgumentException("Invalid department code: " + code);
    }

}

This class is a Java enum (enumeration) called Department, and it's used to define a fixed list of engineering departments along with a short code and full name for each one

Purpose of Department enum

This enum helps you:
1. Store departments using short codes like "CS" or "ME" in the database.
2. Show full names like "Computer Science" or "Mechanical Engineering" in the UI.

• code: Short version like "CS" or "ME".
• fullName: Full readable name like "Computer Science"

fromCode() Method convert a code (like "ME") back into an MECHANICAL:

package com.sc.smartcampus.converter;

import com.sc.smartcampus.model.Department;
import jakarta.persistence.AttributeConverter;
import jakarta.persistence.Converter;

@Converter(autoApply = true)
public class DepartmentConverter implements AttributeConverter<Department, String> {

    @Override
    public String convertToDatabaseColumn(Department department) {
        if (department == null) return null;
        return department.getCode(); // store "ME" instead of "MECHANICAL"
    }

    @Override
    public Department convertToEntityAttribute(String code) {
        if (code == null) return null;
        return Department.fromCode(code); // convert "ME" back to MECHANICAL
    }
}

Converter

Problem It Solves

By default, if you use an enum in a JPA entity (like Department department in Student), it will store it in the database either as:
• The ordinal (position number, like 0, 1, 2) — not readable.
• Or the enum name (like "MECHANICAL").
But you want to store the short code instead, like "ME" or "CS". Why?
✅ It's compact
✅ It's readable
✅ It's customized to your preference ("CS" instead of "COMPUTER_SCIENCE")
To do this, we use a custom converter with JPA: DepartmentConverter.

@Converter(autoApply = true)
Automatically use this converter for any Department type in your entity classes

AttributeConverter
will convert between the Department enum (Java side) and a String (DB side)

validation

-->smartcampus
  |->src
    |->main
      |->java
         |->com.sc.smartcampus
           |->model
           |->converter
           |->validation
                   |->RollNumberValidator.java
                   |->ValidRollNumber(@interface)
      |->resources

In our model we have @ValidRollNumber for private String rollNumber; which was a custome
What We're Doing Here
We're creating a custom validation annotation that checks if a roll number:
1. Follows the correct pattern like 23CS001 (2-digit year + department code + 3 digits)
2. Has a valid department code like CS, ME, EC, etc.

@Documented
@Constraint(validatedBy = RollNumberValidator.class)
@Target({ ElementType.FIELD })
@Retention(RetentionPolicy.RUNTIME)
public @interface ValidRollNumber {
    String message() default "Invalid roll number or department code";
    Class<?>[] groups() default {};
    Class<? extends Payload>[] payload() default {};
}

• @Constraint: This tells Spring which validator class will handle this annotation (in our case, RollNumberValidator).
• @Target(ElementType.FIELD): Can be used on fields.
• @Retention(RUNTIME): The annotation should be available at runtime.

String message() default "Invalid roll number or department code";
Class<?>[] groups() default {};
Class<? extends Payload>[] payload() default {};

are required parts of every custom validation annotation in Spring Boot (using Jakarta Bean Validation).

package com.sc.smartcampus.validation;

import com.sc.smartcampus.model.Department;
import jakarta.validation.ConstraintValidator;
import jakarta.validation.ConstraintValidatorContext;

public class RollNumberValidator implements ConstraintValidator<ValidRollNumber, String> {

    @Override
    public boolean isValid(String rollNumber, ConstraintValidatorContext context) {
        if (rollNumber == null || !rollNumber.matches("^\\d{2}[A-Z]{1,2}\\d{3}$")) {
            return false; // format is invalid
        }

        // extract department code
        String deptCode = rollNumber.substring(2, rollNumber.length() - 3);
        try {
            Department.fromCode(deptCode); // checks if dept code is valid
            return true;
        } catch (IllegalArgumentException e) {
            return false;
        }
    }
}

public class RollNumberValidator implements ConstraintValidator-->
• This is a custom validator class for the annotation @ValidRollNumber.
• It tells Spring how to validate a String field (like a roll number).
• ConstraintValidator: Here, A = ValidRollNumber (custom annotation), and T = String (type of the field being validated).
rollNumber.substring(2, rollNumber.length() - 3);-->it takes only the code from the pattern 21ME093-->ME

2. Repository Layer

In Spring Boot, the repository layer is used to interact with the database. It contains the code to save, find, delete, or update data.
Spring Data JPA makes this super simple — you don’t need to write SQL for common tasks!

-->smartcampus
  |->src
    |->main
      |->java
         |->com.sc.smartcampus
           |->model
           |->converter
           |->validation
               |->repository
                   |-> StudentRepository  
      |->resources

package com.sc.smartcampus.repository;

import org.springframework.data.jpa.repository.JpaRepository;

import com.sc.smartcampus.model.Student;
import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.query.Param;

import java.util.List;

public interface StudentRepository extends JpaRepository<Student, String> {

    @Query("SELECT MAX(s.rollNumber) FROM Student s WHERE s.rollNumber LIKE :pattern")
    String findMaxRollNumberByPattern(@Param("pattern") String pattern);

    @Query("SELECT s FROM Student s WHERE LOWER(s.name) LIKE LOWER(CONCAT('%', :keyword, '%')) " +
            "OR LOWER(s.email) LIKE LOWER(CONCAT('%', :keyword, '%')) " +
            "OR LOWER(s.rollNumber) LIKE LOWER(CONCAT('%', :keyword, '%'))")
    List<Student> searchByKeyword(@Param("keyword") String keyword);
}

-->The

here JPA give you many querys like findById() etc.

but sometime we need custom queries like to get maximum roll number
@Query("SELECT MAX(s.rollNumber) FROM Student s WHERE s.rollNumber LIKE :pattern") String findMaxRollNumberByPattern(@Param("pattern") String pattern);

String pattern -->it wil have a pattern[17ME204] which user passes
so what we do is that we search the DB with the same pattern and find the highest roll number.
When adding a new student, you might want to auto-generate the next roll number based on a pattern

@Query("SELECT s FROM Student s WHERE LOWER(s.name) LIKE LOWER(CONCAT('%', :keyword, '%')) " + "OR LOWER(s.email) LIKE LOWER(CONCAT('%', :keyword, '%')) " + "OR LOWER(s.rollNumber) LIKE LOWER(CONCAT('%', :keyword, '%'))") List<Student> searchByKeyword(@Param("keyword") String keyword);

Allows you to search students by name, email, or roll number — case-insensitive and partial match

3. DTOs (Data Transfer Objects)

A DTO (Data Transfer Object) is a simple Java class used to transfer data between the frontend and backend.
We use DTOs to:
• Control what data is exposed to clients.
• Separate internal entity logic from external data exchange.
• Apply input validation rules cleanly.

-->smartcampus
  |->src
    |->main
      |->java
         |->com.sc.smartcampus
           |->model
           |->converter
           |->validation
               |->repository
               |->dto
                   |-> StudentRequestDTO
                   |-> StudentResponseDTO  
      |->resources

StudentRequestDTO – When client sends data to backend (POST/PUT)

package com.sc.smartcampus.dto;

import jakarta.validation.constraints.Email;
import jakarta.validation.constraints.NotBlank;
import jakarta.validation.constraints.NotNull;
import jakarta.validation.constraints.Size;

import java.time.LocalDate;

public class StudentRequestDTO {

    @NotBlank(message = "Name is required")
    @Size(min = 2, max = 50, message = "Name must be between 2 and 50 characters")
    private String name;

    @Email(message = "Invalid email format")
    @NotBlank(message = "Email is required")
    private String email;

    @NotBlank(message = "Department code is required")
    private String department;

    @NotNull(message = "Enrollment date is required")
    private LocalDate enrollmentDate;

    public StudentRequestDTO() {
    }

    public StudentRequestDTO(String name, String email, String department, LocalDate enrollmentDate) {
        this.name = name;
        this.email = email;
        this.department = department;
        this.enrollmentDate = enrollmentDate;
    }

    public String getName() {
        return name;
    }

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

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }

    public String getDepartment() {
        return department;
    }

    public void setDepartment(String department) {
        this.department = department;
    }

    public LocalDate getEnrollmentDate() {
        return enrollmentDate;
    }

    public void setEnrollmentDate(LocalDate enrollmentDate) {
        this.enrollmentDate = enrollmentDate;
    }
}

• @notblank: Field cannot be empty or only spaces.
• @Size(min, max): Limits name length.

StudentResponseDTO

When backend sends data to client (GET)
Purpose:
This DTO is used when the backend sends student data to the frontend. It contains:
• The generated roll number
• Both department code (CS) and full name (Computer Science)
• All other student info

package com.sc.smartcampus.dto;

import java.time.LocalDate;

public class StudentResponseDTO {

    private String rollNumber;
    private String name;
    private String email;
    private String department;          // e.g., "CS"
    private String departmentFullName;  // e.g., "Computer Science"
    private LocalDate enrollmentDate;

    public StudentResponseDTO() {
    }

    public StudentResponseDTO(String rollNumber, String name, String email,
                              String department, String departmentFullName,
                              LocalDate enrollmentDate) {
        this.rollNumber = rollNumber;
        this.name = name;
        this.email = email;
        this.department = department;
        this.departmentFullName = departmentFullName;
        this.enrollmentDate = enrollmentDate;
    }

    public String getRollNumber() {
        return rollNumber;
    }

    public void setRollNumber(String rollNumber) {
        this.rollNumber = rollNumber;
    }

    public String getName() {
        return name;
    }

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

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }

    public String getDepartment() {
        return department;
    }

    public void setDepartment(String department) {
        this.department = department;
    }

    public String getDepartmentFullName() {
        return departmentFullName;
    }

    public void setDepartmentFullName(String departmentFullName) {
        this.departmentFullName = departmentFullName;
    }

    public LocalDate getEnrollmentDate() {
        return enrollmentDate;
    }

    public void setEnrollmentDate(LocalDate enrollmentDate) {
        this.enrollmentDate = enrollmentDate;
    }
}

Service

What is a Service Interface?

In Spring Boot, the service layer is where:
• Core business logic is written
• The controller sends requests here
• The repository is called from here to talk to the database

-->smartcampus
  |->src
    |->main
      |->java
         |->com.sc.smartcampus
           |->model
           |->converter
           |->validation
               |->repository
               |->dto
               |->service
                   |->impl
                        |->StudentServiceImpl.java
                   |->StudentService(interface) 
      |->resources

package com.sc.smartcampus.service;

import com.sc.smartcampus.dto.StudentRequestDTO;
import com.sc.smartcampus.dto.StudentResponseDTO;

import java.util.List;

public interface StudentService {

    StudentResponseDTO createStudent(StudentRequestDTO dto);

    StudentResponseDTO getStudentByRollNumber(String rollNumber);

    StudentResponseDTO updateStudent(String rollNumber, StudentRequestDTO dto);

    void deleteStudent(String rollNumber);

    List<StudentResponseDTO> getAllStudents();

    List<StudentResponseDTO> searchStudents(String keyword);

    String generateNextRollNumber(String year, String departmentCode);
}

What Is StudentServiceImpl?

• It implements the methods defined in your StudentService interface.
• Handles all business logic: creating, updating, deleting, searching, and managing roll numbers.
• Talks to the repository (StudentRepository) to interact with the database.
• Converts data between the DTOs and Entity classes.

private StudentRepository studentRepository;

public StudentServiceImpl(StudentRepository studentRepository) {
    this.studentRepository = studentRepository;
}

To use/access the repository


package com.sc.smartcampus.service.impl;

import com.sc.smartcampus.dto.StudentRequestDTO;
import com.sc.smartcampus.dto.StudentResponseDTO;
import com.sc.smartcampus.model.Department;
import com.sc.smartcampus.model.Student;
import com.sc.smartcampus.repository.StudentRepository;
import com.sc.smartcampus.service.StudentService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.time.format.DateTimeFormatter;
import java.util.List;
import java.util.stream.Collectors;

@Service
public class StudentServiceImpl implements StudentService {


    private StudentRepository studentRepository;

    public StudentServiceImpl(StudentRepository studentRepository) {
        this.studentRepository = studentRepository;
    }

    private StudentResponseDTO mapToResponseDTO(Student student) {
        StudentResponseDTO dto = new StudentResponseDTO();
        dto.setRollNumber(student.getRollNumber());
        dto.setName(student.getName());
        dto.setEmail(student.getEmail());
        dto.setDepartment(student.getDepartment().getCode());
        dto.setDepartmentFullName(student.getDepartment().getFullName());
        dto.setEnrollmentDate(student.getEnrollmentDate());
        return dto;
    }


// Implement all methods here...

    @Override
    public StudentResponseDTO createStudent(StudentRequestDTO dto) {
        // 1. Convert department code string to enum (throws exception if invalid)
        Department department = Department.fromCode(dto.getDepartment());

        // 2. Generate the year part from enrollment date
        String year = String.valueOf(dto.getEnrollmentDate().getYear()).substring(2); // last two digits, e.g. "23"

        // 3. Generate the next roll number for this year + department
        String nextRollNumber = generateNextRollNumber(year, department.getCode());

        // 4. Create new Student entity
        Student student = new Student();
        student.setRollNumber(nextRollNumber);
        student.setName(dto.getName());
        student.setEmail(dto.getEmail());
        student.setDepartment(department);
        student.setEnrollmentDate(dto.getEnrollmentDate());

        // 5. Save student entity
        student = studentRepository.save(student);

        // 6. Convert to response DTO and return
        return mapToResponseDTO(student);
    }



    @Override
    public StudentResponseDTO getStudentByRollNumber(String rollNumber) {
        Student student = studentRepository.findById(rollNumber)
                .orElseThrow(() -> new RuntimeException("Student not found with roll number: " + rollNumber));
        return mapToResponseDTO(student);
    }


    @Override
    public StudentResponseDTO updateStudent(String rollNumber, StudentRequestDTO dto) {
        // 1. Fetch the existing student by rollNumber
        Student student = studentRepository.findById(rollNumber)
                .orElseThrow(() -> new RuntimeException("Student not found with roll number: " + rollNumber));

        // 2. Update the fields from the DTO (except rollNumber, which is immutable)
        student.setName(dto.getName());
        student.setEmail(dto.getEmail());

        // 3. Convert and update department (validate department code)
        Department department = Department.fromCode(dto.getDepartment());
        student.setDepartment(department);

        // 4. Update enrollment date
        student.setEnrollmentDate(dto.getEnrollmentDate());

        // 5. Save the updated student
        student = studentRepository.save(student);

        // 6. Convert to response DTO and return
        return mapToResponseDTO(student);
    }


    @Override
    public void deleteStudent(String rollNumber) {
        // Check if student exists, else throw exception
        Student student = studentRepository.findById(rollNumber)
                .orElseThrow(() -> new RuntimeException("Student not found with roll number: " + rollNumber));

        // Delete the student
        studentRepository.delete(student);
    }


    @Override
    public List<StudentResponseDTO> getAllStudents() {
        List<Student> students = studentRepository.findAll();
        return students.stream()
                .map(this::mapToResponseDTO)
                .collect(Collectors.toList());
    }


    @Override
    public List<StudentResponseDTO> searchStudents(String keyword) {
        List<Student> students = studentRepository.searchByKeyword(keyword);
        return students.stream()
                .map(this::mapToResponseDTO)
                .collect(Collectors.toList());
    }


    @Override
    public String generateNextRollNumber(String year, String departmentCode) {
        // 1. Create the pattern to find max existing roll numbers for the year+dept
        // Example pattern: "21CS%" to match roll numbers starting with 21CS
        String pattern = year + departmentCode + "%";

        // 2. Get the max existing roll number with this pattern from DB
        String maxRollNumber = studentRepository.findMaxRollNumberByPattern(pattern);

        int nextSerial = 1; // default if no existing roll numbers

        if (maxRollNumber != null) {
            // Extract the last 3 digits of the roll number (serial number)
            String serialStr = maxRollNumber.substring(maxRollNumber.length() - 3);
            try {
                int serialNum = Integer.parseInt(serialStr);
                nextSerial = serialNum + 1;
            } catch (NumberFormatException e) {
                // fallback if parsing fails, start from 1
                nextSerial = 1;
            }
        }

        // 3. Format the serial to be 3 digits with leading zeros (e.g., 001, 042)
        String serialFormatted = String.format("%03d", nextSerial);

        // 4. Build and return the next roll number string
        return year + departmentCode + serialFormatted;
    }


    // You can add private helper methods if needed, for example, a mapper from Student to DTO
}

createStudent(StudentRequestDTO dto)

Converts StudentRequestDTO → Student → StudentResponseDTO
Steps:
1. Converts department string to a valid Department enum using Department.fromCode().
2. Extracts year from enrollment date (e.g., 2023 → "23").
3. Generates the next available roll number like 23CS001.
4. Creates and saves a Student entity.
5. Converts entity to response DTO.

getStudentByRollNumber(String rollNumber)

•  Finds a student using studentRepository.findById(...).
•  Throws a RuntimeException if not found.
•  Returns a StudentResponseDTO

updateStudent(String rollNumber, StudentRequestDTO dto)

Steps:
1. Fetch existing student.
2. Update fields except roll number.
3. Validate department again using fromCode.
4. Save and return updated StudentResponseDTO

deleteStudent(String rollNumber)

•  Checks if student exists.
•  Deletes using studentRepository.delete()

getAllStudents()

•  Fetches all students.
• Maps each entity to a StudentResponseDTO

searchStudents(String keyword)

• Uses a custom query to search by name, email, or roll number.
•  Converts results to DTOs.

generateNextRollNumber(String year, String departmentCode)

Logic:
1. Constructs a search pattern like 23CS%.
2. Finds the current highest roll number matching the pattern.
3. Extracts the last 3 digits → increments → formats to 3 digits (e.g., 003).
4. Returns the new roll number: e.g., 23CS004

mapToResponseDTO

• Converts a Student entity into a readable API-friendly response object (StudentResponseDTO).
• Useful to prevent exposing internal entity structure.

Controller

-->smartcampus
  |->src
    |->main
      |->java
         |->com.sc.smartcampus
           |->model
           |->converter
           |->validation
               |->repository
               |->dto
               |->service
               |-controller
                   |->StudentController 
      |->resources

Purpose of StudentController

This class handles all HTTP requests related to the Student resource. It's part of the Controller layer in a Spring Boot application, which connects the client (frontend/API consumer) to the Service layer.
You’re using:
• @RestController – to mark this class as a REST controller.
@RequestMapping("/api/students") – so all routes start with /api/students

package com.sc.smartcampus.controller;

import com.sc.smartcampus.dto.StudentRequestDTO;
import com.sc.smartcampus.dto.StudentResponseDTO;
import com.sc.smartcampus.service.StudentService;
import jakarta.validation.Valid;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;

import java.util.List;

@RestController
@RequestMapping("/api/students")
public class StudentController {

    @Autowired
    private StudentService studentService;

    // 1. Create Student
    @PostMapping
    public ResponseEntity<StudentResponseDTO> createStudent(@Valid @RequestBody StudentRequestDTO dto) {
        StudentResponseDTO created = studentService.createStudent(dto);
        return ResponseEntity.ok(created);
    }

    // 2. Get Student by Roll Number
    @GetMapping("/{rollNumber}")
    public ResponseEntity<StudentResponseDTO> getStudentByRollNumber(@PathVariable String rollNumber) {
        StudentResponseDTO student = studentService.getStudentByRollNumber(rollNumber);
        return ResponseEntity.ok(student);
    }

    // 3. Update Student by Roll Number
    @PutMapping("/{rollNumber}")
    public ResponseEntity<StudentResponseDTO> updateStudent(@PathVariable String rollNumber,
                                                            @Valid @RequestBody StudentRequestDTO dto) {
        StudentResponseDTO updated = studentService.updateStudent(rollNumber, dto);
        return ResponseEntity.ok(updated);
    }

    // 4. Delete Student by Roll Number
    @DeleteMapping("/{rollNumber}")
    public ResponseEntity<Void> deleteStudent(@PathVariable String rollNumber) {
        studentService.deleteStudent(rollNumber);
        return ResponseEntity.noContent().build();
    }

    // 5. Get All Students
    @GetMapping
    public ResponseEntity<List<StudentResponseDTO>> getAllStudents() {
        List<StudentResponseDTO> students = studentService.getAllStudents();
        return ResponseEntity.ok(students);
    }

    // 6. Search Students by keyword
    @GetMapping("/search")
    public ResponseEntity<List<StudentResponseDTO>> searchStudents(@RequestParam String keyword) {
        List<StudentResponseDTO> results = studentService.searchStudents(keyword);
        return ResponseEntity.ok(results);
    }
}

• @PostMapping – handles POST /api/students.
• @RequestBody – reads JSON body into a Java object.
• @valid – triggers validation (e.g., @notblank, @ValidRollNumber).
• Returns ResponseEntity.ok(...) with the saved student data
• @GetMapping("/{rollNumber}") – dynamic path parameter.
• @PathVariable – binds the rollNumber from the URL
• @PutMapping("/{rollNumber}")-used to update a full resource
• @DeleteMapping("/{rollNumber}")-delte a resource
• @RequestParam is used for query parameters like /api/students/search?keyword=john

Connect to Database

-->smartcampus
  |->src
    |->main
      |->java
         |->com.sc.smartcampus
           |->model
           |->converter
           |->validation
               |->repository
               |->dto
               |->service
               |-controller 
      |->resources
               |->application.properties

spring.datasource.url=jdbc:mysql://localhost:3306/database_name
spring.datasource.username=username
spring.datasource.password=password
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver

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

server.port=9090--> i used port 9090 by default it is 8080

We have create the spring boot app now run and pass api via postman
if you are using default port change 9090 to 8080

POST http://localhost:9090/api/students
Content-Type: application/json

{
  "name": "Joqsadhn a Doe",
  "email": "joewqqhn.wdose@example.com",
  "department": "CS",
  "enrollmentDate": "2023-08-15"
}

GET http://localhost:9090/api/students

GET http://localhost:9090/api/students/23CS001


DELETE http://localhost:9090/api/students/21CS001

GET http://localhost:9090/api/students/search?keyword=john

PUT http://localhost:9090/api/students/23CS001
Content-Type: application/json

{
"name": "John Doe Updated",
"email": "john.updated@example.com",
"department": "ME",
"enrollmentDate": "2023-08-20"
}