【尚硅谷】SpringSecurity笔记

最新推荐文章于 2024-01-07 23:38:24 发布
最新推荐文章于 2024-01-07 23:38:24 发布
阅读量2.4k 收藏 25
点赞数 5
分类专栏： java Spring 文章标签： java 后端 spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43167873/article/details/123614932
版权
java 同时被 2 个专栏收录
90 篇文章 30 订阅
订阅专栏
Spring
6 篇文章 1 订阅
订阅专栏

SpringSecurity

文章目录

简介

Spring 是非常流行和成功的 Java应用开发框架，Spring Security 正是 Spring 家族中的成员。Spring Security 基于 Spring 框架，提供了一套 Web 应用安全性的完整解决方 案。 正如你可能知道的关于安全方面的两个主要区域是“认证”和“授权”（或者访问控 制），一般来说，Web 应用的安全性包括用户认证（Authentication）和用户授权 （Authorization）两个部分，这两点也是 Spring Security 重要核心功能。

（1）用户认证指的是：验证某个用户是否为系统中的合法主体，也就是说用户能否访问该系统。用户认证一般要求用户提供用户名和密码。系统通过校验用户名和密码来完成认证过程。通俗点说就是系统认为用户是否能登录

（2）用户授权指的是：**验证某个用户是否有权限执行某个操作。**在一个系统中，不同用户所具有的权限是不同的。比如对一个文件来说，有的用户只能进行读取，而有的用户可以 进行修改。一般来说，系统会为不同的用户分配不同的角色，而每个角色则对应一系列的权限。通俗点讲就是系统判断用户是否有权限去做某些事情。

和Shiro的区别

Shiro - 轻量级

SpringSecurity - 重量级

相对于 Shiro，在 SSM 中整合 Spring Security 都是比较麻烦的操作，所以，Spring Security 虽然功能比 Shiro 强大，但是使用反而没有 Shiro 多（Shiro 虽然功能没有 Spring Security 多，但是对于大部分项目而言，Shiro 也够用了）。

自从有了 Spring Boot 之后，Spring Boot 对于 Spring Security 提供了自动化配置方 案，可以使用更少的配置来使用 Spring Security。 因此，一般来说，常见的安全管理技术栈的组合是这样的：

  • SSM + Shiro
  • Spring Boot/Spring Cloud + Spring Security

以上只是一个推荐的组合而已，如果单纯从技术上来说，无论怎么组合，都是可以运行的

测试案例

创建spring项目

引入依赖

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-security</artifactId>
            <version>2.2.1.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

controller层

package com.xiaoqi.sedemo01.controller;

import org.springframework.stereotype.Repository;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/test")
public class TestController {
    @GetMapping("hello")
    public String hello(){
        return "springSecurity";
    }
}

访问端口

输入用户名user，密码springsecurity给出

image-20220316183335681

基本原理

SpringSecurity 本质是一个过滤器链：

从启动是可以获取到过滤器链：

org.springframework.security.web.context.request.async.WebAsyncManagerIntegrationFil
ter
org.springframework.security.web.context.SecurityContextPersistenceFilter 
org.springframework.security.web.header.HeaderWriterFilter
org.springframework.security.web.csrf.CsrfFilter
org.springframework.security.web.authentication.logout.LogoutFilter 
org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter 
org.springframework.security.web.authentication.ui.DefaultLoginPageGeneratingFilter 
org.springframework.security.web.authentication.ui.DefaultLogoutPageGeneratingFilter
org.springframework.security.web.savedrequest.RequestCacheAwareFilter
org.springframework.security.web.servletapi.SecurityContextHolderAwareRequestFilter
org.springframework.security.web.authentication.AnonymousAuthenticationFilter 
org.springframework.security.web.session.SessionManagementFilter 
org.springframework.security.web.access.ExceptionTranslationFilter 
org.springframework.security.web.access.intercept.FilterSecurityIntercepto

代码底层流程：

重点看三个过滤器：

FilterSecurityInterceptor：是一个方法级的权限过滤器, 基本位于过滤链的最底部

image-20220316183616426

image-20220316184046475

super.beforeInvocation(fi) 表示查看之前的 filter是否通过。

fi.getChain().doFilter(fi.getRequest(), fi.getResponse());表示真正的调用后台的服务。

ExceptionTranslationFilter：是个异常过滤器，用来处理在认证授权过程中抛出的异常

image-20220316184233973

