2.差分陣列
阿新 • • 發佈：2022-05-17
SpringSecurity從入門到精通
課程介紹
0. 簡介
Spring Security 是 Spring 家族中的一個安全管理框架。相比與另外一個安全框架Shiro，它提供了更豐富的功能，社群資源也比Shiro豐富。
一般來說中大型的專案都是使用SpringSecurity 來做安全框架。小專案有Shiro的比較多，因為相比與SpringSecurity，Shiro的上手更加的簡單。
一般Web應用的需要進行認證和授權。
認證：驗證當前訪問系統的是不是本系統的使用者，並且要確認具體是哪個使用者
授權：經過認證後判斷當前使用者是否有許可權進行某個操作
而認證和授權也是SpringSecurity作為安全框架的核心功能。
1. 快速入門
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. 認證
2.1 登陸校驗流程
2.2 原理初探
想要知道如何實現自己的登陸流程就必須要先知道入門案例中SpringSecurity的流程。
2.2.1 SpringSecurity完整流程
SpringSecurity的原理其實就是一個過濾器鏈，內部包含了提供各種功能的過濾器。這裡我們可以看看入門案例中的過濾器。
圖中只展示了核心過濾器，其它的非核心過濾器並沒有在圖中展示。
UsernamePasswordAuthenticationFilter:負責處理我們在登陸頁面填寫了使用者名稱密碼後的登陸請求。入門案例的認證工作主要有它負責。
ExceptionTranslationFilter：處理過濾器鏈中丟擲的任何AccessDeniedException和AuthenticationException 。
FilterSecurityInterceptor：負責許可權校驗的過濾器。
我們可以通過Debug檢視當前系統中SpringSecurity過濾器鏈中有哪些過濾器及它們的順序。
2.2.2 認證流程詳解
概念速查:
Authentication介面: 它的實現類，表示當前訪問系統的使用者，封裝了使用者相關資訊。
AuthenticationManager介面：定義了認證Authentication的方法
UserDetailsService介面：載入使用者特定資料的核心介面。裡面定義了一個根據使用者名稱查詢使用者資訊的方法。
UserDetails介面：提供核心使用者資訊。通過UserDetailsService根據使用者名稱獲取處理的使用者資訊要封裝成UserDetails物件返回。然後將這些資訊封裝到Authentication物件中。
2.3 解決問題
2.3.1 思路分析
登入
①自定義登入介面
呼叫ProviderManager的方法進行認證 如果認證通過生成jwt
把使用者資訊存入redis中
②自定義UserDetailsService
在這個實現類中去查詢資料庫
校驗：
①定義Jwt認證過濾器
獲取token
解析token獲取其中的userid
從redis中獲取使用者資訊
存入SecurityContextHolder
2.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序列化
*
* @author sg
*/
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;
/**
* @Author 三更 B站： https://space.bilibili.com/663528522
*/
@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;
/**
* 使用者表(User)實體類
*
* @author 三更
*/
@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是否能正常使用
/**
* @Author 三更 B站： https://space.bilibili.com/663528522
*/
@SpringBootTest
public class MapperTest {
@Autowired
private UserMapper userMapper;
@Test
public void testUserMapper(){
List<User> users = userMapper.selectList(null);
System.out.println(users);
}
}
核心程式碼實現
建立一個類實現UserDetailsService介面，重寫其中的方法。更加使用者名稱從資料庫中查詢使用者資訊
/**
* @Author 三更 B站： https://space.bilibili.com/663528522
*/
@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型別，所以需要定義一個類，實現該介面，把使用者資訊封裝在其中。
/**
* @Author 三更 B站： https://space.bilibili.com/663528522
*/
@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。
/**
* @Author 三更 B站： https://space.bilibili.com/663528522
*/
@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);
}
}
/**
* @Author 三更 B站： https://space.bilibili.com/663528522
*/
@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);
}
}
/**
* @Author 三更 B站： https://space.bilibili.com/663528522
*/
@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中對應的資料即可。
/**
* @Author 三更 B站： https://space.bilibili.com/663528522
*/
@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. 授權
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;
/**
* @Author 三更 B站： https://space.bilibili.com/663528522
*/
@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;
/**
* @Author 三更 B站： https://space.bilibili.com/663528522
*/
@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` = 0
package 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)實體類
*
* @author makejava
* @since 2021-11-24 15:30:08
*/
@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;
/**
* @Author 三更 B站： https://space.bilibili.com/663528522
*/
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物件中即可。
/**
* @Author 三更 B站： https://space.bilibili.com/663528522
*/
@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);
}
}
4. 自定義失敗處理
我們還希望在認證失敗或者是授權失敗的情況下也能和我們的介面一樣返回相同結構的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);
}
}
/**
* @Author 三更 B站： https://space.bilibili.com/663528522
*/
@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);
5. 跨域
瀏覽器出於安全的考慮，使用 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();
}
6. 遺留小問題
其它許可權校驗方法
我們前面都是使用@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/86537087
SpringSecurity去防止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();
}
}
其他認證方案暢想
7. 原始碼講解
投票過50更新原始碼講解