SpringSecurity安全性框架详解

SpringSecurity简介

Spring Security是一个高度自定义的安全框架。利用 Spring IoC/DIAOP功能,为系统提供了声明式安全访问控制功能,减少了为系统安全而编写大量重复代码的工作。使用 Spring Secruity 的原因有很多,但大部分都是发现了 javaEE的 Servlet 规范或 EJB 规范中的安全功能缺乏典型企业应用场景。同时认识到他们在 WAR 或 EAR 级别无法移植。因此如果你更换服务器环境,还有大量工作去重新配置你的应用程序。使用 Spring Security解决了这些问题,也为你提供许多其他有用的、可定制的安全功能。正如你可能知道的两个应用程序的两个主要区域是“认证”和“授权”(或者访问控制)。这两点也是 Spring Security 重要核心功能。“认证”,是建立一个他声明的主体的过程(一个“主体”一般是指用户,设备或一些可以在你的应用程序中执行动作的其他系统),通俗点说就是系统认为用户是否能登录。“授权”指确定一个主体是否允许在你的应用程序执行一个动作的过程。通俗点讲就是系统判断用户是否有权限去做某些事情。

快速入门

导入依赖

<?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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.6.7</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.example</groupId>
    <artifactId>demo</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>demo</name>
    <description>Demo project for Spring Boot</description>
    <properties>
        <java.version>1.8</java.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-security</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.security</groupId>
            <artifactId>spring-security-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

前端页面
login.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>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>

访问页面
导入spring-boot-starter-security 启动器后,Spring Security 已经生效,默认拦截全部请求,如果用户没有登录,跳转到内置登录页面
在这里插入图片描述
默认的 username 为 user,password 打印在控制台中
在这里插入图片描述
在浏览器中输入账号和密码后会显示 login.html 页面内容

UserDetailsService详解

当什么也没有配置的时候,账号和密码是由 Spring Security 定义生成的。而在实际项目中账号和密码都是从数据库中查询出来的。所以我们要通过自定义逻辑控制认证逻辑。如果需要自定义逻辑时,只需要实现UserDetailsService 接口即可。接口定义如下:
在这里插入图片描述
返回值 UserDetails 也是一个接口,定义如下

public interface UserDetails extends Serializable {
	Collection<? extends GrantedAuthority> getAuthorities();//获取所有权限

	String getPassword();//获取密码

	String getUsername();//获取用户名

	boolean isAccountNonExpired();//是否账号过期

	boolean isAccountNonLocked();//是否账号被锁定

	boolean isCredentialsNonExpired();//凭证(密码)是否过期

	boolean isEnabled();//是否可用
}

要想返回 UserDetails 的实例就只能返回接口的实现类。SpringSecurity 中提供了如下的实例。对于我们只需要使用里面的 User 类即可
在这里插入图片描述
在 User 类中提供了很多方法和属性,其中构造方法有两个,调用其中任何一个都可以实例化,三个参数的构造方法实际上也是调用 7 个参数的构造方法。

public User(String username, String password, Collection<? extends GrantedAuthority> authorities) {
		this(username, password, true, true, true, true, authorities);
	}

public User(String username, String password, boolean enabled, boolean accountNonExpired,
			boolean credentialsNonExpired, boolean accountNonLocked,
			Collection<? extends GrantedAuthority> authorities) {
		Assert.isTrue(username != null && !"".equals(username) && password != null,
				"Cannot pass null or empty values to constructor");
		this.username = username;
		this.password = password;
		this.enabled = enabled;
		this.accountNonExpired = accountNonExpired;
		this.credentialsNonExpired = credentialsNonExpired;
		this.accountNonLocked = accountNonLocked;
		this.authorities = Collections.unmodifiableSet(sortAuthorities(authorities));
	}

此处的用户名应该是客户端传递过来的用户名,默认情况下必须叫 username。而密码应该是从数据库中查询出来的密码。Spring Security 会根据 User 中的 password 和客户端传递过来的 password 进行比较。如果相同则表示认证通过,如果不相同表示认证失败。
 
authorities 里面的权限对于后面学习授权是很有必要的,包含的所有内容为此用户具有的权限,如果里面没有包含某个权限,而在做某个事情时必须包含某个权限则会出现 403。通常都是通过AuthorityUtils.commaSeparatedStringToAuthorityList(“”) 来创建authorities 集合对象的。参数是一个字符串,多个权限使用逗号分隔。

异常
UsernameNotFoundException 用户名没有发现异常。在 loadUserByUsername 中是需要通过自己的逻辑从数据库中取值的。如果通过用户名没有查询到对应的数据,应该抛出UsernameNotFoundException ,系统就知道用户名没有查询到

PasswordEncoder 密码解析器详解

Spring Security 要求容器中必须有 PasswordEncoder 实例。所以当自定义登录逻辑时要求必须给容器注入 PaswordEncoder 的bean对象。

接口介绍
在这里插入图片描述

  • encode() :把参数按照特定的解析规则进行解析。
  • matches() :验证从存储中获取的编码密码与编码后提交的原始密码是否匹配。如果密码匹配,则返回 true;如果不匹配,则返回
    false。第一个参数表示需要被解析的密码。第二个参数表示存储的密码。
  • upgradeEncoding() :如果解析的密码能够再次进行解析且达到更安全的结果则返回 true,否则返回 false。默认返回
    false。

内置解析器
在 Spring Security 中内置了很多解析器
在这里插入图片描述

BCryptPasswordEncoder 简介

BCryptPasswordEncoder 是 Spring Security 官方推荐的密码解析器,平时多使用这个解析器。
BCryptPasswordEncoder 是对 bcrypt 强散列方法的具体实现。是基于Hash算法实现的单向加密。可以通过strength控制加密强度,默认 10.

代码演示
新建测试方法BCryptPasswordEncoder 用法

@SpringBootTest
public class MyTest {
   @Test
   public void test(){
      //创建解析器
      PasswordEncoder pw = new BCryptPasswordEncoder();
      //对密码加密
      String encode = pw.encode("123");
      System.out.println(encode);
      //判断原字符和加密后内容是否匹配
      boolean matches = pw.matches("1234", encode);
      System.out.println("==================="+matches);
   }
}

自定义登录逻辑

当 进 行 自 定 义 登 录 逻 辑 时 需 要 用 到 之 前 讲 解 的 UserDetailsServicePasswordEncoder 。但是 Spring Security 要求:当进行自定义登录逻辑时容器内必须有PasswordEncoder 实例。所以不能直接 new 对象

编写配置类

package com.example.demo.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;

@Configuration
public class SecurityConfig {

    @Bean
    public PasswordEncoder getPW(){
        return new BCryptPasswordEncoder();
    }
}

自定义逻辑

在 Spring Security 中实现 UserDetailService 就表示为用户详情服务。在这个类中编写用户认证逻辑

package com.example.demo.service;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.core.authority.AuthorityUtils;
import org.springframework.security.core.userdetails.User;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.core.userdetails.UsernameNotFoundException;
import org.springframework.security.crypto.password.PasswordEncoder;

@Service
public class UserServiceImpl implements UserDetailsService {

    @Autowired
    private PasswordEncoder pw;

    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
        //1.查询数据库判断用户名是否存在,如果不存在抛出UsernameNotFoundException异常
        if (!"admin".equals(username)){
            throw new UsernameNotFoundException("用户名不存在");
        }
        //2.把查询出来的密码(注册时已经加密过)进行解析,或直接把密码放入构造方法中
        String password = pw.encode("123");
        return new User(username,password,
                AuthorityUtils.commaSeparatedStringToAuthorityList("admin,normal"));//角色
    }
}

重启项目后,在浏览器中输入账号:admin,密码:123。后可以正确进入到 login.html 页面。

自定义登录页面

编写登录页面

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>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>

修改配置类

修改配置类中主要是设置哪个页面是登录页面。配置类需要继承WebSecurityConfigurerAdapte,并重写configure 方法

  • successForwardUrl() :登录成功后跳转地址
  • loginPage() :登录页面
  • loginProcessingUrl :登录页面表单提交地址,此地址可以不真实存在。
  • antMatchers() :匹配内容
  • permitAll() :允许访问,不需要认证
package com.example.demo.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;

@Configuration
public class SecurityConfig extends WebSecurityConfigurerAdapter {


    @Override
    protected void configure(HttpSecurity http) throws Exception {
        //表单提交
        http.formLogin()
                //自定义登录页面
                .loginPage("/login.html")
                //当发现/login时认为是登录,必须和表单提交的地址一样。去执行UserServiceImpl
                .loginProcessingUrl("/login")
                //登录成功后跳转页面,POST请求,控制器
                .successForwardUrl("/toMain");

        http.authorizeRequests()
                //login.html不需要被认证
                .antMatchers("/login.html").permitAll()
                //所有请求都必须被认证,必须登录后被访问
                .anyRequest().authenticated();

        //关闭csrf防护
        http.csrf().disable();
    }

    @Bean
    public PasswordEncoder getPW(){
        return new BCryptPasswordEncoder();
    }
}

编写控制器

package com.example.demo.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;

@Controller
public class LoginController {

//    该方法不执行
//    @RequestMapping("login")
//    public String login(){
//        return "redirect:main.html";
//    }

    /**
     * 成功后跳转页面
     * @return
     */
    @RequestMapping("/toMain")
    public String toMain(){
        return "redirect:/main.html";
    }
}

认证过程其他常用配置

失败跳转

表单处理中成功会跳转到一个地址,失败也可以跳转到一个地址

编写页面error.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
操作失败,请重新登录 <a href= "/login.html">跳转</a>
</body>
</html>

修改表单配置
在配置方法中表单认证部分添加 failureForwardUrl() 方法,表示登录失败跳转的 url。此处依然是POST 请求,所以跳转到可以接收 POST请求的控制器/error中

//表单提交
http.formLogin()
      //自定义登录页面
     .loginPage("/login.html")
      //当发现/login时认为是登录,必须和表单提交的地址一样。去执行UserServiceImpl
     .loginProcessingUrl("/login")
      //登录成功后跳转页面,POST请求
     .successForwardUrl("/toMain")
      //登录失败后跳转页面,POST请求
     .failureForwardUrl("/toError");

添加控制器的
在控制器类中添加控制器方法,方法映射路径/error。此处要注意:由于是 POST 请求访问/error。所以如果返回值直接转发到 error.html 中,即使有效果,控制台也会报警告,提示 error.html 不支持POST 访问方式

/**
* 失败后跳转页面
* @return
*/
@RequestMapping("/toError")
public String toError(){
   return "redirect:/error.html";
}

设置error.html不需要认证

http.authorizeRequests()
      //login.html不需要被认证
     .antMatchers("/login.html").permitAll()
      //error.html不需要被认证
     .antMatchers("/error.html").permitAll()
      //所有请求都必须被认证,必须登录后被访问
     .anyRequest().authenticated();

设置请求账户和密码的参数名

当进行登录时会执行 UsernamePasswordAuthenticationFilter 过滤器

  • usernamePasrameter :账户参数名
  • passwordParameter :密码参数名
  • postOnly=true :默认情况下只允许POST请求

在这里插入图片描述
修改配置

//表单提交
http.formLogin()
      //自定义登录页面
     .loginPage("/login.html")
      //当发现/login时认为是登录,必须和表单提交的地址一样。去执行UserServiceImpl
     .loginProcessingUrl("/login")
      //登录成功后跳转页面,POST请求
     .successForwardUrl("/toMain")
      //登录失败后跳转页面,POST请求
     .failureForwardUrl("/toError")
     .usernameParameter("myusername")
     .passwordParameter("mypassword");

修改login.html

<form action="/login" method="post">
   用户名:<input type="text" name="myusername" /><br/>
   密码:<input type="password" name="mypassword" /><br/>
    <input type="submit" value="登录" />
</form>

自定义登录成功处理器

使用successForwardUrl()时表示成功后转发请求到地址。内部是通过 successHandler() 方法进行控制成功后交给哪个类进行处理
在这里插入图片描述
ForwardAuthenticationSuccessHandler内部就是最简单的请求转发。由于是请求转发,当遇到需要跳转到站外或在前后端分离的项目中就无法使用了
在这里插入图片描述
所以当需要控制登录成功后去做一些事情时,可以进行自定义认证成功控制器

代码实现

自定义类

package com.example.demo.handle;

import org.springframework.security.core.Authentication;
import org.springframework.security.core.userdetails.User;
import org.springframework.security.web.authentication.AuthenticationSuccessHandler;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

public class MyAuthenticationSuccessHandler implements AuthenticationSuccessHandler {

    private String url;

    public MyAuthenticationSuccessHandler(String url) {
        this.url = url;
    }

    @Override
    public void onAuthenticationSuccess(HttpServletRequest request, HttpServletResponse response, Authentication authentication) throws IOException, ServletException {
        //Principal 主体,存放了登录用户的信息
        User user = (User) authentication.getPrincipal();
        System.out.println(user.getUsername());

        //输出null
        System.out.println(user.getPassword());
        System.out.println(user.getAuthorities());
        response.sendRedirect(url);

    }
}

修改配置项
使用 successHandler()方法设置成功后交给哪个对象进行处理

//表单提交
http.formLogin()
      //自定义登录页面
     .loginPage("/login.html")
      //当发现/login时认为是登录,必须和表单提交的地址一样。去执行UserServiceImpl
     .loginProcessingUrl("/login")
      //登录成功后跳转页面,POST请求
      // .successForwardUrl("/toMain")
      //和successForwardUrl不能共存
     .successHandler(new
MyAuthenticationSuccessHandler("http://www.baidu.com"))
      //登录失败后跳转页面,POST请求
     .failureForwardUrl("/toError")
     .usernameParameter("myusername")
     .passwordParameter("mypassword");

自定义登录失败处理器

failureForwardUrl()内部调用的是 failureHandler() 方法
在这里插入图片描述
ForwardAuthenticationFailureHandler 中也是一个请求转发,并在request 作用域中设置SPRING_SECURITY_LAST_EXCEPTION 的 key,内容为异常对象在这里插入图片描述

代码实现

新建控制器

package com.example.demo.handle;

import org.springframework.security.core.AuthenticationException;
import org.springframework.security.web.authentication.AuthenticationFailureHandler;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

public class MyForwardAuthenticationFailureHandler implements AuthenticationFailureHandler {

    private String url;

    public MyForwardAuthenticationFailureHandler(String url) {
        this.url = url;
    }

    @Override
    public void onAuthenticationFailure(HttpServletRequest request, HttpServletResponse response, AuthenticationException exception) throws IOException, ServletException {
        response.sendRedirect(url);
    }
}

修改配置类
修改配置类中表单登录部分。设置失败时交给失败处理器进行操作。 failureForwardUrl 和failureHandler 不可共存

//表单提交
http.formLogin()
      //自定义登录页面
     .loginPage("/login.html")
      //当发现/login时认为是登录,必须和表单提交的地址一样。去执行UserServiceImpl
     .loginProcessingUrl("/login")
      //登录成功后跳转页面,POST请求
      // .successForwardUrl("/toMain")
      //和successForwardUrl不能共存
     .successHandler(new
MyAuthenticationSuccessHandler("http://www.baidu.com"))
      //登录失败后跳转页面,POST请求
      // .failureForwardUrl("/toError")
     .failureHandler(new MyForwardAuthenticationFailureHandler("/error.html"))
     .usernameParameter("myusername")
     .passwordParameter("mypassword");

访问控制url匹配

在前面讲解了认证中所有常用配置,主要是对 http.formLogin() 进行操作。而在配置类中http.authorizeRequests() 主要是对url进行控制,也就是我们所说的授权(访问控制)。http.authorizeRequests() 也支持连缀写法,总体公式为:url 匹配规则.权限控制方法

anyRequest()

在之前认证过程中我们就已经使用过 anyRequest(),表示匹配所有的请求。一般情况下此方法都会使用,设置全部内容都需要进行认证

.anyRequest().authenticated();  

antMatchers()

参数是不定向参数,每个参数是一个 ant 表达式,用于匹配 URL规则,规则如下:

  • ? : 匹配一个字符
  • :匹配 0 个或多个字符
  • ** :匹配 0 个或多个目录

在实际项目中经常需要放行所有静态资源,下面演示放行 js 文件夹下所有脚本文件

.antMatchers("/js/**","/css/**").permitAll()  

还有一种配置方式是只要是.js 文件都放行

.antMatchers("/**/*.js").permitAll()

regexMatchers()

使用正则表达式进行匹配。和 antMatchers() 主要的区别就是参数, antMatchers() 参数是 ant 表达式, regexMatchers() 参数是正则表达式
以.js 结尾的文件都被放行

.regexMatchers( ".+[.]js").permitAll()

两个参数时使用方式
无论是 antMatchers() 还是 regexMatchers() 都具有两个参数的方法,其中第一个参数都是HttpMethod ,表示请求方式,当设置了 HttpMethod 后表示只有设定的特定的请求方式才执行对应的权限设置
在这里插入图片描述

mvcMatchers()

mvcMatchers()适用于配置了 servletPath 的情况

servletPath 就是所有的 URL 的统一前缀。在 SpringBoot 整合SpringMVC 的项目中可以在application.properties 中添加下面内容设置 ServletPath

spring.mvc.servlet.path=/xxxx

在 Spring Security 的配置类中配置 .servletPath() 是 mvcMatchers()返回值特有的方法,antMatchers()和 regexMatchers()没有这个方法。在 servletPath() 中配置了 servletPath 后,mvcMatchers()直接写 SpringMVC 中@RequestMapping()中设置的路径即可

.mvcMatchers("/demo").servletPath("/xxxx").permitAll()

如果不习惯使用 mvcMatchers()也可以使用 antMatchers(),下面代码和上面代码是等效

.antMatchers("/xxxx/demo").permitAll()

内置访问控制方法

Spring Security 匹配了 URL 后调用了 permitAll() 表示不需要认证,随意访问。在 Spring Security 中提供了多种内置控制
在这里插入图片描述

  • permitAll():表示所匹配的 URL 任何人都允许访问
  • authenticated():表示所匹配的 URL 都需要被认证才能访问
  • anonymous():表示可以匿名访问匹配的URL,和permitAll()效果类似,只是设置为 anonymous()的 url 会执行 filter 链中
  • denyAll():表示所匹配的 URL 都不允许被访问
  • rememberMe() :被“remember me”的用户允许访问
  • fullyAuthenticated():如果用户不是被 remember me 的,才可以访问

角色权限判断

除了之前讲解的内置权限控制。Spring Security 中还支持很多其他权限控制。这些方法一般都用于用户已经被认证后,判断用户是否具有特定的要求

hasAuthority(String)
 判断用户是否具有特定的权限,用户的权限是在自定义登录逻辑中创建 User 对象时指定的。下图中admin和normal 就是用户的权限。admin和normal 严格区分大小写
在这里插入图片描述
在配置类中通过 hasAuthority(“admin”)设置具有 admin 权限时才能访问

.antMatchers("/main1.html").hasAuthority("admin")

hasAnyAuthority(String …)
如果用户具备给定权限中某一个,就允许访问
下面代码中由于大小写和用户的权限不相同,所以用户无权访问

.antMatchers("/main1.html").hasAnyAuthority("adMin","admiN")

hasRole(String)
如果用户具备给定角色就允许访问。否则出现 403;
在给用户赋予角色时角色需要以: **ROLE_**开头 ,后面添加角色名称。例如:ROLE_abc 其中 abc 是角色名,ROLE_是固定的字符开头
使用 hasRole()时参数也只写 abc 即可,否则启动报错
在这里插入图片描述
在配置类中直接写 abc 即可

.antMatchers("/main1.html").hasRole("abc")

hasAnyRole(String …)
如果用户具备给定角色的任意一个,就允许被访问

hasIpAddress(String)
如果请求是指定的 IP 就运行访问,可以通过 request.getRemoteAddr() 获取 ip 地址
需要注意的是在本机进行测试时 localhost 和 127.0.0.1 输出的 ip地址是不一样的

.antMatchers("/main1.html").hasIpAddress("127.0.0.1")

自定义403处理方案

新建类实现 AccessDeniedHandler

package com.example.demo.handle;

import org.springframework.security.access.AccessDeniedException;
import org.springframework.security.web.access.AccessDeniedHandler;
import org.springframework.stereotype.Component;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.PrintWriter;

@Component
public class MyAccessDeniedHandler implements AccessDeniedHandler {
    @Override
    public void handle(HttpServletRequest request, HttpServletResponse response, AccessDeniedException accessDeniedException) throws IOException, ServletException {
        response.setStatus(HttpServletResponse.SC_FORBIDDEN);//错误码   403
        response.setHeader("Content-Type", "application/json;charset=utf-8");
        PrintWriter out = response.getWriter();
        out.write("{\"status\":\"error\",\"msg\":\"权限不足,请联系管理员!\"}");
        out.flush();
        out.close();
    }
}

修改配置类
配置类中重点添加异常处理器,设置访问受限后交给哪个对象进行处理
myAccessDeniedHandler 是在配置类中进行自动注入的

//异常处理
http.exceptionHandling().accessDeniedHandler(myAccessDeniedHandler);

基于注解的访问控制

在 Spring Security 中提供了一些访问控制的注解。这些注解都是默认是都不可用的,需要通过**@EnableGlobalMethodSecurity** 进行开启后使用;如果设置的条件允许,程序正常执行。如果不允许会报 500

这些注解可以写到 Service 接口或方法上,也可以写到 Controller或 Controller 的方法上。通常情况下都是写在控制器方法上的,控制接口URL是否允许被访问

@Secured

专门用于判断是否具有角色的,能写在方法或类上。参数要以 ROLE_开头

开启注解
在 启 动 类 ( 也 可 以 在 配 置 类 等 能 够 扫 描 的 类 上 )上添加**@EnableGlobalMethodSecurity(securedEnabled = true)**

@SpringBootApplication
@EnableGlobalMethodSecurity(securedEnabled = true)
public class SpringsecurityDemoApplication {
   public static void main(String[] args) {
      SpringApplication.run(SpringsecurityDemoApplication.class, args);
   }
}

在控制器方法上添加@Secured 注解

/**
* 成功后跳转页面
* @return
*/
@Secured("ROLE_abc")
@RequestMapping("/toMain")
public String toMain(){
   return "redirect:/main.html";
}

配置类

@Override
protected void configure(HttpSecurity http) throws Exception {
   //表单提交
   http.formLogin()
         //自定义登录页面
         .loginPage("/login.html")
         //当发现/login时认为是登录,必须和表单提交的地址一样。去执行UserServiceImpl
         .loginProcessingUrl("/login")
         //登录成功后跳转页面,POST请求
         .successForwardUrl("/toMain")
         
   //url拦截
   http.authorizeRequests()
         //login.html不需要被认证
         .antMatchers("/login.html").permitAll()
         //所有请求都必须被认证,必须登录后被访问
         .anyRequest().authenticated();
   //关闭csrf防护
   http.csrf().disable();
}

@PreAuthorize/@PostAuthorize

@PreAuthorize/@PostAuthorize都是方法或类级别的注解

  • @PreAuthorize:表示访问方法或类在执行之前先判断权限,大多情况下都是使用这个注解,注解的参数和access()方法参数取值相同,都是权限表达式
  • @PostAuthorize 表示方法或类执行结束后判断权限,此注解很少被使用到

添加@PreAuthorize
在控制器方法上添加@PreAuthorize,参数可以是任何 access()支持的表达式

/**
* 成功后跳转页面
* @return
*/
@PreAuthorize("hasRole('ROLE_abc')")
@RequestMapping("/toMain")
public String toMain(){
   return "redirect:/main.html";
}

RememberMe功能实现

Spring Security 中 Remember Me 为“记住我”功能,用户只需要在登录时添加 remember-me复选框,取值为true。Spring Security 会自动把用户信息存储到数据源中,以后就可以不登录进行访问

添加依赖
Spring Security 实 现 Remember Me 功 能 时 底 层 实 现 依 赖Spring-JDBC,所以需要导入 SpringJDBC。以后多使用 MyBatis 框架而很少直接导入 spring-jdbc,所以此处导入 mybatis 启动器同时还需要添加 MySQL 驱动

