[NEW] Master the Spring Fundamentals, HOW it works inside

Explore Spring core concepts, including the Spring container, bean definitions, scopes, and lifecycle. Compare bean factory post processor and bean factory processor, and examine proxies in Spring AOP.

Understand how the Spring container stores and manages beans. Discover the three configuration approaches—XML, Java config, and annotations—and how the Spring container wires beans in application context.

Explore the Spring container hierarchy, comparing bean factory and application context, and learn how annotation config and classpath xml contexts create bean definitions and apply post processors.

Explore configuring the Spring container with XML, Java configurations, and annotations, create a Maven module, and add the Spring beans dependency to build a working app.

Explore the Spring container by creating a restaurant service that uses a cook interface with fast and slow cooks through dependency injection, enabling flexible order handling.

build a spring container with xml config, inject a cook into the restaurant service via an interface, and run a pizza order while swapping slow to fast cook in xml.

Configure the Spring container with Java config and annotations using an application config class, defining restaurant service and cook beans. Resolve missing bean issues by guiding Spring where to search.

Explore how the Spring container manages beans with and without @Configuration, observe cglib proxies in action, and learn how application config differs when using configuration annotations.

Apply @Component to classes and scan a base package so Spring creates beans. When multiple implementations exist, use primary annotation to choose the bean.

Explain the importance of the configuration annotation and how a Spring proxy ensures a single bean in the Spring container, preventing multiple object creations when calling cook.

Explore bean definition in the Spring container, including metadata, XML and Java configuration, and how a bean factory uses definitions to create beans. Examine abstract, generic, and annotated generic definitions.

Learn to create and inspect bean definitions in a Spring app, adjust scope and init/destroy methods, and transition from annotation config to a Java config class.

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.

Create and register your own bean definition by specifying the bean name and bean class, and observe the init and destroy methods being invoked when you close the context.

Register properties, inject values into a bean, compare constructor versus init method, and demonstrate singleton versus prototype scope in Spring.

Explore singleton and prototype bean scopes in Spring, how singleton maps one bean definition to one instance, how prototype creates a new bean per request, and custom scope basics.

Explore how to inject prototype beans into a singleton in Spring, and learn four solutions—application context, lookup method, proxy mode, and bean factory supplier—for achieving true prototype behavior.

Explore bean scopes, including the default singleton and prototype injection into a singleton, and implement a custom bean using component and annotation-based configuration.

Explore prototype bean behavior and how ApplicationContextAware helps fetch a new cook bean per order to ensure a fresh instance rather than a singleton.

Explore bean scopes with prototype and proxy mode, showing how a prototype bean is created anew by a cglib or jdk dynamic proxy, and how lookup annotation guides proxy behavior.

Explore Spring bean scopes by building a supplier-based bean and a custom scope that uses autowired injection and reuses a bean for five seconds before recreating it.

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.

Learn how bean creation differs from bean initialization, and follow how bean definitions flow through the bean factory, bean post processors, and post construct methods for full configuration.

Learn how the bean life cycle works in Spring, including post construct and pre-destroy annotations, bean post processors, and three init/destroy approaches for singleton and prototype beans.

Explore the bean life cycle with @PostConstruct and @PreDestroy, analyze initialization order between slow cook and restaurant service, and learn why prototype beans are not destroyed by the container.

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.

Explore how @PostConstruct initializes beans and init method call order in Spring. Learn that post construct annotation on default interface methods is supported, while non-default interface methods aren't invoked.

Explore the Spring bean life cycle, prototype scope, and proxy with ApProxy, using a cglib target class and init method invocation. Note property injection order and application context aware behavior.

Explore the bean factory post processor (BFPP): how it retrieves and modifies bean definitions within the bean factory, the role of static methods, and how ordering interfaces control execution.

Practice lesson about bean factory post processor; create a custom annotation @InitMethod to call a specified init method. Explore two registration approaches using component and bean annotations.

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.

Master how to create and test a custom Spring bean factory post processor, register beans, and ensure post construct initialization works, highlighting the importance of static methods in lifecycle handling.

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.

Explore basic annotations like @Configuration, @ComponentScan, and @Import, and learn how configuration marks beans and bean methods for runtime retention, and how Spring scans packages to import components.

Discover the component annotation for auto-detected beans via component scan, the role of stereotypes (controller, service, repository), and how @Bean on methods registers named beans with optional multiple names.

Inject values with @Value and property sources, and control bean scope with @Scope for singleton or prototype, while understanding post construct and pre destroy lifecycle methods.

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.

Master the Spring autowiring basics, including @Autowired with required=false, setter and field injection, collection and map injections, and using qualifiers and interfaces to inject all matching beans.

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.

Learn setter-based dependency injection with @Autowired tricks, including required false and qualifiers, and compare the effects of labeled vs unlabeled injections while Spring injects lists and maps of beans.

Explore how Spring resolves autowired bean injection when multiple beans exist using primary annotations and qualifiers, and observe list versus string injections with different bean configurations.

Demonstrates using qualifiers to select between cook implementations, replaces primary with named qualifiers, and creates custom qualifiers to resolve duplicate injection issues in a bean-based DI setup.

Explore creating and using custom @Qualifier annotations in Spring to control bean injection, resolve multiple beans, and implement targeted qualifier strategies.

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.

Explore how aspect-oriented programming uses aspects to apply common concerns like logging, security, and transactions to multiple methods, using proxies and an AspectJ expression and after advice.

Discover Spring AOP advice types: before, after, after returning, after throwing, and around, and how join points, order methods, and proceeding join points shape proxies, AspectJ, and auto proxy.

Learn practical spring aop concepts by building dynamic proxies and aspects, applying various advices, and implementing a custom annotation to replace bean post processors.

Compare cglib proxy and dynamic proxy in Spring aop, using enhancer and target class versus interface, and apply before advice with AspectJ auto proxy.

Explore auto proxy in Spring as a dynamic proxy wraps the restaurant service to apply @After advice after the order method. Understand proxy behavior and the final execution sequence.

Explore Spring AOP advices: after returning, after throwing, and finally, and master around advice with proceeding join point to control method execution and results.

Implement Spring AOP around advice for a critical annotation, capture method execution time, compare with max time, and log when exceeded.

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.