Course info
May 23, 2016
1h 57m

How do you go about designing and building a complex web application while keeping the code maintainable and testable? This course, Architecting Web Applications with Spring, examines how to build your application from 'components,' where each component is a feature of your application. That feature is isolated as much as possible from the rest of the application and will contain all the code it needs. You'll be shown how to unit test these features by injecting dependencies to make them mockable, and how to use Mockito as the mocking framework that will allow features to be unit-tested. You'll learn how to integrate test components with support from Spring, as well as database integration, using Flyway to manage database migrations, and using Spring Data to access that data. Last, but not least, you'll discover how to use Spring Security to provide a layer of authentication and authorization to your application. By the end of this course, you'll be able to fully architect web apps with multiple components in Spring using code that you can easily test and maintain.

About the author
About the author

Kevin has spent way too many years in the software industry. Starting on PL/1 on IBM mainframes then graduating through dBase IV to Windows and eventually onto Java, .Net and now JavaScript where he finally thinks he has found a home until the next new shiny comes along.

More from the author
Java Web Fundamentals
3h 22m
Jun 5, 2019
Building Web Applications in Kotlin Using Ktor
2h 12m
May 31, 2019
Kotlin: Using Coroutines
3h 50m
Aug 10, 2018
More courses by Kevin Jones
Section Introduction Transcripts
Section Introduction Transcripts

Understanding the Application Architecture
Hi. My name is Kevin Jones, and this is the Understanding in the Application Architecture chapter from the Architecting Web Applications with Spring class. There are already Pluralsight courses that explain how to use Spring and how to create an application in Spring. In this class, we'll take that a little further. We'll take a look at the overall architecture of an application, and we'll take a look at how we should bring that architecture together. In this chapter, we'll take a look at the rationale for some of the decisions made for this architecture. In particular, we'll take a look at the ideas of logical design versus physical design, and we'll take a look at how we separate our code. So that this idea of a vertical separation of the code versus the horizontal separation of the code, and how these two ideas interact.

Managing Your Database Layer
Hi, my name is Kevin Jones from Pluralsight and this is the Managing Your Database Layer chapter from the Architecting Web Applications with Spring class. In the previous module, we talked about logical design versus physical design. We said at the end of the module that one of the first things we have to do is to build out our database. So before we even get into this idea of what consists of a logical design or a physical design or the structure, let's think about how we manage and use the database. So in this chapter, we'll take a look at how we manage databases using something called migrations. If you've not come across migrations before, we'll explain what they are and how we use those. And then we'll talk about how we access the database using repositories. So there's a design pattern called a repository design pattern. There's also something in Spring called Spring Data and Spring Data relies heavily on something called Spring Repositories. And we'll see exactly how those are, how they make our lives so much easier when accessing data in the database.

Securing the Application with Spring Security
Hi, my name is Kevin Jones and this is the Securing the Application with Spring Security chapter from the Architecting Web Applications with Spring class from Pluralsight. So up until now, we've built the application using a mixture of horizontal design and vertical design. We've added repositories, we've added services, and we've added tests. Okay now what we're going to take a look at is how we add security to the application. We want to add both authentication and authorization support to the application, and we'll talk how they differ in a moment. We are going to use Spring Security to do this. So authentication is, who are you? When I log onto an application, I give it some credentials such as a username and password. And given those credentials, the application will know who I am and it may assign some roles to me. Based on who I am, and maybe based on what those roles are, the application will then decide what I'm authorized to do. So authentication is working out who this user is, authorization is allowing to do certain things based on who they are. Spring Security is a set of libraries that come with Spring and they allow us to easily add security into an application. It's a nice library, it's very extensible and very easy to use when you use that library in this module.