SpringSecurity(五):前后端分离认证总结案例。

最新推荐文章于 2023-07-10 19:58:22 发布
最新推荐文章于 2023-07-10 19:58:22 发布
阅读量1.1k 收藏 1
点赞数 1
文章标签： redis java spring boot spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45852626/article/details/131454099
版权

前后端分离认证总结案例

前言

和上一篇一样，从上倒下复制粘贴，所有代码贴完再运行，代码没有问题，只要贴对，都可以顺利跑出来的。

难点分析

前端系统给后端传递的数据为json，就会导致后端系统不能再用request.getParameter获取用户数据。
所以我们要将请求中json格式转换为对象，提取用户数据，然后进行认证。
在web传统项目进行认证请求时，底层调用的是FormLoginConfigurer，里面用UsernamePasswordAuthenticationFilter过滤器中的attempAuthentication试图认证的方法进行处理。下面看一下关键代码：

	if (this.postOnly && !request.getMethod().equals("POST")) {
			throw new AuthenticationServiceException("Authentication method not supported: " + request.getMethod());
		}
		String username = obtainUsername(request);
		username = (username != null) ? username.trim() : "";
		String password = obtainPassword(request);
		password = (password != null) ? password : "";
		UsernamePasswordAuthenticationToken authRequest = UsernamePasswordAuthenticationToken.unauthenticated(username,
				password);

我们可以看到，在前后端分离项目中，上面获取用户名和密码的方式肯定是不可以的（基于request请求获取）。
所以我们就不能再用传统的formLogin中的AuthenticationFilter，我们 要把这个filter做一个重写。

重写的重点是如何获取参数的信息，而且要想有认证功能，最后还是要调用return this.getAuthenticationManager().authenticate(authRequest);这行代码。

实现的思路：
创建一个UsernamePasswordAuthenticationFilter的子类实现，让字类去替换attempAuthentication。

我们确定了UsernamePasswordAuthenticationFilter不适合作为我们要用的过滤器，所以我们自己创建一个名为LoginFilter的过滤器。
但是security里面是有一系列的过滤器的，我们要确保LoginFilter替换UsernamePasswordAuthenticationFilter后位置不变。
请添加图片描述

Controller层

TestController方法：

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class test {

    @GetMapping("/test")
    public String test(){
        System.out.println("test.....");
        return "test OK!";
    }
}

eneity层

Role



public class Role {
    private Integer id;
    private String name;
    private String nameZh;


    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getNameZh() {
        return nameZh;
    }

    public void setNameZh(String nameZh) {
        this.nameZh = nameZh;
    }
}

User



import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.authority.SimpleGrantedAuthority;
import org.springframework.security.core.userdetails.UserDetails;

import java.util.*;


public class User implements UserDetails {
        private Integer id;
        private String username;
        private String password;
        private Boolean enabled;
        private Boolean accountNonExpired;
        private Boolean accountNonLocked;
        private Boolean credentialsNonExpired;
        private List<Role> roles = new ArrayList();
        @Override
        public Collection<? extends GrantedAuthority> getAuthorities() {

           Set<GrantedAuthority> authorities = new HashSet();
            roles.forEach(role->{
                SimpleGrantedAuthority simpleGrantedAuthority = new SimpleGrantedAuthority(role.getName());
                authorities.add(simpleGrantedAuthority);
            });
            return authorities;
        }
        @Override
        public String getPassword() {
            return password;
        }
        @Override
        public String getUsername() {
            return username;
        }
        @Override
        public boolean isAccountNonExpired() {
            return accountNonExpired;
        }
        @Override
        public boolean isAccountNonLocked() {
            return accountNonLocked;
        }
        @Override
        public boolean isCredentialsNonExpired() {
            return credentialsNonExpired;
        }
        @Override
        public boolean isEnabled() {
            return enabled;
        }

    public void setRoles(List<Role> roles) {
        this.roles = roles;
    }

