跟着燕青学Spring Security认证授权04--Servlet3.0 SpringMVC实现Session的认证方式

痛定思痛。 2023-06-05 12:43 1阅读 0赞

### 1 认证流程 ###

基于Session认证方式的流程是，用户认证成功后，在服务端生成用户相关的数据保存在session(当前会话)，而发给客户端的 sesssion\_id 存放到 cookie 中，这样用客户端请求时带上 session\_id 就可以验证服务器端是否存在 session 数据，以此完成用户的合法校验。当用户退出系统或session过期销毁时,客户端的session\_id也就无效了。下图是session认证方式的流程图：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDA2MjMzOQ_size_16_color_FFFFFF_t_70]  
基于Session的认证机制由Servlet规范定制，Servlet容器已实现，用户通过HttpSession的操作方法即可实现，如下是HttpSession相关的操作API。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDA2MjMzOQ_size_16_color_FFFFFF_t_70 1]

### 2 创建工程 ###

本案例工程使用maven进行构建，使用SpringMVC、Servlet3.0实现。

#### 2.1 创建maven工程 ####

创建maven工程 security-springmvc，工程结构如下：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDA2MjMzOQ_size_16_color_FFFFFF_t_70 2]

引入如下依赖如下，注意：

1、由于是web工程，packaging设置为war

2、使用tomcat7-maven-plugin插件来运行工程

<?xml version="1.0" encoding="UTF-8"?>
    <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/xsd/maven-4.0.0.xsd">
        <modelVersion>4.0.0</modelVersion>
    
        <groupId>com.pbteach.security</groupId>
        <artifactId>security-springmvc</artifactId>
        <version>1.0-SNAPSHOT</version>
        <packaging>war</packaging>
        <properties>
            <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
            <maven.compiler.source>1.8</maven.compiler.source>
            <maven.compiler.target>1.8</maven.compiler.target>
        </properties>
        <dependencies>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-webmvc</artifactId>
                <version>5.1.5.RELEASE</version>
            </dependency>
    
            <dependency>
                <groupId>javax.servlet</groupId>
                <artifactId>javax.servlet-api</artifactId>
                <version>3.0.1</version>
                <scope>provided</scope>
            </dependency>
             <dependency>
                <groupId>org.projectlombok</groupId>
                <artifactId>lombok</artifactId>
                <version>1.18.8</version>
            </dependency>
        </dependencies>
        <build>
            <finalName>security-springmvc</finalName>
            <pluginManagement>
                <plugins>
                    <plugin>
                        <groupId>org.apache.tomcat.maven</groupId>
                        <artifactId>tomcat7-maven-plugin</artifactId>
                        <version>2.2</version>
                    </plugin>
                    <plugin>
                        <groupId>org.apache.maven.plugins</groupId>
                        <artifactId>maven-compiler-plugin</artifactId>
                        <configuration>
                            <source>1.8</source>
                            <target>1.8</target>
                        </configuration>
                    </plugin>
    
                    <plugin>
                        <artifactId>maven-resources-plugin</artifactId>
                        <configuration>
                            <encoding>utf-8</encoding>
                            <useDefaultDelimiters>true</useDefaultDelimiters>
                            <resources>
                                <resource>
                                    <directory>src/main/resources</directory>
                                    <filtering>true</filtering>
                                    <includes>
                                        <include>**/*</include>
                                    </includes>
                                </resource>
                                <resource>
                                    <directory>src/main/java</directory>
                                    <includes>
                                        <include>**/*.xml</include>
                                    </includes>
                                </resource>
                            </resources>
                        </configuration>
                    </plugin>
                </plugins>
            </pluginManagement>
        </build>
    
    </project>

#### 2.2 Spring 容器配置 ####

在config包下定义ApplicationConfig.java，它对应web.xml中ContextLoaderListener的配置

@Configuration
    @ComponentScan(basePackages = "com.pbteach.security.springmvc"
                    ,excludeFilters = {@ComponentScan.Filter(type = FilterType.ANNOTATION,value = Controller.class)})
    public class ApplicationConfig {
        //在此配置除了Controller的其它bean，比如：数据库链接池、事务管理器、业务bean等。
    }

#### 2.3 servletContext配置 ####

本案例采用Servlet3.0无web.xml方式，的config包下定义WebConfig.java，它对应s对应于DispatcherServlet配置。

@Configuration
    @EnableWebMvc
    @ComponentScan(basePackages = "com.pbteach.security.springmvc"
                ,includeFilters = {@ComponentScan.Filter(type = FilterType.ANNOTATION,value = Controller.class)})
    public class WebConfig implements WebMvcConfigurer {
    
        //视频解析器
        @Bean
        public InternalResourceViewResolver viewResolver(){
            InternalResourceViewResolver viewResolver = new InternalResourceViewResolver();
            viewResolver.setPrefix("/WEB-INF/views/");
            viewResolver.setSuffix(".jsp");
            return viewResolver;
        }
     }

