"Welcome To Ashok IT"				
			                     "Spring Boot & Microservices"
                                            Topic  : Rest API Development
                                             Date  : 10/06/2025
                                                (Session - 64)                          
_____________________________________________________________________________________________________________________________
Lombok
======
* Lombok is a popular Java library that provides a set of annotations and code generation tools to help simplify and           streamline Java code. 

* It is designed to reduce boilerplate code, enhance code readability, and make Java development more concise and efficient. 

* The importance of Lombok can be understood through several key points

1.Reduces Boilerplate Code 
==========================
* Lombok eliminates the need to write repetitive and verbose code, such as getters, setters, constructors, and toString         methods. This simplifies the codebase and makes it more maintainable.

2.Improves Code Readability
===========================
* By reducing the clutter of boilerplate code, Lombok can make your code more concise and easier to read. This can lead to     better code comprehension and faster development.

3.Saves Development Time
========================
* Lombok automates the generation of common code patterns, which saves developers time and effort. This is especially     valuable in large and complex codebases where manually writing repetitive code can be error-prone and time-consuming.

4.Minimizes Errors: 
===================
* Since Lombok-generated code is automatically generated and updated, it reduces the risk of human error in writing and     maintaining common code patterns.

5.Enhances Code Maintainability
===============================
* Lombok encourages the use of immutable objects and other best practices, which can lead to more maintainable and bug-    resistant code.

6.Integrates with IDEs: 
=======================
* Lombok seamlessly integrates with popular Java IDEs like IntelliJ IDEA and Eclipse, providing code assistance and tooling   support, such as code completion and refactoring.

NOTE
====
* Lombok is important in Java development because it helps developers write cleaner, more readable, and less error-prone       code while saving time and effort. 

* Its ability to reduce boilerplate code and integrate with popular IDEs makes it a valuable tool for Java developers       looking to improve their productivity and code quality.

Configuring the Lombok
======================
Process-1
=========
1) Download the Lombok.jar file from lombok.org website with below link

     https://projectlombok.org/download

2) After downloading the Jar File,Simply double click on it will get Installer window 

   Select Appropriate IDE'S to install/configure lombok Library by checking checkboxes

   Click on Install/Update button it will install automatically 

   Finally click on "Quit installer" Button.

3) After completion of installation to ensure Lombok configure correctly or not in our IDE

    Goto Help Menu >>>> About STSIDE/Eclipse IDE >>>> Find lombok entry after copyrights message.

Process-2
=========
1) Goto STS IDE Select Help Menu >>>> Install New Software >>> Click on Add Button and fill the below Details

       Name ::: Lombok API
    
       Location::: https://projectlombok.org/p2
       
    Finally Click "Ok" Button

2) Select Entry from dropdown "Lombok API" and click button "Install" >>>> Accept the Licences >>> Click On Finish Button


Lombok Annotations
==================
1. @Getter
2. @Setter
3. @NoArgsConstructor
4. @AllArgsConstructor
5. @ToString
6. @Builder
7. @EqualsAndHashCode
8. @Data  = @Getter +  @Setter +  @NoArgsConstructor + @EqualsAndHashCode +  @ToString

NOTE
====
* After Installing the Lombok to IDE make sure we need add lombok dependencies to our projects.

Mini Project Setup
==================
* We Will be Implementing the Rest API Development with Mini Project(GET,POST,PUT,PATCH,DELETE)

* As part of this mini project development will be covering with below concepts

   1) Rest API Development with Database Interaction

   2) Swagger Documentation Configuration for Rest API Mini Project

   3) Exception Handling in Rest API  Development


1) Creating the Spring boot Starter Project using below starter

      * Web Starter

      * Oracle Driver

      * Lombok 
 
      * ModelMapper(Collect From Maven Repoistory)

      * Spring Boot Dev Tools

2) Creating the Following packages to organize our classes in project

     com.ashokit
              |-> Application.java
     com.ashokit.constants
              |-> ApplicationConstants.java
     com.ashokit.controller
              |-> PersonController.java
     com.ashokit.dao
              |-> PersonDao.java
     com.ashokit.service
              |-> PersonService.java
              |-> PersonServiceImpl.java
     com.ashokit.dto
              |-> PersonDTO.java
     com.ashokit.entity
              |-> Person.java
     com.ashokit.exception
              |-> ResourceNotFoundException.java
     com.ashokit.response
              |-> PageResponse.java

