SPRING:

 Spring in depth (LinkedIn learning) : IOC Container, Application Context, DI, Environment,
Profiles, Types of beans/ bean scopes (singleton[EAGER], prototype[LAZY], session, request) -
https://www.youtube.com/watch?v=NnNvDknQJt0 , Component Scan, Bean life cycle -
https://reflectoring.io/spring-bean-lifecycle/ [Just remember 4 high level phases : creation,
ready, destruction and destroyed]
 Byte programming : Spring boot interview questions,
 Global exception handling - https://www.youtube.com/watch?v=xWnU6x5BxyA
 Your project details : Java – 1.8, Spring Boot – 2.4.1, Maven : 4.0.0, Deployment : Azure
functions (PaaS), Logger : applicationinsights-logging-logback, IN QUIKR : External tomcat
container

------------------------------------------------------------------------------------------------------------------------------------

 JPA (LinkedIn learning) – EntityManager, Relationships (OneToOne,ManyToOne[JoinColumns],

OneToMany,ManyToMany[JoinTable]), Your project specific
 Transaction management in spring(Local Transactions) : ACID Properties, How to start, commit
and rollback transactions using EntityManager, @Transactional annotation, parameters used in
transactional like : ,propagation(to handle existing transactions and creation of new
transactions), readOnly, rollbackFor, noRollbackFor - https://www.youtube.com/watch?
v=SUQxXg229Xg,
 Distributed transactions(Theory) : # Optimistic locks(for read heavy operations, row[s] are not
locked, timestamp/version number is matched before and after transaction), pessimistic
locks(more suitable but difficult to implement, set isolation levels) -
https://www.youtube.com/watch?v=VxGKvqHhU5c , # Transactions problems – dirty read, non
repeatable read, phantom read, read_committed -> prevents dirty read, repeatable_read ->
prevents dirty read + non repeatable reads, serilizable -> prevents all three, more the strictness
of isolation level, slower the transaction - https://www.youtube.com/watch?v=CTCAo89fcQw

MICROSERVICES:
 Microservices introduction : What are microservices, beneifts and disadvantages of
microservices and monoliths - https://www.youtube.com/watch?v=-
cnhtFwcWiY&list=PLJN9ydlFnJsiTE9mhNJLomdLBI5YYAMOY&index=1
 Microservices design patterns : Decomposition(Business based, domain based, strangler),
Integration (Client-side UI, Aggergator[composite service], API Gateway), Database(Database
per service, shared database per service, CQRS, SAGA), Observability (Log aggregation, error
tracking, application metrics), Cross-cutting concerns (External config, service discovery, blue
green deployment, circuit breaker) - https://www.youtube.com/watch?v=Bt7aC-
7mEw0&list=PLJN9ydlFnJsiTE9mhNJLomdLBI5YYAMOY&index=2
 API Gateway : Benefits, Jobs( Request routing, authentication, authorization, rate limiting,
application metrics), Ex: Implement own (NGINX, ZUUL, Spring Cloud Gateway), 3 rd Party(Azure
APIM, AWS API Gateway, APIGEE) - https://www.youtube.com/watch?v=1vjOv_f9L8I
https://www.youtube.com/watch?v=1HH6FJPzvho
  Azure APIM, Application insights : Read theory
 Service Discovery: Client-side , server-side , service discovery, service registry, registry clients
https://www.youtube.com/watch?
v=Xt6McO5q2e0&list=PLJN9ydlFnJsiTE9mhNJLomdLBI5YYAMOY&index=4
https://www.youtube.com/watch?v=GboiMJm6WlA
 Circuit-breaker: Use of circuit breaker, advantages - https://www.youtube.com/watch?
v=rH_pvDQP92U&list=PLJN9ydlFnJsiTE9mhNJLomdLBI5YYAMOY&index=5

JAVA 8 :
 Navin Reddy entire playlist
 Working of HashMap - https://www.youtube.com/watch?v=-oafFAPgLao&list=PL3hpmQhMoz-
dMhvnkTunjOMZSa_f3FH24&index=2
 Object Interning - https://www.youtube.com/watch?v=to9DPVsdByE
 Streams API - Java8 - YouTube (Java Techie Java8)
 Equals and HashCode contract - https://www.youtube.com/watch?
v=CpVALR9HeTE&list=PL3hpmQhMoz-dMhvnkTunjOMZSa_f3FH24&index=2
 JVM : https://www.youtube.com/watch?v=QHIWkwxs0AI
 GC - https://www.youtube.com/playlist?list=PLIouBkZvaedS4ukIzMHUy3U5DT86AqkFC
 Multithreading : What is a thread, benefits of thread, Thread creation in java(Thread
class/Runnable interfaces, via lambda expressions), isAlive(), join(), Thread.sleep(), thread
interleaving problem, synchronized keyword(makes processing a bit slow), intrinsic lock
(associated with object), Synchronized block(mutex), Separate lock objects,
executor.shutdown() [ stop accepting new tasks and wait for the completion of previously
submitted tasks ] , CountDownLatch(ThreadSafe) - https://www.youtube.com/watch?
v=NPGjrhDIzrs , Mutex vs Semaphore vs CountDownLatch [explained at the end of the video in
previous link], Blocking Queue, wait() [releases lock instantly], notify() [doesn’t release lock until
synchronized block gets completed] , Producer-consumer using wait notify, Reentrant lock[ Lock
lock = new ReentrantLock(), lock.lock(), lock.unlock()] ,Condition object [ Condition cond =
lock.getCondition() ], cond.await(), cond.signal() [ equivalent of wait and notify but no need to
surround with synchronized block in case of reentrant lock ], Deadlocks [how to avoid
deadlock(try acquiring locks in same order, use lock.tryLock()], Semaphore [acquire, relese,
availablePermits() ], Future[Java equivalent of promise] (Callable, Future, get(), cancel(),
isDone(), isCancelled(), isCancelled() with interrupt flag, get() with timeout, invokeAll() ->
returns list of futures ) - https://www.callicoder.com/java-callable-and-future-tutorial/ ,
CompletableFuture (runAsync(), supplyAsync() ) - https://www.youtube.com/watch?
v=Kk4D8lMVTN4&list=PLn2GH4dN5i2CHTNP4tm0jlRDtdHsH2kgu&index=2 , completable future
functions - https://www.youtube.com/watch?v=Dup4VnMS-9Y

Thread basics from Navin reddy

Synchronization onwards from – Cave of Programming - https://www.youtube.com/playlist?

list=PLBB24CFB073F1048E

 Basic design patterns: Singleton, Factory, Builder, Prototype, Flyweight, MVC

 Core Java interview questions : https://www.youtube.com/playlist?
list=PLyHJZXNdCXscoyL5XEZoHHZ86_6h3GWE1