#### 2.4 加载 Spring容器 ####

在init包下定义Spring容器初始化类SpringApplicationInitializer，此类实现WebApplicationInitializer接口，Spring容器启动时加载WebApplicationInitializer接口的所有实现类。

public class SpringApplicationInitializer extends AbstractAnnotationConfigDispatcherServletInitializer {
        @Override
        protected Class<?>[] getRootConfigClasses() {
            return new Class<?>[] { ApplicationConfig.class };//指定rootContext的配置类
        }
    
        @Override
        protected Class<?>[] getServletConfigClasses() {
            return new Class<?>[] { WebConfig.class }; //指定servletContext的配置类
        }
    
        @Override
        protected String[] getServletMappings() {
            return new String [] {"/"};
        }
    }
    
    
    SpringApplicationInitializer相当于web.xml，使用了servlet3.0开发则不需要再定义web.xml，ApplicationConfig.class对应以下配置的application-context.xml，WebConfig.class对应以下配置的spring-mvc.xml，web.xml的内容参考：
    
    <web-app>
        <listener>
            <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
        </listener>
        <context-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>/WEB-INF/application-context.xml</param-value>
        </context-param>
      
        <servlet>
            <servlet-name>springmvc</servlet-name>
            <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
            <init-param>
                <param-name>contextConfigLocation</param-name>
                <param-value>/WEB-INF/spring-mvc.xml</param-value>
            </init-param>
            <load-on-startup>1</load-on-startup>
        </servlet>
        <servlet-mapping>
            <servlet-name>springmvc</servlet-name>
            <url-pattern>/</url-pattern>
        </servlet-mapping>
    
    </web-app>

### 3.实现认证功能 ###

#### 3.1 认证页面 ####

在webapp/WEB-INF/views下定义认证页面login.jsp，本案例只是测试认证流程，页面没有添加css样式，页面实现可填入用户名，密码，触发登录将提交表单信息至/login，内容如下：
    
    <%@ page contentType="text/html;charset=UTF-8" pageEncoding="utf-8" %>
    <html>
    <head>
        <title>用户登录</title>
    </head>
    <body>
    <form action="login" method="post">
        用户名：<input type="text" name="username"><br>
        密   码:
        <input type="password" name="password"><br>
        <input type="submit" value="登录">
    </form>
    </body>
    </html>

在WebConfig中新增如下配置，将/直接导向login.jsp页面：

@Override
    public void addViewControllers(ViewControllerRegistry registry) {
        registry.addViewController("/").setViewName("login");
    }

启动项目，访问/路径地址，进行测试  
![在这里插入图片描述][20191009080957202.png]

#### 3.2 认证接口 ####

用户进入认证页面，输入账号和密码，点击登录，请求/login进行身份认证。

（1）定义认证接口，此接口用于对传来的用户名、密码校验，若成功则返回该用户的详细信息，否则抛出错误异常：

/**
     * 认证服务
     */
    public interface AuthenticationService {
    
        /**
         * 用户认证
         * @param authenticationRequest 用户认证请求
         * @return 认证成功的用户信息
         */
        UserDto authentication(AuthenticationRequest authenticationRequest);
    }

认证请求结构：

@Data
    public class AuthenticationRequest {
        /**
         * 用户名
         */
        private String username;
    
        /**
         * 密码
         */
        private String password;
    
    
    }

认证成功后返回的用户详细信息，也就是当前登录用户的信息：

/**
     * 当前登录用户信息
     */
    @Data
    @AllArgsConstructor
    public class UserDto {
    
        private String id;
        private String username;
        private String password;
        private String fullname;
        private String mobile;
    }

（2）认证实现类，根据用户名查找用户信息，并校验密码，这里模拟了两个用户：

@Service
    public class AuthenticationServiceImpl implements AuthenticationService{
    
        @Override
        public UserDto authentication(AuthenticationRequest authenticationRequest) {
            if(authenticationRequest == null
                    || StringUtils.isEmpty(authenticationRequest.getUsername())
                    || StringUtils.isEmpty(authenticationRequest.getPassword())){
                throw new RuntimeException("账号或密码为空");
            }
            UserDto userDto = getUserDto(authenticationRequest.getUsername());
            if(userDto == null){
                throw new RuntimeException("查询不到该用户");
            }
            if(!authenticationRequest.getPassword().equals(userDto.getPassword())){
                throw new RuntimeException("账号或密码错误");
            }
    
            return userDto;
        }
        //模拟用户查询
        public UserDto getUserDto(String username){
            return userMap.get(username);
        }
        //用户信息
        private Map<String,UserDto> userMap = new HashMap<>();
        {
            userMap.put("zhangsan",new UserDto("1010","zhangsan","123","张三","133443"));
            userMap.put("lisi",new UserDto("1011","lisi","456","李四","144553"));
        }
    }

