Spring Security 登录认证

已于 2024-01-16 09:40:45 修改
阅读量1.3k 收藏 23
点赞数 32
分类专栏： Spring 文章标签： spring java mysql spring boot
于 2024-01-13 17:16:06 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45722666/article/details/135567464
版权

学习 Spring Security 登录认证 

        学习在 JAVA 开发中如何使用 Spring Security 做登录认证

        注意：下方代码中的注释为重点

 1.介绍

  • Spring Security是 Spring 全家桶中的一个安全管理框架。相比与另外一个安全框架Shiro，它提供了更丰富的功能，社区资源也比 Shiro 丰富活跃；
  • 一般情况分布式开发和一些大型项目会选择使用 SpringSecurity ,对于一些中小型的单体项目多数会选择更加容易上手的 Shiro 或者 JWT + Token 使用 WebMvcConfigurer 去进行认证登录。
  • 一般Web应用的需求就是进行 认证 和 授权 。
    • 认证：验证当前访问系统的用户是否为本系统的用户，并且要确认具体是哪个用户。
    • 授权：经过认证后判断当前用户所拥有的权限，或者是否有权限进行某个操作。

认证 和 授权 也是 SpringSecurity 安全框架的核心功能。

官网链接：Spring Security :: Spring Security

 2.快速入门

2-1.准备工作

创建一个SpringBoot项目，这里就不过多介绍了

2-1-1.pom.xml 文件
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <!-- fastjson -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>2.0.22</version>
        </dependency>
        <!--        数据源-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
            <version>1.2.4</version>
        </dependency>
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.5.1</version>
        </dependency>
        <!--        redis-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-pool2</artifactId>
        </dependency>
        <!--        jwt-->
        <dependency>
            <groupId>io.jsonwebtoken</groupId>
            <artifactId>jjwt</artifactId>
            <version>0.9.0</version>
        </dependency>
2-1-2.配置数据源 yml 文件
server:
  port: 5210

spring:
  application:
    name: spring-security

  datasource:
    type: com.alibaba.druid.pool.DruidDataSource
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/db_name?serverTimezone=Asia/Shanghai&useUnicode=true&characterEncoding=utf-8&zeroDateTimeBehavior=convertToNull&useSSL=false&allowPublicKeyRetrieval=true
    username: 数据库用户名
    password: 数据库密码
    druid:
      initial-size: 5
      min-idle: 5
      max-active: 20
      max-wait: 6000
      time-between-eviction-runs-millis: 60000
      min-evictable-idle-time-millis: 30000
      test-on-borrow: false
      test-on-return: false
      pool-prepared-statements: true
      max-pool-prepared-statement-per-connection-size: 20

  redis:
    # Redis服务器地址
    host: 127.0.0.1
    # Redis服务器端口号
    port: 6379
    # 连接超时时间
    timeout: 1800000
    # 设置密码
    password: root
    # 使用的数据库索引，默认是0
    database: 0
    lettuce:
      pool:
        # 最大阻塞等待时间，负数表示没有限制
        max-wait: -1
        # 连接池中的最大空闲连接
        max-idle: 5
        # 连接池中的最小空闲连接
        min-idle: 0
        # 连接池中最大连接数，负数表示没有限制
        max-active: 20


mybatis-plus:
  mapper-locations: classpath:mapper/**/*.xml
  typeAliasesPackage: com.pojo
  configuration:
    # 驼峰命名
    map-underscore-to-camel-case: true
    cache-enabled: false
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl #日志
  global-config:
    db-config:
      column-underline: true
      id-type: auto
2-1-3自定义 jwt 工具类
@Slf4j
public class JwtUtil {
    private static final long time = 1000 * 60 * 60 * 24 * 7;//有效期7天
    private static final String key = "java_utils_jwt";
    private static SignatureAlgorithm signatureAlgorithm = SignatureAlgorithm.HS256;

    /**
     * 生成密钥
     */
    public static SecretKey getKey() {
        //自定义 key 的编码 采用 base64 编码加密
        String encode = new BASE64Encoder().encode(key.getBytes());
        //根据key生成签名密钥
        byte[] bytes = DatatypeConverter.parseBase64Binary(encode);
        SecretKeySpec secretKeySpec = new SecretKeySpec(bytes, signatureAlgorithm.getJcaName());
        return secretKeySpec;
    }

