Spring Security对用户权限进行管理

基于角色的访问控制
隐式访问控制：根据用户的角色判断是否具有某项操作
显示访问控制：为用户分配某种权限，根据权限判断是否可以进行某种操作。与具体角色无关，权限控制更加灵活

认证（ authentication )：建立主体（ principal) ，确认用户角色。"主体"不仅指用户，还可以是其他执行操作的系统或设备。
授权（authorization )：或称为"访问控制（access-control), 是指决定是否允许主体在应用程序中执行某种操作

Spring Security是Spring中常用的安全服务框架，它包含如下模块：

• 核心，spring-security-core.jar
• 配置，spring-security-config.jar
• Remoting，spring-security-remoting.jar
• Web安全，spring-security-web.jar
• LDAP认证，spring-security-ldap.jar
• ACL访问控制，spring-security-acl.jar
• CAS单点登录，spring-security-cas.jar
• OpenId，spring-security-openid.jar
• 测试，spring-security-test.jar

通过gradle引入Spring Security依赖如下

dependencies {
	implementation('org.springframework.boot:spring-boot-starter-security')
	...
}

基于角色的安全管理

角色权限类Authority

首先创建表示权限的类Authority实现GrantedAuthority接口
所有的Authentication实现类都保存了一个GrantedAuthority列表表示用户所具有的权限，通过AuthenticationManager设置到Authentication对象中的，然后AccessDecisionManager将依据GrantedAuthority来鉴定用户是否具有访问对应资源的权限。
GrantedAuthority是一个接口，其中只定义了一个getAuthority()方法，其返回值为String类型。该方法允许AccessDecisionManager获取一个能够精确代表该权限的字符串。

@Entity
public class Authority implements GrantedAuthority {
    private static final long serialVersionUID = 1L;
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    @Column(nullable = false)
    private String authority;

    public Long getId() {        return id;    }
    public void setId(Long id) {        this.id = id;    }

    @Override
    public String getAuthority() {        return authority;    }
    public void setAuthority(String authority) { this.authority = authority;  }
}

用户实体类User

接着需要创建用户角色类User，它实现了Spring Security的UserDetails接口，该接口需要重写getAuthorities()、getUsername()、getPassword()、isAccountNonExpired()、isEnabled()等方法用于获取、设置用户的基本信息。

其中@ManyToMany声明多对多映射，即User中用authorities字段表示用户的多个权限类Authority，并通过@JoinTable连接到对应的数据表user_authority。

在getAuthorities()返回权限列表时，需要将列表authorities中的Authority类型权限转换为SimpleGrantedAuthority类型后再返回。SimpleGrantedAuthority是Spring Security中GrantedAuthority接口的具体实现类，和我们自定义的Authority类似，用字符串role保存用户的角色信息，并实现了getAuthority()方法返回角色。

@Entity // 实体
public class User implements UserDetails, Serializable {
	private static final long serialVersionUID = 1L;
	
	private Long id; // 用户的唯一标识
	private String name;
	private String email;
	private String username; // 用户账号，用户登录时的唯一标识
	private String password; // 登录时密码
	private String avatar; // 头像图片地址

	@ManyToMany(cascade = CascadeType.DETACH, fetch = FetchType.EAGER)
	@JoinTable(name = "user_authority", joinColumns = @JoinColumn(name = "user_id", referencedColumnName = "id"), 
		inverseJoinColumns = @JoinColumn(name = "authority_id", referencedColumnName = "id"))
	private List<Authority> authorities;

	protected User() { // JPA 的规范要求无参构造函数；设为 protected 防止直接使用
	}

	public User(String name, String email,String username,String password) {
		this.name = name;
		this.email = email;
		this.username = username;
		this.password = password;
	}

	public Long getId() {		return id;	}
	public void setId(Long id) {		this.id = id;	}
	public String getName() {		return name;	}
	public void setName(String name) {		this.name = name;	}
	public String getEmail() {		return email;	}
	public void setEmail(String email) {		this.email = email;	}
	
	@Override
	public Collection<? extends GrantedAuthority> getAuthorities() {
		//  将查询结果 List<Authority> 转换成 List<SimpleGrantedAuthority>
		List<SimpleGrantedAuthority> simpleAuthorities = new ArrayList<>();
		for(GrantedAuthority authority : this.authorities){
			simpleAuthorities.add(new SimpleGrantedAuthority(authority.getAuthority()));
		}
		return simpleAuthorities;
	}
	public void setAuthorities(List<Authority> authorities) {		this.authorities = authorities;	}
	
