Greetings!

I am Sushant Hirave, a Java specialist programmer with a rich academic and

professional background. Born in the vibrant city of Kolhapur, I now reside in Pune, an emerging
IT hub of India. My academic journey began at SKN Sinhgad Institute of Technology, Lonavala,
where I earned my Bachelor's degree in Mechanical Engineering. Recognizing the wave of
digitization and the power of software, I further pursued a Postgraduate diploma at CDAC. Here,
I immersed myself in the intricacies of the Java programming language, augmented by
complementary skills in MySQL and ReactJs.

Beyond my professional commitments, I am an avid reader, always on a quest to expand

my horizons on diverse subjects. My passion lies not just in coding but in leveraging it to find
innovative solutions to complex challenges. With a firm belief in the mantra of continuous
learning, I strive to evolve both personally and professionally. As we delve into this project
document, you'll be experiencing the world of Java and software solutions through the lens of
my expertise and insights.

===============================================================================

Project: I worked on a comprehensive logistics management system, called Hoptek. The main
aim of this project was to streamline the process of freight forwarding – including tracking
shipments, managing inventory, and facilitating communication between all stakeholders. The
application was built using Spring Boot for the backend services and React.js for the frontend.
My main responsibilities included creating RESTful APIs, integrating with the database via
Hibernate, and ensuring secure transactions with Spring Security.

1. What is Spring?: Spring Framework is an application framework and inversion of control

container for the Java platform. In the context of our logistics application, we used Spring to
manage the business services, data access objects, and transaction management. It helped
us focus on the core business logic, rather than dealing with boilerplate code.

2. What is Spring Boot framework?: Spring Boot is a project that is built on top of the Spring
Framework. It provides a simplified approach to creating stand-alone, production-grade
Spring-based applications. In Hoptek, we used Spring Boot to rapidly develop our
microservices, minimize our configuration requirements, and easily package our application
for deployment.

3. Annotations used in Spring MVC: In Hoptek, we used the following annotations:

• @Controller: to denote classes as Spring MVC Controllers

• @Service: to mark service classes

• @Repository: for DAO classes

• @Autowired: for dependency injection

• @RequestMapping, @GetMapping, @PostMapping, @PutMapping,

@DeleteMapping: to map HTTP requests to specific handler methods

• @RequestParam, @PathVariable, @RequestBody: to bind request parameters,

path variables, and request bodies to method parameters

4. What is Stream API?: Java's Stream API is a functional programming feature introduced in
Java 8. In our project, we used Stream API to process collections of shipment, order, and
 inventory data. It provided a more efficient and readable way of handling such data as
compared to traditional loops or iterator-based processing.

5. Where we use Spring MVC: In the Hoptek application, we used Spring MVC in the
development of all our backend services. These services were responsible for managing
various entities such as shipments, orders, inventory, and users. They handled HTTP
requests, executed business logic, interacted with the database, and returned HTTP
responses.

6. What is HTML and CSS?: HTML and CSS are fundamental technologies used to build web
pages. HTML provides the structure of the page, while CSS defines the style. In our project,
these were used primarily in the development of the React.js-based frontend.

7. If we have to fetch data like (name, email id, MobNo., Account number) which
annotations you use in Spring MVC?: To fetch data from the client side, we utilized several
Spring MVC annotations. If these fields are included in a form submission or as query
parameters in a GET request, @RequestParam would be used. If this data is sent in a POST
request in the body, we'd use @RequestBody to bind it to a Java object.

Testing and Deployment: For testing our application, we used JUnit and Mockito for unit
tests and Spring's MockMvc for integration tests. These tools helped us ensure that our code
was working as expected at all levels, from individual units of code to the interaction
between our objects and layers.

8. For deployment, we used Docker to containerize our services and AWS (Amazon Web
Services) to host our application. Docker allowed us to ensure consistency across all
environments from development to production, while AWS provided us with scalable,
secure, and highly available infrastructure.

9. Inter-service Communication: As our application was designed using a microservices

architecture, we needed a way to handle communication between services. For this, we
used Spring Cloud's Feign Client for synchronous HTTP requests, and RabbitMQ for
asynchronous messaging. This ensured a seamless flow of data across different parts of our
application.

