Mastering Spring Framework Fundamentals

Course Curriculum

Chapter 1: Getting Started

Lecture 1: Section Introduction

Lecture 2: Key Spring Resources you Need to Know

Lecture 3: Configuring a project's dependencies to use Spring

Chapter 2: Creating the Spring Container with Application Contexts

Lecture 1: Section Introduction

Lecture 2: A Look at the Application Context (aka The Spring Container)

Lecture 3: Creating the File System XML Application Context

Lecture 4: Configuring Autocomplete when Writing Spring XML Configuration Files

Chapter 3: Creating, Retrieving and Using Spring-Managed Beans

Lecture 1: Section Introduction

Lecture 2: Creating a Bean Managed with Spring's XML Container Configuration

Lecture 3: Retrieving and Using a Bean from the Spring Container

Lecture 4: Using the Classpath XML Application Context

Lecture 5: Understanding Singleton Scope

Lecture 6: Understanding Prototype Scope

Lecture 7: Understanding How Spring Creates Stateless Beans

Chapter 4: Understanding Dependency Injection and Inversion of Control

Lecture 1: Section Introduction

Lecture 2: Coding Beans to Use Constructor Dependency Injection

Lecture 3: Interpreting a Spring Container Exception

Lecture 4: Applying Constructor Dependency Injection to XML Configuration

Lecture 5: Verifying the Constructor Dependency Injection with the Debugger

Lecture 6: The Sharability of Beans in an IoC Container

Lecture 7: The Benefits of Dependency Injection in an IoC Container

Lecture 8: The Hollywood Principle

Lecture 9: Coding Beans to Use Setter Dependency Injection

Lecture 10: Applying Setter Dependency Injection in XML Configuration

Lecture 11: Verifying the Setter Dependency Injection with the Debugger

Chapter 5: Autowiring Dependencies in the Spring Container

Lecture 1: Section Introduction

Lecture 2: Adding Component Scanning to Autodetect Spring Managed Bean Annotations

Lecture 3: Coding Beans to be Automanaged and Autowired by Spring via Annotations

Lecture 4: The Advantage of Annotation-based Configuration over XML Configuration

Lecture 5: Verifying the Annotation-driven Autowired Beans

Lecture 6: Spring's Stereotype Annotations for Better Code Readability

Lecture 7: Setter Dependency Injection with Annotations

Lecture 8: Constructor Dependency Injection with Annotations

Lecture 9: Using the Annotation-Based Application Context

Lecture 10: Creating a Java Configuration Class

Lecture 11: Applying Java-based configuration with @Bean

Lecture 12: Using Scopes with Java-based Configuration

Lecture 13: Modeling a More Complex Application to Demonstrate Autowiring Ambiguity Issues

Lecture 14: Resolving Ambiguous Arguments of the Same Type by Narrowing the Reference Type

Lecture 15: Resolving Ambiguous Arguments of the Same Type by Using @Qualifier

Chapter 6: Using Properties and Profiles in Spring Projects

Lecture 1: Section Introduction

Lecture 2: Injecting Properties read from a Properties File with @Value in Spring Managed B

Lecture 3: Exploring Property Overriding in Spring

Lecture 4: Accessing and using properties with PropertyPlaceholder in XML Configuration

Lecture 5: Specifying default properties for property values

Lecture 6: Exceptions for Missing property keys in Spring

Lecture 7: Resolving and Using a Property Value in a Bean definition in XML Configuration

Lecture 8: Accessing the Current Active Profiles with the Environment interface

Lecture 9: Setting the current active profile programmatically & through a property switch

Lecture 10: Creating Profile-specific bean configuration

Lecture 11: Conditional Beans with @Profile

Chapter 7: Getting to Know the Spring Container

Lecture 1: The Proxy Design Pattern

Lecture 2: Seeing Proxies in Action

Lecture 3: The Disadvantages of a Regular Proxy

Lecture 4: Understanding JDK Dynamic Proxies

Lecture 5: Dynamic Proxies in Spring

Lecture 6: Understanding how Spring Makes Service Methods Transactional using Proxies

Lecture 7: Spring Managed Bean Lifecycle Callback Methods

Lecture 8: JDK Standard Lifecycle Annotations (@PostConstruct and @PreDestroy)

Lecture 9: The Sequence of Spring Container Callbacks on a Spring Managed Bean

Lecture 10: Application Container Callbacks and Events

Lecture 11: Using the *Aware Interfaces to Access Lower-Level Spring Framework Components

Chapter 8: Accessing Databases with Spring

Lecture 1: Creating and Configuring Data Sources

Lecture 2: Creating a Data Access Object to Access a Database

Lecture 3: Connection Pool Data Sources in Spring

Lecture 4: Creating a JDBC Template to Access a Database

Lecture 5: Using JDBC Templates to Insert and Query Data

Lecture 6: Using JDBC DAO Support to Remove Boilerplate JDBC Code

Chapter 9: Aspect Oriented Programming in Spring

Lecture 1: Preparing a Spring Project to Use Aspects

Lecture 2: Creating a Spring Managed Bean to be Intercepted

Lecture 3: Advising Beans in Spring

Lecture 4: Understanding Pointcuts and Joinpoints

Lecture 5: Accessing Joinpoints Programmatically within an Aspect

Lecture 6: Coding Dynamic Advice with Around

Chapter 10: Web Application Development in Spring

Lecture 1: Preparing a Maven Project to Use Spring MVC

Lecture 2: Registering the Dispatcher Servlet as Front Controller

Lecture 3: Creating the Web Application Context

Lecture 4: Creating a Controller Class

Lecture 5: Configuring the Jetty Plugin in Maven to Run a Web App

Lecture 6: Setting Up Remote Debugging of a Web App

Lecture 7: Understanding the Dispatcher Servlet Processing Flow

Lecture 8: Writing a Controller to Service Web Requests

Lecture 9: Rendering a JSP-Based View with View Resolvers

Lecture 10: Understanding How a Request is Serviced

Lecture 11: Passing a Model to the View for More Dynamic Pages

Lecture 12: Injecting the HTTP Servlet Request and Response into a Controller

Lecture 13: Passing Request Parameters and Query Strings to a Controller

Lecture 14: Using Path Variables to Access Parts of the Request Path