	@Override
	public String getUsername() {		return username;	}
	public void setUsername(String username) {		this.username = username;	}
	@Override
	public String getPassword() {		return password;	}
	public void setPassword(String password) {		this.password = password;	}
	public String getAvatar() {		return avatar;	}
	public void setAvatar(String avatar) {		this.avatar = avatar;	}
	@Override
	public boolean isAccountNonExpired() {		return true;	}
	@Override
	public boolean isAccountNonLocked() {		return true;	}
	@Override
	public boolean isCredentialsNonExpired() {		return true;	}
	@Override
	public boolean isEnabled() {		return true;	}
	@Override
	public String toString() {
		return String.format("User[id=%d, username='%s', name='%s', email='%s', password='%s']", id, username, name, email, password);
	}
}

Repository类

权限Authority的Repository，用于完成和数据库的交互，直接继承JPA接口的默认实现即可

public interface AuthorityRepository extends JpaRepository<Authority, Long>{
}

用户User的Repository

public interface UserRepository extends JpaRepository<User, Long> {
    //根据方法名生成查询函数
    User findByUsername(String username);

    //使用Distinct
    List<User> findDistinctByUsername(String username);

    /**
     * 根据用户名分页查询用户列表
     *
     * @param name     名字
     * @param pageable 分页
     * @return 分页用户信息
     */
    Page<User> findByNameLike(String name, Pageable pageable);
}

Service层

定义Authority对应的Service接口与实现类

@Service
public class AuthorityServiceImpl  implements AuthorityService {
	@Autowired
	private AuthorityRepository authorityRepository;
	
	@Override
	public Authority getAuthorityById(Long id) {
		return authorityRepository.getOne(id);
	}
}

定义User对应的Service，通过调用UserRepository实现User的增删改查等操作。此外还需要实现UserDetailsService接口的loadUserByUsername()方法，用于之后权限校验时进行用户查询

@Service
public class UserServiceImpl implements UserService, UserDetailsService {
	@Autowired
	private UserRepository userRepository;
	
	@Transactional
	@Override
	public User saveUser(User user) {
		return userRepository.save(user);
	}

	@Override
	public List<User> listUsers() {
		return userRepository.findAll();
	}
	......

	@Override
	public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
		return userRepository.findByUsername(username);
	}

Controller层

Controller层的定义遵循RESTful风格，当通过GET方法访问路径/users时，触发userList()方法，在其中通过userService的listUser()方法获取所有的User信息列表并放到Model中，最后返回页面user/list

在前端页面完成用户增加或修改操作后会发送Post请求到UserController，此时会触发saveOrUpdateUser()，在其中对用户信息和权限进行保存

通过@DeleteMapping注解定义对DELETE请求的响应方法delete()，完成对用户的删除操作

@RestController
@RequestMapping("/users")
@PreAuthorize("hasAuthority('ROLE_ADMIN')")  // 指定角色权限才能操作方法
public class UserController {
    @Autowired
    private UserService userService;

    @Autowired
    private AuthorityService authorityService;

    @GetMapping
    public ModelAndView userList(Model model) {

        Sort sort = Sort.by(Sort.Order.desc("id"));
        Pageable pageable =PageRequest.of(pageIndex,pageSize, sort);

        Page<User> page = userService.listUsers();
        List<User> list = page.getContent();    // 当前所在页面数据列表

        model.addAttribute("page", page);
        model.addAttribute("userList", list);
        return new ModelAndView("user/list", "userModel", model);
    }
    
    @PostMapping
    public ResponseEntity<Response> saveOrUpdateUser(User user, Long authorityId) {
    	//保存用户的权限列表
        List<Authority> authorities = new ArrayList<>();
        authorities.add(authorityService.getAuthorityById(authorityId));
        user.setAuthorities(authorities);

		//保存用户信息
        try {
            userService.saveUser(user);
        } catch (ConstraintViolationException e) {
            return ResponseEntity.ok().body(new Response(false, ConstraintViolationExceptionHandler.getMessage(e)));
        }

        return ResponseEntity.ok().body(new Response(true, "保存成功", user));
    }

	@DeleteMapping(value = "{id}")
    public ResponseEntity<Response> delete(@PathVariable("id") Long id, Model model) {
        System.out.println("delete reach");
        try {
            userService.removeUser(id);
        } catch (Exception e) {
            return ResponseEntity.ok().body(new Response(false, e.getMessage()));
        }
        return ResponseEntity.ok().body(new Response(true, "处理成功"));
    }
}

SecurityConfigure

在SecurityConfigure类中对Spring Security的访问权限进行配置

在configure()方法中对访问路径的权限进行配置，antMatchers()对访问路径进行匹配，permitAll()代表放行所有对该路径的请求，hasRole("ADMIN")代表只有ADMIN的角色才能访问。formLogin()代表使用表单进行验证，使用loginPage()、failureUrl()定义登录、错误页面

在configureGlobal()方法中对用户认证信息进行管理。在其中通过userDetailsService()获取用户信息，通过authenticationProvider()获取认证信息，除了使用之前定义的userDetailsService获取用户信息外，还用到passwordEncoder来对密码进行加密

@EnableWebSecurity
@EnableGlobalMethodSecurity(prePostEnabled = true) // 启用方法级别的安全校验
public class SecurityConfig extends WebSecurityConfigurerAdapter {
    private static final String KEY = "RM_KEY";

    @Qualifier("userServiceImpl")
    @Autowired
    private UserDetailsService userDetailsService;

    @Autowired
    private PasswordEncoder passwordEncoder;

    @Bean
    public PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();   // 使用BCrypt加密
    }

    @Bean
    public AuthenticationProvider authenticationProvider() {
        DaoAuthenticationProvider authenticationProvider = new DaoAuthenticationProvider();
        authenticationProvider.setUserDetailsService(userDetailsService);
        authenticationProvider.setPasswordEncoder(passwordEncoder); // 设置密码加密方式
        return authenticationProvider;
    }

    /**
     * 自定义配置
     */
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.authorizeRequests().antMatchers("/css/**", "/js/**", "/fonts/**", "/index").permitAll() // 都可以访问
                .antMatchers("/h2-console/**").permitAll() // 都可以访问
                .antMatchers("/admins/**").hasRole("ADMIN") // 需要相应的角色才能访问
                .and()
                .formLogin()   //基于 Form 表单登录验证
                .loginPage("/login").failureUrl("/login-error") // 自定义登录界面、登录失败页面
                .and().rememberMe().key(KEY) // 启用 remember me
                .and().exceptionHandling().accessDeniedPage("/403");  // 处理异常，拒绝访问就重定向到 403 页面
        http.csrf().ignoringAntMatchers("/h2-console/**"); // 禁用 H2 控制台的 CSRF 防护
        http.headers().frameOptions().sameOrigin(); // 允许来自同一来源的H2 控制台的请求
    }

    /**
     * 认证信息管理
     */
    @Autowired
    public void configureGlobal(AuthenticationManagerBuilder auth) throws Exception {
        auth.userDetailsService(userDetailsService);	//获取用户认证信息
        auth.authenticationProvider(authenticationProvider());
    }

其中通过@EnableGlobalMethodSecurity(prePostEnabled=true) 开启了方法级别的安全校验，即可以在某个具体方法上添加注解来精确控制是否允许访问。有如下四种方法注解：

1. @PreAuthorize 在方法调用之前,基于表达式的计算结果来限制对方法的访问
2. @PostAuthorize允许方法调用,但是如果表达式计算结果为false,将抛出一个安全性异
3. @PostFilter允许方法调用,但必须按照表达式来过滤方法的结果
4. @PreFilter 允许方法调用,但必须在进入方法之前过滤输入值

@PreAuthorize("hasRole('ADMIN')")
List<Person> findAll();

Thymeleaf中使用Springsecurity

Thymeleaf中可以引入依赖从而便捷地使用Springsecurity相关特性，通过gradle引入thymeleaf-extras-springsecurity5依赖，注意spring boot2.3.4匹配的版本号为5，版本不匹配无法使用

dependencies {
	//Spring Security
	implementation('org.springframework.boot:spring-boot-starter-security')
	implementation('org.thymeleaf.extras:thymeleaf-extras-springsecurity5')
	...
}

然后在要使用的页面声明spring security标签前缀sec

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

通过isAuthenticated()可以判断用户是否已经登录，isAnonymous()判断用户未登录，从而可以实现根据用户是否登录显示不同的内容。通过sec:authentication="name"可以获取登录的用户名。

<ul class="nav navbar-nav navbar-right">
    <li sec:authorize="isAuthenticated()" class="active">
        <a href="./">
            <span sec:authentication="name"></span>
            <span class="badge">3</span>
        </a>
    </li>
    <li sec:authorize="isAuthenticated()" style="margin-top: 1.5rem;">
        <form th:action="@{/logout}" method="post">
            <input class="btn btn-outline-success " type="submit" value="退出">
        </form>
    </li>
    <li sec:authorize="isAnonymous()">
        <a href="/login" class="btn btn-outline-success my-2 my-sm-0" type="submit">登录</a>
    </li>
    <li sec:authorize="isAnonymous()">
        <a href="/register" class="btn btn-outline-success my-2 my-sm-0" type="submit">注册</a>
    </li>
