Autoplay
Autocomplete
Previous Lesson
Complete and Continue
Mastering Spring Framework Fundamentals
Introduction
Welcome to the Course! (1:37)
Getting Started
Section Introduction (0:30)
Key Spring Resources you Need to Know (4:39)
Configuring a project's dependencies to use Spring (5:15)
Adding the Spring BOM to Better Manage Dependency Versions (5:16)
Creating the Spring Container with Application Contexts
Section Introduction (0:36)
A Look at the Application Context (aka The Spring Container) (10:30)
Creating the File System XML Application Context (4:21)
Configuring Autocomplete when Writing Spring XML Configuration Files (2:53)
Creating, Retrieving and Using Spring-Managed Beans
Section Introduction (0:46)
Creating a Bean Managed with Spring's XML Container Configuration (2:21)
Retrieving and Using a Bean from the Spring Container (2:43)
Using the Classpath XML Application Context (2:06)
Understanding Singleton Scope (2:18)
Understanding Prototype Scope (3:26)
Understanding How Spring Creates Stateless Beans (1:03)
Understanding Dependency Injection and Inversion of Control
Section Introduction (1:04)
Coding Beans to Use Constructor Dependency Injection (3:55)
Interpreting a Spring Container Exception (1:16)
Applying Constructor Dependency Injection to XML Configuration (2:26)
Verifying the Constructor Dependency Injection with the Debugger (1:55)
The Sharability of Beans in an IoC Container (1:40)
The Benefits of Dependency Injection in an IoC Container (1:31)
The Hollywood Principle (2:12)
Coding Beans to Use Setter Dependency Injection (1:35)
Applying Setter Dependency Injection in XML Configuration (1:45)
Verifying the Setter Dependency Injection with the Debugger (1:22)
Autowiring Dependencies in the Spring Container
Section Introduction (0:33)
Adding Component Scanning to Autodetect Spring Managed Bean Annotations (2:33)
Coding Beans to be Automanaged and Autowired by Spring via Annotations (1:28)
The Advantage of Annotation-based Configuration over XML Configuration (0:28)
Verifying the Annotation-driven Autowired Beans (1:22)
Spring's Stereotype Annotations for Better Code Readability (1:31)
Setter Dependency Injection with Annotations (0:41)
Constructor Dependency Injection with Annotations (1:38)
Using the Annotation-Based Application Context (1:14)
Creating a Java Configuration Class (1:42)
Applying Java-based configuration with @Bean (5:01)
Using Scopes with Java-based Configuration (2:30)
Modeling a More Complex Application to Demonstrate Autowiring Ambiguity Issues (7:27)
Resolving Ambiguous Arguments of the Same Type by Narrowing the Reference Type (4:04)
Resolving Ambiguous Arguments of the Same Type by Using @Qualifier (1:42)
Using Properties and Profiles in Spring Projects
Section Introduction (0:31)
Injecting Properties read from a Properties File with @Value in Spring Managed Beans (3:43)
Exploring Property Overriding in Spring (2:40)
Accessing and using properties with PropertyPlaceholder in XML Configuration (1:47)
Specifying default properties for property values (1:15)
Exceptions for Missing property keys in Spring (0:34)
Resolving and Using a Property Value in a Bean definition in XML Configuration (1:30)
Accessing the Current Active Profiles with the Environment interface (4:17)
Setting the current active profile programmatically and through a property switch (1:06)
Creating Profile-specific bean configuration (3:47)
Conditional Beans with @Profile (5:46)
Getting to Know the Spring Container
The Proxy Design Pattern (6:18)
Seeing Proxies in Action (1:14)
The Disadvantages of a Regular Proxy (2:19)
Understanding JDK Dynamic Proxies (9:47)
Dynamic Proxies in Spring (5:08)
Understanding How Spring Makes Service Methods Transactional using Proxies (9:23)
Spring Managed Bean Lifecycle Callback Methods (5:41)
JDK Standard Lifecycle Annotations (@PostConstruct and @PreDestroy) (2:24)
The Sequence of Spring Container Callbacks on a Spring Managed Bean (1:19)
Application Container Callbacks and Events (6:26)
Using the Aware Interfaces to Access Lower-Level Spring Framework Components (6:11)
Accessing Databases with Spring
Creating and Configuring Data Sources (7:29)
Creating a Data Acces Object to Access a Database (3:28)
Connection Pool Data Sources in Spring (3:07)
Creating a JDBC Template to Access a Database (4:59)
Using JDBC Templates to Insert and Query Data (5:43)
Using JDBC DAO Support to Remove Boilerplate JDBC Code (6:51)
Aspect Oriented Programming in Spring
Preparing a Spring Project to Use Aspects (5:44)
Creating a Spring Managed Bean to be Intercepted (2:20)
Advising Beans in Spring (3:08)
Understanding Pointcuts and Joinpoints (3:21)
Accessing Joinpoints Programmatically within an Aspect (3:00)
Coding Dynamic Advice with Around (6:23)
Web Application Development in Spring
Preparing a Maven Project to Use Spring MVC (5:20)
Registering the Dispatcher Servlet as Front Controller (7:13)
Creating the Web Application Context (2:03)
Creating a Controller Class (1:06)
Configuring the Jetty Plugin in Maven to Run a Web App (6:40)
Setting Up Remote Debugging of a Web App (5:41)
Understanding the Dispatcher Servlet Processing Flow (5:39)
Writing a Controller to Service Web Requests (3:19)
Rendering a JSP-Based View with View Resolvers (6:21)
Understanding How a Request is Serviced (8:11)
Passing a Model to the View for More Dynamic Pages (4:16)
Injecting the HTTP Servlet Request and Response into a Controller (1:40)
Passing Request Parameters and Query Strings to a Controller (2:00)
Using Path Variables to Access Parts of the Request Path (2:14)
The Sharability of Beans in an IoC Container
Lesson content locked
If you're already enrolled,
you'll need to login
.
Enroll in Course to Unlock