UsernamePasswordAuthenticationFilter ：对/login 的 POST 请求做拦截，校验表单中用户名，密码

image-20220316184328217

过滤器如何加载？

02-SpringSecurity基本原理

image-20220316185055329

UserDetailsService 接口

当什么也没有配置的时候，账号和密码是由 Spring Security 定义生成的。而在实际项目中账号和密码都是从数据库中查询出来的。 所以我们要通过自定义逻辑控制认证逻辑。

如果需要自定义逻辑时，只需要实现 UserDetailsService 接口即可。接口定义如下：

image-20220316190134518

返回值 UserDetails 这个类是系统默认的用户“主体”

// 表示获取登录用户所有权限 Collection getAuthorities();

// 表示获取密码 String getPassword(); 

// 表示获取用户名 String getUsername(); 

// 表示判断账户是否过期 boolean isAccountNonExpired();

// 表示判断账户是否被锁定 boolean isAccountNonLocked();

// 表示凭证{密码}是否过期 boolean isCredentialsNonExpired();

// 表示当前用户是否可用 boolean isEnabled();

image-20220316190300352

PasswordEncoder 接口

image-20220316191439031

// 表示把参数按照特定的解析规则进行解析
String encode(CharSequence rawPassword);

// 表示验证从存储中获取的编码密码与编码后提交的原始密码是否匹配。如果密码匹配，则返回 true；如果不匹配，则返回 false。第一个参数表示需要被解析的密码。第//二个参数表示存储的密码。

boolean matches(CharSequence rawPassword, String encodedPassword);

// 表示如果解析的密码能够再次进行解析且达到更安全的结果则返回 true，否则返回false。默认返回 false。
default boolean upgradeEncoding(String encodedPassword) {
	return false;
}

image-20220316191315053

方法演示

@Test
public void test01(){
// 创建密码解析器
BCryptPasswordEncoder bCryptPasswordEncoder = new BCryptPasswordEncoder();
    
// 对密码进行加密
String atguigu = bCryptPasswordEncoder.encode("atguigu");
    
// 打印加密之后的数据
System.out.println("加密之后数据：\t"+atguigu);
    
//判断原字符加密后和加密之前是否匹配
boolean result = bCryptPasswordEncoder.matches("atguigu", atguigu);
    // 打印比较结果
    System.out.println("比较结果：\t"+result);
}

SpringSecurity Web 权限方案

设置登陆用户名和密码

方式一：在 application.propertie

spring.security.user.name=xiaoqi
spring.security.user.password=123456

方式二：编写类实现接口

直接new对象加入不到spring容器中

@Configuration
public class SecurityConfig extends WebSecurityConfigurerAdapter {

    @Override
    protected void configure(AuthenticationManagerBuilder auth)throws Exception{
        //加密类
        BCryptPasswordEncoder passwordEncoder = new BCryptPasswordEncoder();
        String encode = passwordEncoder.encode("123456");
        //往内存中写入用户名和密码还有角色
        auth.inMemoryAuthentication().withUser("xiaoqi").password(encode).roles("root");
    }

    // 注入 PasswordEncoder 类到 spring 容器中
    @Bean
    PasswordEncoder passwordEncoder(){
        return  new BCryptPasswordEncoder();
    }
	
}

@Configuration
public class SecurityConfig extends WebSecurityConfigurerAdapter {

    @Override
    protected void configure(AuthenticationManagerBuilder auth)throws Exception{
        //加密类
        BCryptPasswordEncoder passwordEncoder = new BCryptPasswordEncoder();
        String encode = passwordEncoder.encode("123456");
        //往内存中写入用户名和密码还有角色
        auth.inMemoryAuthentication().passwordEncoder(new BCryptPasswordEncoder()).withUser("xiaoqi").password(encode).roles("root");
    }
    
}

方式三：自定义实现类

如果有配置类或者配置文件，先从这里查找出用户名和密码，如果没有则去查找UserDetialService接口去寻找

创建配置类
package com.xiaoqi.sedemo01.config;

import com.xiaoqi.sedemo01.serivce.MyUserDetailsService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;


@Configuration
public class SecurityConfig1 extends WebSecurityConfigurerAdapter {
    @Autowired
    private MyUserDetailsService myUserDetailsService;

    @Override
    protected void configure(AuthenticationManagerBuilder auth)throws Exception{
        auth.userDetailsService(myUserDetailsService).passwordEncoder(new BCryptPasswordEncoder());

    }
}
编写实现类，返回user对象
package com.xiaoqi.sedemo01.serivce;

