Summary of "TOP 100+ Spring Boot & Microservices Interview Questions and Answers | Ashok IT"

Summary of Main Ideas and Concepts

What is Spring? A lightweight, loosely coupled framework for developing enterprise backend applications like banking, e-commerce, RESTful services, microservices, and distributed systems.
Features of Spring:
- Predefined templates (JDBC, Hibernate, REST, JMS) to reduce boilerplate code
- Loose coupling via layered architecture (presentation, service, DAO)
- Lightweight memory footprint
- Easy testing with JUnit and Mockito
- Powerful abstractions (APIs, interfaces)
- Rapid Application Development (RAD)

Dependency Injection: Linking dependent objects automatically to reduce manual object creation. Configured via XML or annotations.
Types of DI:
- Constructor Injection (all dependencies required at object creation)
- Setter Injection (optional/partial injection, modifies existing objects)
- Field Injection (via @Autowired)
- Circular Injection (two objects depend on each other)
- Lookup Method Injection (special case for scope differences)
IoC Container: Manages object lifecycle, creation, linking, and destruction based on configuration (XML or annotations).

Spring Bean: An object managed by Spring container.
Bean Scopes:
- Singleton (one shared instance)
- Prototype (new instance per request)
- Request (per HTTP request)
- Session (per HTTP session)
- (Deprecated scopes also mentioned)
Bean Wiring: Linking beans manually or automatically (autowiring by type, name, constructor).
Annotations: @Autowired, @Inject (Java standard), @Qualifier (to resolve ambiguity), @Primary (to set default bean).

XML configuration files define beans, their properties, and dependencies.
Java-based configuration using annotations like @Component, @Bean, @Configuration.

init and destroy methods for bean lifecycle hooks.
Can be defined declaratively (XML), programmatically (implementing interfaces), or via annotations (@PostConstruct, @PreDestroy).

MVC Pattern: Model (data), View (UI), Controller (business logic).
DispatcherServlet: Front controller handling all requests.
Request Mapping: Using @RequestMapping and HTTP method-specific annotations (@GetMapping, @PostMapping, etc.).
Difference between @Controller and @RestController: @RestController = @Controller + @ResponseBody (returns JSON/XML).
Annotations for handling request data:
- @PathVariable (extracts data from URI path)
- @RequestParam (extracts query parameters)
- @RequestBody and @ResponseBody (for REST APIs)
- @ModelAttribute (binds form data to model objects)
Validation: Using annotations like @NotNull, @Pattern, @Email, and enabling via @Valid.
Exception Handling: Global exception handlers via @ControllerAdvice and @ExceptionHandler.
Cross-Origin Resource Sharing (CORS): @CrossOrigin annotation to enable cross-domain requests.

ORM (Object-Relational Mapping): Mapping Java objects to relational database tables.
JPA: Java Persistence API specification for ORM.
Hibernate: Popular JPA implementation.
Spring Data JPA: Provides repository interfaces (CrudRepository, JpaRepository, PagingAndSortingRepository) to simplify database operations without writing boilerplate code.
Custom Queries: Using @Query annotation with JPQL or native SQL.
Entity Classes: Annotated with @Entity, @Id, @Column.
Finder Methods: Naming conventions like findByLastName generate queries automatically.
Paging and Sorting: Support for pagination and sorting via repository interfaces.
Transactions: Managed by PlatformTransactionManager and @Transactional.
Fetch Types: Eager vs lazy loading for associations.
Join Types: Inner join, left/right/full outer joins in JPQL.