<!-- mybatis 依赖 -->
<dependency>
   <groupId>org.mybatis.spring.boot</groupId>
   <artifactId>mybatis-spring-boot-starter</artifactId>
   <version>2.1.1</version>
</dependency>
<!-- mysql 数据库依赖 -->
<dependency>
   <groupId>mysql</groupId>
   <artifactId>mysql-connector-java</artifactId>
   <version>8.0.18</version>
</dependency>

配置数据源

spring.datasource.driver-class-name= com.mysql.cj.jdbc.Driver
spring.datasource.url= jdbc:mysql://localhost:3306/security?
useUnicode=true&characterEncoding=UTF-8&serverTimezone=Asia/Shanghai
spring.datasource.username= root
spring.datasource.password= root

编写配置

package com.example.demo.config;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.web.authentication.rememberme.JdbcTokenRepositoryImpl;
import org.springframework.security.web.authentication.rememberme.PersistentTokenRepository;

import javax.sql.DataSource;

@Configuration
public class RememberMeConfig {

    @Autowired
    private DataSource dataSource;

    @Bean
    public PersistentTokenRepository getPersistentTokenRepository(){
        JdbcTokenRepositoryImpl jdbcTokenRepository = new
                JdbcTokenRepositoryImpl();
        jdbcTokenRepository.setDataSource(dataSource);
        //自动建表,第一次启动时需要,第二次启动时注释掉
        jdbcTokenRepository.setCreateTableOnStartup(true);
        return jdbcTokenRepository;
    }
}

修改SecurityConfig.java
在SecurityConfig中添加RememberMeConfigUserDetailsService实现类对象,并自动注入
在 configure 中添加下面配置内容

http.rememberMe()
      //登录逻辑交给哪个对象
     .userDetailsService(userService)
      // 持久层对象
     .tokenRepository(persistentTokenRepository);

在客户端页面添加复选框

<form action="/login" method="post">
   用户名:<input type="text" name="username" /><br/>
   密码:<input type="password" name="password" /><br/>
    <input type="checkbox" name="remember-me" value="true"/><br/>
    <input type="submit" value="登录" />
</form>

有效时间
默认情况下重启项目后登录状态失效了。但是可以通过设置状态有效时间,即使项目重新启动下次也可以正常登录

http.rememberMe()
      //失效时间,单位秒
     .tokenValiditySeconds(120)
      //登录逻辑交给哪个对象
     .userDetailsService(userService)
      // 持久层对象
     .tokenRepository(persistentTokenRepository);

Thymeleaf中SpringSecurity的使用

Spring Security 可以在一些视图技术中进行控制显示效果。例如: JSPThymeleaf 。在非前后端分离且使用 Spring Boot 的项目中多使用 Thymeleaf 作为视图展示技术

Thymeleaf 对 Spring Security 的 支 持 都 放 在 thymeleaf-extras-springsecurityX 中,目前最新版本为 5。所以需要在项目中添加此 jar 包的依赖和 thymeleaf 的依赖

<!--thymeleaf springsecurity5 依赖-->
<dependency>
   <groupId>org.thymeleaf.extras</groupId>
   <artifactId>thymeleaf-extras-springsecurity5</artifactId>
</dependency>
<!--thymeleaf依赖-->
<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-thymeleaf</artifactId>
</dependency>

在 html 页面中引入 thymeleaf 命名空间和 security 命名空间

<html xmlns="http://www.w3.org/1999/xhtml"
      xmlns:th="http://www.thymeleaf.org"
      xmlns:sec="http://www.thymeleaf.org/thymeleaf-extras-springsecurity5">

获取属性

可以在html页面中通过 sec:authentication=“” 获取UsernamePasswordAuthenticationToken 中所有 getXXX 的内容,包含父类中的 getXXX 的内容

根据源码得出下面属性:

  • name :登录账号名称
  • principal :登录主体,在自定义登录逻辑中是 UserDetails
  • credentials :凭证
  • authorities :权限和角色
  • details :实际上是 WebAuthenticationDetails 的实例。可以获取 remoteAddress (客户端
    ip)和 sessionId (当前 sessionId)

新建demo.html
在项目 resources 中新建 templates 文件夹,在 templates 中新建demo.html 页面

<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml"
      xmlns:sec="http://www.thymeleaf.org/thymeleaf-extras-springsecurity5">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
   登录账号:<span sec:authentication="name"></span><br/>
   登录账号:<span sec:authentication="principal.username"></span><br/>
   凭证:<span sec:authentication="credentials"></span><br/>
   权限和角色:<span sec:authentication="authorities"></span><br/>
   客户端地址:<span sec:authentication="details.remoteAddress"></span><br/>
   sessionId:<span sec:authentication="details.sessionId"></span><br/>
</body>
</html>

编写Controller
thymeleaf 页面需要控制转发,在控制器类中编写下面方法

@RequestMapping("/demo")
public String demo(){
   return "demo";
}

权限判断

设置用户角色和权限,设定用户具有 admin,/insert,/delete 权限 ROLE_abc 角色

return new User(username,password, 
AuthorityUtils.commaSeparatedStringToAuthorityList("admin,ROLE_abc,/insert,/dele
te"));

控制页面显示效果
在页面中根据用户权限和角色判断页面中显示的内容

通过权限判断:
<button sec:authorize="hasAuthority('/insert')">新增</button>
<button sec:authorize="hasAuthority('/delete')">删除</button>
<button sec:authorize="hasAuthority('/update')">修改</button>
<button sec:authorize="hasAuthority('/select')">查看</button>
<br/>
通过角色判断:
<button sec:authorize="hasRole('abc')">新增</button>
<button sec:authorize="hasRole('abc')">删除</button>
<button sec:authorize="hasRole('abc')">修改</button>
<button sec:authorize="hasRole('abc')">查看</button>

退出登录

用户只需要向 Spring Security 项目中发送 /logout 退出请求即可

在页面中添加 /logout 的超链接即可

<a href="/logout">退出登录</a>

为了实现更好的效果,通常添加退出的配置。默认的退出 url 为 /logout ,退出成功后跳转到 /login?logout
在这里插入图片描述
如果不希望使用默认值,可以通过下面的方法进行修改

http.logout()
     .logoutUrl("/logout")
     .logoutSuccessUrl("/login.html");

SpringSecurity中的CSRF

从刚开始学习Spring Security时,在配置类中一直存在这样一行代码: http.csrf().disable(); 如果没有这行代码导致用户无法被认证。这行代码的含义是:关闭 csrf 防护

什么是CSRF

CSRF(Cross-site request forgery)跨站请求伪造,也被称为“OneClick Attack” 或者 Session
Riding。通过伪造用户请求访问受信任站点的非法请求访问。

跨域:只要网络协议,ip 地址,端口中任何一个不相同就是跨域请求。
客户端与服务进行交互时,由于 http 协议本身是无状态协议,所以引入了cookie进行记录客户端身份。在cookie中会存放session id用来识别客户端身份的。在跨域的情况下,session id 可能被第三方恶意劫持,通过这个 session id 向服务端发起请求时,服务端会认为这个请求是合法的,可能发生很多意想不到的事情。

Spring Security中的CSRF

从 Spring Security4开始CSRF防护默认开启。默认会拦截请求。进行CSRF处理。CSRF为了保证不是其他第三方网站访问,要求访问时携带参数名为 _csrf 值为token(token 在服务端产生)的内容,如果token和服务端的token匹配成功,则正常访问

编写控制器方法
编写控制器方法,跳转到 templates 中 login.html 页面

@RequestMapping("/showLogin")
public String showLogin(){
   return "login";
}

新建login.html

<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml"
      xmlns:th="http://www.thymeleaf.org"
>
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
<form action="/login" method="post">
    <input type="hidden" th:value="${_csrf.token}" name="_csrf"
th:if="${_csrf}"/>
   用户名:<input type="text" name="username" /><br/>
   密码:<input type="password" name="password" /><br/>
    <input type="submit" value="登录" />
</form>
</body>
</html>

修改配置类

//关闭csrf防护
// http.csrf().disable();
  • 3
    点赞
  • 13
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值