import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.authority.AuthorityUtils;
import org.springframework.security.core.userdetails.User;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.core.userdetails.UsernameNotFoundException;

import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.stereotype.Service;

import java.util.List;

@Service
public class MyUserDetailsService implements UserDetailsService {
    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
        List<GrantedAuthority> authorities = AuthorityUtils.commaSeparatedStringToAuthorityList("role");
        if(!"xiaoqi".equals(username)) throw  new UsernameNotFoundException("用户名不存在");
        return new User(username,new BCryptPasswordEncoder().encode("123456"),authorities);
    }
}

配置类从userDetailsService中读取uer对象进行登陆

数据库完成用户登录

整合Mybatis-Plus完成数据库操作

引入依赖
创建数据库
配置文件中写入数据库
#mysql 数据库连接
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver 
spring.datasource.url=jdbc:mysql://localhost:3306/mybatis_plus?serverTimezone=GMT%2B8&userSSL=true&useUnicode=true&characterEncoding=UTF-8
spring.datasource.username=root 
spring.datasource.password=123456
写入实体类
package com.xiaoqi.sedemo01.entity;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@NoArgsConstructor
@AllArgsConstructor
public class Users {
    private Integer id;
    private String name;
    private String password;
}
整合mybatisplus
@Mapper
public interface UserMapper extends BaseMapper<Users> {

}
在UserDetailsService中调用Mapper
@Service
public class MyUserDetailsService implements UserDetailsService {
    @Autowired
    private UserMapper userMapper;
    //调用方法查询数据库

    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
        QueryWrapper<Users> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("name",username);
        Users user = userMapper.selectOne(queryWrapper);
        //判断用户是否存在
        if(user == null) throw new UsernameNotFoundException("用户不存在");

        //设置一个角色权限
        List<GrantedAuthority> authorities = AuthorityUtils.commaSeparatedStringToAuthorityList("role");

        if(!"xiaoqi".equals(username)) throw  new UsernameNotFoundException("用户名不存在");
        return new User(username,new BCryptPasswordEncoder().encode(user.getPassword()),authorities);
    }
}

自定义设置登录页面

在配置类中实现相关的配置

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.formLogin() // 自定义自己编的登录页面
                .loginPage("/login.html") //登陆页面设置
                .loginProcessingUrl("/user/login") //登陆访问的路径
                .defaultSuccessUrl("/test/index").permitAll()  //登陆成功跳转到的路径
                .and().authorizeRequests().antMatchers("/","/test/hello","/user/login").permitAll() //访问这些路径时不需要登陆
                .anyRequest().authenticated() //访问其他路径需要认证
                .and().csrf().disable();//关闭csrf防护
    }

创建页面

<!DOCTYPE html>
<html lang = "en">
<head>
    <meta charset="utf-8">
    <title>Title</title>
</head>
<body>
<form action="/user/login" method="post">
    用户名：<input type="text" name="username"/>
    <br/>
    密码:<input type="text" name="password"/>
    <br/>
    <input type="submit" value="login"/>
</form>
</body>
</html>

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ZpRVNTNJ-1647763146879)(C:/Users/77/AppData/Roaming/Typora/typora-user-images/image-20220317144749302.png)]

基于角色或权限进行访问

hasAuthority 方法

如果当前的主体具有指定的权限，则返回 true,否则返回 false

在配置类中写入

.antMatchers("/test/index").hasAuthority("admins") //只有这个权限的用户才能进行访问

在UserDetailsService设置权限

  //设置一个角色权限
        List<GrantedAuthority> authorities = AuthorityUtils.commaSeparatedStringToAuthorityList("admins");

hasAnyAuthority 方法

如果当前的主体有任何提供的角色（给定的作为一个逗号分隔的字符串列表）的话，返回 true.

.antMatchers("/test/index").hasAnyAuthority("admins","manager") //只有这个权限的用户才能进行访问

hasRole 方法

如果用户具备给定角色就允许访问,否则出现 403。

如果当前主体具有指定的角色，则返回 true。

.antMatchers("/test/index").hasRole("sale") //只有这个权限的用户才能进行访问

image-20220317152354958

hasAnyRole

表示用户具备任何一个条件都可以访问。

自定义4.3

//配置跳转到自定义页面
        http.exceptionHandling().accessDeniedPage("/unauth.html");

注解使用

image-20220317154316461

