記錄一下使用springSecurity搭建用戶認證和授權的代碼、、、

技術堆疊使用springSecurity + redis + JWT + mybatisPlus

部分代碼來自：https://blog.csdn.net/I_am_Hutengfei/article/details/100561564

零. 共用工具類和sql

1.工具類

@Data
public class JsonResult<T> implements Serializable {
    private Boolean success;
    private Integer errorCode;
    private String errorMsg;
    private T data;
?
    public JsonResult() {
    }
?
    public JsonResult(Boolean success, Integer errorCode, String errorMsg, T data) {
        this.success = success;
        this.errorCode = errorCode;
        this.errorMsg = errorMsg;
        this.data = data;
    }
?
    // 成功或者失敗都能走這個
    public JsonResult(boolean success) {
        this.success = success;
        this.errorMsg = success ? ResultCode.SUCCESS.getMessage() : ResultCode.COMMON_FAIL.getMessage();
        this.errorCode = success ? ResultCode.SUCCESS.getCode() : ResultCode.COMMON_FAIL.getCode();
    }
?
    // 成功或者失敗都能走這個，并且可以傳一個列舉來改變默認列舉的值
    public JsonResult(boolean success, ResultCode resultEnum) {
        this.success = success;
        // 傳來的列舉為null就用默認的，不為null就用傳來的列舉
        this.errorCode = success ? (resultEnum==null?ResultCode.SUCCESS.getCode():resultEnum.getCode()) : (resultEnum == null ? ResultCode.COMMON_FAIL.getCode() : resultEnum.getCode());
        this.errorMsg = success ? (resultEnum==null?ResultCode.SUCCESS.getMessage():resultEnum.getMessage()): (resultEnum == null ? ResultCode.COMMON_FAIL.getMessage() : resultEnum.getMessage());
    }
?
    // 成功或者失敗都能用
    // 用戶可以傳一個任意物件過來，用默認的成功或者失敗的列舉
    public JsonResult(boolean success, T data) {
        this.success = success;
        this.errorCode = success ? ResultCode.SUCCESS.getCode() : ResultCode.COMMON_FAIL.getCode();
        this.errorMsg = success ? ResultCode.SUCCESS.getMessage() : ResultCode.COMMON_FAIL.getMessage();
        this.data = data;
    }
?
    // 成功或者失敗都能用
    // 用戶可以傳一個任意物件和自定義列舉過來
    public JsonResult(boolean success, ResultCode resultEnum, T data) {
        this.success = success;
        this.errorCode = success ? (resultEnum==null ? ResultCode.SUCCESS.getCode() : resultEnum.getCode()): (resultEnum == null ? ResultCode.COMMON_FAIL.getCode() : resultEnum.getCode());
        this.errorMsg = success ? (resultEnum==null ? ResultCode.SUCCESS.getMessage() : resultEnum.getMessage()) : (resultEnum == null ? ResultCode.COMMON_FAIL.getMessage() : resultEnum.getMessage());
        this.data = data;
    }
?
    public static JsonResult success() {
        return new JsonResult(true);
    }
?
    public static JsonResult success(ResultCode resultEnum) {
        return new JsonResult(true,resultEnum);
    }
?
    public static <T> JsonResult<T> success(T data) {
        return new JsonResult(true, data);
    }
?
    public static <T> JsonResult<T> success(ResultCode resultEnum,T data){
        return new JsonResult<>(true,resultEnum,data);
    }
?
    public static JsonResult fail() {
        return new JsonResult(false);
    }
?
    public static <T> JsonResult fail(T data) {
        return new JsonResult(false, data);
    }
?
    public static JsonResult fail(ResultCode resultEnum) {
        return new JsonResult(false, resultEnum);
    }
?
    public static <T> JsonResult<T> fail(ResultCode resultEnum, T data) {
        return new JsonResult(false, resultEnum, data);
    }
}
?

public enum ResultCode {
    /* 成功 */
    SUCCESS(200, "請求成功"),
    SUCCESS_login(200, "用戶登錄成功"),
    SUCCESS_logout(200, "用戶退出成功"),
?
    /* 默認失敗 */
    COMMON_FAIL(999, "失敗"),
?
    /* 引數錯誤：1000～1999 */
    PARAM_NOT_VALID(1001, "引數無效"),
    PARAM_IS_BLANK(1002, "引數為空"),
    PARAM_TYPE_ERROR(1003, "引數型別錯誤"),
    PARAM_NOT_COMPLETE(1004, "引數缺失"),
?
    /* 用戶錯誤 */
    USER_FAIL_LOGIN(2000, "登陸失敗"),
    USER_NOT_LOGIN(2001, "用戶未登錄"),
    USER_ACCOUNT_EXPIRED(2002, "賬號已過期"),
    USER_CREDENTIALS_ERROR(2003, "密碼錯誤"),
    USER_CREDENTIALS_EXPIRED(2004, "密碼過期"),
    USER_ACCOUNT_DISABLE(2005, "賬號不可用"),
    USER_ACCOUNT_LOCKED(2006, "賬號被鎖定"),
    USER_ACCOUNT_NOT_EXIST(2007, "賬號不存在"),
    USER_ACCOUNT_ALREADY_EXIST(2008, "賬號已存在"),
    USER_ACCOUNT_USE_BY_OTHERS(2009, "賬號下線"),
?
    /* 業務錯誤 */
    NO_PERMISSION(3001, "當前賬號沒有此權限");
    private Integer code;
    private String message;
?
    ResultCode(Integer code, String message) {
        this.code = code;
        this.message = message;
    }
?
    public Integer getCode() {
        return code;
    }
?
    public void setCode(Integer code) {
        this.code = code;
    }
?
    public String getMessage() {
        return message;
    }
?
    public void setMessage(String message) {
        this.message = message;
    }
?
    /**
     * 根據code獲取message
     *
     * @param code
     * @return
     */
    public static String getMessageByCode(Integer code) {
        for (ResultCode ele : values()) {
            if (ele.getCode().equals(code)) {
                return ele.getMessage();
            }
        }
        return null;
    }
}

2.mybatisplus和sql

//mybatisPlus自動生成代碼使用
public class CreateCode {
    public static void main(String[] args) {
        FastAutoGenerator.create("jdbc:mysql://localhost:3306/security", "root", "123456")
                .globalConfig(builder -> {
                    builder.author("bao") // 設定作者
                            .enableSwagger() // 開啟 swagger 模式
                            .fileOverride() // 覆寫已生成檔案
                            .outputDir("D://user"); // 指定輸出目錄
                })
                .packageConfig(builder -> {
                    builder.parent("com.example.alipay.user") // 設定父包名
                            .moduleName("") // 設定父包模塊名
                            .pathInfo(Collections.singletonMap(OutputFile.xml, "D://user")); // 設定mapperXml生成路徑
                })
                .packageConfig(builder -> {
                    builder.parent("com.example.alipay.user") // 設定父包名
                            .moduleName("") // 設定父包模塊名
                            .pathInfo(Collections.singletonMap(OutputFile.controller, "D://user")); // 設定mapperXml生成路徑
                })
                .packageConfig(builder -> {
                    builder.parent("com.example.alipay.user") // 設定父包名
                            .moduleName("") // 設定父包模塊名
                            .pathInfo(Collections.singletonMap(OutputFile.entity, "D://user")); // 設定mapperXml生成路徑
                })
                .packageConfig(builder -> {
                    builder.parent("com.example.alipay.user") // 設定父包名
                            .moduleName("") // 設定父包模塊名
                            .pathInfo(Collections.singletonMap(OutputFile.mapper, "D://user")); // 設定mapperXml生成路徑
                })
                .packageConfig(builder -> {
                    builder.parent("com.example.alipay.user") // 設定父包名
                            .moduleName("") // 設定父包模塊名
                            .pathInfo(Collections.singletonMap(OutputFile.service, "D://")); // 設定mapperXml生成路徑
                })
                .packageConfig(builder -> {
                    builder.parent("com.example.alipay.user") // 設定父包名
                            .moduleName("") // 設定父包模塊名
                            .pathInfo(Collections.singletonMap(OutputFile.serviceImpl, "D://")); // 設定mapperXml生成路徑
                })
                .strategyConfig(builder -> {
                    builder.addInclude("sys_user") // 設定需要生成的表名
                            .addTablePrefix("t_", "c_"); // 設定過濾表前綴
                })
                .strategyConfig(builder -> {
                    builder.addInclude("sys_role") // 設定需要生成的表名
                            .addTablePrefix("t_", "c_"); // 設定過濾表前綴
                })
                .strategyConfig(builder -> {
                    builder.addInclude("sys_permission") // 設定需要生成的表名
                            .addTablePrefix("t_", "c_"); // 設定過濾表前綴
                })
                .strategyConfig(builder -> {
                    builder.addInclude("sys_request_path") // 設定需要生成的表名
                            .addTablePrefix("t_", "c_"); // 設定過濾表前綴
                })
                .strategyConfig(builder -> {
                    builder.addInclude("sys_request_path_permission_relation") // 設定需要生成的表名
                            .addTablePrefix("t_", "c_"); // 設定過濾表前綴
                })
                .strategyConfig(builder -> {
                    builder.addInclude("sys_role_permission_relation") // 設定需要生成的表名
                            .addTablePrefix("t_", "c_"); // 設定過濾表前綴
                })
                .strategyConfig(builder -> {
                    builder.addInclude("sys_user_role_relation") // 設定需要生成的表名
                            .addTablePrefix("t_", "c_"); // 設定過濾表前綴
                })
                .templateEngine(new FreemarkerTemplateEngine()) // 使用Freemarker引擎模板，默認的是Velocity引擎模板
                .execute();
?
    }
}

sql

