Spring security 整合JWT登录流程_springsecurity登录项目-程序员宅基地

技术标签: spring  java  安全  

Spring security 的工作流程

请添加图片描述
说明

  1. 客户端发起一个请求,进入Security 过滤器链
  2. 当到LogoutFilter 的时候判断是否是登出的路径,如果是登出路径则到logoutHandler ,如果登出成功则到logoutSuccessHandler 登出成功处理,如果不是登出路径则直接进入下一个过滤器
  3. 当到UsernamePasswordSuthenticationFilter 的时候判断是否为登录路径,如果是,则进入该过滤器登录操作,如果失败则到SuthenticationFailureHandler,登录失败处理器处理,如果登录成功则到AuthenticationSuccessHandler 登录成功处理器处理,如果不是登录请求则不进入该过滤器
  4. 进入认证BasicAuthenticationFilter 进行用户认证,成功的话会把认证了的结果写入到SecurityContextHolder 中的 securityContext 的属性authention 上面。如果认证失败就会 认证失败处理类,或者抛出异常被后续ExceptionTranslationFilter过滤器处理异常,如果是AuthenticationException就交给AuthenticationEntryPoint处理,如果是AccessDeniedException异常则交给AccessDeniedHandler处理。
  5. 当到 FilterSecurityInterceptor 的时候会拿到 uri ,根据 uri 去找对应的鉴权管理器,鉴权管理器做鉴权工作,鉴权成功则到 Controller 层,否则到 AccessDeniedHandler 鉴权失败处理器处理。
    总共需要出现的组件
    LogoutFilter - 登出过滤器
    logoutSuccessHandler - 登出成功之后的操作类
    UsernamePasswordAuthenticationFilter - from提交用户名密码登录认证过滤器
    AuthenticationFailureHandler - 登录失败操作类
    AuthenticationSuccessHandler - 登录成功操作类
    BasicAuthenticationFilter - Basic身份认证过滤器
    SecurityContextHolder - 安全上下文静态工具类
    AuthenticationEntryPoint - 认证失败入口
    ExceptionTranslationFilter - 异常处理过滤器
    AccessDeniedHandler - 权限不足操作类
    FilterSecurityInterceptor - 权限判断拦截器、出口

引入Security 与 Jwt

首先我们导入security 包,因为我们前后端交互用户认证凭证用的是Jwt 所以我们也导入jwt 的相关包。导入redis 用作验证码

       <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-security</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
        <!-- jwt -->
        <dependency>
            <groupId>io.jsonwebtoken</groupId>
            <artifactId>jjwt</artifactId>
            <version>0.9.1</version>
        </dependency>

启动redis,然后我们再启动项目,这时候我们再去访问http://localhost:8081/test,会发现系统会先判断到你未登录跳转到http://localhost:8081/login,因为security内置了登录页,用户名为user,密码在启动项目的时候打印在了控制台。登录完成之后我们才可以正常访问接口。因为每次启动密码都会改变,所以我们通过配置文件来配置一下默认的用户名和密码:

spring:
  # Spring security 的账号密码修改
  security:
    user:
      name: user
      password: 111111

在这里插入图片描述

用户认证,验证码生成

分为首次登陆和二次认证

  1. 首次登陆认证:用户名,密码和验证码完成登陆
  2. 二次token认证:请求头携带jwt 进行身份认证
    使用用户名密码来登录的,然后我们还想添加图片验证码,那么security给我们提供的UsernamePasswordAuthenticationFilter就不能使用了。
    解决方式是在UsernamePasswordAuthenticationFilter之前自定义一个图片过滤器CaptchaFilter,提前校验验证码是否正确,这样我们就可以使用UsernamePasswordAuthenticationFilter了,然后登录正常或失败我们都可以通过对应的Handler来返回我们特定格式的封装结果数据。
    生成验证码
    首先我们先生成验证码,之前我们已经引用了google的验证码生成器,我们先来配置一下图片验证码的生成规则:

KaptchaConfig
在这里插入图片描述

// 加上注解
@Configuration
public class KaptchaConfig {
    
    @Bean
    public DefaultKaptcha producer() {
    
        Properties properties = new Properties();
        properties.put("kaptcha.border", "no");
        properties.put("kaptcha.textproducer.font.color", "black");
        properties.put("kaptcha.textproducer.char.space", "4");
        properties.put("kaptcha.image.height", "40");
        properties.put("kaptcha.image.width", "120");
        properties.put("kaptcha.textproducer.font.size", "30");
        Config config = new Config(properties);
        DefaultKaptcha defaultKaptcha = new DefaultKaptcha();
        defaultKaptcha.setConfig(config);
        return defaultKaptcha;
    }
}

上面验证码的长宽字体颜色等,是可以调整的
通过控制器提供生成验证码的方法
**这里需要用到一个redis 的工具类 **

