Course Information
Registration period
Year-round Recruitment
Course Level
Study Mode
Duration
3 Hour(s) 45 Minute(s)
Language
English
Taught by
Paweł Zwarycz
Rating
Course Overview
Go Beyond Core Java: A Deep Dive into the JVM and API Design
Are you an intermediate Java developer who uses powerful frameworks like Spring, Hibernate, or Mockito, but doesn't fully understand the "magic" that makes them work?
Have you ever wondered how @Autowired injects a dependency or how @Transactional manages a database session?
If you're ready to move beyond just using frameworks and want to master the deep, powerful mechanics of the Java platform itself, then this course is your next step. This is not just another "Core Java" course. This is a deep dive into the advanced, "under-the-hood" concepts that separate senior developers from the crowd.
By the end of this course, you will be able to:
Master Advanced Generics: Go beyond List<String> and conquer complex topics like PECS (? extends T vs. ? super T), self-referential patterns for fluent APIs, and the subtle but critical implications of type erasure.
Harness the Power of the Reflection API: Learn to inspect classes, invoke methods, and manipulate fields at runtime to build truly dynamic and flexible applications.
Create Dynamic Proxies: Understand the core mechanism behind AOP (Aspect-Oriented Programming) by creating proxies that can intercept method calls to add logging, security, or caching—without touching the original code.
Build Your Own Spring IoC Container: Demystify @Autowired by re-implementing Spring's core dependency injection mechanism from scratch. You'll manage the entire bean lifecycle, from classpath scanning and bean definition to final instantiation and injection.
Dissect Java Bytecode: Use the Java Class File Disassembler (javap) to see what the compiler is really doing with your code, giving you a profound understanding of the JVM.
Break the Lombok Illusion: Discover how Lombok uses compiler plugins and AST transformations to rewrite your source code on the fly. You’ll trace annotation processing step by step and understand the real cost, limitations, and trade-offs of Lombok in production systems.
This course is a direct, hands-on journey into the heart of the Java platform. You won't just learn theory; you will build practical examples that demystify these advanced topics and give you the confidence to use them in your own projects.
If you are ready to stop being a magician's audience and start becoming the magician, this course is for you.
Enroll today and take the next major step in your journey to becoming a senior Java expert!
Course Content
- 6 section(s)
- 24 lecture(s)
- Section 1 Introduction
- Section 2 How Lombok works "Under the Hood"
- Section 3 Java Deep Dive: Understanding JVM Bytecode with Disassembly
- Section 4 Java Generics Under the Hood: A Deep Dive
- Section 5 Java Metaprogramming: The Magic Behind Modern Frameworks
- Section 6 The Magic of @Autowired: A Deep Dive into Spring's DI Engine
What You’ll Learn
- Re-implement Spring's core dependency injection from scratch, manually managing the bean lifecycle from classpath scanning to instantiation, Gain a deeper understanding of the JVM by reading the bytecode generated from your own Java code, Design flexible and reusable APIs by applying the PECS principle (Producer Extends, Consumer Super) to generic method signatures, Build fluent, chainable APIs by implementing the self-referential generics pattern to ensure methods return the correct subtype, Design type-safe generic components by using multiple bounds to guarantee a type supports behaviors from different classes and interfaces, Explain how type erasure creates fundamental limitations in Java generics, Build dynamic and extensible applications by using the Reflection API to inspect classes, invoke methods, and manipulate fields at runtime, Use dynamic proxies and an InvocationHandler to inject concerns (e.g., logging) into business logic without modifying the original class, Gain practical understanding of Abstract Syntax Trees and see how exactly Lombok’s annotations use them to generate boilerplate code
Skills covered in this course
Reviews
-
DDan n
Good contents and walkthrough. Could have had more detailed explanations as to why instead of how.
-
CChandan Tiwari
its amazing experience learning through this course. the way of explaining topics is wonderful.
-
KKacper
A very interesting topic. Basic knowledge, but from a completely different, much deeper perspective. The instructor guides us step by step through the data displayed on the screen and explains its meaning. This approach is excellent, leaving no room for misunderstanding.
-
PPaul
interesting course