/*
 Navicat Premium Data Transfer
?
 Source Server         : localhost_3306
 Source Server Type    : MySQL
 Source Server Version : 50719
 Source Host           : localhost:3306
 Source Schema         : security
?
 Target Server Type    : MySQL
 Target Server Version : 50719
 File Encoding         : 65001
?
 Date: 27/05/2022 15:05:34
*/
?
SET NAMES utf8mb4;
SET FOREIGN_KEY_CHECKS = 0;
?
-- ----------------------------
-- Table structure for sys_permission
-- ----------------------------
DROP TABLE IF EXISTS `sys_permission`;
CREATE TABLE `sys_permission`  (
  `id` int(11) NOT NULL AUTO_INCREMENT COMMENT '主鍵id',
  `permission_code` varchar(32) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '權限code',
  `permission_name` varchar(32) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '權限名',
  PRIMARY KEY (`id`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 5 CHARACTER SET = utf8 COLLATE = utf8_general_ci COMMENT = '權限表' ROW_FORMAT = COMPACT;
?
-- ----------------------------
-- Records of sys_permission
-- ----------------------------
INSERT INTO `sys_permission` VALUES (1, 'sys:user:list', '用戶查詢');
INSERT INTO `sys_permission` VALUES (2, 'sys:user:delete', '用戶洗掉');
INSERT INTO `sys_permission` VALUES (3, 'sys:user:online', '在線用戶查詢');
?
-- ----------------------------
-- Table structure for sys_role
-- ----------------------------
DROP TABLE IF EXISTS `sys_role`;
CREATE TABLE `sys_role`  (
  `id` int(11) NOT NULL AUTO_INCREMENT COMMENT '主鍵id',
  `role_code` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '角色值',
  `role_name` varchar(32) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '角色名',
  `role_description` varchar(64) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '角色說明',
  PRIMARY KEY (`id`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 3 CHARACTER SET = utf8 COLLATE = utf8_general_ci COMMENT = '用戶角色表' ROW_FORMAT = COMPACT;
?
-- ----------------------------
-- Records of sys_role
-- ----------------------------
INSERT INTO `sys_role` VALUES (1, 'admin', '管理員', '管理員，擁有所有權限');
INSERT INTO `sys_role` VALUES (2, 'user', '普通用戶', '普通用戶，擁有部分權限');
?
-- ----------------------------
-- Table structure for sys_role_permission_relation
-- ----------------------------
DROP TABLE IF EXISTS `sys_role_permission_relation`;
CREATE TABLE `sys_role_permission_relation`  (
  `id` int(11) NOT NULL AUTO_INCREMENT COMMENT '主鍵id',
  `role_id` int(11) NULL DEFAULT NULL COMMENT '角色id',
  `permission_id` int(11) NULL DEFAULT NULL COMMENT '權限id',
  PRIMARY KEY (`id`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 10 CHARACTER SET = utf8 COLLATE = utf8_general_ci COMMENT = '角色-權限關聯關系表' ROW_FORMAT = COMPACT;
?
-- ----------------------------
-- Records of sys_role_permission_relation
-- ----------------------------
INSERT INTO `sys_role_permission_relation` VALUES (1, 1, 1);
INSERT INTO `sys_role_permission_relation` VALUES (7, 1, 2);
INSERT INTO `sys_role_permission_relation` VALUES (8, 1, 3);
INSERT INTO `sys_role_permission_relation` VALUES (9, 2, 1);
?
-- ----------------------------
-- Table structure for sys_user
-- ----------------------------
DROP TABLE IF EXISTS `sys_user`;
CREATE TABLE `sys_user`  (
  `id` varchar(100) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NOT NULL,
  `user_name` varchar(32) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL COMMENT '賬號',
  `nick_name` varchar(32) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL COMMENT '用戶名',
  `password` varchar(64) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '用戶密碼',
  `last_login_time` datetime NULL DEFAULT NULL COMMENT '最后一次登錄時間',
  `enabled` tinyint(1) NULL DEFAULT 1 COMMENT '賬號是否可用，默認為1（可用）',
  `not_expired` tinyint(1) NULL DEFAULT 1 COMMENT '是否過期，默認為1（沒有過期）',
  `account_not_locked` tinyint(1) NULL DEFAULT 1 COMMENT '賬號是否鎖定，默認為1（沒有鎖定）',
  `credentials_not_expired` tinyint(1) NULL DEFAULT 1 COMMENT '證書（密碼）是否過期，默認為1（沒有過期）',
  `create_time` datetime NULL DEFAULT NULL COMMENT '創建時間',
  `update_time` datetime NULL DEFAULT NULL COMMENT '修改時間',
  `create_user` varchar(100) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '創建人',
  `update_user` varchar(100) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '修改人',
  PRIMARY KEY (`id`) USING BTREE
) ENGINE = InnoDB CHARACTER SET = utf8 COLLATE = utf8_general_ci COMMENT = '用戶表' ROW_FORMAT = COMPACT;
?
-- ----------------------------
-- Records of sys_user
-- ----------------------------
INSERT INTO `sys_user` VALUES ('4044aaa1-dca1-11ec-81da-00ff8ecb7c92', 'admin', 'admin', '$2a$10$fdaPecPEB3jJQCR4/E2lz.Gg6cnXLlsR1Qa2C4r7yO.hPjTOMr/he', '2022-05-27 14:18:28', 1, 1, 1, 1, '2019-08-29 06:29:24', '2022-05-26 14:13:09', '', '');
INSERT INTO `sys_user` VALUES ('63561932-dca1-11ec-81da-00ff8ecb7c92', 'user001', 'user001', '$2a$10$fdaPecPEB3jJQCR4/E2lz.Gg6cnXLlsR1Qa2C4r7yO.hPjTOMr/he', '2022-05-27 10:45:30', 1, 1, 1, 1, NULL, '2022-05-25 13:16:30', 'admin', 'admin');
?
-- ----------------------------
-- Table structure for sys_user_role_relation
-- ----------------------------
DROP TABLE IF EXISTS `sys_user_role_relation`;
CREATE TABLE `sys_user_role_relation`  (
  `id` int(11) NOT NULL AUTO_INCREMENT COMMENT '主鍵id',
  `user_id` varchar(100) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '用戶id',
  `role_id` int(11) NULL DEFAULT NULL COMMENT '角色id',
  PRIMARY KEY (`id`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 3 CHARACTER SET = utf8 COLLATE = utf8_general_ci COMMENT = '用戶角色關聯關系表' ROW_FORMAT = COMPACT;
?
-- ----------------------------
-- Records of sys_user_role_relation
-- ----------------------------
INSERT INTO `sys_user_role_relation` VALUES (1, '4044aaa1-dca1-11ec-81da-00ff8ecb7c92', 1);
INSERT INTO `sys_user_role_relation` VALUES (2, '63561932-dca1-11ec-81da-00ff8ecb7c92', 2);
?
SET FOREIGN_KEY_CHECKS = 1;
?

一.redis配置

使用redis來保存登陸用戶的資訊，一來防止驗證重復查詢資料庫，二來后期可以在此基礎上做在線用戶查詢，強退用戶等操作，

1. redis工具類（來自若依框架）

/**
 * spring redis 工具類
 *
 * @author ruoyi
 **/
@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 mapkey
     */
    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);
    }
}
?

2. redis序列化與反序列化配置

這里不做序列化，保存的redis資訊在可視化工具中將是一堆亂碼，后期在通過redisTemplate.keys(pattern)獲取key值時會獲取不到，

/**
 * @descriptions:  fastjson自定義序列化配置
 * @author: bao
 * @date: 2022/5/27 11:18
 * @version: 1.0
 */
public class FastJson2JsonRedisSerializer<T> implements RedisSerializer<T> {
    private ObjectMapper objectMapper = new ObjectMapper();
    public static final Charset DEFAULT_CHARSET = Charset.forName("UTF-8");
?
    private Class<T> clazz;
?
    static {
        ParserConfig.getGlobalInstance().setAutoTypeSupport(true);
        //如果遇到反序列化autoType is not support錯誤，請添加并修改一下包名到bean檔案路徑
//         ParserConfig.getGlobalInstance().addAccept("org.springframework.security.core.authority");
    }
    public FastJson2JsonRedisSerializer(Class<T> clazz) {
        super();
        this.clazz = clazz;
    }
?
    public byte[] serialize(T t) throws SerializationException {
        if (t == null) {
            return new byte[0];
        }
        return JSON.toJSONString(t, SerializerFeature.WriteClassName).getBytes(DEFAULT_CHARSET);
    }
?
    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);
    }
    public void setObjectMapper(ObjectMapper objectMapper) {
        Assert.notNull(objectMapper, "'objectMapper' must not be null");
        this.objectMapper = objectMapper;
    }
?
    protected JavaType getJavaType(Class<?> clazz) {
        return TypeFactory.defaultInstance().constructType(clazz);
    }
?
}
?

/**
 * @descriptions: redis序列化，redisTemplate配置
 * @author: bao
 * @date: 2022/5/26 13:26
 * @version: 1.0
 */
@Configuration
public class RedisConfig {
    @Bean
    public RedisTemplate<Object,Object> redisTemplate(RedisConnectionFactory redisConnectionFactory){
        RedisTemplate<Object, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(redisConnectionFactory);
        //使用Fastjson2JsonRedisSerializer來序列化和反序列化redis的value值 by zhengkai
        FastJson2JsonRedisSerializer serializer = new FastJson2JsonRedisSerializer(Object.class);
?
        ObjectMapper mapper = new ObjectMapper();
        mapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        mapper.activateDefaultTyping(new DefaultBaseTypeLimitingValidator(), ObjectMapper.DefaultTyping.NON_FINAL);
        serializer.setObjectMapper(mapper);
?
        template.setValueSerializer(serializer);
        //使用StringRedisSerializer來序列化和反序列化redis的key值
        template.setKeySerializer(new StringRedisSerializer());
        template.afterPropertiesSet();
        return template;
    }
}
?

3.redis快取常量

由于沒寫別的功能，目前只有一個常量

public class CacheConst {
    public static String LOGIN_USER_KEY = "loginUser:";
}

二 . JWT配置

1.工具類

public class JwtUtils {
    //token過期時間設定24小時
    public static final long EXPIRE = 1000 * 60 * 60 * 24;
    //密鑰
    public static final String APP_SECRET = "sdfkdjAYANMENGod33ksfdkds";
?
?
    /**
     * @descriptions 保存用戶所有資訊
     * @author bao
     * @date 2022/5/25 15:49
     * @return java.lang.String
     */
    public static String getJwtToken(String loginId){
?
        String JwtToken = Jwts.builder()
                .setHeaderParam("typ", "JWT")
                .setHeaderParam("alg", "HS256")
                .setSubject("jacob-user")
                .setIssuedAt(new Date())
                .setExpiration(new Date(System.currentTimeMillis() + EXPIRE))
                .claim("loginId", loginId)
                .signWith(SignatureAlgorithm.HS256, APP_SECRET)
                .compact();
?
        return JwtToken;
    }
?
?
?
    /**
     * 根據token，判斷token是否存在與有效
     * @param jwtToken
     * @return
     */
    public static boolean checkToken(String jwtToken) {
        if(StringUtils.isEmpty(jwtToken)) return false;
        try {
            Jwts.parser().setSigningKey(APP_SECRET).parseClaimsJws(jwtToken);
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
        return true;
    }
?
    /**
     * 根據request判斷token是否存在與有效（也就是把token取出來罷了）
     * @param request
     * @return
     */
    public static boolean checkToken(HttpServletRequest request) {
        try {
            String jwtToken = request.getHeader("UserToken");
            if(StringUtils.isEmpty(jwtToken)) return false;
            Jwts.parser().setSigningKey(APP_SECRET).parseClaimsJws(jwtToken);
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
        return true;
    }
?
    /**
     * 根據token獲取用戶的id
     * @param request
     * @return
     */
    public static String getUseridByJwtToken(HttpServletRequest request) {
        String jwtToken = request.getHeader("UserToken");
        if(StringUtils.isEmpty(jwtToken)) return null;
        try{
            Jws<Claims> claimsJws = Jwts.parser().setSigningKey(APP_SECRET).parseClaimsJws(jwtToken);
            Claims claims = claimsJws.getBody();
            return (String) claims.get("loginId");
        }catch (Exception e){
            e.printStackTrace();
            return null;
        }
    }
}

2. jwt過濾器

* 繼承了OncePerRequestFilter抽象類，該抽象類在每次請求時只執行一次過濾，即它的作用就是保證一次請求只通過一次filter,
* 重寫其doFilterInternal方法來自定義處理邏輯

@Component
public class JwtAuthenticationTokenFilter extends OncePerRequestFilter {
    /**
     * 直接將我們前面寫好的service注入進來，通過service獲取到當前用戶的權限
     * */
    @Autowired
    private RedisCache redisCache;
?
    @Override
    protected void doFilterInternal(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, FilterChain filterChain) throws ServletException, IOException {
        // 驗證當前token是否有效
        if (JwtUtils.checkToken(httpServletRequest)) {
            // 獲取到當前用戶的account
            String id = JwtUtils.getUseridByJwtToken(httpServletRequest);
            //根據id從redis中獲取登錄用戶資訊
            ParserConfig.getGlobalInstance().addAccept("org.springframework.security.core.authority.SimpleGrantedAuthority.");
            LoginUser userDetails = redisCache.getCacheObject(CacheConst.LOGIN_USER_KEY + id);
?
            // token中username不為空，并且Context中的認證為空，進行token驗證
            if (!Objects.isNull(userDetails) && Objects.isNull(SecurityContextHolder.getContext().getAuthentication())) {
                System.out.println("自定義JWT過濾器獲得用戶名為-" + userDetails.getUsername());
                UsernamePasswordAuthenticationToken authentication =
                        new UsernamePasswordAuthenticationToken(userDetails, null, userDetails.getAuthorities());
                authentication.setDetails(new WebAuthenticationDetailsSource().buildDetails(httpServletRequest));
                //將authentication放入SecurityContextHolder中
                SecurityContextHolder.getContext().setAuthentication(authentication);
            }
        }
        // 放行給下個過濾器
        filterChain.doFilter(httpServletRequest, httpServletResponse);
    }
}
?

三. springSecurity配置

1.自定義UserDetails實作類

這個類里面的 Collection<? extends GrantedAuthority> authorities，在反序列化時會失敗，上面的fastjson自定義序列化方式，主要是為了解決這個問題，

public class LoginUser implements Serializable, UserDetails{
?
    private static final long serialVersionUID = 1L;
    private SysUser sysUser;
    private Collection<? extends GrantedAuthority> authorities;
    public LoginUser() {
    }
?
    public LoginUser(SysUser sysUser, Collection<? extends GrantedAuthority> authorities) {
        Assert.isTrue(sysUser.getUserName() != null && !"".equals(sysUser.getUserName()) && sysUser.getPassword() != null,
                "Cannot pass null or empty values to constructor");
        this.sysUser = sysUser;
        this.authorities = Collections.unmodifiableSet((Set<? extends GrantedAuthority>) authorities);
    }
?
    @Override
    public Collection<? extends GrantedAuthority> getAuthorities() {
        return this.authorities;
    }
?
    @Override
    public String getPassword() {
        return this.sysUser.getPassword();
    }
?
    @Override
    public String getUsername() {
        return this.sysUser.getUserName();
    }
?
    @Override
    public boolean isAccountNonExpired() {
        return this.sysUser.getCredentialsNotExpired();
    }
?
    @Override
    public boolean isAccountNonLocked() {
        return this.sysUser.getAccountNotLocked();
    }
?
    @Override
    public boolean isCredentialsNonExpired() {
        return this.sysUser.getCredentialsNotExpired();
    }
?
    @Override
    public boolean isEnabled() {
        return this.sysUser.getEnabled();
    }
?
    public SysUser getSysUser() {
        return sysUser;
    }
?
    public void setSysUser(SysUser sysUser) {
        this.sysUser = sysUser;
    }
?
    public void setAuthorities(Collection<? extends GrantedAuthority> authorities) {
        this.authorities = authorities;
    }
}
?

2.自定義UserDetailsService實作類

在呼叫登錄介面（這里用的security默認登錄介面/login）,會自動執行UserDetailsService的loadUserByUsername，回傳一個userdetails，也就是上面的自定義實作類，

在這個方法中要配置用戶資訊，和用戶權限，

@Service
public class SecurityUserService implements UserDetailsService {
?
    @Autowired
    private SysUserMapper sysUserMapper;
    @Autowired
    private SysPermissionMapper sysPermissionMapper;
?
    /**
     * 根據用戶名查找資料庫，判斷是否存在這個用戶
     *
     * @return*/
    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
?
        // 用戶名必須是唯一的，不允許重復
        SysUser sysUser = sysUserMapper.selectOne(new QueryWrapper<SysUser>().eq("user_name",username));
        //獲取用戶權限
        List<SysPermission> sysPermissions = sysPermissionMapper.getUserRolesByUserId(sysUser.getId());
        //將用戶權限存入Userdetails的authorities中，以便security做權限判斷
        Set<GrantedAuthority> grantedAuthorities = new LinkedHashSet<>();
        sysPermissions.stream().forEach(sysPermission -> {
            GrantedAuthority grantedAuthority = new SimpleGrantedAuthority(sysPermission.getPermissionCode());
            grantedAuthorities.add(grantedAuthority);
        });
?
        LoginUser loginUser = new LoginUser(sysUser, grantedAuthorities);
        return loginUser;
    }
}

這里要用到的一個sql

sysPermissionMapper.getUserRolesByUserId(sysUser.getId());

?
    <select id="getUserRolesByUserId" resultType="com.bao.xinghe.user.entity.SysPermission">
        SELECT
            p.*
        FROM
            sys_user AS u
                LEFT JOIN sys_user_role_relation AS ur
                          ON u.id = ur.user_id
                LEFT JOIN sys_role AS r
                          ON r.id = ur.role_id
                LEFT JOIN sys_role_permission_relation AS rp
                          ON r.id = rp.role_id
                LEFT JOIN sys_permission AS p
                          ON p.id = rp.permission_id
        WHERE u.id = #{userId}
    </select>

3.一些要用到的例外過濾器

登陸成功過濾器

在這個過濾器中實作一些登陸成功后的業務處理邏輯，我這里包括修改登錄用戶資訊，保存登錄快取，

@Component
public class CustomizeAuthenticationSuccessHandler implements AuthenticationSuccessHandler {
    @Autowired
    SysUserMapper mapper;
    @Autowired
    RedisCache redisCache;
?
    @Override
    public void onAuthenticationSuccess(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Authentication authentication) throws IOException, ServletException {
        //更新用戶表上次登錄時間、更新人、更新時間等欄位
        LoginUser userDetails = (LoginUser) authentication.getPrincipal();
        SysUser sysUser = userDetails.getSysUser();
        sysUser.setLastLoginTime(new Date());
        mapper.update(sysUser,new QueryWrapper<SysUser>().eq("id",sysUser.getId()));
?
        //登陸成功用戶資訊保存redis、登陸有效時長1小時
        String id = sysUser.getId();
        redisCache.setCacheObject(CacheConst.LOGIN_USER_KEY + id, userDetails, 60, TimeUnit.MINUTES);
        // 根據用戶的id生成token并回傳
        String jwtToken = JwtUtils.getJwtToken(id);
        Map<String,String> results = new HashMap<>();
        results.put("token",jwtToken);
?
        //回傳json資料
        JsonResult result = JsonResult.success(ResultCode.SUCCESS_login,results);
        //處理編碼方式，防止中文亂碼的情況
        httpServletResponse.setContentType("text/json;charset=utf-8");
        // 把Json資料放入HttpServletResponse中回傳給前臺
        httpServletResponse.getWriter().write(JSON.toJSONString(result));
    }
}

登陸失敗過濾器

?
@Component
public class CustomizeAuthenticationFailureHandler implements AuthenticationFailureHandler {
?
    @Override
    public void onAuthenticationFailure(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, AuthenticationException e) throws IOException, ServletException {
        //回傳json資料
        JsonResult result = null;
        if (e instanceof AccountExpiredException) {
            //賬號過期
            result = JsonResult.fail(ResultCode.USER_ACCOUNT_EXPIRED);
        } else if (e instanceof BadCredentialsException) {
            //密碼錯誤
            result = JsonResult.fail(ResultCode.USER_CREDENTIALS_ERROR);
        } else if (e instanceof CredentialsExpiredException) {
            //密碼過期
            result = JsonResult.fail(ResultCode.USER_CREDENTIALS_EXPIRED);
        } else if (e instanceof DisabledException) {
            //賬號不可用
            result = JsonResult.fail(ResultCode.USER_ACCOUNT_DISABLE);
        } else if (e instanceof LockedException) {
            //賬號鎖定
            result = JsonResult.fail(ResultCode.USER_ACCOUNT_LOCKED);
        } else if (e instanceof InternalAuthenticationServiceException) {
            //用戶不存在
            result = JsonResult.fail(ResultCode.USER_ACCOUNT_NOT_EXIST);
        }else{
            //其他錯誤
            result = JsonResult.fail(ResultCode.COMMON_FAIL);
        }
        //處理編碼方式，防止中文亂碼的情況
        httpServletResponse.setContentType("text/json;charset=utf-8");
        // 把Json資料放入到HttpServletResponse中回傳給前臺
        httpServletResponse.getWriter().write(JSON.toJSONString(result));
    }
}
?

未登錄處理

@Component
public class CustomizeAuthenticationEntryPoint implements AuthenticationEntryPoint {
?
    // 回傳的是Json資料
    @Override
    public void commence(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, AuthenticationException e) throws IOException, ServletException {
        JsonResult result = JsonResult.fail(ResultCode.USER_NOT_LOGIN);
        httpServletResponse.setContentType("text/json;charset=utf-8");
        httpServletResponse.getWriter().write(JSON.toJSONString(result));
    }
}

無權限處理

@Component
public class CustomizeAccessDeniedHandler implements AccessDeniedHandler {
    @Override
    public void handle(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, AccessDeniedException e) throws IOException, ServletException {
        JsonResult noPermission = JsonResult.fail(ResultCode.NO_PERMISSION);
        //處理編碼方式，防止中文亂碼的情況
        httpServletResponse.setContentType("text/json;charset=utf-8");
        // 把Json資料放到HttpServletResponse中回傳給前臺
        httpServletResponse.getWriter().write(JSON.toJSONString(noPermission));
    }
}
?

登出處理

登出時做洗掉redis快取操作

@Component
public class CustomizeLogoutSuccessHandler implements LogoutSuccessHandler {
    @Autowired
    RedisCache redisCache;
    @Override
    public void onLogoutSuccess(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Authentication authentication) throws IOException, ServletException {
        //退出成功洗掉redis快取
        LoginUser userDetails = (LoginUser) authentication.getPrincipal();
        redisCache.deleteObject(CacheConst.LOGIN_USER_KEY + userDetails.getSysUser().getId());
        JsonResult result = JsonResult.success(ResultCode.SUCCESS_logout);
        httpServletResponse.setContentType("text/json;charset=utf-8");
        httpServletResponse.getWriter().write(JSON.toJSONString(result));
    }
}

4.核心配置類

自定義SecurityConfig繼承WebSecurityConfigurerAdapter

重寫configure方法對security進行核心配置

之前寫的所有過濾器都要在這里配置進去，

@Configuration
@EnableWebSecurity
@EnableGlobalMethodSecurity(prePostEnabled = true)  //此注解用于開啟controller介面注解權限認證
public class SecurityConfig extends WebSecurityConfigurerAdapter {
?
    @Autowired
    private SecurityUserService securityUserService;
?
    @Autowired
    private AuthenticationEntryPoint authenticationEntryPoint;
?
    @Autowired
    private AuthenticationFailureHandler authenticationFailureHandler;
?
    @Autowired
    private LogoutSuccessHandler logoutSuccessHandler;
?
    @Autowired
    private AuthenticationSuccessHandler authenticationSuccessHandler;
?
    @Autowired
    private CustomizeAccessDeniedHandler customizeAccessDeniedHandler;
?
    @Autowired
    private JwtAuthenticationTokenFilter jwtAuthenticationTokenFilter;
?
    /**
     * 對請求進行鑒權的配置
     *
     * @param http
     * @throws Exception
     */
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        //關閉cors
        http.cors()
                .and().csrf().disable();
?
        /**
         * anyRequest          |   匹配所有請求路徑
         * access              |   SpringEl運算式結果為true時可以訪問
         * anonymous           |   匿名可以訪問
         * denyAll             |   用戶不能訪問
         * fullyAuthenticated  |   用戶完全認證可以訪問（非remember-me下自動登錄）
         * hasAnyAuthority     |   如果有引數，引數表示權限，則其中任何一個權限可以訪問
         * hasAnyRole          |   如果有引數，引數表示角色，則其中任何一個角色可以訪問
         * hasAuthority        |   如果有引數，引數表示權限，則其權限可以訪問
         * hasIpAddress        |   如果有引數，引數表示IP地址，如果用戶IP和引數匹配，則可以訪問
         * hasRole             |   如果有引數，引數表示角色，則其角色可以訪問
         * permitAll           |   用戶可以任意訪問
         * rememberMe          |   允許通過remember-me登錄的用戶訪問
         * authenticated       |   用戶登錄后可訪問
         */
        http.authorizeRequests()    
                .antMatchers("/sysUser/signUp").permitAll()  //這是測驗代碼，，注冊用戶
                .anyRequest().authenticated()
            .and()
                .exceptionHandling()
                .authenticationEntryPoint(authenticationEntryPoint)
                .accessDeniedHandler(customizeAccessDeniedHandler)
            .and()
                .formLogin()  // 登錄
                .permitAll()  //允許所有用戶
                .successHandler(authenticationSuccessHandler)  //登錄成功處理邏輯
                .failureHandler(authenticationFailureHandler)  //登錄失敗處理邏輯
            .and()
                .logout()      // 退出
                .permitAll()   //允許所有用戶
                .logoutSuccessHandler(logoutSuccessHandler)  //退出成功處理邏輯
                .deleteCookies("JSESSIONID")   //登出之后洗掉cookie
            .and()
                // 不通過session保存securityContext
                .sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS);
?
        http.addFilterBefore(jwtAuthenticationTokenFilter, UsernamePasswordAuthenticationFilter.class);
        http.addFilterBefore(jwtAuthenticationTokenFilter, LogoutFilter.class);
        http.headers().cacheControl();
    }
?
    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        auth.userDetailsService(securityUserService);
    }
?
    /**
     * 默認開啟密碼加密，前端傳入的密碼Security會在加密后和資料庫中的密文進行比對，一致的話就登錄成功
     * 所以必須提供一個加密物件，供security加密前端明文密碼使用
     * @return
     */
    @Bean
    PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();
    }
?
    @Bean
    @Override
    public AuthenticationManager authenticationManagerBean() throws Exception {
        return super.authenticationManagerBean();
    }
}
?

