Java Under the Hood: Bytecode, Generics & Frameworks

Name: Java Under the Hood: Bytecode, Generics & Frameworks
Rating: 4.9 (25 reviews)

Go Beyond Core Java: A Deep Dive into the JVM and API Design

Created byPaweł Zwarycz

Last updated 2/2026

English

English [Auto],

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

Coding Exercises

This course includes our updated coding exercises so you can practice your skills as you learn.

Course content

6 sections • 24 lectures • 3h 45m total length

Introduction1:21
Explore how the JVM sees Java code, and dive into generics, the reflection API, and dynamic proxies, then understand how Spring dependency injection works to deepen your mastery.

Annotation creation7:31
This video explains what basic setup is needed in Intellij for annotation processor creation and how basic annotation is made
What AST is11:07
Explain abstract syntax trees (AST) and how Lombok modifies AST to generate code, illustrated by creating a worker class and a say hello from AST method.
Disclaimer1:23
Lombok interacts with compiler internals using an API not meant for outside use, risking code breaking across compiler updates and Java versions; nevertheless, this video shows how Lombok works.
AutoService annotation8:24
Annotation Processor Initialization17:45
process Method Implementation12:25
Final Annotation Processor Config6:26
Check on Lombok topic

The javap -help Command2:33
Explore how the Java virtual machine views generic types by inspecting bytecode with the javap disassembler, using terminal commands like javap, -h, -cp, and -v to reveal class file details.
Test Your Knowledge: javap Help Options
The javap -verbose Command3:16
javap -v option
How to Read Class Structure from Bytecode with javap7:26
Learn how to read a class's structure from bytecode with javap, exploring type erasure and how the class file disassembler reveals constant pool entries, flags, methods, and attributes.
What is a Constant Pool?
Understanding Java Constructors with javap6:38
Explore erasure constructor with javap and how the compiler generates a super object constructor. Analyze bytecode details such as operand stack, locals, constant pool, and invokespecial.
aload_0 instruction
Understanding Java Methods with javap15:07
Explore how the JVM executes the main method, tracks an operand stack and locals, handles generics through type erasure, and uses constructors, checkcast, and print line via javap inspection.
ldc instruction

What the Compiler Hides: A Deep Dive into Generic Type Erasure14:31
The lecture shows how Java generics undergo type erasure, replacing unbound types with object and bounded ones with their bound, then adding casts and bridge methods.
Bridge methods purpose
Writing Reusable Generics: The PECS Approach13:31
Apply the PECS principle—producer extends and consumer super—to decide when to read from or write to a generic list, using extends for reads and super for writes.
Consumer in practice
Limitation of types we could read from Producer
From Confusion to Clarity: Reading Complex Generic Signatures7:48
Explore reading from a source, transforming with a function, and collecting into a destination using Java generics and the PECS principle, with examples from integers to strings.
Complex Generic Signature Exercise
The Self-Referential Generic Pattern10:40
Self-Referential Pattern in practice
What's Not Allowed in Java Generics, and Why?8:02
Prohibited Generics

Reading the Blueprint: A Guide to Java Reflection11:14
Rewriting the Blueprint: Manipulating Objects with Reflection16:48
Explore how to use reflection to inspect a class's fields and methods, access private members, read and modify values, and invoke methods at runtime to reveal internal behavior.
Reflection practice
Intercept Any Method Call: The Power of Dynamic Proxies12:22
Intercepting Methods with Dynamic Proxies
The Magic Behind Spring's @Transactional & @Cacheable11:26

Spring's Startup Secrets: How It Scans Your Classpath and Finds Beans13:12
Learn how Spring dependency injection scans a base package using a resource pattern resolver and metadata reader to identify concrete classes annotated as components and produce bean blueprints.
How Spring Manages Beans: An Introduction to the BeanFactory4:55
Explore how Spring manages beans by generating unique bean names, registering bean definitions in a default listable bean factory, and wiring dependencies with an autowired post processor during runtime.
Spring Dependency Injection Quiz

Requirements

This course requires a solid foundation in core Java, including practical experience with object-oriented programming, the Collections Framework, and basic generics
Practical Java Development Experience: You should be able to write, compile, and run Java applications using a modern IDE like IntelliJ IDEA, Eclipse, or VS Code

Description

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!

Who this course is for:

This course is for intermediate to advanced Java developers who are ready to master the powerful, "under-the-hood" mechanics of the language. It is perfect for curious developers who want to understand how frameworks like Spring and Hibernate work, rather than just using them. You will gain the deep knowledge needed to design your own flexible APIs and prepare for senior-level technical interviews. The course teaches you to solve complex problems using advanced topics like reflection, dynamic proxies, and dependency injection. If you want to transition from simply writing application code to truly understanding the Java platform, this course is for you

Java Under the Hood: Bytecode, Generics & Frameworks

What you'll learn

Explore related topics

Coding Exercises

Course content

Introduction1 lecture • 1min

How Lombok works "Under the Hood"7 lectures • 1hr 5min

Java Deep Dive: Understanding JVM Bytecode with Disassembly5 lectures • 35min

Java Generics Under the Hood: A Deep Dive5 lectures • 55min

Java Metaprogramming: The Magic Behind Modern Frameworks4 lectures • 52min

The Magic of @Autowired: A Deep Dive into Spring's DI Engine2 lectures • 18min

Requirements

Description

Who this course is for: