Servlet JSP Tutorial -- 1.12 Spring Security Example Tutorial

系统管理员 2022-06-01 00:22 151阅读 0赞

`Spring Security` 提供了在 Web 应用程序中执行身份验证和授权的方法。我们可以在任何基于`servlet`的 web 应用程序中使用`Spring Security`。

1.  Spring Security  
    
    
    1.  Spring Security Example
    2.  Spring Security Maven Dependencies
    3.  Spring Security Example View Pages
    4.  Spring Security Example UserDetailsService DAO Implementation
    5.  Spring Security Example WebSecurityConfigurer implementation
    6.  Integrating Spring Security Web with Servlet API  
        
        
        1.  Accessing HTML Page without Security
        2.  Authentication Failed for Bad Credentials
        3.  Home Page with Spring Security JDBC Authentication
        4.  Home Page with Spring Security UserDetailsService DAO Authentication
        5.  Home Page with Spring Security In-Memory Authentication
        6.  Logout Page

## Spring Security ##

使用`Spring Security`的好处  
\- 经过验证的技术，你最好使用它而不是重新发明轮子。安全是我们需要格外小心的事情，否则我们的应用程序将容易受到攻击者的攻击。  
\- 防止一些常见的攻击，如 CSRF（Cross-site request forgery, 跨站伪造请求），会话固定攻击，  
\- 易于集成到任何 Web 应用程序。我们不需要需改 Web 应用程序配置，`Spring` 会自动向 Web 应用程序注入 `security filter`。  
\- 通过不同的方式提供对认证的支持 - in-memory、DAO、JDBC、LDAP 等等。  
\- 提供忽略特定 URL 模式的选项，适合提供静态 HTML，图像文件。  
\- 支持 组 和 角色。

### Spring Security Example ###

我们将创建一个 Web 应用程序并将其与`Spring Security`集成。

在 IDEA 中使用“Maven”选项创建一个 Maven Web 应用程序。我们正在使用 Maven 进行构建和部署。如果您不熟悉这些步骤，请参阅 Java Web Application Tutorial.

最终的项目结构将如下图所示。

我们将研究三种 `Spring Security` 认证方法。

1.  in-memory
2.  DAO
3.  JDBC

对于`JDBC`，我使用`MySQL`数据库并执行以下脚本来创建用户详细信息表。

CREATE TABLE `Employees` ( `username` varchar(20) NOT NULL DEFAULT '', `password` varchar(20) NOT NULL DEFAULT '', `enabled` tinyint(1) NOT NULL DEFAULT '1', PRIMARY KEY (`username`) ) ENGINE=InnoDB DEFAULT CHARSET=utf8;
    
    CREATE TABLE `Roles` ( `username` varchar(20) NOT NULL DEFAULT '', `role` varchar(20) NOT NULL DEFAULT '', PRIMARY KEY (`username`,`role`) ) ENGINE=InnoDB DEFAULT CHARSET=utf8;
    
    INSERT INTO `Employees` (`username`, `password`, `enabled`) VALUES ('pankaj', 'pankaj123', 1);
    
    INSERT INTO `Roles` (`username`, `role`) VALUES ('pankaj', 'Admin'), ('pankaj', 'CEO');
    
    commit;

我们还需要在我们的 servlet 容器中将`JDBC DataSource`配置为`JNDI`，[Spring Security Example Tutorial][]

### Spring Security Maven Dependencies ###

最终的 pom.xml 文件

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
      <modelVersion>4.0.0</modelVersion>
      <groupId>com.journaldev.webapp</groupId>
      <artifactId>WebappSpringSecurity</artifactId>
      <packaging>war</packaging>
      <version>1.0-SNAPSHOT</version>
      <name>WebappSpringSecurity Maven Webapp</name>
      <url>http://maven.apache.org</url>
      <dependencies>
        <dependency>
          <groupId>junit</groupId>
          <artifactId>junit</artifactId>
          <version>3.8.1</version>
          <scope>test</scope>
        </dependency>
    
        
        <dependency>
          <groupId>org.springframework.security</groupId>
          <artifactId>spring-security-web</artifactId>
          <version>4.2.3.RELEASE</version>
        </dependency>
    
        
        <dependency>
          <groupId>org.springframework.security</groupId>
          <artifactId>spring-security-config</artifactId>
          <version>4.2.3.RELEASE</version>
        </dependency>
    
        
        <dependency>
          <groupId>org.springframework.security</groupId>
          <artifactId>spring-security-taglibs</artifactId>
          <version>4.2.3.RELEASE</version>
        </dependency>
    
        
        <dependency>
          <groupId>javax.servlet</groupId>
          <artifactId>jstl</artifactId>
          <version>1.2</version>
        </dependency>
    
        
        <dependency>
          <groupId>javax.servlet</groupId>
          <artifactId>javax.servlet-api</artifactId>
          <version>3.1.0</version>
          <scope>provided</scope>
        </dependency>
    
        
        <dependency>
          <groupId>javax.servlet</groupId>
          <artifactId>jsp-api</artifactId>
          <version>2.0</version>
          <scope>provided</scope>
        </dependency>
    
    
        
        <dependency>
          <groupId>commons-logging</groupId>
          <artifactId>commons-logging</artifactId>
          <version>1.2</version>
        </dependency>
    
        
        <dependency>
          <groupId>org.springframework</groupId>
          <artifactId>spring-jdbc</artifactId>
          <version>4.3.13.RELEASE</version>
        </dependency>
      </dependencies>
      <build>
        <finalName>WebappSpringSecurity</finalName>
      </build>
    </project>

我们有以下与 `Spring` 框架相关的依赖：  
1. `spring-jdbc:` 这是通过 JDBC 身份验证方法用于 JDBC 操作. 它需要将 DataSource 设置为 JNDI。有关它的用法完整实例，请参阅[Spring Security Example Tutorial][]  
2. `spring-security-taglibs:`Spring Security 标签库，我用它来显示 JSP 页面中的用户角色。大多数时候，你不会需要它。  
3. `spring-security-config:` 它用于配置身份验证提供程序，是否使用 JDBC、DAO、LDAP 等。  
4. `spring-security-web:` 这个组件将 Spring Security 集成到 Servlet API 中。我们需要它来在 Web 应用程序中插入我们的安全配置。

另外请注意，我们将使用 Servlet API 3.0 功能以编程方式添加监听器和过滤器，这就是为什么servlet api 版本的依赖关系应该是 3.0 或更高。

### Spring Security Example View Pages ###

我们的应用程序中有 JSP 和 HTML 页面。 我们希望在除 HTML 页面以外的所有页面中应用身份验证。

`health.html`

<!DOCTYPE html>
    <html lang="en">
    <head>
        <meta charset="UTF-8">
        <title>Health Check</title>
    </head>
    <body>
    <body>
    <h3>Service is up and running!!</h3>
    </body>
    </body>
    </html>

`index.jsp`

<%@ taglib prefix="sec" uri="http://www.springframework.org/security/tags" %>
    <%@ page contentType="text/html;charset=UTF-8" language="java" %>
    <html>
    <head>
        <title>Home Page</title>
    </head>
    <body>
    <h3>Home Page</h3>
    
    <p>
        Hello <b><c:out value="${pageContext.request.remoteUser}"/></b><br>
        Roles: <b><sec:authentication property="principal.authorities" /></b>
    </p>
    
    <form action="logout" method="post">
        <input type="submit" value="Logout" />
        <input type="hidden" name="${_csrf.parameterName}" value="${_csrf.token}"/>
    </form>
    </body>
    </html>

我在应用程序部署描述文件中包含了 index.jsp 作为 welcome-file 。

Spring Security 处理 CSRF 攻击，所以当我们提交注销表单时，我们将 CSRF 令牌发送回服务器以删除它。Spring Security 组件设置的 CSRF 对象是 \_csrf ，我们使用它的属性名和标记值在注销请求中传递。

现在我们来看看 Spring Security 的配置。

### Spring Security Example UserDetailsService DAO Implementation ###

因为我们将使用基于 DAO 的身份验证，因此我们需要实现`UserDetailsService`接口并为`loadUserByUsername()`方法提供实现。

理想情况下，我们应该使用一些资源来验证用户，但为了简单起见，我只是在做基本验证。

`AppUserDetailsServiceDAO.java`

package com.journaldev.webapp.spring.dao;
    
    import java.util.Collection;
    import java.util.List;
    
    import org.apache.commons.logging.Log;
    import org.apache.commons.logging.LogFactory;
    import org.springframework.security.core.GrantedAuthority;
    import org.springframework.security.core.authority.SimpleGrantedAuthority;
    import org.springframework.security.core.userdetails.UserDetails;
    import org.springframework.security.core.userdetails.UserDetailsService;
    import org.springframework.security.core.userdetails.UsernameNotFoundException;
    
    public class AppUserDetailsServiceDAO implements UserDetailsService { 
    
        protected final Log logger = LogFactory.getLog(getClass());
    
        public UserDetails loadUserByUsername(final String username)
                throws UsernameNotFoundException {
    
            logger.info("loadUserByUsername username=" + username);
    
            if (!username.equals("pankaj")) {
                throw new UsernameNotFoundException(username + " not found");
            }
    
            //creating dummy user details, should do JDBC operations
            return new UserDetails() {
    
                private static final long serialVersionUID = 2059202961588104658L;
    
                public boolean isEnabled() {
                    return false;
                }
    
                public boolean isCredentialsNonExpired() {
                    return true;
                }
    
                public boolean isAccountNonLocked() {
                    return true;
                }
    
                public boolean isAccountNonExpired() {
                    return true;
                }
    
                public String getUsername() {
                    return username;
                }
    
                public String getPassword() {
                    return "pankaj123";
                }
    
                public Collection<? extends GrantedAuthority> getAuthorities() {
                    List<SimpleGrantedAuthority> auths = new java.util.ArrayList<SimpleGrantedAuthority>();
                    auths.add(new SimpleGrantedAuthority("admin"));
                    return auths;
                }
            };
        }
    
    }