    public Integer getId() {
        return id;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public Boolean getEnabled() {
        return enabled;
    }

    public void setEnabled(Boolean enabled) {
        this.enabled = enabled;
    }

    public Boolean getAccountNonExpired() {
        return accountNonExpired;
    }

    public void setAccountNonExpired(Boolean accountNonExpired) {
        this.accountNonExpired = accountNonExpired;
    }

    public Boolean getAccountNonLocked() {
        return accountNonLocked;
    }

    public void setAccountNonLocked(Boolean accountNonLocked) {
        this.accountNonLocked = accountNonLocked;
    }

    public Boolean getCredentialsNonExpired() {
        return credentialsNonExpired;
    }

    public void setCredentialsNonExpired(Boolean credentialsNonExpired) {
        this.credentialsNonExpired = credentialsNonExpired;
    }

    public List<Role> getRoles() {
        return roles;
    }
}

dao层


import com.wang.entity.Role;
import com.wang.entity.User;
import org.apache.ibatis.annotations.Mapper;

import java.util.List;

@Mapper
public interface UserDao {
    //提供根据用户名返回方法
    User loadUserByUsername(String username);

    //提供根据用户id查询用户角色信息方法
    List<Role> getRoleByUid(Integer id);
}

service层


import com.wang.dao.UserDao;
import com.wang.entity.Role;
import com.wang.entity.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.core.userdetails.UsernameNotFoundException;
import org.springframework.stereotype.Service;
import org.springframework.util.ObjectUtils;

import java.util.List;

@Service
public class MyUserDetailService implements UserDetailsService {

    private final UserDao userDao;
    @Autowired
    public MyUserDetailService (UserDao userDao){
        this.userDao = userDao;
    }

    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
        //1. 查询用户
        User user = userDao.loadUserByUsername(username);
        if (ObjectUtils.isEmpty(user)) {
            throw new UsernameNotFoundException("用户名不存在");
        }
        //2. 查询权限信息
        List<Role> roles = userDao.getRoleByUid(user.getId());
        user.setRoles(roles);
        return user;
    }
}

config层

LoginFilter

import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.http.MediaType;
import org.springframework.security.authentication.AuthenticationServiceException;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.AuthenticationException;
import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.Map;

public class LoginFilter extends UsernamePasswordAuthenticationFilter {

    public Authentication attemptAuthentication(HttpServletRequest request, HttpServletResponse response) throws AuthenticationException {
        //1. 判断是否是post方式请求。
        if (!request.getMethod().equals("POST")) {
            throw new AuthenticationServiceException("Authentication method not supported: " + request.getMethod());
        }
        //2. 判断是否是json格式请求类型。
        if(request.getContentType().equalsIgnoreCase(MediaType.APPLICATION_JSON_VALUE)){
            //3. 从json数据中获取用户输入用户名和密码进行认证{"uname":"xxx","password":"xxx"}
            try{
                Map<String,String> userInfo = new ObjectMapper().readValue(request.getInputStream(), Map.class);
                String username = userInfo.get(getUsernameParameter());
                String password =userInfo.get(getPasswordParameter());

                System.out.println("用户名："+username + "密码："+password);

                UsernamePasswordAuthenticationToken authRequest = new UsernamePasswordAuthenticationToken(username,password);

                setDetails(request,authRequest);
                return this.getAuthenticationManager().authenticate(authRequest);
            } catch (IOException e) {
              e.printStackTrace();
            }
        }
        return super.attemptAuthentication(request,response);
    }
}

SecurityConfig


import com.fasterxml.jackson.databind.ObjectMapper;
import com.wang.service.MyUserDetailService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.http.HttpMethod;
import org.springframework.http.HttpStatus;
import org.springframework.http.MediaType;
import org.springframework.security.authentication.AuthenticationManager;
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.configuration.WebSecurityConfiguration;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
import org.springframework.security.core.userdetails.User;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.provisioning.InMemoryUserDetailsManager;
import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;
import org.springframework.security.web.util.matcher.AntPathRequestMatcher;
import org.springframework.security.web.util.matcher.OrRequestMatcher;

import javax.print.attribute.standard.Media;
import java.util.HashMap;
import java.util.Map;

@Configuration
public class SecurityConfig extends WebSecurityConfigurerAdapter {

