Java full stack mock Interview 03 | Can You Crack Cognizant Java Interview? | Full Stack Q&A

Technical concepts & interview topics covered (Spring Boot / Java / Full-Stack)

Candidate introduction + skills/tools

• Training skills mentioned:
  • Spring Boot
  • Java 8 / Java 17
  • Collections
  • Multi-threading
  • Exception Handling
  • Spring Data JPA
  • Threading / exceptions
  • Design patterns: Factory, Template

---

Spring Boot core

• Dependency Injection (DI) as the core feature
  • Helps keep apps loosely coupled.
• IoC / Inversion of Control
  • Spring’s IoC container manages object creation and wiring.
• Types of IoC containers:
  • BeanFactory
  • ApplicationContext
• Spring Boot startup behavior:
  • Spring scans classes with stereotype annotations
  • Creates objects stored in the IoC container (key-value style)
• Stereotype annotations listed:
  • @Controller
  • @Service
  • @Component
  • @Repository
• Relation to design pattern:
  • Mentions Spring using the IoC container / factory-like object creation.

---

Database access using Spring Data JPA

• JPA described as a way to perform database operations via repositories.
• Repository approach:
  • Extending JPA repository-style functionality
  • Common methods mentioned:
    • save
    • findById
    • findAll
• Key Hibernate/JPA annotations:
  • @Entity
  • @Table
  • @Id
• Difference:
  • @Entity maps a class to a table entity
  • @Table changes the table name
• Dependencies noted:
  • Spring starters such as Spring Data JPA
  • A database driver (exact name appears noisy in the source)
  • Devtools dependency mentioned to avoid repeated restarts

---

REST & controller concepts

@RestController vs @Controller

• @RestController
  • Returns JSON/XML responses
• @Controller
  • Returns HTML/view responses

DispatcherServlet architecture (Spring MVC request flow)

• Request enters DispatcherServlet (entry point)
• Uses HandlerMapping to route to the controller + method
• Returns response
• Uses ViewResolver to render HTML/view

---

Exception handling (Spring)

• @ExceptionHandler
  • Used for global exception handling
• Goal:
  • Avoid writing multiple try-catch blocks
  • Return proper HTTP status/message using ResponseEntity
• Mentions custom/user-defined exceptions (e.g., service-based exceptions)
• General Java exception handling concept:
  • An exception is an unwanted event; handled using try/catch

---

Threading / Java concurrency

• Thread definition:
  • Smallest unit of work
• Thread creation methods (4):
  1. Extend Thread
  2. Implement Runnable
  3. Implement Callable
  4. Use lambda expressions (Java 8)
• ExecutorService
  • Interface for creating/managing threads via submitting Runnable/Callable
  • Mentions Future for result retrieval
  • Thread pool types named:
    • single thread
    • cached thread pool
    • fixed thread pool
    • scheduled thread pool
• Multi-threading:
  • Multiple independent tasks concurrently to improve performance
• Synchronization / thread safety
  • Thread safety described as safe concurrent access to a collection
  • General guidance:
    • Use synchronization when thread safety is required
    • Avoid it if performance is critical (performance vs safety tradeoff)
• ConcurrentModificationException
  • Happens during simultaneous read/write while iterating
  • Mitigation: Concurrent Collections
  • Types mentioned:
    • CopyOnWriteArrayList
    • CopyOnWriteArraySet
    • ConcurrentHashMap
• ReentrantLock (Lock interface implementation)
  • Mentions lock/unlock and tryLock
    • optionally with waiting time
    • described as non-blocking behavior
• Immutable
  • Immutable = unchangeable object
  • Achieved using:
    • final class
    • final variables
    • no setter methods
• String immutability issue
  • Discusses memory concerns with repeated String creation
  • Mentions solutions:
    • StringBuffer
    • StringBuilder

---

Java 8 streams & collections

Java 8 features

• Functional Interface
• Lambda
• Stream API

Stream API

• Represents sequences of objects
• Supports filtering, mapping, sorting
• Operations:
  • intermediate
  • terminal
• Types:
  • parallel stream
  • sequential stream

Collections

• Collections as an interface for groups of objects (mentions List/Set)
• ArrayList / LinkedList / Vector
  • ArrayList: general use
  • LinkedList: node-based
  • Vector: synchronization use-case
• HashMap
  • Stores key-value pairs; disallows duplicate keys
  • equals/hashCode contract:
    • if equals is true, hash codes should match
  • Internal working described:
    • default array size 16
    • bucket index computed from hash / (buckets - 1)
    • collision handling using equals, then replacement/creation of nodes

---

REST vs SOAP & communication

GET/POST mappings

• Mentions:
  • @PostMapping used to save records
  • @GetMapping used to retrieve data

SOAP vs REST

• SOAP
  • More secure (uses XML)
  • Slower and less flexible
• REST
  • Faster and more flexible
  • Less secure (per subtitle statement)

Communication styles

• Synchronous
  • Mentioned via REST / “restful API”
• Asynchronous
  • Using RabbitMQ and Kafka
• Why async:
  • If the receiving service is down, messages should not be lost
  • Kafka/RabbitMQ buffer/store messages for later consumption

---

Microservices concepts

Monolith vs Microservices

• Monolith
  • Single deployable app
  • Easier maintenance
  • Failure in one part can bring down the whole app
  • Redeploy the whole app
• Microservices
  • Split into smaller services
  • Easier to isolate failures
  • More complex to maintain

Eureka Server

• Service registry/discovery
• Services register so others can find them

API Gateway

• Entry point for requests
• Routes to the relevant microservices

Load balancing

• Distributes requests across multiple instances
  • Example: round robin

Inter-service communication tools

• Mentions RestTemplate / FeignClient (source subtitle suggests “FinClient”)
• Async via RabbitMQ / Kafka

---

Performance and caching

• Ways to improve performance:
  • caching
  • indexing
  • load balancing
• Cache concept:
  • Caches data temporarily
• Cache types mentioned:
  • In-memory cache (example: Caffeine)
  • Distributed cache (example: Redis)
• Tie-in to architecture:
  • monolithic vs microservices (deployment/performance connection)

---

Security in Spring Boot

• Two security approaches mentioned:
  • Session-based security
  • JWT security
• Preference for JWT:
  • JWT is stateless (no server-side session storage)
  • Session-based security can become heavy with many users creating many sessions

---

Transactions and rollback

• Example scenario:
  • Order/payment mismatch (payment succeeds but order fails)
• Solution described:
  • Use transactions with propagation and isolation levels
• Subtitle indicates transaction-level categories exist (propagation names appear partially unclear/noisy in the source)

---

Key product/feature takeaways for interview readiness

• Spring Boot
  • Dependency Injection, IoC container
  • BeanFactory vs ApplicationContext
  • Stereotype annotations
  • Typical startup scanning
• Data layer
  • Spring Data JPA repository method approach
  • @Entity / @Table / @Id mapping
• Controller layer
  • @RestController vs @Controller
  • DispatcherServlet flow (HandlerMapping → controller → ViewResolver)
• Resilience
  • @ExceptionHandler / @ControllerAdvice for global exceptions + custom exceptions
• Java fundamentals
  • Exceptions
  • Threading creation
  • Executor framework
  • Streams & collections
  • Concurrency issues
  • HashMap mechanics
  • Immutability
• System design
  • REST/SOAP comparison
  • Async messaging (Kafka/RabbitMQ)
  • Microservices (Eureka, API Gateway, load balancing)
  • Caching
  • Security (JWT vs sessions)

---

Main speakers / sources

• Vaishnavi Sopade (interviewee / candidate)
• Sir (interviewer / host)