（3）登录Controller，对/login请求处理，它调用AuthenticationService完成认证并返回登录结果提示信息：

@RestController
    public class LoginController {
    
        @Autowired
        private AuthenticationService authenticationService;
    
        /**
         * 用户登录
         * @param authenticationRequest 登录请求
         * @return
         */
        @PostMapping(value = "/login",produces = {"text/plain;charset=UTF-8"})
        public String login(AuthenticationRequest authenticationRequest){
            UserDetails userDetails = authenticationService.authentication(authenticationRequest);
            return userDetails.getFullname() + " 登录成功";
        }
    
    }

（5）测试  
启动项目，访问/路径地址，进行测试  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDA2MjMzOQ_size_16_color_FFFFFF_t_70 3]

以上的测试全部符合预期，到目前为止最基础的认证功能已经完成，它仅仅实现了对用户身份凭证的校验，若某用户认证成功，只能说明他是该系统的一个合法用户。

### 4.实现会话功能 ###

会话是指用户登入系统后，系统会记住该用户的登录状态，他可以在系统连续操作直到退出系统的过程。

认证的目的是对系统资源的保护，每次对资源的访问，系统必须得知道是谁在访问资源，才能对该请求进行合法性拦截。因此，在认证成功后，一般会把认证成功的用户信息放入Session中，在后续的请求中，系统能够从Session中获取到当前用户，用这样的方式来实现会话机制。

（1）增加会话控制

首先在UserDto中定义一个SESSION\_USER\_KEY，作为Session中存放登录用户信息的key。

public static final String SESSION_USER_KEY = "_user";

然后修改LoginController，认证成功后，将用户信息放入当前会话。并增加用户登出方法，登出时将session置为失效。

/**
     * 用户登录
     * @param authenticationRequest 登录请求
     * @param session http会话
     * @return
     */
     @PostMapping(value = "/login",produces = "text/plain;charset=utf-8")
        public String login(AuthenticationRequest authenticationRequest, HttpSession session){
    
            UserDto userDto = authenticationService.authentication(authenticationRequest);
            //用户信息存入session
            session.setAttribute(UserDto.SESSION_USER_KEY,userDto);
            return userDto.getUsername() + "登录成功";
        }
    
        @GetMapping(value = "logout",produces = "text/plain;charset=utf-8")
        public String logout(HttpSession session){
            session.invalidate();
            return "退出成功";
        }

（2）增加测试资源

修改LoginController，增加测试资源1，它从当前会话session中获取当前登录用户，并返回提示信息给前台。
    
      /**
         * 测试资源1
         * @param session
         * @return
         */
     
        @GetMapping(value = "/r/r1",produces = {"text/plain;charset=UTF-8"})
        public String r1(HttpSession session){
            String fullname = null;
            Object userObj = session.getAttribute(UserDto.SESSION_USER_KEY);
            if(userObj != null){
                fullname = ((UserDto)userObj).getFullname();
            }else{
                fullname = "匿名";
            }
            return fullname + " 访问资源1";
        }

（3）测试

未登录情况下直接访问测试资源/r/r1：  
![在这里插入图片描述][20191009081149162.png]  
成功登录的情况下访问测试资源/r/r1：  
![在这里插入图片描述][20191009081157242.png]

测试结果说明，在用户登录成功时，该用户信息已被成功放入session，并且后续请求可以正常从session中获取当前登录用户信息，符合预期结果。

### 5.实现授权功能 ###

现在我们已经完成了用户身份凭证的校验以及登录的状态保持，并且我们也知道了如何获取当前登录用户(从Session中获取)的信息，接下来，用户访问系统需要经过授权，即需要完成如下功能：

*  匿名用户（未登录用户）访问拦截：禁止匿名用户访问某些资源。
 *  登录用户访问拦截：根据用户的权限决定是否能访问某些资源。

（1）增加权限数据

为了实现这样的功能，我们需要在UserDto里增加权限属性，用于表示该登录用户所拥有的权限，同时修改UserDto的构造方法。

@Data
    @AllArgsConstructor
    public class UserDto {
        public static final String SESSION_USER_KEY = "_user";
    
        private String id;
        private String username;
        private String password;
        private String fullname;
        private String mobile;
        /**
         * 用户权限
         */
        private Set<String> authorities;
    
    }