@Secured

判断是否具有角色，另外需要注意的是这里匹配的字符串需要添加前缀“ROLE_“。

controller
    @GetMapping("/update")
    @Secured({"ROLE_sale","ROLE_manager"})//具有这个角色才可以访问
    public String update(){
        return "hello update";
    }

@PreAuthorize

@PreAuthorize：注解适合进入方法前的权限验证， @PreAuthorize 可以将登录用户的 roles/permissions 参数传到方法中。

image-20220317155026970

    @GetMapping("/update")
    //@Secured({"ROLE_sale","ROLE_manager"})//具有这个角色才可以访问
    @PreAuthorize("hasAnyAuthority('admins')") 
    public String update(){
        return "hello update";
    }

@PostAuthorize

@PostAuthorize 注解使用并不多，在方法执行后再进行权限验证，适合验证带有返回值的权限.

@PostFilter

@PostFilter ：权限验证之后对数据进行过滤，返回之后的数据进行过滤

    @RequestMapping("/getAll")
    @Secured({"ROLE_sale","ROLE_manager"})
    @PostFilter("filterObject.name == 'admin1'")
    @ResponseBody
    public List<Users> update1(){
        Users users = new Users(1,"admin1","123456");
        Users users1 = new Users(2,"admin2","123456");
        ArrayList<Users> arrayList = new ArrayList<>();
        arrayList.add(users);
        arrayList.add(users1);
        System.out.println(arrayList);
        return arrayList;
    }

image-20220317160749638

@PreFilter

@PreFilter: 进入控制器之前对数据进行过滤

用户注销

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
登录成功
<br>
<a href="/logout">退出</a>
</body>
</html>

//退出
http.logout().logoutUrl("/logout").logoutSuccessUrl("/test/hello").permitAll();

记住我功能

image-20220317162539579

image-20220317162550454

创建数据库

编写配置类

    //注入数据源
    @Autowired
    private DataSource dataSource;

    //生成Token
    @Bean
    public PersistentTokenRepository persistentTokenRepository(){
        JdbcTokenRepositoryImpl jdbcTokenRepository = new JdbcTokenRepositoryImpl();
        //赋值数据源
        jdbcTokenRepository.setDataSource(dataSource);
        //自动创建表
        //jdbcTokenRepository.setCreateTableOnStartup(true);
        return jdbcTokenRepository;
    }

                .and().rememberMe().tokenRepository(persistentTokenRepository()) //开启记住我
                .tokenValiditySeconds(60) //设置有效时长
                .userDetailsService(userDetailsService()) //userDetailsService

在登陆也添加复选框

    记住我:<input type="checkbox" name="remeber-me" title="记住密码"/><br/>

此处：name 属性值必须位 remember-me.不能改为其他值

CSRF

跨站请求伪造（英语：Cross-site request forgery），也被称为 one-click attack 或者 session riding，通常缩写为 CSRF 或者 XSRF， 是一种挟制用户在当前已 登录的 Web 应用程序上执行非本意的操作的攻击方法。跟跨网站脚本（XSS）相比，XSS 利用的是用户对指定网站的信任，CSRF 利用的是网站对用户网页浏览器的信任。

漏洞：简单的身份验证只能保证请求发自某个用户的浏览器，却不能保证请求本身是用户自愿发出的。

SpringSecurity 微服务权限方案

认证授权过程分析

image-20220317204000562

如果系统的模块众多，每个模块都需要进行授权与认证，所以我们选择基于token 的形式进行授权与认证，用户根据用户名密码认证成功，然后获取当前用户角色的一系列权限 值，并以用户名为 key，权限列表为 value 的形式存入 redis 缓存中，根据用户名相关信息 生成 token返回，浏览器将 token记录到 cookie 中，每次调用 api 接口都默认将 token携带 到 header 请求头中，Spring-security 解析 header 头获取 token 信息，解析 token 获取当前 用户名，根据用户名就可以从 redis 中获取权限列表，这样 Spring-security 就能够判断当前 请求是否有权限访问

权限管理数据模

image-20220317204910955

搭建Maven工程

image-20220317210745879

工具类的说明

image-20220317213044250

编写认证授权的工具类

密码处理的工具类

package com.atguigu.security.security;

import com.atguigu.utils.utils.MD5;
import org.springframework.security.crypto.password.PasswordEncoder;

public class DefaultPasswordEncoder implements PasswordEncoder {
    public DefaultPasswordEncoder() {
        this(-1);
    }
    public DefaultPasswordEncoder(int strength) {

    }
    