请注意，我正在创建 UserDetails 的匿名内部类并将其返回。你可以为它创建一个实现类，然后实例化并返回它。通常这是实际应用中的方法。

### Spring Security Example WebSecurityConfigurer implementation ###

我们可以实现`WebSecurityConfigurer`接口，或者我们可以扩展基本实现类`WebSecurityConfigurerAdapter`并覆盖方法。

`SecurityConfig.java`

package com.journaldev.webapp.spring.security;
    
    import javax.naming.Context;
    import javax.naming.InitialContext;
    import javax.sql.DataSource;
    
    import org.springframework.context.annotation.Configuration;
    import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder;
    import org.springframework.security.config.annotation.web.builders.WebSecurity;
    import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
    import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
    
    import com.journaldev.webapp.spring.dao.AppUserDetailsServiceDAO;
    
    @Configuration
    @EnableWebSecurity
    public class SecurityConfig extends WebSecurityConfigurerAdapter {
    
        @Override
        public void configure(AuthenticationManagerBuilder auth)
                throws Exception {
    
            // in-memory authentication
            // auth.inMemoryAuthentication().withUser("pankaj").password("pankaj123").roles("USER");
    
            // using custom UserDetailsService DAO
            // auth.userDetailsService(new AppUserDetailsServiceDAO());
    
            // using JDBC
            Context ctx = new InitialContext();
            DataSource ds = (DataSource) ctx
                    .lookup("java:/comp/env/jdbc/MyLocalDB");
    
            final String findUserQuery = "select username,password,enabled "
                    + "from Employees " + "where username = ?";
            final String findRoles = "select username,role " + "from Roles "
                    + "where username = ?";
    
            auth.jdbcAuthentication().dataSource(ds)
                    .usersByUsernameQuery(findUserQuery)
                    .authoritiesByUsernameQuery(findRoles);
        }
    
        @Override
        public void configure(WebSecurity web) throws Exception {
            web.ignoring()// Spring Security should completely ignore URLs ending with .html
                    .antMatchers("/*.html");
        }
    
    }

请注意，我们通过重写配置（`WebSecurity web`）方法来忽略所有的 HTML 文件。

代码显示了如何插入 `JDBC` 认证。我们需要通过提供 `DataSource` 来配置它。由于我们使用自定义 table，因此我们还需要提供选择查询来获取用户详细信息和角色。

配置 `in-memory` 和基于 `DAO` 的身份验证很容易，他们在上面的代码中进行了注释。你可以取消注释以使用它们，确保一次只有一个配置。

需要`@Configuration`和`@EnableWebSecurity`注解，以便`Spring`框架知道这个类将用于`Spring`安全配置。

`Spring Security Configuration`使用了`Builder Pattern`，并且基于`authenticate`方法，以后某些方法将不可用。 例如，`auth.userDetailsService()`返回`UserDetailsService`的实例，然后我们不能有任何其他选项，比如我们不能在其后面设置`DataSource`。

### Integrating Spring Security Web with Servlet API ###

最后一部分是将我们的`Spring Security`配置类集成到`Servlet API`中。 这可以通过扩展`AbstractSecurityWebApplicationInitializer`类并在超类构造函数中传递`Security`配置类来轻松完成。

`SecurityWebApplicationInitializer.java`

package com.journaldev.webapp.spring.security;
    
    import org.springframework.security.web.context.AbstractSecurityWebApplicationInitializer;
    
    public class SecurityWebApplicationInitializer extends AbstractSecurityWebApplicationInitializer { 
    
        public SecurityWebApplicationInitializer() {
            super(SecurityConfig.class);
        }
    }

当我们的上下文启动时，它使用`ServletContext`来添加`ContextLoaderListener`监听器，并将我们的配置类注册为`Servlet Filter`。

请注意，这仅适用于`Servlet 3` 容器。 所以如果你使用的是`Apache Tomcat`，确保它的版本是7.0 或更高。

我们的项目已经准备就绪，只需将它部署在您最喜欢的`servlet`容器中。 我正在使用`Apache Tomcat-8`来运行这个应用程序。

下图显示了各种情况下的响应。

如果您想使用不支持 Servlet 3 规范的 Servlet容器，那么您需要通过部署描述文件来注册`DispatcherServlet`。请参阅`WebApplicationInitializer`的JavaDoc以获取更多详细信息。

这就是Spring Security Example Tutorial，它是基于 Servlet 的 Web 应用程序的集成。

[Spring Security Example Tutorial]: http://blog.csdn.net/oktfolio/article/details/79065744