并在AuthenticationServiceImpl中为模拟用户初始化权限，其中张三给了p1权限，李四给了p2权限。

//用户信息
        private Map<String,UserDto> userMap = new HashMap<>();
        {
            Set<String> authorities1 = new HashSet<>();
            authorities1.add("p1");
            Set<String> authorities2 = new HashSet<>();
            authorities2.add("p2");
            userMap.put("zhangsan",new UserDto("1010","zhangsan","123","张三","133443",authorities1));
            userMap.put("lisi",new UserDto("1011","lisi","456","李四","144553",authorities2));
        }
        private UserDetails getUserDetails(String username) {
            return userDetailsMap.get(username);
        }

（2）增加测试资源

我们想实现针对不同的用户能访问不同的资源，前提是得有多个资源，因此在LoginController中增加测试资源2。

/**
     * 测试资源2
     * @param session
     * @return
     */
    @GetMapping(value = "/r/r2",produces = {"text/plain;charset=UTF-8"})
    public String r2(HttpSession session){
        String fullname = null;
        Object userObj = session.getAttribute(UserDto.SESSION_USER_KEY);
        if(userObj != null){
            fullname = ((UserDto)userObj).getFullname();
        }else{
            fullname = "匿名";
        }
        return fullname + " 访问资源2";
    }

（3）实现授权拦截器

在interceptor包下定义SimpleAuthenticationInterceptor拦截器，实现授权拦截：

1、校验用户是否登录

2、校验用户是否拥有操作权限

@Component
    public class SimpleAuthenticationInterceptor implements HandlerInterceptor {
        //请求拦截方法
        @Override
        public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
            //读取会话信息
            Object object = request.getSession().getAttribute(UserDto.SESSION_USER_KEY);
            if(object == null){
                writeContent(response,"请登录");
            }
            UserDto user = (UserDto) object;
            //请求的url
            String requestURI = request.getRequestURI();
            if(user.getAuthorities().contains("p1") && requestURI.contains("/r1")){
                return true;
            }
            if(user.getAuthorities().contains("p2") && requestURI.contains("/r2")){
                return true;
            }
            writeContent(response,"权限不足，拒绝访问");
            return false;
        }
    
        //响应输出
        private void writeContent(HttpServletResponse response, String msg) throws IOException {
            response.setContentType("text/html;charset=utf-8");
            PrintWriter writer = response.getWriter();
            writer.print(msg);
            writer.close();
            response.resetBuffer();
        }
    
    }

在WebConfig中配置拦截器，匹配/r/\*\*的资源为受保护的系统资源，访问该资源的请求进入SimpleAuthenticationInterceptor拦截器。

@Autowired
     private SimpleAuthenticationInterceptor simpleAuthenticationInterceptor;
        
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(simpleAuthenticationInterceptor).addPathPatterns("/r/**");
    }

（4）测试

未登录情况下，/r/r1与/r/r2均提示 “请先登录”。

张三登录情况下，由于张三有p1权限，因此可以访问/r/r1，张三没有p2权限，访问/r/r2时提示 “权限不足 “。

李四登录情况下，由于李四有p2权限，因此可以访问/r/r2，李四没有p1权限，访问/r/r1时提示 “权限不足 “。

测试结果全部符合预期结果。

### 6 案例代码 ###

[https://github.com/pbteach/SpringSecurity/tree/master/security-springmvc][https_github.com_pbteach_SpringSecurity_tree_master_security-springmvc]

### 视频下载 ###

[燕青SpringSecurity视频下载][SpringSecurity]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDA2MjMzOQ_size_16_color_FFFFFF_t_70]: /images/20230601/1612d592e0fc4e38abdc52b6fc166743.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDA2MjMzOQ_size_16_color_FFFFFF_t_70 1]: /images/20230601/46f5a7c7616e48f9b953a04e92b3ada0.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDA2MjMzOQ_size_16_color_FFFFFF_t_70 2]: /images/20230601/d990001108c84ff88550699b81e9430c.png
[20191009080957202.png]: /images/20230601/f2ec62d579b24a3cb848fce5e795d6e2.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDA2MjMzOQ_size_16_color_FFFFFF_t_70 3]: /images/20230601/21af776aea3048a48eb9cd71608230bd.png
[20191009081149162.png]: /images/20230601/d5529730c21b47b7acf9095dc6de9066.png
[20191009081157242.png]: /images/20230601/676e7885ea7a4eefb21a75438304eef3.png
[https_github.com_pbteach_SpringSecurity_tree_master_security-springmvc]: https://github.com/pbteach/SpringSecurity/tree/master/security-springmvc
[SpringSecurity]: https://blog.csdn.net/weixin_44062339/article/details/102598424