    /**
     * 生成 token
     */
    public static String getToken(Integer id) {
        return Jwts.builder()
                .setHeaderParam("Type", "JWT")
                .setId(UUID.randomUUID().toString())
                .setSubject("user_login")
                .claim("userId", id)
                .setExpiration(new Date(System.currentTimeMillis() + time))
                .signWith(signatureAlgorithm, JwtUtil.getKey())
                .compact();
    }

    /**
     * 解析 token
     */
    public static Claims parserToken(String token) {
        byte[] bytes = DatatypeConverter.parseBase64Binary(new BASE64Encoder().encode(key.getBytes()));
        return Jwts.parser()
                .setSigningKey(bytes)
                .parseClaimsJws(token)
                .getBody();
    }

    /**
     * 获取 token 中的用户信息
     */
    public static Integer getUserId(String token) {
        Claims claims = parserToken(token);
        Integer id = (Integer) claims.get("userId");
        return id;
    }
}
2-1-4.自定义RedisConfig类
@Configuration
public class RedisConfig {

    @Bean
    public RedisTemplate<String, Object> redisTemplate(
            RedisConnectionFactory redisConnectionFactory) {
        RedisTemplate<String, Object> template = new RedisTemplate<>();

        GenericFastJsonRedisSerializer serializer = new GenericFastJsonRedisSerializer();

        // value值的序列化采用fastJsonRedisSerializer
        template.setValueSerializer(serializer);
        template.setHashValueSerializer(serializer);
        // key的序列化采用StringRedisSerializer
        template.setKeySerializer(new StringRedisSerializer());
        template.setHashKeySerializer(new StringRedisSerializer());
        template.setConnectionFactory(redisConnectionFactory);
        return template;
    }


}
2-1-5.RedisUtils类
public class RedisUtils {

    /* 登录用户token值 */
    public static final String LOGIN_USER_ID = "login_user_id_";
    public static final long TOKEN_TIMES = 4;//小时
    public static final long TOKEN_LONG_TIME = 7;//天


}
2-1-6.User实体类
@Data
@TableName("java_user")
public class User {

    @TableId(value = "id", type = IdType.AUTO)
    private Integer id;
    /**
     * 登录名
     */
    private String loginName;
    /**
     * 登录密码(明文)
     */
    private String loginPwd;
    /**
     * 角色id
     */
    private Integer roleId;
    /**
     * 密文
     */
    private String password;
    /**
     * 姓名
     */
    private String name;

    /**
     * 联系方式
     */
    private String phone;
    /**
     * 身份证号
     */
    private String idCard;
    /**
     * 年龄
     */
    private Integer age;
    /**
     * 性别： 0.女 1.男
     */
    private Integer sex;
    /**
     * 是否启用： 0.未启用  1.启用
     */
    private Integer isEnable;
    /**
     * 创建时间
     */
    private Date insDate;
    /**
     * 修改时间
     */
    private Date updDate;
    /**
     * 是否删除：0.未删除 1.删除
     */
    @TableLogic(value = "0",delval = "1")
    private Integer isDel;


    /*
     * 非表字段
     * */
    @TableField(exist = false)
    private String title;
    @TableField(exist = false)
    private String token;
}

2-2.启动项目测试

2-3.开始Security

2-3-1.添加 SpringSecurity 依赖
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-security</artifactId>
</dependency>

如果SpringBoot是2.5.x版本，那么Spring Security的版本是5.5

如果SpringBoot是2.7.x版本，那么Spring Security的版本是5.7

2-3-2.重新启动测试

这里可以看到我们重新访问刚才的 /login/test 路径会自动跳转到登录页面，

默认用户名：user  ，密码在启动项目的控制台中：

登录后就会重新访问到我们的接口并返回数据：

2-3-3.退出登录

访问 http://localhost:5210/logout

点击上面的 Log Out 按钮则会退出登录，重新访问刚才的测试接口就会从新回到登录页面进行登录认证功能。

2-4.认证流程

系统中肯定会存在大量的用户信息，security如何确认当前登录系统的是哪一个用户呢？

Authentication： 存储了认证信息，代表当前登录用户。

使用方法：

        通过 SecurityContext 来获取 Authentication，SecurityContext就是我们的上下文对象，SecurityContext 对象是交给 SecurityContextHolder 进行管理，你可以在程序任何地方拿到它。