</ul>

如下所示，如果用户已经登陆则显示用户名和退出按钮，若未登录则显示登录和注册
类似地，在Spring boot中可以通过SecurityContextHolder获取当前登录的用户信息

User user= (User) SecurityContextHolder.getContext().getAuthentication().getPrincipal();

值得注意的是Spring security会自动实现对/login、/logout请求的处理，例如下面的登陆页面发送Post请求到@{/login}，Spring Security会对用户名密码进行判断，如果登录成功会跳转到请求的页面，否则跳转到/login-error。此外还可以通过name="remember-me"的checkbox实现记住我的功能，关闭浏览器再次访问无需重新登录。发送Post请求到@{/logout}会注销用户并跳转到登陆页面。

<form  th:action="@{/login}" method="post">
    <h2 >请登录</h2>
    <div class="form-group col-md-5">
        <label for="username" class="col-form-label">账号</label>
        <input type="text" class="form-control" id="username" name="username" maxlength="50" placeholder="请输入账号">
    </div>
    <div class="form-group col-md-5">
        <label for="password" class="col-form-label">密码</label>
        <input type="password" class="form-control" id="password" name="password" maxlength="30" placeholder="请输入密码" >
    </div>
    <div class="form-group col-md-2">
        <input type="checkbox" name="remember-me"/> 记住我
    </div>
    <div class="form-group col-md-5">
        <button type="submit" class="btn btn-primary">登录</button>
    </div>
    <div class=" col-md-5" th:if="${loginError}">
        <p class="blog-label-error" th:text="${errorMsg}"></p>
    </div>
</form>

CSRF防护

在上面的configure()中通过http.csrf()开启了网站的CSFR防护，CSRF全称为跨站点请求伪造(Cross—Site Request Forgery)，即当用户A在通过网页安全验证后访问B网站，并将校验信息保存到本地cookie，之后黑客通过诱导A访问C页面后再去访问B网站，这样C就可以使用A本地的校验信息通过B的安全验证，从而以A的身份进行危险操作。

CSRF 攻击之所以能够成功，是因为黑客可以完全伪造用户的请求，该请求中所有的用户验证信息都是存在于 cookie 中，因此黑客可以在不知道这些验证信息的情况下直接利用用户自己的 cookie 来通过安全验证。要抵御 CSRF，关键在于在请求中放入黑客所不能伪造的信息，并且该信息不存在于 cookie 之中。可以在 HTTP 请求中以参数的形式加入一个随机产生的 token，并在服务器端验证这个 token，如果请求中没有 token 或者 token 内容不正确，则认为可能是 CSRF 攻击而拒绝该请求。

对于 GET 请求，token 将附在请求地址之后，这样 URL 就变成 http://url?csrftoken=tokenvalue。 而对于 POST 请求来说，要在 form 的最后加上 ，Thymeleaf模板引擎会自动在form表单后添加csrf校验字段。但是我们通过Ajax发送请求时就需要手动添加校验信息了。
如下所示，首先在页面模板中添加csfr字段，这样所有页面公用头部模板就都添加了

<head th:fragment="static">
    <!-- CSRF -->
    <meta name="_csrf" th:content="${_csrf.token}"/>
    <!-- default header name is X-CSRF-TOKEN -->
    <meta name="_csrf_header" th:content="${_csrf.headerName}"/>
    ...
</head>

接着在js中获取头部的csrf内容，并且在发送Ajax请求时将其添加到请求头即可通过CSRF验证

    // 删除用户
    $("#mainContainer").on("click", ".blog-delete-user", function () {
        // 获取 CSRF Token
        const csrfToken = $("meta[name='_csrf']").attr("content");
        const csrfHeader = $("meta[name='_csrf_header']").attr("content");

        const deleteUrl = projectName + "/users/" + $(this).attr("userId")

        $.ajax({
            url: deleteUrl,
            type: 'DELETE',
            beforeSend: function (request) {
                request.setRequestHeader(csrfHeader, csrfToken); // 在请求头添加CSRF Token
            },
            success: function (data) {
                if (data.success) {
                    getUersByName(0, _pageSize);    //删除成功刷新主界面
                } else {
                    console.log("del fail");
                }
            }
        });
    });
});