@Component
public class RedisUtil {
    

    @Autowired
    private RedisTemplate redisTemplate;

    /**
     * 指定缓存失效时间
     *
     * @param key  键
     * @param time 时间(秒)
     * @return
     */
    public boolean expire(String key, long time) {
    
        try {
    
            if (time > 0) {
    
                redisTemplate.expire(key, time, TimeUnit.SECONDS);
            }
            return true;
        } catch (Exception e) {
    
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 根据key 获取过期时间
     *
     * @param key 键 不能为null
     * @return 时间(秒) 返回0代表为永久有效
     */
    public long getExpire(String key) {
    
        return redisTemplate.getExpire(key, TimeUnit.SECONDS);
    }

    /**
     * 判断key是否存在
     *
     * @param key 键
     * @return true 存在 false不存在
     */
    public boolean hasKey(String key) {
    
        try {
    
            return redisTemplate.hasKey(key);
        } catch (Exception e) {
    
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 删除缓存
     *
     * @param key 可以传一个值 或多个
     */
    @SuppressWarnings("unchecked")
    public void del(String... key) {
    
        if (key != null && key.length > 0) {
    
            if (key.length == 1) {
    
                redisTemplate.delete(key[0]);
            } else {
    
                redisTemplate.delete(CollectionUtils.arrayToList(key));
            }
        }
    }

    //============================String=============================

    /**
     * 普通缓存获取
     *
     * @param key 键
     * @return 值
     */
    public Object get(String key) {
    
        return key == null ? null : redisTemplate.opsForValue().get(key);
    }

    /**
     * 普通缓存放入
     *
     * @param key   键
     * @param value 值
     * @return true成功 false失败
     */
    public boolean set(String key, Object value) {
    
        try {
    
            redisTemplate.opsForValue().set(key, value);
            return true;
        } catch (Exception e) {
    
            e.printStackTrace();
            return false;
        }

    }

    /**
     * 普通缓存放入并设置时间
     *
     * @param key   键
     * @param value 值
     * @param time  时间(秒) time要大于0 如果time小于等于0 将设置无限期
     * @return true成功 false 失败
     */
    public boolean set(String key, Object value, long time) {
    
        try {
    
            if (time > 0) {
    
                redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);
            } else {
    
                set(key, value);
            }
            return true;
        } catch (Exception e) {
    
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 递增
     *
     * @param key 键
     * @param delta  要增加几(大于0)
     * @return
     */
    public long incr(String key, long delta) {
    
        if (delta < 0) {
    
            throw new RuntimeException("递增因子必须大于0");
        }
        return redisTemplate.opsForValue().increment(key, delta);
    }

    /**
     * 递减
     *
     * @param key 键
     * @param delta  要减少几(小于0)
     * @return
     */
    public long decr(String key, long delta) {
    
        if (delta < 0) {
    
            throw new RuntimeException("递减因子必须大于0");
        }
        return redisTemplate.opsForValue().increment(key, -delta);
    }

    //================================Map=================================

    /**
     * HashGet
     *
     * @param key  键 不能为null
     * @param item 项 不能为null
     * @return 值
     */
    public Object hget(String key, String item) {
    
        return redisTemplate.opsForHash().get(key, item);
    }

    /**
     * 获取hashKey对应的所有键值
     *
     * @param key 键
     * @return 对应的多个键值
     */
    public Map<Object, Object> hmget(String key) {
    
        return redisTemplate.opsForHash().entries(key);
    }

    /**
     * HashSet
     *
     * @param key 键
     * @param map 对应多个键值
     * @return true 成功 false 失败
     */
    public boolean hmset(String key, Map<String, Object> map) {
    
        try {
    
            redisTemplate.opsForHash().putAll(key, map);
            return true;
        } catch (Exception e) {
    
            e.printStackTrace();
            return false;
        }
    }

    /**
     * HashSet 并设置时间
     *
     * @param key  键
     * @param map  对应多个键值
     * @param time 时间(秒)
     * @return true成功 false失败
     */
    public boolean hmset(String key, Map<String, Object> map, long time) {
    
        try {
    
            redisTemplate.opsForHash().putAll(key, map);
            if (time > 0) {
    
                expire(key, time);
            }
            return true;
        } catch (Exception e) {
    
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 向一张hash表中放入数据,如果不存在将创建
     *
     * @param key   键
     * @param item  项
     * @param value 值
     * @return true 成功 false失败
     */
    public boolean hset(String key, String item, Object value) {
    
        try {
    
            redisTemplate.opsForHash().put(key, item, value);
            return true;
        } catch (Exception e) {
    
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 向一张hash表中放入数据,如果不存在将创建
     *
     * @param key   键
     * @param item  项
     * @param value 值
     * @param time  时间(秒)  注意:如果已存在的hash表有时间,这里将会替换原有的时间
     * @return true 成功 false失败
     */
    public boolean hset(String key, String item, Object value, long time) {
    
        try {
    
            redisTemplate.opsForHash().put(key, item, value);
            if (time > 0) {
    
                expire(key, time);
            }
            return true;
        } catch (Exception e) {
    
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 删除hash表中的值
     *
     * @param key  键 不能为null
     * @param item 项 可以使多个 不能为null
     */
    public void hdel(String key, Object... item) {
    
        redisTemplate.opsForHash().delete(key, item);
    }

    /**
     * 判断hash表中是否有该项的值
     *
     * @param key  键 不能为null
     * @param item 项 不能为null
     * @return true 存在 false不存在
     */
    public boolean hHasKey(String key, String item) {
    
        return redisTemplate.opsForHash().hasKey(key, item);
    }

    /**
     * hash递增 如果不存在,就会创建一个 并把新增后的值返回
     *
     * @param key  键
     * @param item 项
     * @param by   要增加几(大于0)
     * @return
     */
    public double hincr(String key, String item, double by) {
    
        return redisTemplate.opsForHash().increment(key, item, by);
    }

    /**
     * hash递减
     *
     * @param key  键
     * @param item 项
     * @param by   要减少记(小于0)
     * @return
     */
    public double hdecr(String key, String item, double by) {
    
        return redisTemplate.opsForHash().increment(key, item, -by);
    }

    //============================set=============================

    /**
     * 根据key获取Set中的所有值
     *
     * @param key 键
     * @return
     */
    public Set<Object> sGet(String key) {
    
        try {
    
            return redisTemplate.opsForSet().members(key);
        } catch (Exception e) {
    
            e.printStackTrace();
            return null;
        }
    }

    /**
     * 根据value从一个set中查询,是否存在
     *
     * @param key   键
     * @param value 值
     * @return true 存在 false不存在
     */
    public boolean sHasKey(String key, Object value) {
    
        try {
    
            return redisTemplate.opsForSet().isMember(key, value);
        } catch (Exception e) {
    
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 将数据放入set缓存
     *
     * @param key    键
     * @param values 值 可以是多个
     * @return 成功个数
     */
    public long sSet(String key, Object... values) {
    
        try {
    
            return redisTemplate.opsForSet().add(key, values);
        } catch (Exception e) {
    
            e.printStackTrace();
            return 0;
        }
    }

    /**
     * 将set数据放入缓存
     *
     * @param key    键
     * @param time   时间(秒)
     * @param values 值 可以是多个
     * @return 成功个数
     */
    public long sSetAndTime(String key, long time, Object... values) {
    
        try {
    
            Long count = redisTemplate.opsForSet().add(key, values);
            if (time > 0) expire(key, time);
            return count;
        } catch (Exception e) {
    
            e.printStackTrace();
            return 0;
        }
    }

    /**
     * 获取set缓存的长度
     *
     * @param key 键
     * @return
     */
    public long sGetSetSize(String key) {
    
        try {
    
            return redisTemplate.opsForSet().size(key);
        } catch (Exception e) {
    
            e.printStackTrace();
            return 0;
        }
    }

    /**
     * 移除值为value的
     *
     * @param key    键
     * @param values 值 可以是多个
     * @return 移除的个数
     */
    public long setRemove(String key, Object... values) {
    
        try {
    
            Long count = redisTemplate.opsForSet().remove(key, values);
            return count;
        } catch (Exception e) {
    
            e.printStackTrace();
            return 0;
        }
    }
    //===============================list=================================

    /**
     * 获取list缓存的内容
     *
     * @param key   键
     * @param start 开始
     * @param end   结束  0 到 -1代表所有值
     * @return
     */
    public List<Object> lGet(String key, long start, long end) {
    
        try {
    
            return redisTemplate.opsForList().range(key, start, end);
        } catch (Exception e) {
    
            e.printStackTrace();
            return null;
        }
    }

    /**
     * 获取list缓存的长度
     *
     * @param key 键
     * @return
     */
    public long lGetListSize(String key) {
    
        try {
    
            return redisTemplate.opsForList().size(key);
        } catch (Exception e) {
    
            e.printStackTrace();
            return 0;
        }
    }

    /**
     * 通过索引 获取list中的值
     *
     * @param key   键
     * @param index 索引  index>=0时, 0 表头,1 第二个元素,依次类推;index<0时,-1,表尾,-2倒数第二个元素,依次类推
     * @return
     */
    public Object lGetIndex(String key, long index) {
    
        try {
    
            return redisTemplate.opsForList().index(key, index);
        } catch (Exception e) {
    
            e.printStackTrace();
            return null;
        }
    }

    /**
     * 将list放入缓存
     *
     * @param key   键
     * @param value 值
     * @return
     */
    public boolean lSet(String key, Object value) {
    
        try {
    
            redisTemplate.opsForList().rightPush(key, value);
            return true;
        } catch (Exception e) {
    
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 将list放入缓存
     *
     * @param key   键
     * @param value 值
     * @param time  时间(秒)
     * @return
     */
    public boolean lSet(String key, Object value, long time) {
    
        try {
    
            redisTemplate.opsForList().rightPush(key, value);
            if (time > 0) expire(key, time);
            return true;
        } catch (Exception e) {
    
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 将list放入缓存
     *
     * @param key   键
     * @param value 值
     * @return
     */
    public boolean lSet(String key, List<Object> value) {
    
        try {
    
            redisTemplate.opsForList().rightPushAll(key, value);
            return true;
        } catch (Exception e) {
    
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 将list放入缓存
     *
     * @param key   键
     * @param value 值
     * @param time  时间(秒)
     * @return
     */
    public boolean lSet(String key, List<Object> value, long time) {
    
        try {
    
            redisTemplate.opsForList().rightPushAll(key, value);
            if (time > 0) expire(key, time);
            return true;
        } catch (Exception e) {
    
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 根据索引修改list中的某条数据
     *
     * @param key   键
     * @param index 索引
     * @param value 值
     * @return
     */
    public boolean lUpdateIndex(String key, long index, Object value) {
    
        try {
    
            redisTemplate.opsForList().set(key, index, value);
            return true;
        } catch (Exception e) {
    
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 移除N个值为value
     *
     * @param key   键
     * @param count 移除多少个
     * @param value 值
     * @return 移除的个数
     */
    public long lRemove(String key, long count, Object value) {
    
        try {
    
            Long remove = redisTemplate.opsForList().remove(key, count, value);
            return remove;
        } catch (Exception e) {
    
            e.printStackTrace();
            return 0;
        }
    }

    //================有序集合 sort set===================
    /**
     * 有序set添加元素
     *
     * @param key
     * @param value
     * @param score
     * @return
     */
    public boolean zSet(String key, Object value, double score) {
    
        return redisTemplate.opsForZSet().add(key, value, score);
    }

    public long batchZSet(String key, Set<ZSetOperations.TypedTuple> typles) {
    
        return redisTemplate.opsForZSet().add(key, typles);
    }

    public void zIncrementScore(String key, Object value, long delta) {
    
        redisTemplate.opsForZSet().incrementScore(key, value, delta);
    }

    public void zUnionAndStore(String key, Collection otherKeys, String destKey) {
    
        redisTemplate.opsForZSet().unionAndStore(key, otherKeys, destKey);
    }

    /**
     * 获取zset数量
     * @param key
     * @param value
     * @return
     */
    public long getZsetScore(String key, Object value) {
    
        Double score = redisTemplate.opsForZSet().score(key, value);
        if(score==null){
    
            return 0;
        }else{
    
            return score.longValue();
        }
    }

    /**
     * 获取有序集 key 中成员 member 的排名 。
     * 其中有序集成员按 score 值递减 (从大到小) 排序。
     * @param key
     * @param start
     * @param end
     * @return
     */
    public Set<ZSetOperations.TypedTuple> getZSetRank(String key, long start, long end) {
    
        return redisTemplate.opsForZSet().reverseRangeWithScores(key, start, end);
    }

}

一个常量类
在这里插入图片描述
生成验证码Controller

@RestController
public class AuthController extends BaseController {
    
    // 生成验证码的 控制器
    // 注入 我们的图片验证码
    @Autowired
    private Producer producer;
// 注入redis 的工具类
    @Autowired
    RedisUtil redisUtil;
    @GetMapping("/captcha")
    public Result captcha(HttpServletRequest request, HttpServletResponse response) throws IOException {
    
        // 获取状态码
        String code = producer.createText();
        // 获取 key 的值 设置为 uuid
        String key = UUID.randomUUID().toString();
        // 生成图片
        BufferedImage image = producer.createImage(code);
        // 获取字节数组 输出流
        ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
        ImageIO.write(image, "jpg", outputStream);
        // 64 位转码
        BASE64Encoder encoder = new BASE64Encoder();
        String str = "data:image/jpeg;base64,";
        String base64Img = str + encoder.encode(outputStream.toByteArray());
        // 存到redis 中 并且设置过期时间
        redisUtil.hset(Const.CAPTCHA_KEY,key,code,120);
        return Result.succ(
                MapUtil.builder()
                .put("token",key)
                .put("base64Img",base64Img)
                .build()
        );
    }
}

因为前后端分离,禁用了session,所以我们把验证码放在了redis 中,使用一个随机字符串作为key 传到前端,前端再把随机字符串和用户输入的验证码提交上来,这样就可以通过随机字符串获取保存的验证码和用户的验证码比较是否正确

编写JwtTokenUtil 类 用来生成JWT 的Token

修改yml

# 这个是 jwt 的配置
jwt:
  tokenHeader: Authorization
  secret: fjj-secrt
  expiration: 604800
  tokenHead: Bearer
/**
 * JWT 工具类
 * */
@Component
public class JwtTokenUtil {
    
    @Value("${jwt.secret}")
    private String secret;
    @Value("${jwt.expiration}")
    private Long expiration;
    /**
     * 根据用户信息生成token
     *
     * @param userDetails
     * @return
     */
    public String generateToken(UserDetails userDetails) {
    
        Map<String, Object> claims = new HashMap<>();
        claims.put(Corst.CLAIM_KEY_USERNAME, userDetails.getUsername());
        claims.put(Corst.CLAIM_KEY_CREATED, new Date());
        return generateToken(claims);
    }

    /**
     * 从token中获取登录用户名
     * @param token
     * @return
     */
    public String getUserNameFromToken(String token){
    
        String username;
        try {
    
            Claims claims = getClaimsFormToken(token);
            username = claims.getSubject();
        } catch (Exception e) {
    
            username = null;
        }
        return username;
    }

    /**
     * 验证token是否有效
     * @param token
     * @param userDetails
     * @return
     */
    public boolean validateToken(String token,UserDetails userDetails){
    
        String username = getUserNameFromToken(token);
        return username.equals(userDetails.getUsername()) && !isTokenExpired(token);
    }


    /**
     * 判断token是否可以被刷新
     * @param token
     * @return
     */
    public boolean canRefresh(String token){
    
        return !isTokenExpired(token);
    }

    /**
     * 刷新token
     * @param token
     * @return
     */
    public String refreshToken(String token){
    
        Claims claims = getClaimsFormToken(token);
        claims.put(Corst.CLAIM_KEY_CREATED,new Date());
        return generateToken(claims);
    }

    /**
     * 判断token是否失效
     * @param token
     * @return
     */
    private boolean isTokenExpired(String token) {
    
        Date expireDate = getExpiredDateFromToken(token);
        return expireDate.before(new Date());
    }

    /**
     * 从token中获取过期时间
     * @param token
     * @return
     */
    private Date getExpiredDateFromToken(String token) {
    
        Claims claims = getClaimsFormToken(token);
        return claims.getExpiration();
    }

    /**
     * 从token中获取荷载
     * @param token
     * @return
     */
    private Claims getClaimsFormToken(String token) {
    
        Claims claims = null;
        try {
    
            claims = Jwts.parser()
                    .setSigningKey(secret)
                    .parseClaimsJws(token)
                    .getBody();
        } catch (Exception e) {
    
            e.printStackTrace();
        }
        return claims;
    }


    /**
     * 根据荷载生成JWT TOKEN
     *
     * @param claims
     * @return
     */
    private String generateToken(Map<String, Object> claims) {
    
        return Jwts.builder()
                .setClaims(claims)
                .setExpiration(generateExpirationDate())
                .signWith(SignatureAlgorithm.HS512, secret)
                .compact();
    }

    /**
     * 生成token失效时间
     *
     * @return
     */
    private Date generateExpirationDate() {
    
        return new Date(System.currentTimeMillis() + expiration * 1000);
    }
}

登录成功之后返回 token

修改实体类实现 UserDetails

当然也可以自己在编写一个类实现 UserDetails

@Data
@EqualsAndHashCode(callSuper = false)
public class MUser implements Serializable , UserDetails {
    

    private static final long serialVersionUID = 1L;

    @TableId(value = "id", type = IdType.AUTO)
    private Long id;

    private String username;

    private String avatar;

    private String email;

    private String password;

    private Integer status;

    private LocalDateTime created;

    private LocalDateTime lastLogin;


    @Override
    public Collection<? extends GrantedAuthority> getAuthorities() {
    
        return null;
    }

    @Override
    public boolean isAccountNonExpired() {
    
        return true;
    }

    @Override
    public boolean isAccountNonLocked() {
    
        return true;
    }

    @Override
    public boolean isCredentialsNonExpired() {
    
        return true;
    }

    @Override
    public boolean isEnabled() {
    
        return true;
    }
}

编写Controller 类

@RestController
@RequestMapping("/m-user")
@Api("MUserController")
public class MUserController {
    
    @Autowired
    MUserServiceImpl userService;
    @Autowired
    RedisUtil redisUtil;
    @GetMapping("/login")
    @ApiOperation("登录")
    public Results login(@RequestBody HashMap<String,String> data, HttpRequest request) {
    
        String username = data.get("username");
        String password = data.get("password");
        String code = data.get("code");
        String token = data.get("rediskey");
        // 验证验证码是否成功
        if (!code.equals(redisUtil.hget(Corst.CAPTCHA_KEY, token))) {
    
            return Results.fail("验证码错误");
        }
        return userService.login(username,password,request);

    }

}

service impl 类

    @Autowired
    UserDetailsService userDetailsService;
    @Autowired
    PasswordEncoder passwordEncoder;
    @Value("${jwt.tokenHead}")
    private String tokenHead;
    @Autowired
    JwtTokenUtil jwtTokenUtil;
        /**
         * 登录成功返回token
         * */
    @Override
    public Results login(String username, String password, HttpRequest request) {
    
        // 登录
        UserDetails userDetails = userDetailsService.loadUserByUsername(username);
        // 判断用户名字或者密码是否正确
        if (null == userDetails.getUsername() || !passwordEncoder.matches(password, userDetails.getPassword())) {
    
            return Results.fail("用户名或者密码不正确");
        }
        // 把登录的信息保存到全局
        UsernamePasswordAuthenticationToken usernamePasswordAuthenticationToken = new UsernamePasswordAuthenticationToken(userDetails, null, userDetails.getAuthorities());
        SecurityContextHolder.getContext().setAuthentication(usernamePasswordAuthenticationToken);
        // 生成 token 并且返回
        String token = jwtTokenUtil.generateToken(userDetails);
        HashMap<String, Object> map = new HashMap<>();
        map.put("token", token);
        map.put("tokenHead", tokenHead);
        return Results.succ(200, "登录成功", map);
    }

配置security 登录授权过滤器

package com.vue.eblog.demo.config;

import com.vue.eblog.demo.Filter.JwtAuthencationTokenFilter;
import com.vue.eblog.demo.entity.MUser;
import com.vue.eblog.demo.service.impl.MUserServiceImpl;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.ObjectPostProcessor;
import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.builders.WebSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
import org.springframework.security.config.http.SessionCreationPolicy;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.core.userdetails.UsernameNotFoundException;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.security.web.access.intercept.FilterSecurityInterceptor;
import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;

/**
 * Security配置类
 *
 * @author zhoubin
 * @since 1.0.0
 */
@Configuration
public class SecurityConfig extends WebSecurityConfigurerAdapter {
    
    @Autowired
    private MUserServiceImpl userService;
    @Autowired
    private RestAuthorizationEntryPoint restAuthorizationEntryPoint;
    @Autowired
    RestfulAccessDeniedHandler restfulAccessDeniedHandler;


    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
    
        auth.userDetailsService(userDetailsService()).passwordEncoder(passwordEncoder());
    }
    @Bean
    public PasswordEncoder passwordEncoder() {
    
        return new BCryptPasswordEncoder();
    }
    @Override
    public void configure(WebSecurity web) throws Exception {
    
        web.ignoring().antMatchers(
                "/**/**",
                "/m-user/login",
                "/logout",
                "/css/**",
                "/js/**",
                "/index.html",
                "favicon.ico",
                "/doc.html",
                "/webjars/**",
                "/swagger-resources/**",
                "/v2/api-docs/**",
                "/captcha",
                "/ws/**",
                "/system/cfg/menu",
                "/api/**",
                "/m-user/user/info"
        );
    }
    @Override
    protected void configure(HttpSecurity http) throws Exception {
    
//使用JWT,不需要csrf
        http.csrf()
                .disable()
                //基于token,不需要session
                .sessionManagement()
                .sessionCreationPolicy(SessionCreationPolicy.STATELESS)
                .and()
                .authorizeRequests()
                //所有请求都要求认证
                .anyRequest()
                .authenticated()
       
                .and()
                //禁用缓存
                .headers()
                .cacheControl();
        //添加jwt 登录授权过滤器
        http.addFilterBefore(jwtAuthencationTokenFilter(), UsernamePasswordAuthenticationFilter.class);
        //添加自定义未授权和未登录结果返回
        http.exceptionHandling()
                .accessDeniedHandler(restfulAccessDeniedHandler)
                .authenticationEntryPoint(restAuthorizationEntryPoint);
    }
    @Bean
    public JwtAuthencationTokenFilter jwtAuthencationTokenFilter() {
    
        return new JwtAuthencationTokenFilter();
    }
    // 重写 userDetailsService
    @Override
    public UserDetailsService userDetailsService()  {
    
        return username->{
    
            MUser userName = userService.getAdminUserName(username);
            if (null!=userName) {
    
                return userName;
            }
            return null;
        };
    }
}


编写过滤器

JwtAuthencationTokenFilter
/**
 * JWT登录授权过滤器
 *
 * @author zhoubin
 * @since 1.0.0
 */
public class JwtAuthencationTokenFilter extends OncePerRequestFilter {
    

	@Value("${jwt.tokenHeader}")
	private String tokenHeader;
	@Value("${jwt.tokenHead}")
	private String tokenHead;
	@Autowired
	private JwtTokenUtil jwtTokenUtil;
	@Autowired
	private UserDetailsService userDetailsService;

	@Override
	protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException {
    
		String authHeader = request.getHeader(tokenHeader);
		//存在token
		if (null != authHeader && authHeader.startsWith(tokenHead)) {
    
			String authToken = authHeader.substring(tokenHead.length());
			String username = jwtTokenUtil.getUserNameFromToken(authToken);
			//token存在用户名但未登录
			if (null != username && null == SecurityContextHolder.getContext().getAuthentication()) {
    
				//登录
				UserDetails userDetails = userDetailsService.loadUserByUsername(username);
				//验证token是否有效,重新设置用户对象
				if (jwtTokenUtil.validateToken(authToken, userDetails)) {
    
					UsernamePasswordAuthenticationToken authenticationToken =
							new UsernamePasswordAuthenticationToken(userDetails, null, userDetails.getAuthorities());
					authenticationToken.setDetails(new WebAuthenticationDetailsSource().buildDetails(request));
					SecurityContextHolder.getContext().setAuthentication(authenticationToken);
				}
			}

		}
		filterChain.doFilter(request, response);
	}
}

添加自定义返回的结果

RestfulAccessDeniedHandler

/**
 * 当访问接口没有权限时,自定义返回结果
 *
 * @author zhoubin
 * @since 1.0.0
 */
@Component
public class RestfulAccessDeniedHandler implements AccessDeniedHandler {
    

	@Override
	public void handle(HttpServletRequest request, HttpServletResponse response, AccessDeniedException accessDeniedException) throws IOException, ServletException {
    
		response.setCharacterEncoding("UTF-8");
		response.setContentType("application/json");
		PrintWriter out = response.getWriter();
		Results bean = Results.fail("权限不足,请联系管理员!");
		bean.setCode(403);
		out.write(new ObjectMapper().writeValueAsString(bean));
		out.flush();
		out.close();
	}
}

RestAuthorizationEntryPoint
/**
 * 当未登录或者token失效时访问接口时,自定义的返回结果
 *
 * @author zhoubin
 * @since 1.0.0
 */
@Component
public class RestAuthorizationEntryPoint implements AuthenticationEntryPoint {
    

	@Override
	public void commence(HttpServletRequest request, HttpServletResponse response, AuthenticationException authException) throws IOException, ServletException {
    
		response.setCharacterEncoding("UTF-8");
		response.setContentType("application/json");
		PrintWriter out = response.getWriter();
		Results bean = Results.fail("尚未登录,请登录!");
		bean.setCode(401);
		out.write(new ObjectMapper().writeValueAsString(bean));
		out.flush();
		out.close();
	}
}

版权声明:本文为博主原创文章,遵循 CC 4.0 BY-SA 版权协议,转载请附上原文出处链接和本声明。
本文链接:https://blog.csdn.net/m0_46937429/article/details/122472883

智能推荐

【22】数据可视化:基于 Echarts + Python 动态实时大屏范例- MySQL数据源_python mysql echarts 源代码-程序员宅基地

文章浏览阅读3.8k次,点赞7次,收藏77次。写在前面,最近收到了很多小伙伴们的建议,大屏的数据源是否可以展示更丰富的种类,比如Excel,数据库等,那就更加贴近小伙伴们的实际工作场景,可以很快在工作中应用,所以应小伙伴需求,就诞生了这篇【基于 Echarts + Python 动态实时大屏范例(DataBase数据源)- 可视大屏案例】。另外,很多实际展示场景下需要自动播放效果,本案例也展示了Events和DispatchAction触发的饼图和地图高亮效果,非常实用。之前小伙伴们建.._python mysql echarts 源代码

递归算法(图文详解)-程序员宅基地

文章浏览阅读10w+次,点赞229次,收藏1.1k次。递归算法说简单点即就是自身程序的调用,若你掌握递归相应逻辑,递归之时你便可以起飞!!!_递归算法

一觉醒来2T硬盘数据化为乌有,背后或是两名黑客在竞争式入侵-程序员宅基地

文章浏览阅读1.3w次,点赞153次,收藏125次。博雯 发自 凹非寺量子位 报道 | 公众号 QbitAI一觉醒来,几个T的硬盘数据化为乌有。不说暗无天日吧,也至少是惨绝人寰了。毫不夸张的说,上周四的6月24日,西部数据硬盘的My Boo...

html中页面超出浏览器滚动条,html页面内容超出后显示水平滚动条的问题_html/css_WEB-ITnose...-程序员宅基地

文章浏览阅读1.5k次。这个问题已经遇到好几次,解决起来也熟练了很多。出现这种问题一般都是html或页面中的某一内部元素宽度超了。下面总结我遇到的几种情况:1、某一内部元素width设为100%,然而它还有border的宽度,border的宽度不包含在width中,所以结果超了。2、span行内元素,由于它是行内元素,不设display:block之类,宽度设定对它没用,当初弄的时候没有意识到这个问题,结果在谷歌浏览器没..._html页面設置超出100%出現滾動條

【EXCEL绘制地图】获取地图图标信息时遇到问题。请确保处于联机状态,然后重试_获取地图图表信息时遇到问题,请确保处于联机状态-程序员宅基地

文章浏览阅读3.3k次。【EXCEL绘制地图】获取地图图标信息时遇到问题。请确保处于联机状态,然后重试问题说明:如题,在绘制全球数据地图时报错,但是中国地图不会报错。解决方案:将excel上的office账户退出即可参考网站:为什么我的3D地图无法使用..._获取地图图表信息时遇到问题,请确保处于联机状态

hdu5391威尔逊定理-程序员宅基地

文章浏览阅读1.5k次。威尔逊定理在初等数论中,威尔逊定理给出了判定一个自然数是否为素数的充分必要条件。即:当且仅当p为素数时:( p -1 )! ≡ -1 ( mod p ),但是由于阶乘是呈爆炸增长的,其结论对于实际操作意义不大。hdu5391用到了这一数论定理。Zball in Tina TownTime Limit: 3000/1500 MS (Java/Others) Me_hdu5391

随便推点

开发常用网站_网页开发常用的一些图片网站-程序员宅基地

文章浏览阅读1.2k次,点赞4次,收藏20次。图床 - 引用ur图片api - 调用接口和生产借口文档说明MDN - 学习前端chrome插件Octotree - github展示树Allow-Control-Allow-Origin - 跨域_网页开发常用的一些图片网站

飞桨深度学习笔记(二)-程序员宅基地

文章浏览阅读668次。文章目录第一章零基础入门深度学习(下)加载库数据处理模型设计训练配置训练过程保存模型测试模型完整代码今天是学习这门课程的第二天,学习内容是利用飞桨的深度学习平台来进行波士顿房价的预测,至于为什么要用飞桨这个平台,以下是官方回答,我也是刚接触,之前用的都是pytorch,现在一起学习呗,再次附上脑图链接:打卡学习笔记第一章零基础入门深度学习(下)加载库#加载飞桨、Numpy和相关类库import paddleimport paddle.fluid as fluidimport paddle.f

vc6 运行库的bug---C++程序稳定运行一段时间后异常中止__heap_alloc_dbg-程序员宅基地

文章浏览阅读1.5k次。转自:http://blog.csdn.net/Miracle08/article/details/1457060 最近发现Visual C++ 6.0有一个有趣的,能让programmer发疯的bug。Debug版本编译出来的程序可能最终会异常中止,也许是报告程序停在断点xxxxxxx。更确切地说是用debug 版本的运行时库编译的程序。 由于项目需要写了一个求最短路径的引__heap_alloc_dbg

Python 玩出花儿了!一文教你用 Python 制作吃豆人游戏! | 附代码-程序员宅基地

文章浏览阅读7.1k次,点赞19次,收藏70次。作者 | 李秋键责编 | Carol封图 | CSDN 下载自视觉中国近几年来Python语言得到了快速发展,而Pygame作为Python开发应用和游戏必备的库更是展现了Python的..._python吃豆人实验原理

tgp英雄联盟无法连接服务器未响应,lol点开始游戏没反应怎么办 完整解决办法一览...-程序员宅基地

文章浏览阅读2.6k次。相信不少玩家都在游戏中会碰到登陆游戏了之后不能点PLAY,不能点商城,不能点个人资料,反正什么都点不了的问题,今天小编就给大家来解答下要怎么解决吧。LOL点了PLAY没反映要怎么解决?很多人都有出现这个问题,在进游戏之前,应该就是在输入账号密码那里吧,要不就是选择服务器哪里,有一个选项,把QT勾选上,就可以了。以上就是特玩小编为大家带来的关于lol点了play反映的解决办法了,希望对你有帮助。相信..._tgp不能用

HDFS体系结构(各种进程状态)_hdfs中包含哪些守护进程-程序员宅基地

文章浏览阅读851次。HDFS体系结构(各种进程状态)NameNode【名称节点】开启方式(关闭方式):hdfs namenode(关闭Terminal)hadoop-daemon.sh start namenode(hadoop-daemon.sh stop namenode或杀死进程)start-dfs.sh(stop-dfs.sh或杀死进程)namenode默认大小..._hdfs中包含哪些守护进程

推荐文章

热门文章

相关标签