Authentication authentication = SecurityContextHolder.getContext().getAuthentication();

原理：使用 ThreadLocal 线程来保证传递同一个对象。

  • UsernamePasswordAuthenticationFilter：是最常用的用户名和密码认证方式的主要处理类,构造了一个UsernamePasswordAuthenticationToken对象实现类，将用请求信息封装为Authentication
  • BasicAuthenticationFilter：将UsernamePasswordAuthenticationToken封装成的 Authentication进行登录逻辑处理
  • ExceptionTranslationFilter：主要处理认证和授权的异常
  • FilterSecurityInterceptor：负责权限校验
  • 等。。。

参考地址： Spring Security Reference

3.整合mysql、redis、jwt 进行登录认证 - 核心代码

3-1.实现 UserDetailsService 类

1.创建一个类实现 UserDetailsService

2.重写 loadUserByUsername 方法

3.通过用户名从数据库中查询用户信息

@Service
public class UserDetailsServiceImpl implements UserDetailsService {
    @Resource
    private UserMapper userMapper;
    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
        //（认证，即校验该用户是否存在）查询用户信息
        LambdaQueryWrapper<User> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(User::getLoginName,username);
        User user = userMapper.selectOne(queryWrapper);
        //如果没有查询到用户
        if (Objects.isNull(user)){
            throw new RuntimeException("用户名或者密码错误");
        }


        // (授权，即查询用户具有哪些权限)查询对应的用户信息

        return new LoginUserDetails(user);
    }
}

因为UserDetailsService方法的返回值是UserDetails类型，所以需要定义一个类，实现该接口，把用户信息封装在其中。

如果你想让用户的密码是明文存储，需要在密码前加 {noop}

@Data
@NoArgsConstructor
@AllArgsConstructor
public class LoginUserDetails implements UserDetails {

    private User user;

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

    @Override
    public String getPassword() {
        return user.getPassword();
    }

    @Override
    public String getUsername() {
        return user.getLoginName();
    }

    //是否未过期
    @Override
    public boolean isAccountNonExpired() {
        return true;
    }

    //是否未锁定
    @Override
    public boolean isAccountNonLocked() {
        return true;
    }

    //凭证是否未过期
    @Override
    public boolean isCredentialsNonExpired() {
        return true;
    }

    //是否可用
    @Override
    public boolean isEnabled() {
        return true;
    }
}

3-2.密码加密存储

        在实际开发项目中明文密码一般不会存储在数据库中，默认使用的PasswordEncoder要求数据库中的密码格式为：{id}password 。它会根据id去判断密码的加密方式。但是我们一般不会采用这种方式。所以就需要替换PasswordEncoder。

        使用 BCryptPasswordEncoder 进行替换

        使用的时候把 BCryptPasswordEncoder 对象注入Spring容器中，SpringSecurity就会使用当前的 PasswordEncoder 来进行密码校验。

3-2-1.配置config类继承 WebSecurityConfigurerAdapter 

@Configuration
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter implements WebMvcConfigurer {

    /*
    * 默认使用的PasswordEncoder要求数据库中的密码格式为：{id}password ，它会根据id去判断密码的加密方式（一般不会采用这种方式），
    *   所以就需要替换PasswordEncoder，我们一般使用SpringSecurity为我们提供的BCryptPasswordEncoder。
    *
    * 只需要使用把BCryptPasswordEncoder对象注入Spring容器中，SpringSecurity就会使用该PasswordEncoder来进行密码校验。
    * */
    @Bean
    public PasswordEncoder passwordEncoder(){
        return new BCryptPasswordEncoder();
    }


}

3-3.登录接口

重点：下文放行登录接口一定要注意config文件的变化

  1. 登录接口一定要走security的过滤器连，在自定义的认证过滤器中进行访问路径判断放行方式。（因为整个过程中，还有其他事情要做。 登录成功之后，将用户用户数据存在 SecurityContextHolder 中 ，如果没走 Security 过滤器链 无法通过 SecurityContextHolder 获取到登录用户信息，因此其他的请求还是会被拦截）
  2. 静态资源采用白名单方式，重写 configure(WebSecurity web) 方法。（登录接口不可在这里配置）
