CF

Java Spring Tutorial Masterclass - Learn Spring Framework 5

45h 18m 33s
English
Paid

Elevate your career as a Java developer by mastering the Spring Framework—a skill in high demand with lucrative opportunities. The framework's size can be daunting due to its numerous modules and projects, making traditional tutorials less effective as they often focus on rarely used aspects.

Focus Areas for Learning Spring Framework

Key Spring Technologies

What Spring technologies should you focus on initially? If you're beginning with Spring, prioritize learning Spring Core, Spring MVC, and Spring Boot 2. These components offer the greatest impact:

  • Spring Core: An application framework and inversion of control (IoC) container for Java.
  • Spring MVC: A web framework offering Model View Controller architecture, using a DispatcherServlet.
  • Spring Boot 2.0: Facilitates the creation and deployment of standalone Spring applications with embedded databases and automated configuration.

Course Highlights

Why this course is perfect for learning Spring 5 fast.

Our course is highly acclaimed, with feedback like:

"Great and deep understanding of Spring in this course. Perfect speed, new technologies, and explanation of every detail." - Arkadiusz Siry
"Amazing. Very good instructions." - Emmanuel Akono Sarsah

Check reviews to see why it's among the highest-rated Spring courses on Udemy.

Essential Training

The course covers vital technologies such as Thymeleaf 4 and Maven 3, ensuring you are well-prepared with template engine knowledge and build tool proficiency for single and multi-module projects.

Upcoming Content: We are developing modules on Gradle, Spring Data, JPA, Hibernate, and database versioning, to be added free of charge for current students.

Bonus Free Spring Training

Our original course launched with Spring 4 and was overhauled for Spring 5, now including IntelliJ IDEA. Legacy content remains for those encountering Spring 4 in practice.

Prerequisites

What skills do you need to take the course? This course is designed for newcomers to the Spring framework. A basic understanding of Java, particularly Java SE, is necessary. Prior completion of Java Masterclass or similar training is beneficial.

Instructor Expertise

Who are the instructors? Taught by Tim Buchalka and Goran Lochert, seasoned developers with extensive industry experience, you learn from true professionals. Tim is a veteran Java expert and Goran is certified in Spring and Oracle Java.

Support and Engagement

What if you have questions? This course offers robust support, with instructors available seven days a week. Tim has been recognized among the top 10 Udemy instructors, ensuring quality guidance throughout your learning journey.

Course Requirements and Audience

Requirements:
  • A computer (Windows, Mac, or Linux). Instructions for setup and installation are provided.
  • A passion for learning the world’s leading web framework and enhancing your résumé.
  • All necessary materials are included in the course.
Who this course is for:
  • Iideal for aspiring Spring programmers.
  • Not recommended for seasoned Spring experts familiar with the latest advancements.
  • Requires basic Java knowledge; the Java Masterclass is suggested for foundational skills.

Learning Outcomes

What you'll learn:

  • Confidently apply for Spring developer roles.
  • Master core Spring Framework skills.
  • Develop your own Spring 5 projects.
  • Transition smoothly to other Java EE technologies.
  • Learn Spring 5 development best practices from experienced professionals.
  • Showcase your Spring Framework development knowledge.
  • Understand technologies such as Spring Core and Spring MVC.
  • Grasp how Spring integrates with Java EE.

About the Author: Udemy

Udemy thumbnail

Udemy is the largest open marketplace for online courses on the internet. Founded in 2010 by Eren Bali, Oktay Caglar, and Gagan Biyani and headquartered in San Francisco, the company went public on the Nasdaq in 2021 under the ticker UDMY. The platform hosts well over two hundred thousand courses across software development, IT and cloud, data science, design, business, marketing, and creative skills, taught by tens of thousands of independent instructors. Roughly seventy million learners use it worldwide, and the corporate arm — Udemy Business — supplies a curated subset of that catalog to enterprise customers.

Because Udemy is a marketplace rather than a single editorial publisher, the catalog is uneven by design. The strongest material lives in the long-form, project-based courses authored by working engineers — full-stack JavaScript, React, Node.js, Python data science, AWS, Docker and Kubernetes, mobile development with Flutter and React Native, and cloud certification preparation. The CourseFlix listing under this source is the slice of that catalog that has been mirrored here for offline-friendly viewing, organized by topic and updated as new releases land. Pricing on Udemy itself swings dramatically with the site's near-permanent sales, which is why the platform is best treated as a deep reference catalog: pick instructors with strong reviews and a track record of updating their material rather than buying on the headline price alone.

