Overview

With this course, you gain in-depth knowledge to Use the Spring Framework to develop Web applications, Spring Tool Suite and Web Sockets. With our cloud labs, learn how to implement RESTful servers using Spring MVC, Use Spring Boot to build applications quickly with auto-configuration, Secure Web applications with Spring Security and Test Web applications for correctness and performance.

This course serves as a prerequisite for the Spring Web Application Developer Certification exam. At the end of this course, you will be able to confidently take the Spring Web Application Developer Exam and earn one of the highest paying certifications in the industry.

Schedule Classes

Looking for more sessions of this class?

What You'll learn

At the end of the training, you should be able to:

  • Use the Spring Framework to develop Web applications
  • Use Spring Tool Suite
  • Implement REST ful servers using Spring MVC
  • Use Spring Boot to build applications quickly with auto configuration
  • Secure Web applications with Spring Security
  • Test Web applications for correctness and performance
  • Understand and use Web Sockets with Spring MVC

Duration: 32 Hours

Curriculum

  • Java EE: The Good, The Bad, and the Ugly
  • Enter the Framework
  • Spring Value Proposition
  • The Spring Container
  • Web Applications
  • Persistence Support
  • Aspect-Oriented Programming
  • The Java EE Module(s)

JavaBeans, Reconsidered

  • The Factory Pattern
  • Inversion of Control
  • XML View: Declaring Beans
  • Java View: Using Beans
  • Singletons and Prototypes

Configuring Through Properties

  • Configuration Namespaces
  • The p: Notation
  • Bean (Configuration) Inheritance
  • Configuring Through Constructors
  • Bean Post-Processors
  • Lifecycle Hooks
  • Integrating Existing Factory Code
  • Awareness Interfaces

Assembling Object Graphs

  • Dependency Injection
  • Single and Multiple Relationships
  • The Utility Schema
  • Using Spring Expression Language (SpEL)
  • Inner Beans
  • Autowiring
  • @Component, @Service, & Company
  • @Autowired Properties
  • Best Practices with Spring Annotations
  • Java Classes as @Configurations
  • AnnotationConfigApplicationContext
  • Capabilities and Limitations
  • Mixing and Importing XML and Java Configurations

Collections and Maps

  • Support for Generics
  • The Spring Utility Schema (util:)
  • Auto-wiring to Multiple Beans
  • Order of Instantiation
  • Bean Factory vs. Application Context

Servlets and JSPs: What’s Missing

  • The MVC Pattern
  • The Front Controller Pattern
  • DispatcherServlet
  • A Request/Response Cycle
  • The Strategy Pattern
  • Web Application Contexts
  • Annotation-Based Handler Mappings
  • @Controller and @RequestMapping
  • “Creating” a Model
  • Views and View Resolvers

Matching URLs

  • Identifying Views
  • Request Parameters
  • Injectable Parameters
  • Command Objects
  • Return Types
  • HTTP Methods
  • Path Variables
  • Scope and Granularity of Command Objects
  • Headers and Cookies
  • RESTFUL Web Services

Form Processing in Spring MVC

  • Command Objects in Request Methods
  • Spring Custom Tags
  • <form:form> and Friends
  • Text Fields, Check Boxes, and Buttons
  • Radio Buttons and Select/Option Lists
  • Command objects at Session Scope
  • Limitations of @Session Attributes

A Consolidated Process

  • Property Editors
  • DataBinder and @InitBinder Methods
  • Converters and Formatters
  • Using <mvc:annotation-driven/>
  • Custom Formatters

Validating Form Input

  • Spring Validators
  • Deriving a Validator Reference
  • Applying a Validator
  • <form:errors>
  • Bean Validation, a/k/a JSR-303
  • Configuring Bean-Validation Support
  • Automatic Support with @Valid

Configuring Message Sources

  • Resolving Error Codes
  • Codes for Bean Validation
  • HandlerExceptionResolver
  • @ExceptionHandler
  • @ControllerAdvice for Global Error Handling
  • Configuring Interceptors
  • Filters in the Request-Handling Cycle

Reducing Code Complexity

  • The DataAccessException Hierarchy
  • JdbcTemplate
  • RowMapper<T> and ResultSetExtractor<T>
  • The DaoSupport Hierarchy
  • Capturing Generated Keys
  • Transaction Control
  • TransactionTemplate
  • Isolation Levels
  • Transaction Propagation

Object/Relational Mapping

  • The Java Persistence API
  • JpaDaoSupport and JpaTemplate
  • @PersistenceUnit and @PersistenceContext
  • Shared Entity Managers
  • Using <tx:annotation-driven>
  • The @Transaction Annotation
  • Isolation and Propagation
  • A Limitation of @Transactional
  • Understanding Entity States
  • Bean Validation in JPA
  • Optimistic Locking

Testability of Spring Applications

  • Dependency Injection
  • Mocking
  • SpringJUnit4ClassRunner
  • TestContext
  • @ContextConfiguration
  • Preserving Test Isolation
  • @DirtiesContext
  • Mocking Spring MVC
  • Building Requests
  • Checking the ModelAndView
  • Profiles
  • Testing Persistence Components

Prerequisites

  • Basic understanding of Spring and/or completion of the Core Spring course
  • Experience developing enterprise Java applications

Reach out to us for more information

Interested in this course? Let’s connect!

  • This field is for validation purposes and should be left unchanged.

Course features

Course Duration
Course Duration

16 hours of live, online, instructor-led training

24x7 Support
24x7 Support

Technical & query support round the clock

Lifetime LMS Access
Lifetime LMS Access

Access all the materials on LMS anytime, anywhere

Price Match Gurantee
Price match Gurantee

Guranteed best price aligning with quality of deliverables