3-3-1.配置 config

        在接口中我们通过AuthenticationManager的authenticate方法来进行用户认证,所以需要在SecurityConfig中配置把AuthenticationManager注入容器。认证成功的话使用JWT生成一个token放在返回中，下次用户请求直接在头部信息中加入token一起请求可以通过JWT识别当前登录的用户。

@Configuration
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {

    @Bean
    public PasswordEncoder passwordEncoder(){
        return new BCryptPasswordEncoder();
    }

    @Bean
    @Override
    public AuthenticationManager authenticationManagerBean() throws Exception {
        return super.authenticationManagerBean();
    }


    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
                //关闭csrf
                .csrf().disable()
                //不通过Session获取SecurityContext
                .sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS)
                .and()
                //过滤请求
                .authorizeRequests()
                // 静态资源或者放行接口 允许匿名访问
                .antMatchers("/login/user_login").permitAll()
                //options 方法的请求放行
                .antMatchers(HttpMethod.OPTIONS).permitAll()
                // 除上面外的所有请求全部需要鉴权认证
                .anyRequest().authenticated();


    }


}
3-3-2.编写Controller 接口
@RestController
@RequestMapping("/login")
public class LoginController {
    
    @Resource
    private LoginService loginService;

    @PostMapping("/user_login")
    public Map<String,Object> user_login(@RequestBody LoginVo loginVo){
        return loginService.user_login(loginVo);
    }

}
3-3-3. LoginVo 传参实体类对象
@Data
public class LoginVo {
    private String loginName;
    private String loginPwd;
}
3-3-4. LoginServiceImpl 业务实现类
@Service
public class LoginServiceImpl implements LoginService {

    @Resource
    private AuthenticationManager authenticationManager;

    @Resource
    private RedisTemplate redisTemplate;

    @Override
    public Map<String,Object> user_login(LoginVo loginVo) {
        Map<String,Object> map = new HashMap<>();

        //通过UsernamePasswordAuthenticationToken获取用户名和密码
        UsernamePasswordAuthenticationToken authenticationToken = new UsernamePasswordAuthenticationToken(loginVo.getLoginName(), loginVo.getLoginPwd());
        //AuthenticationManager委托机制对authenticationToken 进行用户认证
        Authentication authenticate = authenticationManager.authenticate(authenticationToken);

        //如果认证没有通过，给出对应的提示
        if (Objects.isNull(authenticate)) {
            map.put("err","用户名或密码错误");
        }

        //如果认证通过，使用user 通过 jwt 生成 token 返回token
        //拿到这个当前登录用户信息
        LoginUserDetails loginUserDetails = (LoginUserDetails) authenticate.getPrincipal();
        //获取当前用户的user
        User user = loginUserDetails.getUser();

        String token = JwtUtil.getToken(user.getId());
        user.setToken(token);

        //置空密码 ： 我这边使用了保存明文密码，所以这边要隐藏明文密码，实际开发一般不选择保存明文密码
        user.setLoginPwd(null);

        //将完整的用户信息存入redis缓存
        redisTemplate.opsForValue().set(RedisUtils.LOGIN_USER_ID + user.getId(), user, RedisUtils.TOKEN_TIMES, TimeUnit.HOURS);

        map.put("code",200);
        map.put("msg","认证成功");
        map.put("token",token);

        return map;
    }
}
3-3-5.自定义认证过滤器 实现 OncePerRequestFilter
@Slf4j
@Component
public class AuthenticationTokenFilter extends OncePerRequestFilter {

    @Resource
    private RedisTemplate redisTemplate;

    @Override
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException {

        //放行登录接口
        String requestURI = request.getRequestURI();
        if (requestURI.equals("/login/user_login")){
            filterChain.doFilter(request, response);
            return;
        }

        //获取token
        String token = request.getHeader("token");
        if (token == null || token.equals("")) {
            this.return_message(response, 501, "请登录!");
            return;
        } else {
            token = token.replace("Bearer ", "");
        }

        //解析token 获取userId
        Integer userId = null;
        try {
            userId = JwtUtil.getUserId(token);
        } catch (Exception e) {
            this.return_message(response, 501, "非法登录令牌！");
            return;
        }

        //从redis中获取用户信息
        User user = (User) redisTemplate.opsForValue().get(RedisUtils.LOGIN_USER_ID + userId);
        if (Objects.isNull(user)) {
            this.return_message(response, 501, "未登录！");
            return;
        }

        //封装Authentication对象存入SecurityContextHolder && 获取权限信息封装到Authentication中
        UsernamePasswordAuthenticationToken authenticationToken = new UsernamePasswordAuthenticationToken(user, null, null);
        SecurityContextHolder.getContext().setAuthentication(authenticationToken);

        //放行
        filterChain.doFilter(request, response);
    }