10. Security: We used Spring Security to handle security in our application. This included
authenticating users based on their roles, securing endpoints, and encrypting sensitive data.
OAuth2 was used for managing secure access to our services with JWT (JSON Web Token)
for maintaining user session information.

11. Data Management: We used Spring Data JPA to interact with our database. This reduced the
amount of boilerplate code we had to write and made it easier to implement complex
database operations. In terms of databases, we used MySQL for relational data and
MongoDB for data that was more suited to a NoSQL structure.

12. Real-Time Tracking: One of the key features of our application was real-time tracking of
shipments. For this, we used a combination of IoT devices on the trucks and a microservice
that processed this data. This service used Spring WebFlux to handle the stream of data
coming from the IoT devices and provided real-time updates to the client applications.
 13. Exception Handling: We used Spring's @ControllerAdvice to handle exceptions across our
application. This allowed us to centralize our exception handling logic and provide consistent
responses when errors occurred.

14. Batch Processing: For certain operations, like end-of-day reports or sending bulk
notifications, we used Spring Batch. This made it easier to handle these large operations in
an efficient, scalable manner.

Through this project, I gained extensive experience in building a complex, scalable

application using the Spring ecosystem, from the core Spring Framework and Spring Boot, to
Spring Data JPA, Spring Security, and Spring Cloud. It was a challenging project, but the
flexibility and power of Spring made it a rewarding one.

1. What is Spring?

Spring is a powerful, lightweight framework developed by Rod Johnson in 2003. It is used for
enterprise application development. It is an open-source Java platform and can be used to develop
any Java application. It provides comprehensive infrastructure support for developing robust Java
applications easily and rapidly. The Spring Framework supports dependency injection, aspect-
oriented programming, and many other features that allow you to create enterprise-grade
applications.

2. OOP Concepts:

Object-Oriented Programming (OOP) is a programming paradigm that uses objects, which are
instances of classes, which interact together to design applications and programs. There are four
major principles of Object-Oriented Programming:

• Encapsulation: This is the process of hiding data details and protecting them from
modification. It's often achieved using private variables and public getter and setter
methods.

• Abstraction: This involves creating simple, abstract models of more complex

systems by breaking them down into smaller, more manageable parts.

• Inheritance: This is a process where one class can inherit properties and methods
from another class. This allows for code reusability and logical structuring of code.

• Polymorphism: This allows one interface to be used for a general class of actions. It
means that the correct function is called for an object/class, depending on the type
of the object or arguments.

3. What is Exception Handling and their types?

Exception handling in programming is a construct to handle or deal with errors automatically. Most
modern programming languages provide exception handling mechanisms to help developers create
more robust and fault-tolerant software.

Exceptions are runtime anomalies or unusual conditions that a program encounters during its
execution. When such conditions occur, the normal flow of the program is disrupted.

In Java, there are mainly two types of exceptions:

 • Checked Exceptions: These exceptions are checked at compile-time. Example:
IOException, SQLException etc.

• Unchecked Exceptions: These exceptions are not checked at compile-time, but at

runtime. Example: NullPointerException, ArrayIndexOutOfBoundsException etc.

4. Difference between interface and abstract class:

Basis of
Comparison Interface Abstract Class

An interface is a reference type in Java and is

similar to a class. It is a collection of abstract An abstract class, also in Java, is a class
methods (methods without bodies) and static that cannot be instantiated and is
1. What is it? constants. always used as a base class.

Multiple Abstract classes do not support multiple

Inheritance Interfaces support multiple inheritance. inheritance.

An abstract class can provide a default

Default An interface cannot provide any code at all, implementation of some methods and
Implementation just the method signatures. only the method signatures of others.

Interface cannot have access modifiers for the Abstract classes can contain access
subs, functions, properties etc everything is modifiers for the subs, functions,
Access Modifiers assumed as public. properties.

Keyword for "implements" keyword is used to implement "extends" keyword is used to extend an
Implementation an interface. abstract class.

Variables declared in an interface is by default An abstract class may contain non-final

Type of Variables final. variables.

Interface is slower as it requires extra

Speed indirection. Abstract class is faster.