Watch Online 266 lessons

This is a demo lesson (10:00 remaining)

You can watch up to 10 minutes for free. Subscribe to unlock all 266 lessons in this course and access 10,000+ hours of premium content across all courses.

View Pricing
0:00
/
#1: Introduction
All Course Lessons (266)
#Lesson TitleDurationAccess
1
Introduction Demo
02:42
2
Which Version Of Java?
04:34
3
Installing JDK 11 on Windows
05:42
4
Installing and Configuring IntelliJ IDEA on Windows
10:31
5
Installing JDK 11 on a Mac
02:47
6
Installing and Configuring IntelliJ IDEA on a Mac
11:14
7
Installing JDK 11 on a Linux Machine
07:21
8
Installing and Configuring IntelliJ IDEA on a Linux Machine
11:38
9
Your Programming Careers Questions Answered
01:54
10
Spring 5 Feature Overview
02:09
11
Maven and Other Tools
04:14
12
Creating a Maven Project
06:32
13
Importing Maven Projects
01:57
14
Maven Lifecycle Plugin and Goals
04:06
15
Fix our Maven Project
09:51
16
What is Logging?
07:06
17
Using Logging with Logback
13:22
18
Logback Configuration
16:19
19
Project Overview
04:13
20
Create Multi Module Project
08:30
21
Project Setup
14:31
22
Using a Spring Container
17:13
23
Implementing the Game
12:16
24
Constructor Based Dependency Injection
07:51
25
Setter Based Dependency Injection
03:45
26
Setter or Constructor
04:49
27
Using Bean Lifecycle Callbacks
13:13
28
XML or Annotation Configuration
05:54
29
Autowiring Beans
09:59
30
Beans as Components
08:35
31
Using Java Annotation Configuration
09:55
32
Message Generator Challenge
10:03
33
Implementing MessageGenerator Logic
06:02
34
Console Module Setup Challenge
10:56
35
Application Events
08:19
36
Finish Game Logic
07:20
37
Using Qualifiers
11:50
38
Creating Custom Annotations
06:29
39
Using Properties
10:47
40
minNumber Challenge
09:12
41
Code Cleanup and Constructor Injection
10:18
42
Code Cleanup Challenge
08:25
43
Lombok Introduction
05:16
44
Setup Lombok
13:15
45
Using Lombok
06:00
46
Lombok Challenge
03:21
47
Spring MVC Introduction
02:52
48
Creating todo List Project
01:38
49
Project Setup Challenge
11:18
50
Setup Maven War Plugin
09:47
51
Setup Maven Cargo Plugin and Tomcat
08:10
52
Setup Dispatcher Servlet
15:51
53
Simple Controller
11:35
54
View Resolver and View
13:55
55
Spring MVC Request Processing
03:13
56
Model and Model Attributes
11:06
57
Simple Service Challenge
10:35
58
Request Parameters
08:25
59
Project Requirements
01:40
60
ToDo Item Class
09:20
61
ToDo Data Class
14:49
62
Creating the Todo Item Controller
08:39
63
Creating View and Basic JSTL tags
10:16
64
Todo Item Service Challenge
11:19
65
Implementing the Add Item Feature
11:39
66
Implementing Post Redirect Get Pattern
09:29
67
Home View and Navigation
17:56
68
Delete Item Challenge
04:49
69
Implement Edit Item Feature
12:03
70
View Item Challenge
11:18
71
Introduction to Spring Boot 2
02:06
72
Using Spring Initializr
05:28
73
Understanding Spring Boot Project Structure
09:25
74
Simple Spring Boot Application
19:03
75
Add Spring Boot to an Existing Project
16:11
76
Spring Boot Web Module
08:06
77
Thymeleaf Introduction
02:26
78
Setup Thymeleaf and Initial Template
13:32
79
Spring Boot Developer Tools
08:22
80
Game Service Challenge
09:33
81
Play Thymeleaf Template
18:22
82
Thymeleaf Preprocessing
12:20
83
Thymeleaf Template Challenge
13:48
84
Thymeleaf Fragments
13:24
85
Thymeleaf Fragment Challenge
05:56
86
Thymeleaf Decoupled Template Logic
17:33
87
Thymeleaf Decoupled Template Logic Challenge
15:11
88
Bug Fixes
01:18
89
Spring Internationalization
24:27
90
Thmyeleaf Internationalization Challenge
14:28
91
Message Generator Internationalization Main Message
09:45
92
Message Generator Internationalization Result Message
12:25
93
Request Interception
13:27
94
Locale Change Interceptor
08:12
95
Thymeleaf Recap
04:06
96
What is Gradle?
03:27
97
Creating a Gradle Spring Boot Project
05:45
98
Gradle Build Lifecycle Projects and Tasks
02:25
99
Understanding the Gradle Scripts
06:49
100
Running Gradle Tasks
06:33
101
Simple Spring Gradle Application
06:35
102
Creating a Spring Boot Project Challenge
05:57
103
Configure Gradle Multi-module Project
15:09
104
Configure Sub Modules
08:19
105
Testing our Project
07:44
106
More Content
00:49
107
Install JDK for Windows
05:16
108
Install Eclipse for Windows
07:55
109
Install Tomcat for Windows
06:30
110
Configure Tomcat Within Eclipse for Windows
08:15
111
Install JDK for Mac
02:45
112
Install Eclipse for Mac
07:35
113
Install Tomcat for Mac
06:06
114
Configure Tomcat Within Eclipse for Mac
06:43
115
Install JDK for Linux
04:21
116
Install Eclipse for Linux
08:32
117
Install and Configure Tomcat for Linux
09:14
118
Introduction to JEE
05:35
119
Exploring Java EE basics: Drilling into the Concepts
09:19
120
Exploring Java EE basics: Building the Servlet
09:51
121
Exploring Java EE basics: Creating a JSP and running the App
11:39
122
Exploring Java EE basics: Adding a Service layer to the mix
09:25
123
Exploring Java EE basics: Adding JSTL Library Support
06:09
124
Exploring Java EE basics: JSTL in JSP
06:41
125
Overview of Spring Tooling
06:13
126
Install Spring IDE
04:14
127
Installing Maven
05:01
128
Creating a Maven Project
12:45
129
Understanding the Project Object Model
14:03
130
Why Spring
03:35
131
Overview of the Spring Framework
06:36
132
Spring Framework vs JEE
09:43
133
Introducing the Spring IoC container
10:57
134
Spring IoC container: Accessing metadata from the file system
14:20
135
Spring IoC container: Accessing metadata from the classpath
09:22
136
Spring IoC Container Challenge
12:27
137
Setting Constructor Arguments using the Spring bean config file
17:58
138
Setting Properties using the Spring bean config file
12:58
139
Setter based Dependency Injection in Spring
09:47
140
Setter based Dependency Injection in Spring continued
08:22
141
Spring Setter based Dependency Injection in Spring : Running the App
11:26
142
Constructor based Dependency Injection in Spring
16:06
143
Spring Constructor based Dependency Injection : Running the App
10:09
144
Creating Spring MVC Project Infrastructure
10:13
145
Adding dependencies in an alternative way in a Spring MVC Project
08:14
146
Adding Spring MVC Dispatcher Servlet
13:22
147
Building the Spring Controller - "C" part of MVC
10:27
148
Context and MVC Configuration
05:15
149
Autowiring collaborating objects in Spring
07:50
150
Bringing View Resolver in the mix and running the App
12:30
151
Bean scopes for a Spring Bean
03:12
152
Spring bean scopes: Singleton and Prototype
10:47
153
Spring bean scopes, Request and Session: creating the project and Java classes
10:01
154
Spring bean scopes, Request and Session: creating the config file and Controller
07:47
155
Spring bean scopes, Request and Session: Running the App
08:48
156
Customize Spring Bean with Callbacks
11:20
157
Standard Naming for Spring Bean Callbacks
09:04
158
Spring Bean instantiation using Static Factory and Instance Factory methods
12:04
159
Spring Bean Definition with C Namespace
16:51
160
Spring Bean Definition with P Namespace
07:43
161
Pros and Cons of Spring Configuration : Annotations vs XML
07:24
162
Autowiring Spring Beans: creating project infrastructure
12:05
163
Autowiring Spring Beans: using setters, constructors and fields
12:11
164
Spring Beans as Components: Cutting down on xml config
08:19
165
Handling Properties in Spring: using XML config
12:20
166
Handling Properties in Spring: mixing XML with Annotations
10:35
167
Handling Properties in Spring using pure Annotations: creating infrastructure
13:34
168
Handling Properties in Spring using pure Annotations: building and running the a
12:28
169
Install MySQL for Windows
15:01
170
Install MySQL on Mac
12:18
171
Install MySQL on Linux
11:08
172
MySQL Workbench Basics : Environment and table creation
11:14
173
MySQL Workbench Basics : Insert and Export
10:47
174
Introduction to Spring JDBC
05:17
175
CRUD with Spring JDBC Template: Project Setup
14:54
176
CRUD with Spring JDBC Template: Creating DAO Layer
12:18
177
CRUD with Spring JDBC Template: XML config & Property file
14:17
178
CRUD with Spring JDBC Template: More with DAOs
17:58
179
CRUD with Spring JDBC Template: DAO and Test Harness
16:08
180
CRUD with Spring JDBC Template: Building App and executing Test Harness
10:26
181
CRUD with Spring JDBC Template: Expanding DAO Layer further
15:33
182
Spring JDBC Exceptions : an Overview
10:07
183
Spring Named Parameters Template: Understanding the API
10:38
184
Spring Named Parameters Template: Building the DAO
12:40
185
Spring Named Parameters Template : Components and Testing
08:58
186
Spring Java Config: Creating the project infrastructure
13:00
187
Spring Java Config: Creating the Java and Web Configuration
15:27
188
Spring Java Config: Running the App
06:59
189
Fix minor error in WebMvcConfig
04:12
190
JNDI Datasource: Building the Spring Service and Controller
14:35
191
JNDI Datasource: Conceptual Overview and Configuration
13:57
192
JNDI Datasource: Building views and Running the App
17:14
193
Spring MVC Architecture Going Deeper
06:41
194
Spring Handler Mapping Customization: Creating the infrastructure
16:21
195
Spring Handler Mapping Customization: Seeing the effect of customization
13:51
196
Spring Interceptors: an Introduction
13:40
197
Spring Interceptors: Integrating and building views with CSS inline styling
14:38
198
Spring Interceptors: Continuing building the views with CSS Internal styling
14:32
199
Spring Interceptors: Continue building views with mixed styling
12:31
200
Spring Interceptors: Running the app with a closing summary
12:27
201
Introducing Logging
08:08
202
Logging: Working with SLF4J, a powerful logging API
11:15
203
Logging: LOG4J implementation and introducing Logger, Appender and Layout
10:00
204
Logging: Continuing with log4j and getting to know Conversion Patterns
15:01
205
Logging: Configuring log4j.properties and wrapping up
10:20
206
Spring Interceptors: Invoking all the Interceptor methods
11:46
207
Spring Interceptors: Running the app and wrapping up!
09:53
208
Section Overview
01:52
209
RequestMapping and RequestParams In-depth : Introduction & test harness
11:33
210
RequestMapping and RequestParams In-depth : Class level mapping
13:12
211
RequestMapping and RequestParams In-depth : Wrapping up first test
08:11
212
RequestMapping and RequestParams In-depth : method attribute & fallback
12:41
213
RequestMapping and RequestParams In-depth : defaultAttribute and default naming
09:08
214
RequestMapping and RequestParams In-depth : resolving ambiguous request mapping
15:46
215
RequestMapping and RequestParams In-depth : multiple request mapping
14:05
216
Model Attributes on Methods in-depth: Adding multiple attributes
18:30
217
Model Attributes on Methods in-depth: working with 'name' attribute
09:00
218
Model Attributes on Methods in-depth: working with 'value' attribute
10:13
219
Model Attributes on Methods in-depth: working with ModelAndView API
10:09
220
Model Attributes on Methods in-depth: Introducing Spring Form Tag and Elements
19:57
221
Model Attributes on Methods in-depth: Exploring ModelAndView API
12:52
222
Model Attributes on Methods in-depth: Default data binding
07:39
223
Model Attributes on Methods in-depth: Implicit resolution of logical view name
10:11
224
Session Attributes: Creating the project infrastructure
19:17
225
Session Attributes: Bringing in the Controller
19:34
226
Session Attributes: Adding the JSPs
16:42
227
Session Attributes: Cranking the Java configuration
15:57
228
Session Attributes: Testing our application
15:49
229
Session Attribute & Request Attribute: an Introduction
06:12
230
Session Attribute & Request Attribute: Applying to Interceptor and Controller
15:22
231
Session Attributes, Session Attribute & Request Attribute: Testing all
12:14
232
Spring Form Tags: An Overview
08:09
233
Spring Form Tags: Creating project infrastructure - part 1
11:59
234
Spring Form Tags: Creating project infrastructure - part 2
09:54
235
Spring Form Tags: SELECT tags - part 1
22:39
236
Spring Form Tags: SELECT tags - part 2
10:48
237
Spring Form Tags: SELECT tags - part 3
17:12
238
Spring Form Tags: CHECKBOX tags - part 1
15:59
239
Spring Form Tags: CHECKBOX tags - part 2
14:38
240
Spring Form Tags: CHECKBOX tags - part 3
07:49
241
Spring Form Tags: CHECKBOXES tags
11:00
242
Spring Form Tags: RADIOBUTTON & RADIOBUTTONS tags
17:03
243
Spring Form Validation: an Introduction
05:12
244
Spring Form Validation: Creating the project Infrastructure
19:49
245
Spring Form Validation: Creating the JSPs
21:02
246
Spring Form Validation: Running the first validation test
09:42
247
Spring Form Validation: Working with @Size and @Notblank validations
07:59
248
Spring Form Validation: Introducing Custom Validation Constraints
07:28
249
Spring Form Validation: Creating our first Custom Validation Constraint
18:08
250
Spring Form Validation: Regular Expression Validation
13:18
251
Spring Form Validation: Using Apache Commons API Validator
14:01
252
Spring Form Validation: Class Level Validation
15:39
253
Spring Form Validation: Final Changes and Test
13:37
254
IntelliJ Spring Config and Test Import
18:09
255
Import Non Web Based Project
08:34
256
Build Spring MVC Demo
11:25
257
Controller Service and JSP
09:49
258
Welcome Service and Add Beans
09:27
259
Which version of Java should you use?
05:17
260
How To Install The Java Development Kit (JDK) For Windows
04:49
261
Download and Install IntelliJ (FREE and PAID version) for Windows
09:54
262
How To Install The Java Development Kit (JDK) For Mac OS X
02:20
263
Download and Install IntelliJ (FREE and PAID version) on a Mac
09:41
264
How To Install The Java Development Kit (JDK) For Ubuntu Linux
04:37
265
Install and Configure IntelliJ (FREE and PAID version) for Ubuntu Linux
09:40
266
Bonus Lecture and Information
04:49
Unlock unlimited learning

