一文講透 SpringSecurity ，精彩！
內容介紹
簡介
Spring Security 是 Spring 家族中的一個安全管理框架。相比與另外一個安全框架 Shiro，它提供了更豐富的功能，社區資源也比 Shiro 豐富。
一般來說中大型的項目都是使用 SpringSecurity 來做安全框架。小項目有 Shiro 的比較多，因爲相比與 SpringSecurity，Shiro 的上手更加的簡單。
一般 Web 應用的需要進行認證和授權。
-
認證：驗證當前訪問系統的是不是本系統的用戶，並且要確認具體是哪個用戶
-
授權：經過認證後判斷當前用戶是否有權限進行某個操作
而認證和授權也是 SpringSecurity 作爲安全框架的核心功能。
- 快速入門
1.1 準備工作
我們先要搭建一個簡單的 SpringBoot 工程
① 設置父工程 添加依賴
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.5.0</version>
</parent>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<optional>true</optional>
</dependency>
</dependencies>② 創建啓動類
@SpringBootApplication
public class SecurityApplication {
public static void main(String[] args) {
SpringApplication.run(SecurityApplication.class,args);
}
}③ 創建 Controller
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
public class HelloController {
@RequestMapping("/hello")
public String hello(){
return "hello";
}
}1.2 引入 SpringSecurity
在 SpringBoot 項目中使用 SpringSecurity 我們只需要引入依賴即可實現入門案例。
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-security</artifactId>
</dependency>引入依賴後我們在嘗試去訪問之前的接口就會自動跳轉到一個 SpringSecurity 的默認登陸頁面，默認用戶名是 user, 密碼會輸出在控制檯。
須登陸之後才能對接口進行訪問。
- 認證
2.1 登陸校驗流程
2.2 原理初探
想要知道如何實現自己的登陸流程就必須要先知道入門案例中 SpringSecurity 的流程。
2.2.1 SpringSecurity 完整流程
SpringSecurity 的原理其實就是一個過濾器鏈，內部包含了提供各種功能的過濾器。這裏我們可以看看入門案例中的過濾器。
圖中只展示了核心過濾器，其它的非核心過濾器並沒有在圖中展示。
UsernamePasswordAuthenticationFilter: 負責處理我們在登陸頁面填寫了用戶名密碼後的登陸請求。入門案例的認證工作主要有它負責。
ExceptionTranslationFilter： 處理過濾器鏈中拋出的任何 AccessDeniedException 和 AuthenticationException 。
FilterSecurityInterceptor： 負責權限校驗的過濾器。
我們可以通過 Debug 查看當前系統中 SpringSecurity 過濾器鏈中有哪些過濾器及它們的順序。
@SpringBootApplication
public class SecurityApplication {
public static void main(String[] args) {
ConfigurableApplicationContext run = SpringApplication.run(SecurityApplication.class,args);
System.out.println("----");
}
}2.2.2 認證流程詳解
概念速查:
-
Authentication 接口: 它的實現類，表示當前訪問系統的用戶，封裝了用戶相關信息。
-
AuthenticationManager 接口：定義了認證 Authentication 的方法
-
UserDetailsService 接口：加載用戶特定數據的核心接口。裏面定義了一個根據用戶名查詢用戶信息的方法。
-
UserDetails 接口：提供核心用戶信息。通過 UserDetailsService 根據用戶名獲取處理的用戶信息要封裝成 UserDetails 對象返回。然後將這些信息封裝到 Authentication 對象中。
2.3.1 思路分析
- 登錄
①自定義登錄接口
調用ProviderManager的方法進行認證 如果認證通過生成jwt
把用戶信息存入redis中
②自定義UserDetailsService
在這個實現類中去查詢數據庫- 校驗：
①定義 Jwt 認證過濾器
獲取token解析 token 獲取其中的 userid
從 redis 中獲取用戶信息
存入SecurityContextHolder2.3.2 準備工作
①添加依賴
<!--redis依賴-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
<!--fastjson依賴-->
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>fastjson</artifactId>
<version>1.2.33</version>
</dependency>
<!--jwt依賴-->
<dependency>
<groupId>io.jsonwebtoken</groupId>
<artifactId>jjwt</artifactId>
<version>0.9.0</version>
</dependency>② 添加 Redis 相關配置
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.serializer.SerializerFeature;
import com.fasterxml.jackson.databind.JavaType;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.type.TypeFactory;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.data.redis.serializer.SerializationException;
import com.alibaba.fastjson.parser.ParserConfig;
import org.springframework.util.Assert;
import java.nio.charset.Charset;
/**
* Redis使用FastJson序列化
*/
public class FastJsonRedisSerializer<T> implements RedisSerializer<T>
{
public static final Charset DEFAULT_CHARSET = Charset.forName("UTF-8");
private Class<T> clazz;
static
{
ParserConfig.getGlobalInstance().setAutoTypeSupport(true);
}
public FastJsonRedisSerializer(Class<T> clazz)
{
super();
this.clazz = clazz;
}
@Override
public byte[] serialize(T t) throws SerializationException
{
if (t == null)
{
return new byte[0];
}
return JSON.toJSONString(t, SerializerFeature.WriteClassName).getBytes(DEFAULT_CHARSET);
}
@Override
public T deserialize(byte[] bytes) throws SerializationException
{
if (bytes == null || bytes.length <= 0)
{
return null;
}
String str = new String(bytes, DEFAULT_CHARSET);
return JSON.parseObject(str, clazz);
}
protected JavaType getJavaType(Class<?> clazz)
{
return TypeFactory.defaultInstance().constructType(clazz);
}
}import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.StringRedisSerializer;
@Configuration
public class RedisConfig {
@Bean
@SuppressWarnings(value = { "unchecked", "rawtypes" })
public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory connectionFactory)
{
RedisTemplate<Object, Object> template = new RedisTemplate<>();
template.setConnectionFactory(connectionFactory);
FastJsonRedisSerializer serializer = new FastJsonRedisSerializer(Object.class);
// 使用StringRedisSerializer來序列化和反序列化redis的key值
template.setKeySerializer(new StringRedisSerializer());
template.setValueSerializer(serializer);
// Hash的key也採用StringRedisSerializer的序列化方式
template.setHashKeySerializer(new StringRedisSerializer());
template.setHashValueSerializer(serializer);
template.afterPropertiesSet();
return template;
}
}③ 響應類
import com.fasterxml.jackson.annotation.JsonInclude;
@JsonInclude(JsonInclude.Include.NON_NULL)
public class ResponseResult<T> {
/**
* 狀態碼
*/
private Integer code;
/**
* 提示信息，如果有錯誤時，前端可以獲取該字段進行提示
*/
private String msg;
/**
* 查詢到的結果數據，
*/
private T data;
public ResponseResult(Integer code, String msg) {
this.code = code;
this.msg = msg;
}
public ResponseResult(Integer code, T data) {
this.code = code;
this.data = data;
}
public Integer getCode() {
return code;
}
public void setCode(Integer code) {
this.code = code;
}
public String getMsg() {
return msg;
}
public void setMsg(String msg) {
this.msg = msg;
}
public T getData() {
return data;
}
public void setData(T data) {
this.data = data;
}
public ResponseResult(Integer code, String msg, T data) {
this.code = code;
this.msg = msg;
this.data = data;
}
}④工具類
import io.jsonwebtoken.Claims;
import io.jsonwebtoken.JwtBuilder;
import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.SignatureAlgorithm;
import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;
import java.util.Base64;
import java.util.Date;
import java.util.UUID;
/**
* JWT工具類
*/
public class JwtUtil {
//有效期爲
public static final Long JWT_TTL = 60 * 60 *1000L;// 60 * 60 *1000 一個小時
//設置祕鑰明文
public static final String JWT_KEY = "sangeng";
public static String getUUID(){
String token = UUID.randomUUID().toString().replaceAll("-", "");
return token;
}
/**
* 生成jtw
* @param subject token中要存放的數據（json格式）
* @return
*/
public static String createJWT(String subject) {
JwtBuilder builder = getJwtBuilder(subject, null, getUUID());// 設置過期時間
return builder.compact();
}
/**
* 生成jtw
* @param subject token中要存放的數據（json格式）
* @param ttlMillis token超時時間
* @return
*/
public static String createJWT(String subject, Long ttlMillis) {
JwtBuilder builder = getJwtBuilder(subject, ttlMillis, getUUID());// 設置過期時間
return builder.compact();
}
private static JwtBuilder getJwtBuilder(String subject, Long ttlMillis, String uuid) {
SignatureAlgorithm signatureAlgorithm = SignatureAlgorithm.HS256;
SecretKey secretKey = generalKey();
long nowMillis = System.currentTimeMillis();
Date now = new Date(nowMillis);
if(ttlMillis==null){
ttlMillis=JwtUtil.JWT_TTL;
}
long expMillis = nowMillis + ttlMillis;
Date expDate = new Date(expMillis);
return Jwts.builder()
.setId(uuid) //唯一的ID
.setSubject(subject) // 主題 可以是JSON數據
.setIssuer("sg") // 簽發者
.setIssuedAt(now) // 簽發時間
.signWith(signatureAlgorithm, secretKey) //使用HS256對稱加密算法簽名, 第二個參數爲祕鑰
.setExpiration(expDate);
}
/**
* 創建token
* @param id
* @param subject
* @param ttlMillis
* @return
*/
public static String createJWT(String id, String subject, Long ttlMillis) {
JwtBuilder builder = getJwtBuilder(subject, ttlMillis, id);// 設置過期時間
return builder.compact();
}
public static void main(String[] args) throws Exception {
String token = "eyJhbGciOiJIUzI1NiJ9.eyJqdGkiOiJjYWM2ZDVhZi1mNjVlLTQ0MDAtYjcxMi0zYWEwOGIyOTIwYjQiLCJzdWIiOiJzZyIsImlzcyI6InNnIiwiaWF0IjoxNjM4MTA2NzEyLCJleHAiOjE2MzgxMTAzMTJ9.JVsSbkP94wuczb4QryQbAke3ysBDIL5ou8fWsbt_ebg";
Claims claims = parseJWT(token);
System.out.println(claims);
}
/**
* 生成加密後的祕鑰 secretKey
* @return
*/
public static SecretKey generalKey() {
byte[] encodedKey = Base64.getDecoder().decode(JwtUtil.JWT_KEY);
SecretKey key = new SecretKeySpec(encodedKey, 0, encodedKey.length, "AES");
return key;
}
/**
* 解析
*
* @param jwt
* @return
* @throws Exception
*/
public static Claims parseJWT(String jwt) throws Exception {
SecretKey secretKey = generalKey();
return Jwts.parser()
.setSigningKey(secretKey)
.parseClaimsJws(jwt)
.getBody();
}
}import java.util.*;
import java.util.concurrent.TimeUnit;
@SuppressWarnings(value = { "unchecked", "rawtypes" })
@Component
public class RedisCache
{
@Autowired
public RedisTemplate redisTemplate;
/**
* 緩存基本的對象，Integer、String、實體類等
*
* @param key 緩存的鍵值
* @param value 緩存的值
*/
public <T> void setCacheObject(final String key, final T value)
{
redisTemplate.opsForValue().set(key, value);
}
/**
* 緩存基本的對象，Integer、String、實體類等
*
* @param key 緩存的鍵值
* @param value 緩存的值
* @param timeout 時間
* @param timeUnit 時間顆粒度
*/
public <T> void setCacheObject(final String key, final T value, final Integer timeout, final TimeUnit timeUnit)
{
redisTemplate.opsForValue().set(key, value, timeout, timeUnit);
}
/**
* 設置有效時間
*
* @param key Redis鍵
* @param timeout 超時時間
* @return true=設置成功；false=設置失敗
*/
public boolean expire(final String key, final long timeout)
{
return expire(key, timeout, TimeUnit.SECONDS);
}
/**
* 設置有效時間
*
* @param key Redis鍵
* @param timeout 超時時間
* @param unit 時間單位
* @return true=設置成功；false=設置失敗
*/
public boolean expire(final String key, final long timeout, final TimeUnit unit)
{
return redisTemplate.expire(key, timeout, unit);
}
/**
* 獲得緩存的基本對象。
*
* @param key 緩存鍵值
* @return 緩存鍵值對應的數據
*/
public <T> T getCacheObject(final String key)
{
ValueOperations<String, T> operation = redisTemplate.opsForValue();
return operation.get(key);
}
/**
* 刪除單個對象
*
* @param key
*/
public boolean deleteObject(final String key)
{
return redisTemplate.delete(key);
}
/**
* 刪除集合對象
*
* @param collection 多個對象
* @return
*/
public long deleteObject(final Collection collection)
{
return redisTemplate.delete(collection);
}
/**
* 緩存List數據
*
* @param key 緩存的鍵值
* @param dataList 待緩存的List數據
* @return 緩存的對象
*/
public <T> long setCacheList(final String key, final List<T> dataList)
{
Long count = redisTemplate.opsForList().rightPushAll(key, dataList);
return count == null ? 0 : count;
}
/**
* 獲得緩存的list對象
*
* @param key 緩存的鍵值
* @return 緩存鍵值對應的數據
*/
public <T> List<T> getCacheList(final String key)
{
return redisTemplate.opsForList().range(key, 0, -1);
}
/**
* 緩存Set
*
* @param key 緩存鍵值
* @param dataSet 緩存的數據
* @return 緩存數據的對象
*/
public <T> BoundSetOperations<String, T> setCacheSet(final String key, final Set<T> dataSet)
{
BoundSetOperations<String, T> setOperation = redisTemplate.boundSetOps(key);
Iterator<T> it = dataSet.iterator();
while (it.hasNext())
{
setOperation.add(it.next());
}
return setOperation;
}
/**
* 獲得緩存的set
*
* @param key
* @return
*/
public <T> Set<T> getCacheSet(final String key)
{
return redisTemplate.opsForSet().members(key);
}
/**
* 緩存Map
*
* @param key
* @param dataMap
*/
public <T> void setCacheMap(final String key, final Map<String, T> dataMap)
{
if (dataMap != null) {
redisTemplate.opsForHash().putAll(key, dataMap);
}
}
/**
* 獲得緩存的Map
*
* @param key
* @return
*/
public <T> Map<String, T> getCacheMap(final String key)
{
return redisTemplate.opsForHash().entries(key);
}
/**
* 往Hash中存入數據
*
* @param key Redis鍵
* @param hKey Hash鍵
* @param value 值
*/
public <T> void setCacheMapValue(final String key, final String hKey, final T value)
{
redisTemplate.opsForHash().put(key, hKey, value);
}
/**
* 獲取Hash中的數據
*
* @param key Redis鍵
* @param hKey Hash鍵
* @return Hash中的對象
*/
public <T> T getCacheMapValue(final String key, final String hKey)
{
HashOperations<String, String, T> opsForHash = redisTemplate.opsForHash();
return opsForHash.get(key, hKey);
}
/**
* 刪除Hash中的數據
*
* @param key
* @param hkey
*/
public void delCacheMapValue(final String key, final String hkey)
{
HashOperations hashOperations = redisTemplate.opsForHash();
hashOperations.delete(key, hkey);
}
/**
* 獲取多個Hash中的數據
*
* @param key Redis鍵
* @param hKeys Hash鍵集合
* @return Hash對象集合
*/
public <T> List<T> getMultiCacheMapValue(final String key, final Collection<Object> hKeys)
{
return redisTemplate.opsForHash().multiGet(key, hKeys);
}
/**
* 獲得緩存的基本對象列表
*
* @param pattern 字符串前綴
* @return 對象列表
*/
public Collection<String> keys(final String pattern)
{
return redisTemplate.keys(pattern);
}
}import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
public class WebUtils
{
/**
* 將字符串渲染到客戶端
*
* @param response 渲染對象
* @param string 待渲染的字符串
* @return null
*/
public static String renderString(HttpServletResponse response, String string) {
try
{
response.setStatus(200);
response.setContentType("application/json");
response.setCharacterEncoding("utf-8");
response.getWriter().print(string);
}
catch (IOException e)
{
e.printStackTrace();
}
return null;
}
}⑤實體類
import java.io.Serializable;
import java.util.Date;
@Data
@AllArgsConstructor
@NoArgsConstructor
public class User implements Serializable {
private static final long serialVersionUID = -40356785423868312L;
/**
* 主鍵
*/
private Long id;
/**
* 用戶名
*/
private String userName;
/**
* 暱稱
*/
private String nickName;
/**
* 密碼
*/
private String password;
/**
* 賬號狀態（0正常 1停用）
*/
private String status;
/**
* 郵箱
*/
private String email;
/**
* 手機號
*/
private String phonenumber;
/**
* 用戶性別（0男，1女，2未知）
*/
private String sex;
/**
* 頭像
*/
private String avatar;
/**
* 用戶類型（0管理員，1普通用戶）
*/
private String userType;
/**
* 創建人的用戶id
*/
private Long createBy;
/**
* 創建時間
*/
private Date createTime;
/**
* 更新人
*/
private Long updateBy;
/**
* 更新時間
*/
private Date updateTime;
/**
* 刪除標誌（0代表未刪除，1代表已刪除）
*/
private Integer delFlag;
}2.3.3 實現
2.3.3.1 數據庫校驗用戶
從之前的分析我們可以知道，我們可以自定義一個 UserDetailsService, 讓 SpringSecurity 使用我們的 UserDetailsService。我們自己的 UserDetailsService 可以從數據庫中查詢用戶名和密碼。
準備工作
我們先創建一個用戶表， 建表語句如下：
CREATE TABLE `sys_user` (
`id` BIGINT(20) NOT NULL AUTO_INCREMENT COMMENT '主鍵',
`user_name` VARCHAR(64) NOT NULL DEFAULT 'NULL' COMMENT '用戶名',
`nick_name` VARCHAR(64) NOT NULL DEFAULT 'NULL' COMMENT '暱稱',
`password` VARCHAR(64) NOT NULL DEFAULT 'NULL' COMMENT '密碼',
`status` CHAR(1) DEFAULT '0' COMMENT '賬號狀態（0正常 1停用）',
`email` VARCHAR(64) DEFAULT NULL COMMENT '郵箱',
`phonenumber` VARCHAR(32) DEFAULT NULL COMMENT '手機號',
`sex` CHAR(1) DEFAULT NULL COMMENT '用戶性別（0男，1女，2未知）',
`avatar` VARCHAR(128) DEFAULT NULL COMMENT '頭像',
`user_type` CHAR(1) NOT NULL DEFAULT '1' COMMENT '用戶類型（0管理員，1普通用戶）',
`create_by` BIGINT(20) DEFAULT NULL COMMENT '創建人的用戶id',
`create_time` DATETIME DEFAULT NULL COMMENT '創建時間',
`update_by` BIGINT(20) DEFAULT NULL COMMENT '更新人',
`update_time` DATETIME DEFAULT NULL COMMENT '更新時間',
`del_flag` INT(11) DEFAULT '0' COMMENT '刪除標誌（0代表未刪除，1代表已刪除）',
PRIMARY KEY (`id`)
) ENGINE=INNODB AUTO_INCREMENT=2 DEFAULT CHARSET=utf8mb4 COMMENT='用戶表'引入 MybatisPuls 和 mysql 驅動的依賴
<dependency>
<groupId>com.baomidou</groupId>
<artifactId>mybatis-plus-boot-starter</artifactId>
<version>3.4.3</version>
</dependency>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
</dependency>配置數據庫信息
spring:
datasource:
url: jdbc:mysql://localhost:3306/sg_security?characterEncoding=utf-8&serverTimezone=UTC
username: root
password: root
driver-class-name: com.mysql.cj.jdbc.Driver定義 Mapper 接口
public interface UserMapper extends BaseMapper<User> {
}修改 User 實體類
類名上加@TableName(value = "sys_user") ,id字段上加 @TableId配置 Mapper 掃描
@SpringBootApplication
@MapperScan("com.sangeng.mapper")
public class SimpleSecurityApplication {
public static void main(String[] args) {
ConfigurableApplicationContext run = SpringApplication.run(SimpleSecurityApplication.class);
System.out.println(run);
}
}添加 junit 依賴
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
</dependency>測試 MP 是否能正常使用
@SpringBootTest
public class MapperTest {
@Autowired
private UserMapper userMapper;
@Test
public void testUserMapper(){
List<User> users = userMapper.selectList(null);
System.out.println(users);
}
}核心代碼實現
創建一個類實現 UserDetailsService 接口，重寫其中的方法。更加用戶名從數據庫中查詢用戶信息
@Service
public class UserDetailsServiceImpl implements UserDetailsService {
@Autowired
private UserMapper userMapper;
@Override
public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
//根據用戶名查詢用戶信息
LambdaQueryWrapper<User> wrapper = new LambdaQueryWrapper<>();
wrapper.eq(User::getUserName,username);
User user = userMapper.selectOne(wrapper);
//如果查詢不到數據就通過拋出異常來給出提示
if(Objects.isNull(user)){
throw new RuntimeException("用戶名或密碼錯誤");
}
//TODO 根據用戶查詢權限信息 添加到LoginUser中
//封裝成UserDetails對象返回
return new LoginUser(user);
}
}因爲 UserDetailsService 方法的返回值是 UserDetails 類型，所以需要定義一個類，實現該接口，把用戶信息封裝在其中。
@Data
@NoArgsConstructor
@AllArgsConstructor
public class LoginUser implements UserDetails {
private User user;
@Override
public Collection<? extends GrantedAuthority> getAuthorities() {
return null;
}
@Override
public String getPassword() {
return user.getPassword();
}
@Override
public String getUsername() {
return user.getUserName();
}
@Override
public boolean isAccountNonExpired() {
return true;
}
@Override
public boolean isAccountNonLocked() {
return true;
}
@Override
public boolean isCredentialsNonExpired() {
return true;
}
@Override
public boolean isEnabled() {
return true;
}
}注意：如果要測試，需要往用戶表中寫入用戶數據，並且如果你想讓用戶的密碼是明文存儲，需要在密碼前加 {noop}。例如
這樣登陸的時候就可以用 sg 作爲用戶名，1234 作爲密碼來登陸了。
2.3.3.2 密碼加密存儲
實際項目中我們不會把密碼明文存儲在數據庫中。
默認使用的 PasswordEncoder 要求數據庫中的密碼格式爲：{id}password 。它會根據 id 去判斷密碼的加密方式。但是我們一般不會採用這種方式。所以就需要替換 PasswordEncoder。
我們一般使用 SpringSecurity 爲我們提供的 BCryptPasswordEncoder。
我們只需要使用把 BCryptPasswordEncoder 對象注入 Spring 容器中，SpringSecurity 就會使用該 PasswordEncoder 來進行密碼校驗。
我們可以定義一個 SpringSecurity 的配置類，SpringSecurity 要求這個配置類要繼承 WebSecurityConfigurerAdapter。
@Configuration
public class SecurityConfig extends WebSecurityConfigurerAdapter {
@Bean
public PasswordEncoder passwordEncoder(){
return new BCryptPasswordEncoder();
}
}2.3.3.3 登陸接口
接下我們需要自定義登陸接口，然後讓 SpringSecurity 對這個接口放行, 讓用戶訪問這個接口的時候不用登錄也能訪問。
在接口中我們通過 AuthenticationManager 的 authenticate 方法來進行用戶認證, 所以需要在 SecurityConfig 中配置把 AuthenticationManager 注入容器。
認證成功的話要生成一個 jwt，放入響應中返回。並且爲了讓用戶下回請求時能通過 jwt 識別出具體的是哪個用戶，我們需要把用戶信息存入 redis，可以把用戶 id 作爲 key。
@RestController
public class LoginController {
@Autowired
private LoginServcie loginServcie;
@PostMapping("/user/login")
public ResponseResult login(@RequestBody User user){
return loginServcie.login(user);
}
}@Configuration
public class SecurityConfig extends WebSecurityConfigurerAdapter {
@Bean
public PasswordEncoder passwordEncoder(){
return new BCryptPasswordEncoder();
}
@Override
protected void configure(HttpSecurity http) throws Exception {
http
//關閉csrf
.csrf().disable()
//不通過Session獲取SecurityContext
.sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS)
.and()
.authorizeRequests()
// 對於登錄接口 允許匿名訪問
.antMatchers("/user/login").anonymous()
// 除上面外的所有請求全部需要鑑權認證
.anyRequest().authenticated();
}
@Bean
@Override
public AuthenticationManager authenticationManagerBean() throws Exception {
return super.authenticationManagerBean();
}
}@Service
public class LoginServiceImpl implements LoginServcie {
@Autowired
private AuthenticationManager authenticationManager;
@Autowired
private RedisCache redisCache;
@Override
public ResponseResult login(User user) {
UsernamePasswordAuthenticationToken authenticationToken = new UsernamePasswordAuthenticationToken(user.getUserName(),user.getPassword());
Authentication authenticate = authenticationManager.authenticate(authenticationToken);
if(Objects.isNull(authenticate)){
throw new RuntimeException("用戶名或密碼錯誤");
}
//使用userid生成token
LoginUser loginUser = (LoginUser) authenticate.getPrincipal();
String userId = loginUser.getUser().getId().toString();
String jwt = JwtUtil.createJWT(userId);
//authenticate存入redis
redisCache.setCacheObject("login:"+userId,loginUser);
//把token響應給前端
HashMap<String,String> map = new HashMap<>();
map.put("token",jwt);
return new ResponseResult(200,"登陸成功",map);
}
}2.3.3.4 認證過濾器
我們需要自定義一個過濾器，這個過濾器會去獲取請求頭中的 token，對 token 進行解析取出其中的 userid。
使用 userid 去 redis 中獲取對應的 LoginUser 對象。
然後封裝 Authentication 對象存入 SecurityContextHolder
@Component
public class JwtAuthenticationTokenFilter extends OncePerRequestFilter {
@Autowired
private RedisCache redisCache;
@Override
protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException {
//獲取token
String token = request.getHeader("token");
if (!StringUtils.hasText(token)) {
//放行
filterChain.doFilter(request, response);
return;
}
//解析token
String userid;
try {
Claims claims = JwtUtil.parseJWT(token);
userid = claims.getSubject();
} catch (Exception e) {
e.printStackTrace();
throw new RuntimeException("token非法");
}
//從redis中獲取用戶信息
String redisKey = "login:" + userid;
LoginUser loginUser = redisCache.getCacheObject(redisKey);
if(Objects.isNull(loginUser)){
throw new RuntimeException("用戶未登錄");
}
//存入SecurityContextHolder
//TODO 獲取權限信息封裝到Authentication中
UsernamePasswordAuthenticationToken authenticationToken =
new UsernamePasswordAuthenticationToken(loginUser,null,null);
SecurityContextHolder.getContext().setAuthentication(authenticationToken);
//放行
filterChain.doFilter(request, response);
}
}@Configuration
public class SecurityConfig extends WebSecurityConfigurerAdapter {
@Bean
public PasswordEncoder passwordEncoder(){
return new BCryptPasswordEncoder();
}
@Autowired
JwtAuthenticationTokenFilter jwtAuthenticationTokenFilter;
@Override
protected void configure(HttpSecurity http) throws Exception {
http
//關閉csrf
.csrf().disable()
//不通過Session獲取SecurityContext
.sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS)
.and()
.authorizeRequests()
// 對於登錄接口 允許匿名訪問
.antMatchers("/user/login").anonymous()
// 除上面外的所有請求全部需要鑑權認證
.anyRequest().authenticated();
//把token校驗過濾器添加到過濾器鏈中
http.addFilterBefore(jwtAuthenticationTokenFilter, UsernamePasswordAuthenticationFilter.class);
}
@Bean
@Override
public AuthenticationManager authenticationManagerBean() throws Exception {
return super.authenticationManagerBean();
}
}2.3.3.5 退出登陸
我們只需要定義一個登陸接口，然後獲取 SecurityContextHolder 中的認證信息，刪除 redis 中對應的數據即可。
@Service
public class LoginServiceImpl implements LoginServcie {
@Autowired
private AuthenticationManager authenticationManager;
@Autowired
private RedisCache redisCache;
@Override
public ResponseResult login(User user) {
UsernamePasswordAuthenticationToken authenticationToken = new UsernamePasswordAuthenticationToken(user.getUserName(),user.getPassword());
Authentication authenticate = authenticationManager.authenticate(authenticationToken);
if(Objects.isNull(authenticate)){
throw new RuntimeException("用戶名或密碼錯誤");
}
//使用userid生成token
LoginUser loginUser = (LoginUser) authenticate.getPrincipal();
String userId = loginUser.getUser().getId().toString();
String jwt = JwtUtil.createJWT(userId);
//authenticate存入redis
redisCache.setCacheObject("login:"+userId,loginUser);
//把token響應給前端
HashMap<String,String> map = new HashMap<>();
map.put("token",jwt);
return new ResponseResult(200,"登陸成功",map);
}
@Override
public ResponseResult logout() {
Authentication authentication = SecurityContextHolder.getContext().getAuthentication();
LoginUser loginUser = (LoginUser) authentication.getPrincipal();
Long userid = loginUser.getUser().getId();
redisCache.deleteObject("login:"+userid);
return new ResponseResult(200,"退出成功");
}
}- 授權
3.0 權限系統的作用
例如一個學校圖書館的管理系統，如果是普通學生登錄就能看到借書還書相關的功能，不可能讓他看到並且去使用添加書籍信息，刪除書籍信息等功能。但是如果是一個圖書館管理員的賬號登錄了，應該就能看到並使用添加書籍信息，刪除書籍信息等功能。
總結起來就是不同的用戶可以使用不同的功能。這就是權限系統要去實現的效果。
我們不能只依賴前端去判斷用戶的權限來選擇顯示哪些菜單哪些按鈕。因爲如果只是這樣，如果有人知道了對應功能的接口地址就可以不通過前端，直接去發送請求來實現相關功能操作。
所以我們還需要在後臺進行用戶權限的判斷，判斷當前用戶是否有相應的權限，必須具有所需權限才能進行相應的操作。
3.1 授權基本流程
在 SpringSecurity 中，會使用默認的 FilterSecurityInterceptor 來進行權限校驗。在 FilterSecurityInterceptor 中會從 SecurityContextHolder 獲取其中的 Authentication，然後獲取其中的權限信息。當前用戶是否擁有訪問當前資源所需的權限。
所以我們在項目中只需要把當前登錄用戶的權限信息也存入 Authentication。
然後設置我們的資源所需要的權限即可。
3.2 授權實現
3.2.1 限制訪問資源所需權限
SpringSecurity 爲我們提供了基於註解的權限控制方案，這也是我們項目中主要採用的方式。我們可以使用註解去指定訪問對應的資源所需的權限。
但是要使用它我們需要先開啓相關配置。
@EnableGlobalMethodSecurity(prePostEnabled = true)然後就可以使用對應的註解。@PreAuthorize
@RestController
public class HelloController {
@RequestMapping("/hello")
@PreAuthorize("hasAuthority('test')")
public String hello(){
return "hello";
}
}3.2.2 封裝權限信息
我們前面在寫 UserDetailsServiceImpl 的時候說過，在查詢出用戶後還要獲取對應的權限信息，封裝到 UserDetails 中返回。
我們先直接把權限信息寫死封裝到 UserDetails 中進行測試。
我們之前定義了 UserDetails 的實現類 LoginUser，想要讓其能封裝權限信息就要對其進行修改。
package com.sangeng.domain;
import com.alibaba.fastjson.annotation.JSONField;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.authority.SimpleGrantedAuthority;
import org.springframework.security.core.userdetails.UserDetails;
import java.util.Collection;
import java.util.List;
import java.util.stream.Collectors;
@Data
@NoArgsConstructor
public class LoginUser implements UserDetails {
private User user;
//存儲權限信息
private List<String> permissions;
public LoginUser(User user,List<String> permissions) {
this.user = user;
this.permissions = permissions;
}
//存儲SpringSecurity所需要的權限信息的集合
@JSONField(serialize = false)
private List<GrantedAuthority> authorities;
@Override
public Collection<? extends GrantedAuthority> getAuthorities() {
if(authorities!=null){
return authorities;
}
//把permissions中字符串類型的權限信息轉換成GrantedAuthority對象存入authorities中
authorities = permissions.stream().
map(SimpleGrantedAuthority::new)
.collect(Collectors.toList());
return authorities;
}
@Override
public String getPassword() {
return user.getPassword();
}
@Override
public String getUsername() {
return user.getUserName();
}
@Override
public boolean isAccountNonExpired() {
return true;
}
@Override
public boolean isAccountNonLocked() {
return true;
}
@Override
public boolean isCredentialsNonExpired() {
return true;
}
@Override
public boolean isEnabled() {
return true;
}
}LoginUser 修改完後我們就可以在 UserDetailsServiceImpl 中去把權限信息封裝到 LoginUser 中了。我們寫死權限進行測試，後面我們再從數據庫中查詢權限信息。
package com.sangeng.service.impl;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.conditions.query.LambdaQueryChainWrapper;
import com.sangeng.domain.LoginUser;
import com.sangeng.domain.User;
import com.sangeng.mapper.UserMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.core.userdetails.UsernameNotFoundException;
import org.springframework.stereotype.Service;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Objects;
@Service
public class UserDetailsServiceImpl implements UserDetailsService {
@Autowired
private UserMapper userMapper;
@Override
public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
LambdaQueryWrapper<User> wrapper = new LambdaQueryWrapper<>();
wrapper.eq(User::getUserName,username);
User user = userMapper.selectOne(wrapper);
if(Objects.isNull(user)){
throw new RuntimeException("用戶名或密碼錯誤");
}
//TODO 根據用戶查詢權限信息 添加到LoginUser中
List<String> list = new ArrayList<>(Arrays.asList("test"));
return new LoginUser(user,list);
}
}3.2.3 從數據庫查詢權限信息
3.2.3.1 RBAC 權限模型
RBAC 權限模型（Role-Based Access Control）即：基於角色的權限控制。這是目前最常被開發者使用也是相對易用、通用權限模型。
3.2.3.2 準備工作
CREATE DATABASE /*!32312 IF NOT EXISTS*/`sg_security` /*!40100 DEFAULT CHARACTER SET utf8mb4 */;
USE `sg_security`;
/*Table structure for table `sys_menu` */
DROP TABLE IF EXISTS `sys_menu`;
CREATE TABLE `sys_menu` (
`id` bigint(20) NOT NULL AUTO_INCREMENT,
`menu_name` varchar(64) NOT NULL DEFAULT 'NULL' COMMENT '菜單名',
`path` varchar(200) DEFAULT NULL COMMENT '路由地址',
`component` varchar(255) DEFAULT NULL COMMENT '組件路徑',
`visible` char(1) DEFAULT '0' COMMENT '菜單狀態（0顯示 1隱藏）',
`status` char(1) DEFAULT '0' COMMENT '菜單狀態（0正常 1停用）',
`perms` varchar(100) DEFAULT NULL COMMENT '權限標識',
`icon` varchar(100) DEFAULT '#' COMMENT '菜單圖標',
`create_by` bigint(20) DEFAULT NULL,
`create_time` datetime DEFAULT NULL,
`update_by` bigint(20) DEFAULT NULL,
`update_time` datetime DEFAULT NULL,
`del_flag` int(11) DEFAULT '0' COMMENT '是否刪除（0未刪除 1已刪除）',
`remark` varchar(500) DEFAULT NULL COMMENT '備註',
PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=2 DEFAULT CHARSET=utf8mb4 COMMENT='菜單表';
/*Table structure for table `sys_role` */
DROP TABLE IF EXISTS `sys_role`;
CREATE TABLE `sys_role` (
`id` bigint(20) NOT NULL AUTO_INCREMENT,
`name` varchar(128) DEFAULT NULL,
`role_key` varchar(100) DEFAULT NULL COMMENT '角色權限字符串',
`status` char(1) DEFAULT '0' COMMENT '角色狀態（0正常 1停用）',
`del_flag` int(1) DEFAULT '0' COMMENT 'del_flag',
`create_by` bigint(200) DEFAULT NULL,
`create_time` datetime DEFAULT NULL,
`update_by` bigint(200) DEFAULT NULL,
`update_time` datetime DEFAULT NULL,
`remark` varchar(500) DEFAULT NULL COMMENT '備註',
PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=3 DEFAULT CHARSET=utf8mb4 COMMENT='角色表';
/*Table structure for table `sys_role_menu` */
DROP TABLE IF EXISTS `sys_role_menu`;
CREATE TABLE `sys_role_menu` (
`role_id` bigint(200) NOT NULL AUTO_INCREMENT COMMENT '角色ID',
`menu_id` bigint(200) NOT NULL DEFAULT '0' COMMENT '菜單id',
PRIMARY KEY (`role_id`,`menu_id`)
) ENGINE=InnoDB AUTO_INCREMENT=2 DEFAULT CHARSET=utf8mb4;
/*Table structure for table `sys_user` */
DROP TABLE IF EXISTS `sys_user`;
CREATE TABLE `sys_user` (
`id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT '主鍵',
`user_name` varchar(64) NOT NULL DEFAULT 'NULL' COMMENT '用戶名',
`nick_name` varchar(64) NOT NULL DEFAULT 'NULL' COMMENT '暱稱',
`password` varchar(64) NOT NULL DEFAULT 'NULL' COMMENT '密碼',
`status` char(1) DEFAULT '0' COMMENT '賬號狀態（0正常 1停用）',
`email` varchar(64) DEFAULT NULL COMMENT '郵箱',
`phonenumber` varchar(32) DEFAULT NULL COMMENT '手機號',
`sex` char(1) DEFAULT NULL COMMENT '用戶性別（0男，1女，2未知）',
`avatar` varchar(128) DEFAULT NULL COMMENT '頭像',
`user_type` char(1) NOT NULL DEFAULT '1' COMMENT '用戶類型（0管理員，1普通用戶）',
`create_by` bigint(20) DEFAULT NULL COMMENT '創建人的用戶id',
`create_time` datetime DEFAULT NULL COMMENT '創建時間',
`update_by` bigint(20) DEFAULT NULL COMMENT '更新人',
`update_time` datetime DEFAULT NULL COMMENT '更新時間',
`del_flag` int(11) DEFAULT '0' COMMENT '刪除標誌（0代表未刪除，1代表已刪除）',
PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=3 DEFAULT CHARSET=utf8mb4 COMMENT='用戶表';
/*Table structure for table `sys_user_role` */
DROP TABLE IF EXISTS `sys_user_role`;
CREATE TABLE `sys_user_role` (
`user_id` bigint(200) NOT NULL AUTO_INCREMENT COMMENT '用戶id',
`role_id` bigint(200) NOT NULL DEFAULT '0' COMMENT '角色id',
PRIMARY KEY (`user_id`,`role_id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;SELECT
DISTINCT m.`perms`
FROM
sys_user_role ur
LEFT JOIN `sys_role` r ON ur.`role_id` = r.`id`
LEFT JOIN `sys_role_menu` rm ON ur.`role_id` = rm.`role_id`
LEFT JOIN `sys_menu` m ON m.`id` = rm.`menu_id`
WHERE
user_id = 2
AND r.`status` = 0
AND m.`status` = 0package com.sangeng.domain;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import com.fasterxml.jackson.annotation.JsonInclude;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.io.Serializable;
import java.util.Date;
/**
* 菜單表(Menu)實體類
*/
@TableName(value="sys_menu")
@Data
@AllArgsConstructor
@NoArgsConstructor
@JsonInclude(JsonInclude.Include.NON_NULL)
public class Menu implements Serializable {
private static final long serialVersionUID = -54979041104113736L;
@TableId
private Long id;
/**
* 菜單名
*/
private String menuName;
/**
* 路由地址
*/
private String path;
/**
* 組件路徑
*/
private String component;
/**
* 菜單狀態（0顯示 1隱藏）
*/
private String visible;
/**
* 菜單狀態（0正常 1停用）
*/
private String status;
/**
* 權限標識
*/
private String perms;
/**
* 菜單圖標
*/
private String icon;
private Long createBy;
private Date createTime;
private Long updateBy;
private Date updateTime;
/**
* 是否刪除（0未刪除 1已刪除）
*/
private Integer delFlag;
/**
* 備註
*/
private String remark;
}3.2.3.3 代碼實現
我們只需要根據用戶 id 去查詢到其所對應的權限信息即可。
所以我們可以先定義個 mapper，其中提供一個方法可以根據 userid 查詢權限信息。
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.sangeng.domain.Menu;
import java.util.List;
public interface MenuMapper extends BaseMapper<Menu> {
List<String> selectPermsByUserId(Long id);
}尤其是自定義方法，所以需要創建對應的 mapper 文件，定義對應的 sql 語句
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
<mapper namespace="com.sangeng.mapper.MenuMapper">
<select id="selectPermsByUserId" resultType="java.lang.String">
SELECT
DISTINCT m.`perms`
FROM
sys_user_role ur
LEFT JOIN `sys_role` r ON ur.`role_id` = r.`id`
LEFT JOIN `sys_role_menu` rm ON ur.`role_id` = rm.`role_id`
LEFT JOIN `sys_menu` m ON m.`id` = rm.`menu_id`
WHERE
user_id = #{userid}
AND r.`status` = 0
AND m.`status` = 0
</select>
</mapper>在 application.yml 中配置 mapperXML 文件的位置
spring:
datasource:
url: jdbc:mysql://localhost:3306/sg_security?characterEncoding=utf-8&serverTimezone=UTC
username: root
password: root
driver-class-name: com.mysql.cj.jdbc.Driver
redis:
host: localhost
port: 6379
mybatis-plus:
mapper-locations: classpath*:/mapper/**/*.xml然後我們可以在 UserDetailsServiceImpl 中去調用該 mapper 的方法查詢權限信息封裝到 LoginUser 對象中即可。
@Service
public class UserDetailsServiceImpl implements UserDetailsService {
@Autowired
private UserMapper userMapper;
@Autowired
private MenuMapper menuMapper;
@Override
public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
LambdaQueryWrapper<User> wrapper = new LambdaQueryWrapper<>();
wrapper.eq(User::getUserName,username);
User user = userMapper.selectOne(wrapper);
if(Objects.isNull(user)){
throw new RuntimeException("用戶名或密碼錯誤");
}
List<String> permissionKeyList = menuMapper.selectPermsByUserId(user.getId());
// //測試寫法
// List<String> list = new ArrayList<>(Arrays.asList("test"));
return new LoginUser(user,permissionKeyList);
}
}- 自定義失敗處理
我們還希望在認證失敗或者是授權失敗的情況下也能和我們的接口一樣返回相同結構的 json，這樣可以讓前端能對響應進行統一的處理。要實現這個功能我們需要知道 SpringSecurity 的異常處理機制。
在 SpringSecurity 中，如果我們在認證或者授權的過程中出現了異常會被 ExceptionTranslationFilter 捕獲到。在 ExceptionTranslationFilter 中會去判斷是認證失敗還是授權失敗出現的異常。
如果是認證過程中出現的異常會被封裝成 AuthenticationException 然後調用 AuthenticationEntryPoint 對象的方法去進行異常處理。
如果是授權過程中出現的異常會被封裝成 AccessDeniedException 然後調用 AccessDeniedHandler 對象的方法去進行異常處理。
所以如果我們需要自定義異常處理，我們只需要自定義 AuthenticationEntryPoint 和 AccessDeniedHandler 然後配置給 SpringSecurity 即可。
①自定義實現類
@Component
public class AccessDeniedHandlerImpl implements AccessDeniedHandler {
@Override
public void handle(HttpServletRequest request, HttpServletResponse response, AccessDeniedException accessDeniedException) throws IOException, ServletException {
ResponseResult result = new ResponseResult(HttpStatus.FORBIDDEN.value(), "權限不足");
String json = JSON.toJSONString(result);
WebUtils.renderString(response,json);
}
}@Component
public class AuthenticationEntryPointImpl implements AuthenticationEntryPoint {
@Override
public void commence(HttpServletRequest request, HttpServletResponse response, AuthenticationException authException) throws IOException, ServletException {
ResponseResult result = new ResponseResult(HttpStatus.UNAUTHORIZED.value(), "認證失敗請重新登錄");
String json = JSON.toJSONString(result);
WebUtils.renderString(response,json);
}
}②配置給 SpringSecurity
先注入對應的處理器
@Autowired
private AuthenticationEntryPoint authenticationEntryPoint;
@Autowired
private AccessDeniedHandler accessDeniedHandler;然後我們可以使用 HttpSecurity 對象的方法去配置。
http.exceptionHandling()
.authenticationEntryPoint(authenticationEntryPoint)
.accessDeniedHandler(accessDeniedHandler);- 跨域
瀏覽器出於安全的考慮，使用 XMLHttpRequest 對象發起 HTTP 請求時必須遵守同源策略，否則就是跨域的 HTTP 請求，默認情況下是被禁止的。同源策略要求源相同才能正常進行通信，即協議、域名、端口號都完全一致。
前後端分離項目，前端項目和後端項目一般都不是同源的，所以肯定會存在跨域請求的問題。
所以我們就要處理一下，讓前端能進行跨域請求。
①先對 SpringBoot 配置，運行跨域請求
@Configuration
public class CorsConfig implements WebMvcConfigurer {
@Override
public void addCorsMappings(CorsRegistry registry) {
// 設置允許跨域的路徑
registry.addMapping("/**")
// 設置允許跨域請求的域名
.allowedOriginPatterns("*")
// 是否允許cookie
.allowCredentials(true)
// 設置允許的請求方式
.allowedMethods("GET", "POST", "DELETE", "PUT")
// 設置允許的header屬性
.allowedHeaders("*")
// 跨域允許時間
.maxAge(3600);
}
}②開啓 SpringSecurity 的跨域訪問
由於我們的資源都會收到 SpringSecurity 的保護，所以想要跨域訪問還要讓 SpringSecurity 運行跨域訪問。
@Override
protected void configure(HttpSecurity http) throws Exception {
http
//關閉csrf
.csrf().disable()
//不通過Session獲取SecurityContext
.sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS)
.and()
.authorizeRequests()
// 對於登錄接口 允許匿名訪問
.antMatchers("/user/login").anonymous()
// 除上面外的所有請求全部需要鑑權認證
.anyRequest().authenticated();
//添加過濾器
http.addFilterBefore(jwtAuthenticationTokenFilter, UsernamePasswordAuthenticationFilter.class);
//配置異常處理器
http.exceptionHandling()
//配置認證失敗處理器
.authenticationEntryPoint(authenticationEntryPoint)
.accessDeniedHandler(accessDeniedHandler);
//允許跨域
http.cors();
}- 遺留小問題
其它權限校驗方法
我們前面都是使用 @PreAuthorize 註解，然後在在其中使用的是 hasAuthority 方法進行校驗。SpringSecurity 還爲我們提供了其它方法例如：hasAnyAuthority，hasRole，hasAnyRole 等。
這裏我們先不急着去介紹這些方法，我們先去理解 hasAuthority 的原理，然後再去學習其他方法你就更容易理解，而不是死記硬背區別。並且我們也可以選擇定義校驗方法，實現我們自己的校驗邏輯。
hasAuthority 方法實際是執行到了 SecurityExpressionRoot 的 hasAuthority，大家只要斷點調試既可知道它內部的校驗原理。
它內部其實是調用 authentication 的 getAuthorities 方法獲取用戶的權限列表。然後判斷我們存入的方法參數數據在權限列表中。
hasAnyAuthority 方法可以傳入多個權限，只有用戶有其中任意一個權限都可以訪問對應資源。
@PreAuthorize("hasAnyAuthority('admin','test','system:dept:list')")
public String hello(){
return "hello";
}hasRole 要求有對應的角色纔可以訪問，但是它內部會把我們傳入的參數拼接上 **ROLE_** 後再去比較。所以這種情況下要用用戶對應的權限也要有 **ROLE_** 這個前綴纔可以。
@PreAuthorize("hasRole('system:dept:list')")
public String hello(){
return "hello";
}hasAnyRole 有任意的角色就可以訪問。它內部也會把我們傳入的參數拼接上 **ROLE_** 後再去比較。所以這種情況下要用用戶對應的權限也要有 **ROLE_** 這個前綴纔可以。
@PreAuthorize("hasAnyRole('admin','system:dept:list')")
public String hello(){
return "hello";
}自定義權限校驗方法
我們也可以定義自己的權限校驗方法，在 @PreAuthorize 註解中使用我們的方法。
@Component("ex")
public class SGExpressionRoot {
public boolean hasAuthority(String authority){
//獲取當前用戶的權限
Authentication authentication = SecurityContextHolder.getContext().getAuthentication();
LoginUser loginUser = (LoginUser) authentication.getPrincipal();
List<String> permissions = loginUser.getPermissions();
//判斷用戶權限集合中是否存在authority
return permissions.contains(authority);
}
}在 SPEL 表達式中使用 @ex 相當於獲取容器中 bean 的名字爲 ex 的對象。然後再調用這個對象的 hasAuthority 方法
@RequestMapping("/hello") @PreAuthorize("@ex.hasAuthority('system:dept:list')")
public String hello(){
return "hello";
}基於配置的權限控制
我們也可以在配置類中使用使用配置的方式對資源進行權限控制。
@Override
protected void configure(HttpSecurity http) throws Exception {
http
//關閉csrf
.csrf().disable()
//不通過Session獲取SecurityContext
.sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS)
.and()
.authorizeRequests()
// 對於登錄接口 允許匿名訪問
.antMatchers("/user/login").anonymous()
.antMatchers("/testCors").hasAuthority("system:dept:list222")
// 除上面外的所有請求全部需要鑑權認證
.anyRequest().authenticated();
//添加過濾器
http.addFilterBefore(jwtAuthenticationTokenFilter, UsernamePasswordAuthenticationFilter.class);
//配置異常處理器
http.exceptionHandling()
//配置認證失敗處理器
.authenticationEntryPoint(authenticationEntryPoint)
.accessDeniedHandler(accessDeniedHandler);
//允許跨域
http.cors();
}CSRF
CSRF 是指跨站請求僞造（Cross-site request forgery），是 web 常見的攻擊之一。
https://blog.csdn.net/freeking101/article/details/86537087SpringSecurity 去防止 CSRF 攻擊的方式就是通過 csrf_token。後端會生成一個 csrf_token，前端發起請求的時候需要攜帶這個 csrf_token, 後端會有過濾器進行校驗，如果沒有攜帶或者是僞造的就不允許訪問。
我們可以發現 CSRF 攻擊依靠的是 cookie 中所攜帶的認證信息。但是在前後端分離的項目中我們的認證信息其實是 token，而 token 並不是存儲中 cookie 中，並且需要前端代碼去把 token 設置到請求頭中才可以，所以 CSRF 攻擊也就不用擔心了。
認證成功處理器
實際上在 UsernamePasswordAuthenticationFilter 進行登錄認證的時候，如果登錄成功了是會調用 AuthenticationSuccessHandler 的方法進行認證成功後的處理的。AuthenticationSuccessHandler 就是登錄成功處理器。
我們也可以自己去自定義成功處理器進行成功後的相應處理。
@Component
public class SGSuccessHandler implements AuthenticationSuccessHandler {
@Override
public void onAuthenticationSuccess(HttpServletRequest request, HttpServletResponse response, Authentication authentication) throws IOException, ServletException {
System.out.println("認證成功了");
}
}@Configuration
public class SecurityConfig extends WebSecurityConfigurerAdapter {
@Autowired
private AuthenticationSuccessHandler successHandler;
@Override
protected void configure(HttpSecurity http) throws Exception {
http.formLogin().successHandler(successHandler);
http.authorizeRequests().anyRequest().authenticated();
}
}認證失敗處理器
實際上在 UsernamePasswordAuthenticationFilter 進行登錄認證的時候，如果認證失敗了是會調用 AuthenticationFailureHandler 的方法進行認證失敗後的處理的。AuthenticationFailureHandler 就是登錄失敗處理器。
我們也可以自己去自定義失敗處理器進行失敗後的相應處理。
@Component
public class SGFailureHandler implements AuthenticationFailureHandler {
@Override
public void onAuthenticationFailure(HttpServletRequest request, HttpServletResponse response, AuthenticationException exception) throws IOException, ServletException {
System.out.println("認證失敗了");
}
}@Configuration
public class SecurityConfig extends WebSecurityConfigurerAdapter {
@Autowired
private AuthenticationSuccessHandler successHandler;
@Autowired
private AuthenticationFailureHandler failureHandler;
@Override
protected void configure(HttpSecurity http) throws Exception {
http.formLogin()
// 配置認證成功處理器
.successHandler(successHandler)
// 配置認證失敗處理器
.failureHandler(failureHandler);
http.authorizeRequests().anyRequest().authenticated();
}
}登出成功處理器
@Component
public class SGLogoutSuccessHandler implements LogoutSuccessHandler {
@Override
public void onLogoutSuccess(HttpServletRequest request, HttpServletResponse response, Authentication authentication) throws IOException, ServletException {
System.out.println("註銷成功");
}
}@Configuration
public class SecurityConfig extends WebSecurityConfigurerAdapter {
@Autowired
private AuthenticationSuccessHandler successHandler;
@Autowired
private AuthenticationFailureHandler failureHandler;
@Autowired
private LogoutSuccessHandler logoutSuccessHandler;
@Override
protected void configure(HttpSecurity http) throws Exception {
http.formLogin()
// 配置認證成功處理器
.successHandler(successHandler)
// 配置認證失敗處理器
.failureHandler(failureHandler);
http.logout()
//配置註銷成功處理器
.logoutSuccessHandler(logoutSuccessHandler);
http.authorizeRequests().anyRequest().authenticated();
}
}其它認證方案暢想
https://toscode.gitee.com/xiaoming1129/spring-security-demo
https://blog.csdn.net/HXBest/article/details/106433454本文由 Readfog 進行 AMP 轉碼，版權歸原作者所有。
來源：https://mp.weixin.qq.com/s/7mkQaoKjNPteMbgg1C5rOg