
Explore inversion of control and dependency injection, their types, and when to use each, then build your first Spring application and set up IntelliJ IDEA and documentation sources.
Discover inversion of control, a design principle that moves dependency creation to another component, reducing coupling and enabling easier testing with mock objects.
Explore dependency injection techniques in a barista example, comparing constructor, setter, and direct injection. Use latte and espresso instructions, and note optional dependencies within the Spring framework.
Explore Spring dependency injection by comparing constructor, setter, and field injection, using @Autowired and @Primary to manage two coffee instruction implementations in a barista app.
Explore how bean definitions differ between annotation-based components and Java configuration, as a restaurant service returns a cook implementation; understand how autowired mode changes and the role of configuration classes.
Explore bean scopes, including the default singleton and prototype injection into a singleton, and implement a custom bean using component and annotation-based configuration.
Implement a custom Spring scope that reuses a bean for five seconds, creating a new bean if the previous one is older, and register destruction callback with the bean factory.
Explore the Spring bean life cycle by implementing init and destroy methods, using post construct and pre-destroy, and configuring via annotations or Java config for singleton and prototype beans.
Develop a custom bean factory postprocessor to scan bean definitions in our package, detect the init method annotation, and register and set each bean's init method name.
Explore how bean post processor works with bean factory post processor, detailing before and after initialization steps, bean vs proxy distinction, and the chain of responsibility among processors.
Create two custom bean post processors to practice preparing code for bean post processors, exploring postProcessBeforeInitialization, postProcessAfterInitialization, and postConstruct, with proxy, dynamic proxy, and cglib considerations.
Explore implementing a dynamic proxy via a bean post processor with an invocation handler. See how the proxy forwards methods to the target bean and impacts post construct annotations.
Learn to build dynamic and cglib proxies using enhancer, callback, and invocation handler, switch proxy types, and preserve the original bean for post processors through method interception.
Create a second bean post processor that enforces the @Critical annotation with a max time, uses reflection to time methods, and prints a warning when execution exceeds the limit.
Explore a dynamic proxy approach in Spring to enforce a critical annotation, measuring method execution time against a max threshold and emitting warnings when exceeded during a pizza order workflow.
Master spring autowiring with @Autowired and @Qualifier in constructor, method, field injections. Learn how Spring resolves candidates via primary or bean name, and when no unique bean definition exception arises.
Explore how primary annotation prioritizes beans and how @Qualifier with custom qualifiers selects the correct bean for autowired injection, such as fast cook or slow cook.
Explore how autowired and qualifiers wire dependencies in Spring through hands-on practice, covering single vs multiple constructors, required and qualifier annotations, and injecting lists and maps of beans.
Explore how spring aop uses dynamic and cglib proxies to intercept methods. See interface-based dynamic proxies and target-class cglib proxies created with enhancer, including before and after method calls.
Test Spring AOP in practice by using dynamic proxies and cli proxies, adjust proxy target class, and implement aspects with different advices around a critical annotation.
Master the Core Fundamentals of Spring Framework and Build Rock-Solid Java Applications
Are you ready to take your Java development skills to the next level? This comprehensive Spring Framework course will teach you everything you need to know about Spring's core concepts, from the ground up.
Why This Course?
Spring Framework is the most popular Java framework used by millions of developers worldwide. But here's the problem: most developers jump straight into Spring Boot without understanding the fundamental concepts that power it. This course fixes that by teaching you the core principles that make Spring so powerful.
What Makes This Course Different?
Deep Dive Into Core Concepts: Unlike surface-level tutorials, we explore how Spring actually works under the hood. You'll understand WHY things work, not just HOW to make them work.
Theory + Practice Approach: Every concept is explained theoretically first, then immediately reinforced with hands-on coding exercises using real-world examples like coffee shop and restaurant applications.
Professional Development Setup: Learn to work with IntelliJ IDEA like a pro, including project setup, navigation, and debugging techniques.
What You'll Master:
Section 1: Foundation Concepts
Inversion of Control (IoC): Understand this fundamental design principle and its relationship with SOLID principles
Dependency Injection: Master all three types of DI with practical implementations
IntelliJ IDEA Mastery: Complete IDE setup and project structure understanding
Section 2: Spring Core Deep Dive
Spring Container: Configure applications using XML, Java Config, and component scanning
Bean Definitions: Create and manipulate bean definitions programmatically
Bean Scopes: Master Singleton, Prototype, and custom scopes with real-world scenarios
Bean Lifecycle: Control bean initialization and destruction with various callback methods
Advanced Topics:
Bean Factory Post Processors (BFPP): Build custom processors to modify bean definitions
Bean Post Processors (BPP): Create powerful interceptors using dynamic proxies and CGLIB
Spring Annotations: Master @Configuration, @ComponentScan, @Autowired, @Qualifier, and more
Aspect-Oriented Programming (AOP): Implement cross-cutting concerns with various advice types
Hands-On Learning Experience
You'll build multiple practical applications throughout the course:
Coffee shop instruction system demonstrating IoC and DI
Restaurant service application showcasing Spring Container features
Custom annotation processors for real-world scenarios
AOP implementations for logging and error handling
Students Feebdack:
Over 500 students have already completed my Russian-language version of this course on Stepik platform.
"I really enjoyed the course. It will be very useful for beginners. I've been working as a Java developer for 5 years and decided to dive deeper into Spring out of curiosity. I definitely don't regret taking it - I learned something new and refreshed my knowledge on familiar topics."