pom.xml
=======
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<parent>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-parent</artifactId>
		<version>3.4.5</version>
		<relativePath /> <!-- lookup parent from repository -->
	</parent>
	<groupId>com.ashokit</groupId>
	<artifactId>36_SpringBootRest_MiniProject_App</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<packaging>war</packaging>
	<name>36_SpringBootRest_MiniProject_App</name>
	<description>SpringBoot Rest API Mini Project</description>
	<properties>
		<java.version>17</java.version>
	</properties>
	<dependencies>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-data-jpa</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-web</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-devtools</artifactId>
			<scope>runtime</scope>
			<optional>true</optional>
		</dependency>
		<dependency>
			<groupId>com.oracle.database.jdbc</groupId>
			<artifactId>ojdbc8</artifactId>
			<scope>runtime</scope>
		</dependency>
		<dependency>
			<groupId>org.projectlombok</groupId>
			<artifactId>lombok</artifactId>
			<optional>true</optional>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-tomcat</artifactId>
			<scope>provided</scope>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-test</artifactId>
			<scope>test</scope>
		</dependency>
		<!-- Converting the java Objects from one type(Person.java) to another type(PersonDTO.java) -->
		<dependency>
			<groupId>org.modelmapper</groupId>
			<artifactId>modelmapper</artifactId>
			<version>3.1.1</version>
		</dependency>
			<!-- JSON to XML Conversion dependency -->
		<dependency>
			<groupId>com.fasterxml.jackson.dataformat</groupId>
			<artifactId>jackson-dataformat-xml</artifactId>
		</dependency>
			<!-- Rest API Documentation for openAPI dependency -->
		<dependency>
			<groupId>org.springdoc</groupId>
			<artifactId>springdoc-openapi-starter-webmvc-ui</artifactId>
			<version>2.2.0</version>
		</dependency>
	</dependencies>
	<build>
		<plugins>
			<plugin>
				<groupId>org.springframework.boot</groupId>
				<artifactId>spring-boot-maven-plugin</artifactId>
				<!--<configuration>
					<excludes>
						<exclude>
							<groupId>org.projectlombok</groupId>
							<artifactId>lombok</artifactId>
						</exclude>
					</excludes>
				</configuration>-->
			</plugin>
		</plugins>
	</build>

</project>


application.properties
======================
#server port changing
server.port=8899

#Database Configuration
spring.datasource.driver-class-name=oracle.jdbc.driver.OracleDriver
spring.datasource.url=jdbc:oracle:thin:@localhost:1521:xe
spring.datasource.username=system
spring.datasource.password=manager

#Hibernate Configuration
spring.jpa.hibernate.ddl-auto=update
spring.jpa.show-sql=true

#FileUploading Configurations
project.images=profilepics
spring.servlet.multipart.max-file-size=10MB
spring.servlet.multipart.max-request-size=10MB

Person.java
===========
package com.ashokit.entity;

import java.time.LocalDate;
import java.time.LocalDateTime;

import jakarta.persistence.Column;
import jakarta.persistence.Entity;
import jakarta.persistence.GeneratedValue;
import jakarta.persistence.GenerationType;
import jakarta.persistence.Id;
import jakarta.persistence.Table;
import jakarta.persistence.Temporal;
import jakarta.persistence.TemporalType;
import lombok.AllArgsConstructor;
import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.Setter;
import lombok.ToString;

@Entity
@Table(name="ashokit_persons")
@NoArgsConstructor
@AllArgsConstructor
@Getter
@Setter
@ToString
public class Person {
	
	@Id
	@Column(name="person_id",nullable = false)
	@GeneratedValue(strategy = GenerationType.AUTO)
	private Integer id;
	
	@Column(name="person_name")
	private String name;
	
	@Column(name="location")
	private String location;
	
	@Column(name="email_id")
	private String emailId;
	
	@Column(name="address")
	private String address;
	
	@Column(name="created_dt")
	@Temporal(TemporalType.TIMESTAMP)
	private LocalDateTime createdDate;

}


PersonDTO.java
==============
package com.ashokit.dto;

import java.time.LocalDateTime;

import io.swagger.v3.oas.annotations.media.Schema;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@NoArgsConstructor
@AllArgsConstructor
@Builder
@Schema(description = "Request Payload for Creating the Person Record....")
public class PersonDTO {

	@Schema(description = "PersonID Will be auto generated....")
	private Integer id;
	
	@Schema(description = "PersonName",example = "Mahesh")
	private String name;

	@Schema(description = "PersonLocation",example="Hyderabad")
	private String location;
	
	@Schema(description = "PersonEmailID",example="mahesh.ashokit@gmail.com")
	private String emailId;
	
	@Schema(description = "PersonAddress",example="Hyderabad,Ameerpet")
	private String address;
	
	@Schema(description = "Person Record CreatedData Will be autogenerated.....")
	private LocalDateTime createdDate;
}

PersonService.java
==================
package com.ashokit.service;

import java.util.List;

import org.springframework.web.multipart.MultipartFile;

import com.ashokit.dto.PersonDTO;
import com.ashokit.response.PageResponse;

