tags | projects | ||
---|---|---|---|
|
|
This guide walks you through the process of creating a simple web application with resources that are protected by Spring Security.
You’ll build a Spring MVC application that secures the page with a login form backed by a fixed list of users.
build.gradle
link:initial/build.gradle[role=include]
Before you can apply security to a web application, you need a web application to secure. The steps in this section walk you through creating a very simple web application. Then you secure it with Spring Security in the next section.
The web application includes two simple views: a home page and a "Hello World" page. The home page is defined in the following Thymeleaf template:
src/main/resources/templates/home.html
link:initial/src/main/resources/templates/home.html[role=include]
As you can see, this simple view include a link to the page at "/hello". That is defined in the following Thymeleaf template:
src/main/resources/templates/hello.html
link:initial/src/main/resources/templates/hello.html[role=include]
The web application is based on Spring MVC. Thus you need to configure Spring MVC and set up view controllers to expose these templates. Here’s a configuration class for configuring Spring MVC in the application.
src/main/java/hello/MvcConfig.java
link:initial/src/main/java/hello/MvcConfig.java[role=include]
The addViewControllers()
method (overriding the method of the same name in WebMvcConfigurerAdapter
) adds four view controllers. Two of the view controllers reference the view whose name is "home" (defined in home.html
), and another references the view named "hello" (defined in hello.html
). The fourth view controller references another view named "login". You’ll create that view in the next section.
At this point, you could jump ahead to the [run] section and run the application.
With the base simple web application created, you can add security to it.
Suppose that you want to prevent unauthorized users from viewing the greeting page at "/hello". As it is now, if users click the link on the home page, they see the greeting with no barriers to stop them. You need to add a barrier that forces the user to sign in before seeing that page.
You do that by configuring Spring Security in the application. Here’s a security configuration that ensures that only authenticated users can see the secret greeting:
src/main/java/hello/WebSecurityConfig.java
link:complete/src/main/java/hello/WebSecurityConfig.java[role=include]
The WebSecurityConfig
class is annotated with @EnableWebMvcSecurity
to enable Spring Security’s web security support and provide the Spring MVC integration. It also extends WebSecurityConfigurerAdapter
and overrides a couple of its methods to set some specifics of the web security configuration.
The configure(HttpSecurity)
method defines with URL paths should be secured and which should not. Specifically, the "/" and "/home" paths are configured to not require any authentication. All other paths must be authenticated.
When a user successfully logs in, they will be redirected to the previously requested page that requires authentication. There is a custom "/login" page specified by loginPage()
, and everyone is allowed to view it.
As for the configure(AuthenticationManagerBuilder)
method, it sets up an in-memory user store with a single user. That user is given a username of "user", a password of "password", and a role of "USER".
Now we need to create the login page. There’s already a view controller for the "login" view, so you only need to create the login view itself:
src/main/resources/templates/login.html
link:complete/src/main/resources/templates/login.html[role=include]
As you can see, this Thymeleaf template simply presents a form that captures a username and password and posts them to "/login". As configured, Spring Security provides a filter that intercepts that request and authenticates the user. If the user fails to authenticate, the page is redirected to "/login?error" and our page displays the appropriate error message. Upon successfully signing out, our application is sent to "/login?logout" and our page displays the appropriate success message.
Last we need to provide the user a way to display the current username and Sign Out. Update the hello.html
to say hello to the current user and contain a "Sign Out" form as shown below
src/main/resources/templates/hello.html
link:complete/src/main/resources/templates/hello.html[role=include]
We display the username by using Spring Security’s integration with HttpServletRequest#getRemoteUser()
. The "Sign Out" form submits a POST to "/logout". Upon successfully logging out it will redirect the user to "/login?logout".
Although it is possible to package this service as a traditional web application archive or WAR file for deployment to an external application server, the simpler approach demonstrated below creates a standalone application. You package everything in a single, executable JAR file, driven by a good old Java main()
method. And along the way, you use Spring’s support for embedding the Tomcat servlet container as the HTTP runtime, instead of deploying to an external instance.
src/main/java/hello/Application.java
link:complete/src/main/java/hello/Application.java[role=include]
The main()
method defers to the SpringApplication
helper class, providing Application.class
as an argument to its run()
method. This tells Spring to read the annotation metadata from Application
and to manage it as a component in the Spring application context.
The @ComponentScan
annotation tells Spring to search recursively through the hello
package and its children for classes marked directly or indirectly with Spring’s @Component
annotation. This directive ensures that Spring finds and registers the WebConfig
and WebSecurityConfig
, because they are marked with @Configuration
, which in turn is a kind of @Component
annotation. In effect, those configuration classes are also used to configure Spring.
The @EnableAutoConfiguration
annotation switches on reasonable default behaviors based on the content of your classpath. For example, because the application depends on the embeddable version of Tomcat (tomcat-embed-core.jar), a Tomcat server is set up and configured with reasonable defaults on your behalf. And because the application also depends on Spring MVC (spring-webmvc.jar), a Spring MVC DispatcherServlet
is configured and registered for you — no web.xml
necessary! Auto-configuration is a powerful, flexible mechanism. See the API documentation for further details.
https://raw.github.com/spring-guides/getting-started-macros/master/build_an_executable_jar_subhead.adoc https://raw.github.com/spring-guides/getting-started-macros/master/build_an_executable_jar_with_both.adoc
... app starts up ...
Once the application starts up, point your browser to http://localhost:8080. You should see the home page:
When you click on the link, it attempts to take you to the greeting page at /hello
. But because that page is secured and you have not yet logged in, it takes you to the login page:
At the login page, sign in as the test user by entering "user" and "password" for the username and password fields, respectively. Once you submit the login form, you are authenticated and then taken to the greeting page:
If you click on the "Sign Out" button, your authentication is revoked, and you are returned to the log in page with a message indicating you are logged out.