    //进行MD5加密
    @Override
    public String encode(CharSequence charSequence) {
        return MD5.encrypt(charSequence.toString());
    }

    //进行密码的比对
    @Override
    public boolean matches(CharSequence charSequence, String s) {
        return s.equals(MD5.encrypt(charSequence.toString()));//把加密的和不加密的进行对比
    }
}

Token管理工具类

package com.atguigu.security.security;

import io.jsonwebtoken.CompressionCodecs;
import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.SignatureAlgorithm;

import java.util.Date;
//token生成
public class TokenManager {
    //Token的有效时长
    private long tokenEcpiration = 24*60*60*1000;
    //编码的密码
    private String tokenSecurity ="123456";

    //使用JWT根据用户名生成Token
    public String createToken(String username){
        String token = Jwts.builder().setSubject(username)
                .setExpiration(new Date(System.currentTimeMillis() + tokenEcpiration))//设置有效时长
                .signWith(SignatureAlgorithm.ES512,tokenSecurity)//设置加密方式，密钥
                .compressWith(CompressionCodecs.GZIP).compact();//解压算法
        return token;
    }

    //根据Token字符串得到用户信息
    public String getUserInfoFromToken(String token){
        //解析，设置密码，传入token，得到用户信息
        String userInfo = Jwts.parser().setSigningKey(tokenSecurity).parseClaimsJws(token).getBody().getSubject();
        return userInfo;
    }

    //删除Token
    public void removeToken(String token){
        //jwttoken 无需删除，客户端扔掉即可。
    }
}

退出实现

//退出
public class TokenLogoutHandler implements LogoutHandler {

    private TokenManager tokenManager;
    @Autowired
    private RedisTemplate redisTemplate;

    //构造方法
    public TokenLogoutHandler(TokenManager tokenManager, RedisTemplate redisTemplate) {
        this.tokenManager = tokenManager;
        this.redisTemplate = redisTemplate;
    }

    //根据用户名得到token，从redis中删除token

    @Override
    public void logout(HttpServletRequest request, HttpServletResponse response, Authentication authentication) {
        //从header中获取token
        String token = request.getHeader("token");
        //token不为空，移除token，从redis中删除token
        if (token != null){
            tokenManager.removeToken(token);
            //从token获取用户名
            String username = tokenManager.getUserInfoFromToken(token);
            redisTemplate.delete(username);
        }
        ///返回数据
        ResponseUtil.out(response, R.ok());
    }
}

未授权

public class UnauthorizedEntryPoint implements AuthenticationEntryPoint {

    @Override
    public void commence(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, AuthenticationException e) throws IOException, ServletException {
        ResponseUtil.out(httpServletResponse, R.error());
    }
}

实体类

SecurityUser

package com.atguigu.security.entity;

import com.baomidou.mybatisplus.core.toolkit.StringUtils;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.authority.SimpleGrantedAuthority;
import org.springframework.security.core.userdetails.UserDetails;

import java.util.ArrayList;
import java.util.Collection;
import java.util.List;

public class SecurityUser  implements UserDetails {
    //当前登录用户
    private transient User currentUserInfo;
    //当前权限
    private List<String> permissionValueList;
    public SecurityUser() {
    }
    public SecurityUser(User user) {
        if (user != null) {
            this.currentUserInfo = user;
        }
    }
    @Override
    public Collection<? extends GrantedAuthority> getAuthorities() {
        Collection<GrantedAuthority> authorities = new ArrayList<>();
        for(String permissionValue : permissionValueList) {
            if(StringUtils.isEmpty(permissionValue)) continue;
            SimpleGrantedAuthority authority = new
                    SimpleGrantedAuthority(permissionValue);
            authorities.add(authority);
        }
        return authorities;
    }
    @Override
    public String getPassword() {
        return currentUserInfo.getPassword();
    }
    @Override
    public String getUsername() {
        return currentUserInfo.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;
    }

}

Users

package com.atguigu.security.entity;

import io.swagger.annotations.ApiModel;
import lombok.Data;

import java.io.Serializable;

@Data
@ApiModel(description = "用户实体类")
public class User implements Serializable {
    private String username;
    private String password;
    private String nickName;
    private String salt;
    private String token;
}

过滤器

认证的filter