    /*
     * 返回信息
     * */
    public void return_message(HttpServletResponse response, Integer code, String msg) {
        Map<String,Object> map = new HashMap<>();
        map.put("code",code);
        map.put("msg",msg);
        String s = JSON.toJSONString(map);
        response.setContentType("application/json");
        response.setCharacterEncoding("UTF-8");
        PrintWriter writer = null;
        try {
            writer = response.getWriter();
        } catch (IOException e) {
            log.info("信息返回异常:{}",e);
        }
        writer.write(s);
    }

}

 把token校验过滤器添加到过滤器链中

@Configuration
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {

    @Bean
    public PasswordEncoder passwordEncoder(){
        return new BCryptPasswordEncoder();
    }

    @Bean
    @Override
    public AuthenticationManager authenticationManagerBean() throws Exception {
        return super.authenticationManagerBean();
    }

    @Resource
    private AuthenticationTokenFilter authenticationTokenFilter;


    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
                //关闭csrf
                .csrf().disable()
                //不通过Session获取SecurityContext
                .sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS)
                .and()
                //过滤请求
                .authorizeRequests()
                // 静态资源或者放行接口 允许匿名访问
                .antMatchers("/login/user_login").permitAll()
                //options 方法的请求放行
                .antMatchers(HttpMethod.OPTIONS).permitAll()
                // 除上面外的所有请求全部需要鉴权认证
                .anyRequest().authenticated();

        //把token校验过滤器添加到过滤器链中
        http.addFilterBefore(authenticationTokenFilter, UsernamePasswordAuthenticationFilter.class);


    }


}
3-3-6.放行登录接口
@Configuration
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {

    /*
     * 静态资源
     * */
    String[] state_url = new String[]{
            "/favicon.ico",
    };

    /*
    * 白名单 -> HttpSecurity 中的 antMatchers(state_url).permitAll() 只是放行security过滤器链中的拦截
    *  WebSecurity -> mvc放行所有的拦截 : 不会再走security的过滤器链
    * */
    @Override
    public void configure(WebSecurity web) throws Exception {
        web.ignoring().antMatchers(state_url);
    }

    @Resource
    private AuthenticationTokenFilter authenticationTokenFilter;

    /*
    * 注意： /login/user_login 登录接口必须要走 Security 过滤器链，因为在这个过程中，还有其他事情要做。 登录成功之后，将用户用户数据存在 SecurityContextHolder 中
    *   如果没走 Security 过滤器链 无法通过 SecurityContextHolder 获取到登录用户信息，因此请求还是会被拦截
    * */
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
                //关闭csrf
                .csrf().disable()
                //不通过Session获取SecurityContext
                .sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS)
                .and()
                //过滤请求
                .authorizeRequests()
                // 静态资源或者放行接口 允许匿名访问
                .antMatchers("/login/user_login").permitAll()
                //options 方法的请求放行
                .antMatchers(HttpMethod.OPTIONS).permitAll()
                // 除上面外的所有请求全部需要鉴权认证
                .anyRequest().authenticated();

        //把token校验过滤器添加到过滤器链中
        http.addFilterBefore(authenticationTokenFilter, UsernamePasswordAuthenticationFilter.class);

    }


    @Bean
    @Override
    public AuthenticationManager authenticationManagerBean() throws Exception {
        return super.authenticationManagerBean();
    }


    @Bean
    public PasswordEncoder passwordEncoder(){
        return new BCryptPasswordEncoder();
    }



}

3-4.退出登录

        只需要定义一个登陆接口，然后获取SecurityContextHolder中的认证信息，删除redis中对应的数据即可。

    @PostMapping("/user_login_out")
    public Map<String,Object> user_login_out(){
        return loginService.user_login_out();
    }
    @Override
    public Map<String, Object> user_login_out() {
        //从SecurityContextHolder中的userid
        Authentication authentication = SecurityContextHolder.getContext().getAuthentication();
        User user= (User) authentication.getPrincipal();
        //从缓存中删除当前用户登录信息
        redisTemplate.delete(RedisUtils.LOGIN_USER_ID + user.getId());

        Map<String, Object> map = new HashMap<>();
        map.put("code",200);
        map.put("msg","退出成功");
        return map;
    }