    private final MyUserDetailService myUserDetailService;
    @Autowired
    public SecurityConfig(MyUserDetailService myUserDetailService){
        this.myUserDetailService = myUserDetailService;
    }
//    @Bean
//    public UserDetailsService userDetailsService() {
//        InMemoryUserDetailsManager inMemoryUserDetailsManager = new InMemoryUserDetailsManager();
//        inMemoryUserDetailsManager.createUser(User.withUsername("root").password("{noop}123").roles("admin").build());
//        return inMemoryUserDetailsManager;
//    }

    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        auth.userDetailsService(myUserDetailService);
    }

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

    //自定义filter交给工厂管理
    @Bean
    public LoginFilter loginFilter() throws Exception {
        LoginFilter loginFilter = new LoginFilter();
        loginFilter.setFilterProcessesUrl("/doLogin"); //指定认证的url
        loginFilter.setUsernameParameter("uname"); //指定接受json 用户名key
        loginFilter.setPasswordParameter("passwd"); //指定接受json 密码key
        loginFilter.setAuthenticationManager(authenticationManagerBean());
        loginFilter.setAuthenticationSuccessHandler(
                ((request, response, authentication) -> {
                    Map<String, Object> result = new HashMap<>();
                    result.put("msg", "登陆成功");
                    result.put("用户信息", authentication.getPrincipal());
                    response.setContentType("application/json;charset=UTF-8");
                    response.setStatus(HttpStatus.OK.value());
                    String s = new ObjectMapper().writeValueAsString(result);
                    response.getWriter().println(s);
                })
        ); //认证成功处理
        loginFilter.setAuthenticationFailureHandler(
                ((request, response, exception) -> {
                    Map<String, Object> result = new HashMap<>();
                    result.put("msg", "登陆失败：" + exception.getMessage());
                    response.setContentType("application/json;charset=UTF-8");
                    response.setStatus(HttpStatus.INTERNAL_SERVER_ERROR.value());
                    String s = new ObjectMapper().writeValueAsString(result);
                    response.getWriter().println(s);
                })
        ); //认证失败处理
        return loginFilter;
    }

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.authorizeHttpRequests()
                .anyRequest().authenticated() //所有请求必须认证
                .and()
                .formLogin()
                .and()
                .exceptionHandling()
                .authenticationEntryPoint(
                        ((request, response, authException) -> {
                            response.setContentType(MediaType.APPLICATION_JSON_UTF8_VALUE);
                            response.setStatus(HttpStatus.UNAUTHORIZED.value());
                            response.getWriter().println("请认证后再去处理！");
                        })
                )
                .and()
                .logout()
                .logoutRequestMatcher(
                        new OrRequestMatcher(
                                new AntPathRequestMatcher("/logout", HttpMethod.DELETE.name()),
                                new AntPathRequestMatcher("/logout", HttpMethod.GET.name())
                        )
                )
                .logoutSuccessHandler(
                        ((request, response, authentication) -> {
                            Map<String, Object> result = new HashMap<>();
                            result.put("msg", "注销成功");
                            result.put("用户信息", authentication.getPrincipal());
                            response.setContentType("application/json;charset=UTF-8");
                            response.setStatus(HttpStatus.OK.value());
                            String s = new ObjectMapper().writeValueAsString(result);
                            response.getWriter().println(s);
                        })
                )
                .and()
                .csrf().disable();
        // at:用来某个filter替换过滤器链中的某个filter。
        http.addFilterAt(loginFilter(), UsernamePasswordAuthenticationFilter.class);
    }
}

resources

mapper

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.wang.dao.UserDao">

    <!--        更具用户名查询用户方法-->
    <select id="loadUserByUsername" resultType="com.wang.entity.User">
        select id,
               username,
               password,
               enabled,
               accountNonExpired,
               accountNonLocked,
               credentialsNonExpired
        from user
        where username = #{username}
    </select>
    <!--        查询指定⾏数据-->
    <select id="getRoleByUid" resultType="com.wang.entity.Role">
        select r.id,
               r.name,
               r.name_zh nameZh
        from role r,
             user_role ur
        where r.id = ur.rid
          and ur.uid = #{uid}
    </select>
</mapper>

properties

server.port= 9092
# 关闭thymeleaf 缓存
spring.thymeleaf.cache= false


# 配置数据源
spring.datasource.type= com.alibaba.druid.pool.DruidDataSource
spring.datasource.driver-class-name= com.mysql.cj.jdbc.Driver
spring.datasource.url= jdbc:mysql://localhost:3306/security?characterEncoding=UTF-8&useSSL=false&&serverTimezone=CST
spring.datasource.username= 你的账号
spring.datasource.password= 你的密码