public class TokenLoginFilter extends UsernamePasswordAuthenticationFilter {
    private TokenManager tokenManager;
    private AuthenticationManager authenticationManager;
    private RedisTemplate redisTemplate;

    public TokenLoginFilter(TokenManager tokenManager, AuthenticationManager authenticationManager, RedisTemplate redisTemplate) {
        this.tokenManager = tokenManager;
        this.authenticationManager = authenticationManager;
        this.redisTemplate = redisTemplate;
        setPostOnly(false);//只允许post的方法提交
        this.setRequiresAuthenticationRequestMatcher(new AntPathRequestMatcher("/admin/acl/login","POST"));
    }

    @Override
    public Authentication attemptAuthentication(HttpServletRequest req,
                                                HttpServletResponse res) throws AuthenticationException {
        //提交表单获取数据
        try {
            //从流中获取到用户
            User user = new ObjectMapper().readValue(req.getInputStream(), User.class);
            //返回用户的名字和密码
            return  authenticationManager.authenticate(new UsernamePasswordAuthenticationToken
                    (user.getUsername(),user.getPassword(),new ArrayList<>()));
        } catch (IOException e) {
            e.printStackTrace();
            throw  new RuntimeException();
        }
    }

    /**
     * 登录成功
     */
    @Override
    protected void successfulAuthentication(HttpServletRequest req,
                                            HttpServletResponse res, FilterChain chain,
                                            Authentication auth) throws IOException, ServletException {

        //认证成功，返回用户信息
        SecurityUser user  = (SecurityUser) auth.getPrincipal();
        //根据用户名生成token
        String token = tokenManager.createToken(user.getUsername());
        //把用户名称和权限列表放入到redis中
        redisTemplate.opsForValue().set(user.getUsername(),user.getAuthorities());
        //返回Token
        ResponseUtil.out(res, R.ok().data("token",token));
    }

    protected void unsuccessfulAuthentication(HttpServletRequest request, HttpServletResponse response, AuthenticationException failed) throws IOException, ServletException {
        ResponseUtil.out(response,R.error());
    }
}

授权过滤器

public class TokenAuthenticationFilter extends BasicAuthenticationFilter {
    private RedisTemplate redisTemplate;
    private TokenManager tokenManager;

    public TokenAuthenticationFilter(AuthenticationManager authManager, TokenManager tokenManager,RedisTemplate redisTemplate) {
        super(authManager);
        this.tokenManager = tokenManager;
        this.redisTemplate = redisTemplate;
    }
    @Override
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain chain)
            throws IOException, ServletException {
        //获取认证成功当前用户的授权信息
        logger.info("================="+request.getRequestURI());
        if(request.getRequestURI().indexOf("admin") == -1) {
            chain.doFilter(request, response);
            return;
        }
        UsernamePasswordAuthenticationToken authentication = null;
        try {
            authentication = getAuthentication(request);
        } catch (Exception e) {
            ResponseUtil.out(response, R.error());
        }
        if (authentication != null) {
            //放入权限的上下文中
            SecurityContextHolder.getContext().setAuthentication(authentication);
        } else {
            ResponseUtil.out(response, R.error());
        }
        chain.doFilter(request, response);


    }
    private UsernamePasswordAuthenticationToken getAuthentication(HttpServletRequest request) {
        //从header中获取token
        String token = request.getHeader("token");
        if (token != null || !"".equals(token.trim())) {
            //从token中获取用户名
            String username = tokenManager.getUserInfoFromToken(token);
            if(!StringUtils.isEmpty(username)){
                //从redis中获取对应的权限列表
                List<String> premissionValueList = (List<String>) redisTemplate.opsForValue().get(username);
                Collection<GrantedAuthority> authorities = new ArrayList<>();
                for (String s : premissionValueList) {
                    if (StringUtils.isEmpty(s)) continue;
                    SimpleGrantedAuthority authority = new SimpleGrantedAuthority(s);
                    authorities.add(authority);
                }
                return new UsernamePasswordAuthenticationToken(username, token, authorities);
            }
            return null;
        }
        return null;
    }
}

UserDetailsService

package com.atguigu.aclservice.service.impl;

import com.alibaba.fastjson.JSONObject;
import com.atguigu.aclservice.entity.User;
import com.atguigu.aclservice.service.PermissionService;
import com.atguigu.aclservice.service.UserService;
import com.atguigu.security.entity.SecurityUser;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.access.prepost.PreAuthorize;
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 org.springframework.util.StringUtils;

import java.util.List;