Get instant access to all 265 lessons in this course, plus thousands of other premium courses. One subscription, unlimited knowledge.

Learn more about subscription

Related courses

Frequently asked questions

What prerequisites should I have before taking this course?
Before enrolling in this course, you should have a basic understanding of Java programming as the course focuses on the Spring Framework, which is built on Java. Familiarity with Java development environments like IntelliJ IDEA will be beneficial, as the course includes lessons on configuring IntelliJ IDEA on different operating systems.
What will I be able to build by the end of the course?
By the end of the course, you will be able to build and deploy standalone Spring applications using Spring Boot 2.0. The course includes practical projects such as creating a todo list application, which covers essential skills like setting up a Maven project, using a DispatcherServlet, and implementing a Model View Controller architecture.
Who is the target audience for this course?
This course is ideal for Java developers looking to enhance their skills by mastering the Spring Framework. It's particularly suited for those aiming to build web applications using Spring MVC and Spring Boot 2.0. Developers who want to gain proficiency with tools like Thymeleaf and Maven will also benefit greatly.
How does this course compare in depth and scope to other Spring courses?
This course offers a detailed exploration of the core Spring technologies such as Spring Core, Spring MVC, and Spring Boot 2.0, focusing on practical, high-impact components rather than rarely used aspects. With 266 lessons, it provides a thorough understanding compared to courses that might only cover basic concepts or a narrower range of Spring modules.
What specific tools and technologies does the course cover?
The course covers several key tools and technologies integral to Spring development. These include Spring Core, Spring MVC, Spring Boot 2.0, Thymeleaf 4 for template engine knowledge, Maven 3 for build tool proficiency, and Logback for logging. It also includes setup and configuration of IntelliJ IDEA across different operating systems.
What topics are not covered in this course?
The course does not cover advanced topics beyond the core Spring technologies, such as Spring Security, Spring Data JPA, or microservices architecture. It focuses primarily on fundamental components like Spring Core, Spring MVC, and Spring Boot 2.0, ensuring a solid foundation before tackling more advanced Spring modules.
What is the estimated time commitment for completing this course?
With a total of 266 lessons, the course requires a significant time commitment to complete. While the exact runtime is not specified, students should be prepared to dedicate substantial time to cover all topics thoroughly. This includes time spent on practical exercises, challenges, and setting up development environments across different operating systems.