# Mybatis配置
# 注意mapper目录必须用"/"
mybatis.mapper-locations= classpath:com/wang/mapper/*.xml
mybatis.type-aliases-package=com.example.eneity

# 日志处理
logging.level.com.example = debug

pom.xml

    <dependencies>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.1.16</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.18</version>
        </dependency>
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>2.2.0</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-security</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-thymeleaf</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.thymeleaf.extras</groupId>
            <artifactId>thymeleaf-extras-springsecurity5</artifactId>
        </dependency>

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

结尾

所有代码都是测试过的，保证没有问题，如果存在错误，请仔细检查，欢迎留言讨论，结合编程不良人视频配套更佳。

左灯右行的爱情
关注
Spring-Boot结合Security+JWT 简单实现前后端分离用户登录、授权案例
07-12
Spring-Security结合JWT 实现前后端分离完成权限验证功能案例，案例中，主要完成用户登录获取Token，通过Token访问Rest接口，没有权限或授权失败时返回JSON，前端根据状态码进行重新登录；案例中的用户名称： jake_j...
SpringSecurity入门，前后端分离案例（笔记持续更新...）
weixin_47201411的博客
04-09 279
SpringSecurity入门
SpringSecurity登录流程详解
weixin_43132031的博客
08-04 4896
本文重点解析了SpringSecurity在登录过程中的详细流程，以及整体总结
Spring Security框架 前后端分离版
asddasddeedd的博客
11-19 3704
Spring 是非常流行和成功的 Java 应用开发框架，Spring Security 正是 Spring 家族中的 成员。Spring Security 基于 Spring 框架，提供了一套 Web 应用安全性的完整解决方 案。正如你可能知道的关于安全方面的两个主要区域是“认证”和“授权”（或者访问控 制），一般来说，Web 应用的安全性包括用户认证（Authentication）和用户授权 （Authorization）两个部分，这两点也是 Spring Security 重要核心功能。
SpringSecurity前后端分离的使用
make_progress的博客
07-07 2067
使用SpringSecurity实现安全认证，使用模拟redis的缓存机制，实现不同权限的登录设置。注：application.yml文件没有添加内容。 3.2 config包 3.2.1 WebSecurityConfig 安全配置 3.2.2 UserDetailsServiceImp 用户登录认证 3.2.3 AuthenticationEntryPointImp 用户登录状态认证 3.2.4 AccessDeniedHandlerImp 用户鉴权 3.3 filter包下Authentication
SpringBoot 整合SpringSecurity示例实现前后分离权限注解+JWT登录认证
程序员小明1024
10-05 1010
.markdown-body { line-height: 1.75; font-weight: 400; font-size: 16px; overflow-x: hidden; color: rgba(51, 51, 51, 1) } .markdown-body h1, .markdown-body h2, .markdown-body h3, .markdown-body h4, .ma...
springbootspringsecurity前后端分离（一个小demo）
08-21
总的来说，这个小demo展示了如何在Spring Boot和Spring Security的环境中实现前后端分离的安全控制，其中后端负责验证用户身份和授权，前端则根据后端的反馈来决定用户界面的行为。这样的设计模式在现代Web开发中...
springboot项目——基于springSecurity实现的前后端分离的企业级人事管理系统
10-03
本文将深入探讨如何在SpringBoot项目中集成SpringSecurity，构建一个前后端分离的企业级人事管理系统。 首先，SpringBoot简化了Spring应用的初始化和配置过程，使得开发者可以快速搭建项目结构。在这个案例中，...
VUE+Springboot 前后端分离的代码案例
11-21
在本项目中，我们探索了如何使用Vue.js前端框架与Spring Boot后端框架实现一个完整的前后端分离的应用。Vue.js是轻量级的渐进式JavaScript框架，它以组件化开发为核心，易于学习且功能强大；而Spring Boot是Java领域...
SpringBoot + SpringSecurity + JPA 实现用户角色权限登录认证
09-10
总结来说，本项目展示了如何利用SpringBoot、SpringSecurity和JPA在IntelliJ IDEA环境下构建一个完整的用户角色权限管理系统，通过security.sql和security-jpa这两个关键组件，实现了数据初始化和核心业务逻辑的构建...
如何在自定义接口中实现Spring Security的登录登出功能？
最新发布
qq_37185373的博客
07-10 907
Spring Security的登录登出功能通常使用配置中的表单登录实现。但在某些情况下需要在controller层中实现登录登出功能，从而更很灵活地自定义自己的security。1.通过WebSecurityConfigurerAdapter，获取AuthenticationManager来进行用户验证。3.实现记住我令牌持久化功能。2.在接口中实现登录功能。3.在接口中实现登出功能。
SpringSecurity实现前后端分离登录token认证详解
热门推荐
qq_43649937的博客
06-12 1万+
SpringSecurity Springboot java
SpringSecurity - 简单前后端分离 - 自定义认证篇
铠の魂博客
07-21 1713
终于到了我们关心的第一个问题，认证篇。此篇我们将结合前面的认证架构来详细讲解如何实现自定义认证处理，会简单的讲解一些原理，不会太过深入。要想玩转SpringSecurity的认证，就必须先看懂其认证架构。我们要自定义认证类，只需要继承其抽象认证基类即可，完全可以根据其它的默认实现进行复制粘贴。我们知道在前后端交互中，都是JSON交互，所以我们自定义一个JSON的认证类。项目包路径可以自定义，我的关于Security的都在security包下，自定义token放在token包下。自定义认证类。......
【Java】Spring Security + JWT 前后端分离及源码流程分析
weixin_44798538的博客
08-23 511
。UsernamePasswordAuthenticationFilter Authentication AuthenticationManager AuthenticationProvider UserDetailsService
若依前后端分离项目源码解读笔记
qq_31856061的博客
11-29 2960
然后通过的安全管理器调用方法,传入刚才创建的认证对象进行认授权认证 在若依框架中，这个安全管理器是在配置类中手动注入容器的 安全管理器调用方法，会进入方法做登录校验操作，这个是若依实现的，方法里就是若依自定义的登录逻辑。这里跳过了一些细节，就是如何保证方法用的是若依自定义的登录逻辑？这个是通过重写这个安全适配器里面的方法来指定的。首先可以看到配置类是继承了这个父类的，然后通过重写方法来指定用户详情业务对象,这个就是若依自定义的认证业务对象。 再来看这个若依自定义的业务，这个业务实现了的接口，并通
SpringSecurity学习（三）自定义数据源、前后端分离案例
Huathy的博客
03-08 570
发起认证请求，携带用户名密码，请求被UsernamePasswordAuthenticationFilter拦截在UsernamePasswordAuthenticationFilter的attemptAuthentication方法将请求的用户名和密码，封装为Authentication对象，交给AuthenticationManager进行认证。
超全的springboot+springsecurity前后端分离简单实现！！！
weixin_42375707的博客
12-05 1万+
1、前言部分 1.1、唠嗑部分(如何学习?) 看springsecurtiy原理图的时候以为洒洒水，妈的，结果自己动手做的时候一窍不通，所以一定不要眼高手低，实践出真知！ 通过各种方式学习springsecurity，在B站、腾讯课堂、网易课堂、慕课网没有springsecurity的前后端分离的教学视频，那我就去csdn去寻找springsecurity博客，发现几个问题： 要么就是前后端不分离，要么就是通过内存方式读取数据，而不是通过数据库的方式读取数据，要么就是大佬们给的代码不全、把代码.
SpringSecurity+JWT实现前后端分离认证授权
weixin_58005665的博客
07-02 177
1 前后端分离进行认证的核心是依赖的token,可理解成加密之后的字符串，通过是否携带token判断是不是我系统的用户，也可以拿到token之后获取加密之前的数据来看你是哪一个用户。
Sping Security前后端分离两种方案
sdasdas12的博客
07-10 462
Spring Security是基于Spring框架，提供了一套Web应用安全性的完整解决方案。关于安全方面的两个核心功能是认证和授权，Spring Security重要核心功能就是实现用户认证（Authentication）和用户授权（Authorization）。Spring Security进行认证和鉴权的时候，采用的一系列的Filter来进行拦截的。下图是Spring Security基于表单认证授权的流程，
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值