@Service("userDetailsService")
public class UserDetailServiceImpl implements UserDetailsService {
    @Autowired
    private UserService userService;
    @Autowired
    private PermissionService permissionService;
    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
        //根据用户名查询数据库
        User user = userService.selectByUsername(username);
        if (user == null){
            throw new UsernameNotFoundException("用户不存在");
        }
        com.atguigu.security.entity.User curUser = new com.atguigu.security.entity.User();
        BeanUtils.copyProperties(user,curUser);
        //根据用户查询用户权限列表信息
        List<String> permission = permissionService.selectPermissionValueByUserId(user.getId());
        SecurityUser securityUser = new SecurityUser();
        securityUser.setCurrentUserInfo(curUser);
        securityUser.setPermissionValueList(permission);
        return securityUser;
    }
}

网关

跨域问题

package com.atguigu.gateway.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.cors.CorsConfiguration;
import org.springframework.web.cors.reactive.CorsWebFilter;
import org.springframework.web.cors.reactive.UrlBasedCorsConfigurationSource;
import org.springframework.web.util.pattern.PathPatternParser;

@Configuration
public class CorsConfig {

    //解决跨域
    @Bean
    public CorsWebFilter corsWebFilter() {
        CorsConfiguration config = new CorsConfiguration();
        //该服务器运行任何类型的请求，允许任何域名来源的请求，允许携带任何请求头
        config.addAllowedMethod("*");
        config.addAllowedOrigin("*");
        config.addAllowedHeader("*");

        UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource(new PathPatternParser());
        source.registerCorsConfiguration("/**",config);

        return new CorsWebFilter(source);
    }
}
小七rrrrr
关注
  • 5
    点赞
  • 踩
  • 25
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
尚硅谷springMvc+SpringSecurity+jbpm
03-24
分布式、高并发、低耦合、服务化大型互联网企业级架构 Maven项目构建: SpringMVC + Mybatis + SpringSecurity(权限控制到方法按钮) + Rest(服务) + Webservice（服务） + Quartz（定时调度）+ Lucene(搜索引擎) + HTML5 bootstrap
尚硅谷Spring Boot整合篇（下）视频教程
03-05
尚硅谷Spring Boot整合篇（下）视频教程 想学习的朋友抓紧时间下载吧
SpringSecurity框架学习（尚硅谷的）
最新发布
m0_59690068的博客
01-07 1862
*** * springboot项目启动类* * @SpringBootApplication 它的作用是将当前类标识为 Spring Boot 应用的入口点，并启用自动配置和组件扫描。* @Slf4j 在这里就是这个作用 log.info("项目启动成功。。。。。");* @Slf4j 用于自动为类生成一个名为 “log” 的日志对象。它是 Lombok 项目中提供的一个注解，通过在类上添加 @Slf4j 注解，* 可以方便地在代码中使用日志记录功能。**/
尚硅谷-SpringSecurity
hxinx的博客
01-04 538
功能强于Shiro，但比Shiro复杂。
尚硅谷springSecurity笔记
m0_51654746的博客
06-13 1434
spring是非常流行和成功的框架，springSecurity也是spring家族中的成员，springSecurity基于spring框架，提供了一套Web应用安全性的完整解决方案关于安全方面的两个主要区域是“认证”和“授权”，一般来说，web应用的安全性包括用户认证和用户授权两个部分，这两点也是spring security重要核心功能Shiro：Apache旗下的安全框架springsecurity特点:Shiro特点：创建一个springboot的项目,并将版本修改为版本。创建过程中不需要导入任何
非常珍贵的Spring Security企业级认证与授权全套视频（自鉴过后，良心推荐）
04-02
Maven构建多项目，如何前后端，B/S A/S分离，代码结构清晰。 SpringSecurity 全套开发，设计源码解读，整个拦截器链分析，QQ登录，微信登录，短信验证，短信登录，在security基础上学习写一个自定义验证授权设计模式，整套视频讲解的分享细致认真，非常值得学习。不管小白还是老鸟，觉得能得到收获
尚硅谷spring5视频笔记.zip
04-21
《尚硅谷spring5视频笔记》是一份详尽的Spring框架第五版的学习资料，它涵盖了Spring 5的关键概念、新特性和实战应用。Spring是Java领域中最流行的企业级应用框架之一，Spring 5作为其最新版本，引入了许多重要的...
Spring5-尚硅谷框架课堂笔记.rar
08-10
《Spring5 尚硅谷框架课堂笔记》是一份深入解析 Spring 框架的珍贵资料，主要针对 Spring 5 版本进行了详尽的讲解。Spring 是一个开源的 Java 应用程序框架，它以 IoC（Inversion of Control，控制反转）和 AOP...
尚硅谷Spring Boot课堂笔记.rar
06-08
《尚硅谷Spring Boot课堂笔记》是一份详尽的Spring Boot学习资源，旨在帮助开发者深入理解和掌握这一现代Java应用开发框架。这份笔记源自尚硅谷教育机构的视频课程，视频链接为，涵盖了Spring Boot的基础知识到高级...
尚硅谷spring boot 代码及笔记
05-06
在“尚硅谷spring boot 代码及笔记”中，你将找到一系列关于 Spring Boot 的实践代码和学习笔记，这对于初学者或有一定经验的开发者来说都是宝贵的资源。 首先，Spring Boot 的核心特性包括自动配置、起步依赖和...
尚硅谷SpringBoot视频全套(核心技术篇+整合篇)
05-30
SpringBoot是企业级开发的整体整合解决方案，特别用于快速构建微服务应用，旨在用简单的方式让开发人员适应各种开发场景； 本视频着重介绍SpringBoot的使用和内部原理；内容包含微服务概念、配置文件、日志框架的使用、web开发、Thymeleaf模板引擎、Docker容器技术、MyBatis、Spring Data JPA、自定义starter等； 着重介绍SpringBoot的与各大场景的整合使用，内容包括：缓存（整合Redis），消息中间件（整合RabbitMQ），检索（整合ElasticSearch），任务（异步任务，定时任务，邮件任务），安全（整合SpringSecurity），分布式（整合Zookeeper/dubbo，整合SpringCloud），SpringBoot应用监管； 学习本套视频需要掌握SpringBoot；对于其他技术，视频包含快速入门讲解；
尚硅谷SpringBoot核心技术笔记-视频-资料（全）
12-14
尚硅谷SpringBoot核心技术笔记-视频-资料（全），里面包括尚硅谷的所有资料
收藏一套不错的讲spring security的视频教程
jackyrongvip的专栏
07-20 2743
https://www.ictgu.cn/share/1c69465d
SpringSecurity整合JWT
胡峻峥的博客
01-19 1075
一、前言 　　最近负责支付宝小程序后端项目设计，这里主要分享一下用户会话、接口鉴权的设计。参考过微信小程序后端的设计，会话需要依靠redis。相关的开发人员和我说依靠Redis并不是很靠谱，redis在业务高峰期不稳定，容易出现问题，总会出现用户会话丢失、超时的问题。之前听过JWT相关的设计，决定尝试一下。 二、什么是JWT 　　JSON Web Token（JWT）是一个开放标准（RFC ...
Spring-尚硅谷-学习笔记
weixin_45581692的博客
10-10 6299
Spring框架是一个轻量级的开源的JavaEE框架。 Spring可以解决企业应用开发的复杂性。 Spring有两个核心部分：IOC和AOP IOC：控制反转，把创建对象的过程交给Spring AOP：面向切面，不修改源代码的情况下进行功能增强 Spring特点 方便解耦，简化开发 AOP编程支持 方便程序测试 方便和其他框架进行整合
SpringSecurity-总结-尚硅谷
超级氯化钾的博客
05-27 747
文章目录配置总结尚硅谷 配置总结 @Configuration public class SecurityConfig extends WebSecurityConfigurerAdapter { @Autowired MyAccessDeniedHandler mMyAccessDeniedHandler; //403 @Autowired UserDetailServiceImpl mUserDetailsService; //自定义认证逻辑 @Autow
5、Spring Boot尚硅谷笔记整理高级篇-安全
∑
11-08 1202
五、Spring Boot与安全 安全、Spring Security 一、安全 Spring Security是针对Spring项目的安全框架，也是Spring Boot底层安全模 块默认的技术选型。他可以实现强大的web安全控制。对于安全控制，我们仅 需引入spring-boot-starter-security模块，进行少量的配置，即可实现强大的 安全管理。 几个类： WebSecurity...
尚硅谷springsecurity笔记
06-28
以下是一些我在学习和使用 Spring Security 过程中的笔记和心得： 1. Spring Security 的核心是安全过滤器链（Security Filter Chain），它是一组过滤器，每个过滤器都负责某种安全任务。Spring Security 的默认...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

小七rrrrr

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值