4.测试认证

我这边测试使用测试工具 Postman

1.测试未登录状态访问 /login/test

2.测试登录接口（明文密码测试认证失败的去查看下面的解决异常里面）

3.登录状态下访问 /login/test

4.测试退出登录

5.授权

         授权功能请参考：Spring Security 授权-CSDN博客

0.解决异常

0-1.解决跨域问题

        浏览器出于安全的考虑，发起 HTTP请求时必须遵守同源策略，否则就是跨域的HTTP请求，默认情况下是被禁止的。 同源策略要求源相同才能正常进行通信，即协议、域名、端口号都完全一致。

        前后端分离开发项目中一般是不同源的 （域名，端口...不一致）产生跨域问题

 我这边曹勇同一个 config 进行配置，也可将其分开。

0-1-1.配置上文中的  SecurityConfig
@Configuration
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter implements WebMvcConfigurer {

    //此处为上文中 Security 的配置，省略。。。

    @Override
    public void addCorsMappings(CorsRegistry registry) {
        //允许跨域请求的路径
        registry.addMapping("/**")
                // 设置允许跨域请求的域名
                .allowedOrigins("*")
                // 是否允许cookie
                .allowCredentials(true)
                // 设置允许的请求方式
                .allowedMethods("*")
                // 设置允许的header属性
                .allowedHeaders("*")
                // 跨域允许时间
                .maxAge(3600);
    }

}
 0-1-2.开启SpringSecurity的跨域访问
@Configuration
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter implements WebMvcConfigurer {

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
                //关闭csrf
                .csrf().disable()
                //不通过Session获取SecurityContext
                .sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS)
                .and()
                //过滤请求
                .authorizeRequests()
                // 静态资源或者放行接口 允许匿名访问
                .antMatchers("/login/user_login").permitAll()
                //options 方法的请求放行
                .antMatchers(HttpMethod.OPTIONS).permitAll()
                // 除上面外的所有请求全部需要鉴权认证
                .anyRequest().authenticated();

        //把token校验过滤器添加到过滤器链中
        http.addFilterBefore(authenticationTokenFilter, UsernamePasswordAuthenticationFilter.class);

        //允许跨域(开启跨域)
        http.cors();
    }

}

0-2.明文密码认证失败

数据库保存明文密码，密码前面加 {noop} ,但是使用明文密码认证还是失败原因：

        在SpmingSecunty升级到新版本(SpringBoot2x)后,因为默以把之前的明文方式给去挂了所以在对授权客户端的密码进行加密时可能就会出现 Encoded password does not look like BCrypt 异常问题。

    @Resource
    private UserDetailsService userDetailsService;
    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        auth.userDetailsService(userDetailsService).passwordEncoder(NoOpPasswordEncoder.getInstance());
    }

此时数据库中的密码需要去掉 {noop} 

注意：

        如果在config中加入上面的方法，则数据库保存的密码要一定是明文密码，此时数据库中保存的密码如果为加密后的密文，则会认证失败。想要换成密文存储方式就把上面config中加入的配置给注释掉或删掉。（并且此方法已经过时）

        个人推荐使用密文存储方式。

        本文亲测有效！！！

        本文到此也就结束了，文章中给大家简单的介绍了使用的方法，其他的一些细节问题需要大家进行细节优化。欢迎大家评论区留言一起探讨学习。