public interface PersonService {	
	
	//Getting all Persons with out pagination
	public List<PersonDTO> getAllPersons();

	//Getting all Persons with pagination
	public PageResponse getAllPersons(Integer pageNumber,Integer pageSize,String sortBy,String sortDirection);
	
}


PersonServiceImpl.java
======================
package com.ashokit.service;

import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.time.LocalDateTime;
import java.util.List;
import java.util.Optional;
import java.util.UUID;
import java.util.stream.Collectors;

import org.modelmapper.ModelMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.domain.Pageable;
import org.springframework.data.domain.Sort;
import org.springframework.stereotype.Service;
import org.springframework.web.multipart.MultipartFile;

import com.ashokit.dao.PersonDao;
import com.ashokit.dto.PersonDTO;
import com.ashokit.entity.Person;
import com.ashokit.exceptions.ResourceNotFoundException;
import com.ashokit.response.PageResponse;

@Service
public class PersonServiceImpl implements PersonService {
	
	@Autowired
	private PersonDao personDao;
	
	@Autowired
	private ModelMapper modelMapper;
	
	@Override
	public List<PersonDTO> getAllPersons() {
		
		List<Person> allPersons = personDao.findAll();
		
		//converting from List<Person> into List<PersonDTO>
		//allPersons.stream()  -> converting List<Person> into Stream<Person> object
		//map() -> Its is a intermediate stream operation which take one input(Person) and give it as one output(PersonDTO)
		//collect() -> It is a terminal operation to collect data into single object
		//Collectors -> It is utility class from Java8 Stream library to collect data into list,set,map object
		// i.e..,Collectors.toList(), Collectors.toSet(), Collectors.toMap()
		List<PersonDTO> allPersonDtos = allPersons.stream().map(eachPerson ->{
			return new PersonDTO(eachPerson.getId(),eachPerson.getName(),
					             eachPerson.getLocation(),eachPerson.getEmailId(),
					             eachPerson.getAddress(),eachPerson.getCreatedDate());
		}).collect(Collectors.toList());
		
		return allPersonDtos;
	}
	
	
	@Override
	public PageResponse getAllPersons(Integer pageNumber, Integer pageSize, String sortBy, String sortDirection) {
		//sortBy ::: Sorting Field
		Sort sort = Sort.by(sortBy).descending();
		if("asc".equalsIgnoreCase(sortDirection)) {
			sort = sort.by(sortBy).ascending();
		}
		
		//Creating the PageRequest Object
		Pageable pageable = PageRequest.of(pageNumber, pageSize, sort);
		
		//Get All the Records based on Pagination
		Page<Person> pageInfo = personDao.findAll(pageable);
		
		//Getting the pagecontent from above Page object
		List<Person> personList = pageInfo.getContent();
		
		//Converting List<Person> into List<PersonDTO>
		//modelMapper -> predefined class from modelMapper library.
		//            -> We represented this class as spring bean then we can autowire anywhere in our application
		//            -> Modelmapper contains map() which takes two arguments first argument-> source type
		//            ->                                                      Second argument -> destination type
		//            ->                                                      return type  -> destination type
		List<PersonDTO> personDTOList = personList.stream()
				.map(eachPerson -> this.modelMapper.map(eachPerson, PersonDTO.class))
		        .collect(Collectors.toList());
		
		//Creating PageResponse Object for setting pagination Information
		PageResponse pageResponse = new PageResponse();
		pageResponse.setContent(personDTOList);
		pageResponse.setPageNumber(pageInfo.getNumber());
		pageResponse.setPageSize(pageInfo.getSize());
		pageResponse.setTotalElements(pageInfo.getTotalElements());
		pageResponse.setTotalPages(pageInfo.getTotalPages());
		pageResponse.setLastPage(pageInfo.isLast());
		
		return pageResponse;
	}	
}


PageResponse.java
==================
package com.ashokit.response;

import java.util.List;

import com.ashokit.dto.PersonDTO;

import lombok.AllArgsConstructor;
import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.Setter;

@NoArgsConstructor
@AllArgsConstructor
@Setter
@Getter
public class PageResponse {
	
	//Holding page specific records
	private List<PersonDTO> content;
	
	private int pageNumber;
	
	private int pageSize;
	
	private long totalElements;
	
	private long totalPages;
	
	//If current page is lastPage means will return true otherwise will return false
	private boolean lastPage;
}

Application.java
================
package com.ashokit;

import org.modelmapper.ModelMapper;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;


@SpringBootApplication
public class Application {

	public static void main(String[] args) {
		SpringApplication.run(Application.class, args);
	}
	
	//Making ModelMapper as SpringBean
	@Bean
	public ModelMapper getModelMapper() {
		return new ModelMapper();
	}
}



+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++