四.測驗介面

@RestController
@RequestMapping("/sysUser")
public class SysUserController {
?
    @Autowired
    SysUserServiceImpl sysUserService;
?
    @Autowired
    PasswordEncoder passwordEncoder;
?
    @RequestMapping("getUser")
    @PreAuthorize("hasAuthority('sys:user:list')")
    public JsonResult list(){
        List<SysUser> list = sysUserService.list();
        return new JsonResult(true, list);
    }
?
?
    @RequestMapping("deleteUser")
    @PreAuthorize("hasAuthority('sys:user:delete')")
    public JsonResult deleteUser(){
        List<SysUser> list = sysUserService.list();
        return new JsonResult(true, list);
    }
?
?
    @RequestMapping("signUp")
    public JsonResult signUp(SysUser sysUser){
        String password = passwordEncoder.encode(sysUser.getPassword());
        sysUser.setPassword(password);
        sysUserService.save(sysUser);
        return new JsonResult(true, sysUser);
    }
?
    @GetMapping("onlineUser")
    @PreAuthorize("hasAuthority('sys:user:online')")
    public JsonResult onlineUser(){
        List<SysUser> userList = sysUserService.onlineUser();
        if (userList == null){
            JsonResult.success("當前無登錄用戶");
        }
        return JsonResult.success(userList);
    }
?
}
?

    @Override
    public List<SysUser> onlineUser() {
        //獲取redis所有在線用戶key值、
        Set<String> keys = (Set<String>) redisCache.keys("*" + CacheConst.LOGIN_USER_KEY + "*");
        if (keys == null){
            return null;
        }
        List<SysUser> userList = new ArrayList<>();
        keys.stream().forEach( key -> {
            LoginUser loginUser = redisCache.getCacheObject(key);
            userList.add(loginUser.getSysUser());
        });
        return userList;
    }

標籤：Java

上一篇：在Spring中測驗CGLIB動態代理遇到ClassNotFoundException: org.objectweb.asm.Type問題

下一篇：返回列表