spring security认证过程详解
CVPR收割机的博客
04-18 4256
在 Web 应用中这是通过 SecurityContextPersistentFilter 实现的，默认情况下其会在每次请求开始的时候从 session 中获取 SecurityContext，然后把它设置给 SecurityContextHolder，在请求结束后又会将 SecurityContextHolder 所持有的 SecurityContext 保存在 session 中，并且清除 SecurityContextHolder 所持有的 SecurityContext。
Spring Security进行登录认证和授权
afjja的博客
08-19 5984
我们要定制化实现接口来达到从数据库查询用户信息，所以重新写一个实现类。然后认证通过使用用户id生成一个jwt（也就是token），然后用userId作为key,用户信息作为value存入redis中。用户第一次登陆认证流程如下图。导入依赖
SpringSecurity登录认证流程
爱敲键盘的程序源的博客
11-19 1002
SpringSecurity登录认证流程
SpringSecurity认证流程详解和代码实现
qq_44749491的博客
06-29 1万+
/ 封装该用户拥有的权限信息，这里还只是讲认证，所以直接返回null跳过 @Override public Collection
SpringSecurity-用户认证
2302_76552486的博客
09-25 1462
SpringSecurity实现用户认证过程
SpringSecurity用户认证
m0_62787705的博客
06-06 846
Spring 是非常流行和成功的 Java 应用开发框架，Spring Security 正是 Spring 家族中的成员。Spring Security 基于 Spring 框架，提供了一套 Web 应用安全性的完整解决方案。正如你可能知道的关于安全方面的两个核心功能是“认证”和“授权”，一般来说，Web 应用的安全性包括**用户认证（Authentication）和用户授权（Authorization）**两个部分，这两点也是 SpringSecurity 重要核心功能。
（新）Spring Security如何实现登录认证（实战篇）
weixin_55772633的博客
06-15 3448
①编写实现类去实现UserDetailsService接口，然后重写里面的loadUserByUsername()方法，用来用来在数据库中查询用户信息并且封装到UserDetail对象中。其中UserDetail是个接口，我们需要编写相应的实体类去实现这个接口。详细内容如4.2.1、4.2.2②更改密码加密存储模式，这时我们就可以使用Spring Security默认提供的登录接口localhost:8080/login来尝试登陆。详细内容如：4.2.3③如何登陆接口？
Spring Security 用户认证的方式
qq_60458298的博客
03-22 1077
这里的角色只是一个字符串，可以自定义，可以根据自己的业务需要指定不同的角色。在configure(AuthenticationManagerBuilder auth)方法中，我们使用ldapAuthentication()方法来启用基于LDAP的认证，并通过userDnPatterns()方法来指定用户DN的格式，groupSearchBase()方法和groupRoleAttribute()方法用于指定LDAP中的组信息，contextSource()方法用于指定LDAP服务器的URL和管理员账号密码。
Spring Cloud Gateway 整合 Spring Security 统一登录认证鉴权
02-24
在压缩包文件`spring_gateway_security_webflux`中，可能包含了示例代码或配置文件，用于演示如何在Spring Cloud Gateway中集成Spring Security，实现统一登录认证鉴权。这些资源可以帮助开发者更快地理解和实践上述...
基于Spring Security的JWT实现登录认证及多账号登录互斥设计源码
最新发布
10-09
本项目为基于Spring Security框架实现的JWT登录认证系统源码，涵盖41个Java源文件、3个XML配置文件、1个Git忽略文件、1个Markdown文件和1个YAML配置文件，共计48个文件。系统支持单账号登录和多账号登录互斥功能，...
【智能排班系统】基于SpringSecurity实现登录验证、权限验证
记录一名在读研究生的学习笔记、感悟、开发产物
04-06 1455
本文介绍了Spring Security在Java应用中的使用，特别是其在身份验证和授权方面的强大功能。通过整合Spring Security，开发者能简便地实施细粒度的权限控制，适合拥有多种用户角色（如系统管理员、门店管理员、普通员工）的应用场景。文章还探讨了如何利用JWT进行用户认证管理，展示了关键的工具类实现，包括JWT生成与解析、密码加密及用户上下文管理等技术细节。此外，还提到了基于Redis的会话管理和IP流量控制的配置示例。
【使用springsecurity实现登录、认证、授权】
qq_39445235的博客
09-22 512
使用springsecurity实现登录、认证、授权
springboot3整合SpringSecurity实现登录校验与权限认证（万字超详细讲解）
热门推荐
2301_78646673的博客
12-11 1万+
用户提交登录请求Spring Security 将请求交给 UsernamePasswordAuthenticationFilter 过滤器处理。UsernamePasswordAuthenticationFilter 获取请求中的用户名和密码，并生成一个 AuthenticationToken 对象，将其交给 AuthenticationManager 进行认证。
Spring Security登录的认证和授权
S mile0804的博客
02-21 4391
一、Spring Security简介 Spring Security是一个专注于为Java应用程序提供身份认证和授权的框架，是一个能够为基于Spring的企业应用系统提供声明式的安全访问控制解决方案的安全框架。它提供了一组可以在Spring应用上下文中配置的Bean，充分利用了Spring IoC，DI（控制反转Inversion of Control ,DI:Dependency Injection 依赖注入）和AOP（面向切面编程）功能，为应用系统提供声明式的安全访问控制功能，减少了......
SpringBoot security 安全认证（一）——登录验证
朗朗的博客
02-01 2163
本节内容：使用springboot自动security模块实现用户登录验证功能；登录过程如下图：AuthenticationManager内容实现用户账号密码验证，还可以对用户状态（启用/禁用），逻辑删除，账号是否被锁定等判断。密码默认使用BCryptPasswordEncoder。那么我们在用户注册时密码要使用 new BCryptPasswordEncoder().encode(pwd)进行加密。代码实现过程：1、引入相关依赖；2、创建UserDetails实现类LoginUser；
一文梳理SpringSecurity中的登录认证流程
heshengfu1211的博客
03-20 5167
想要在基于SpringSecurity的SpringBoot项目中实现多种自定义的登录认证方式，先把一文梳理SpringSecurity中的登录认证流程中基于用户名密码模式的登录认证搞懂了再说！
Spring Security+Redis实现登录
sky2019116的博客
02-03 1467
Spring Security是一个基于Spring框架的安全框架，它提供了一套完整的认证和授权机制，可以方便地实现登录功能需要实现UserDetails接口，并重写其中方法和定义一下自己需要用到的属性。@Data/** 用户唯一标识 *//** 登陆时间 *//** 过期时间 *//** 登录IP地址 *//** 浏览器类型 *//** 操作系统 *//** 用户信息 */@Override@Override/*** 账户是否未过期,过期无法验证*/
SpringSecurity认证添加pom.xml依赖，实现MP代码生成，创建配置Controller，自定义MD5加密，BCryptPasswordEncoder密码编码器，以及CSRF防御
qq_73126462的博客
01-22 1273
创建自定义MD5加密类并实现@Override//对密码进行 md5 加密​@Override// 通过md5校验修改@Bean// 自定义MD5加密方式：数据库中的用户密码也需要更换成对应自定义MD5//MD5自定义加密方式：最后，将生成的MD5加密密码保存到数据库表中。CSRF，跨站请求伪造）是一种利用用户已登录的身份在用户不知情的情况下发送恶意请求的攻击方式。
Spring Security 登录认证傻瓜教程
08-27
Spring Security登录认证可以分为首次登录认证和二次token认证。 首次登录认证需要用户提供用户名、密码和验证码进行登录。首先，用户需要输入用户名和密码，并且输入验证码。用户输入的信息会被用于进行身份认证，判断用户是否合法。 在实现首次登录认证之前，需要进行一些准备工作。首先，需要导入相关的依赖，包括spring-boot-starter-data-redis、kaptcha和hutool-all。这些依赖会提供所需的功能，比如操作Redis、生成验证码等等。 然后，需要配置Spring Security的配置文件和service层。在配置文件中，需要处理Spring Security的相关配置，比如设置登录路径、认证成功后的跳转页面等。在service层，需要处理用户登录的逻辑，包括验证用户名和密码是否匹配等。 此外，还需要自定义异常处理。可以创建一个继承自AuthenticationException的Custom_RuntimeException类，用于处理用户登录时出现的异常。该异常类可以被CustomAuthenticationFailureHandler接收并进行处理。 总结起来，Spring Security登录认证包括首次登录认证和二次token认证。在首次登录认证中，用户需要提供用户名、密码和验证码进行身份认证。在实现登录认证之前，需要进行相关的准备工作，包括导入依赖、配置Spring Security和处理异常。<span class="em">1</span><span class="em">2</span><span class="em">3</span> #### 引用[.reference_title] - *1* [傻瓜式使用SpringSecurity完成前后端分离+JWT+登录认证+权限控制](https://blog.csdn.net/weixin_46684099/article/details/117434577)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_1"}}] [.reference_item style="max-width: 50%"] - *2* *3* [SSM-SpringSecurity进阶](https://blog.csdn.net/weixin_45203607/article/details/120251445)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_1"}}] [.reference_item style="max-width: 50%"] [ .reference_list ]
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值