SpringSecurity使用详细讲解，附源码详细每一步的引导

淡淡的烟草味﹌ 2024-03-24 20:23 15阅读 0赞

#### Spring Security是一个用于在Java应用程序中实现身份验证和授权的框架。它提供了一套强大的安全性功能，可帮助您保护您的应用程序免受未经授权的访问和攻击。 ####

接下来就带领大家进行一个SpringSecurity的引入和简单使用

##### **pom依赖引入：** #####

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

##### 1.自定义实现类，实现UserDetailService, #####

/**
     *这个类实现了Sucrity框架的一个接口 UserDetailsService，重写UserDetails方法，
     * 将查询出来的User对象存储到UserDetails中（我们自己创建了一个类LoginUserDetails实现了UserDetails接口）
     */
    @Service
    public class LoginUserService implements UserDetailsService {
    
        @Autowired
        private UserMapper userMapper;
    
        /*
        * 这个方法是sucrity框架已经写好的，我们实现UserDetailsService接口重写方法
        * 在登录的时候会先走到这一步，我们在这里检验一下用户名是否存在
        * */
        @Override
        public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
            QueryWrapper<User> userQueryWrapper = new QueryWrapper<>();
            userQueryWrapper.eq("username",username);
            User user = userMapper.selectOne(userQueryWrapper);
            if (ObjectUtils.isEmpty(user)){
                throw new RuntimeException("登录失败，用户名或密码输入错误");
            }
    
            // TODO: 2023/7/17 同时将user存入到redis中
            // 这里需要返回UserDetails类型，UserDetails是个接口，我们需要自己创建一个类去实现它
            // 将user返回之后，sucrity会自己去比较密码是否正确，注意；sucrity比较的时候是将密码加密之后比较，所以在数据库存储时，需要将密码加密
            return new LoginUserDetails(user);
        }
    }

##### 2. 创建UserLogin类实现UserDetals #####

@Data
    @AllArgsConstructor
    @NoArgsConstructor
    public class LoginUserDetails implements UserDetails {
        /*
        * 我们在这里创建一个成员变量，对象为我们的实体类 User，这样有参构造就会有User，下面的各种返回方法，也都是从user中取
        * */
        private User user;
    
        /**
         *这个是返回权限集合的方法
         * @return
         */
        @Override
        public Collection<? extends GrantedAuthority> getAuthorities() {
            return null;
        }
    
        /**
         * 这个是返回用户密码方法
         * @return
         */
        @Override
        public String getPassword() {
            return user.getPassword();
        }
    
        /**
         * 这个是返回用户名方法
         * @return
         */
        @Override
        public String getUsername() {
            return user.getUsername();
        }
    
        /**
         * 下面几个方法改成true
         * @return
         */
        @Override
        public boolean isAccountNonExpired() {
            return true;
        }
    
        @Override
        public boolean isAccountNonLocked() {
            return true;
        }
    
        @Override
        public boolean isCredentialsNonExpired() {
            return true;
        }
    
        @Override
        public boolean isEnabled() {
            return true;
        }
    }

截止到这一步，简单的登录校验就做好了，sucrity会根据返回的user自己比较密码，注意密码存储数据库时一定要加密，否则比对不成功。

##### 3. 实现项目的登陆接口 #####

@RestController
    @RequestMapping("/cxx")
    public class UserController {
    
        @Autowired
        private UserService userService;
    
        @PostMapping("/userLogin")
        public ResponseResult userLogin(@RequestBody User user){
            String token = userService.userLogin(user);
            return new ResponseResult(200,"登录成功",token);
        }
    
    
    
    }

以上先创建一个接口，是我们的登录接口，具体业务在impl中

首先我们需要用到Security框架的校验，所以我们需要创建AuthenticationManager对象，这个对象是需要我们在SecurityConfig中创建出来然后交给Spring管理，具体代码如下：

@Configuration
    @EnableGlobalMethodSecurity(prePostEnabled = true)
    public class SecurityConfig extends WebSecurityConfigurerAdapter {
    
        @Bean
        public PasswordEncoder passwordEncoder(){
            // 使用BCrypt加密密码
            return new BCryptPasswordEncoder();
        }
    
        /*
         * 重写AuthenticationManager，并且交给Spring管理
         * */
        @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("/cxx/userLogin", "/user/save").anonymous()
                    // 除上面外的所有请求全部需要鉴权认证
                    .anyRequest().authenticated();
    
        }

然后再impl中我们使用@Autowired来注入， 详细请看具体的代码，其中我写了注释

// 在配置类中重写方法，然后交给Spring管理，我们在这里直接注入
        @Autowired
        private AuthenticationManager authenticationManager;
    
        /**
         * 登录业务逻辑
         * @param user
         * @return
         */
        @Override
        public String userLogin(User user) {
    /*        这里我们使用了sucrity框架，我们需要拿到AucesscationManager对象，那么这个对象我们是要交给Spring管理的
            我们去SucrityConfiger的配置类中重写然后交给Spring管理
            调用authenticationManager的authenticate方法，但是我们发现参数是Authentication类型的，Authentication是一个
            接口，我们需要创建它的实现类对象，点进去接口发现他有一个实现类叫UsernamePasswordAuthenticationToken，我们直接new他，
            里面的参数分别是用户的用户名和密码
            */
            UsernamePasswordAuthenticationToken usernamePasswordAuthenticationToken = new UsernamePasswordAuthenticationToken(user.getUsername(), user.getPassword());
            // 调用下面这个方法，其实就走到了我们之前自定义的LoginUserService，进行用户名密码判定
            Authentication authenticate = authenticationManager.authenticate(usernamePasswordAuthenticationToken);
            // 我们只需要判定Authentication对象是否为空，就知道校验有没有成功
            if (ObjectUtils.isEmpty(authenticate)){
                // 如果为空，说明登录校验失败
                throw new RuntimeException("登录失败，请检查用户名或密码");
            }
            // 如果登录成功，那么就返回给前端jwt（token），为了安全，我们只返回userId
            // 那么我们怎么拿到UserId呢，其实我们在LoginUserService里面已经把User信息返回给了Sucrity，在这里可以直接从authenticate拿
            LoginUserDetails loginUserDetails = (LoginUserDetails) authenticate.getPrincipal();
            User loginUser = loginUserDetails.getUser();
            String token = JwtUtil.createJWT(loginUser.getId().toString());
            // 三天后过期
            redisTemplate.opsForValue().set(loginUser.getId().toString(), loginUserDetails, 3, TimeUnit.DAYS);
            return token;
        }

截至到这里，登录成功之后我们将用户id用JWT进行了加密，然后返回给前端。

##### 4. 实现项目的Jwt校验，保证系统的安全 #####

前面我们说到了，当用户登录成功之后，我们会把生成的jwt返回给前端，然后前端在每次请求的时候都要带上这个token，

我们用这个token从redis中拿到用户的信息，然后存到SeucrityContextHolder中，这样Seucrity会自己判定请求是否合法

那么具体怎么做我们需要先创建一个自定义的Jwt校验的过滤器，然后把这个过滤器加入到Security的过滤链中。

首先我们创建一个过滤器，注意这个过滤器我们继承OncePerRequestFilter类，具体代码如下

/**
     * 这是我们自定义的Jwt过滤器，来校验token是否正确，保证我们的系统安全
     */
    @Component
    public class MyJwtFilter extends OncePerRequestFilter {
    
        @Resource
        private RedisTemplate<String,Object> redisTemplate;
    
    
        @Override
        protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException {
            // 首先我们要拿到前端传递过来的token,token是放在请求头中的
            String token = request.getHeader("token");
            // 这里我们要判定token是否为空，如果为空，就说明没有登录，或者非法请求
            if (ObjectUtils.isEmpty(token)){
                // 如果为空我们这里就给放行，不走下面的业务,在Seucrity的框架中后面的过滤器会自己判定
                filterChain.doFilter(request,response);
                // 记住这里一定要return,因为Security在做完判定在以后，过滤链会再返回走一圈，如果我们这里不return,他就又会走下面的业务代码
                return;
            }
            // 如果token存在，那么我们就解密token并在redis中取出用户信息，存到SeucrutyContext中
            try {
                Claims claims = JwtUtil.parseJWT(token);
                token = claims.getSubject();
            } catch (Exception e) {
                e.printStackTrace();
                // 如果这里解析异常报错，就说明token出了问题，我们抛出异常
                throw new RuntimeException("token非法");
            }
            LoginUserDetails loginUserDetails =(LoginUserDetails)redisTemplate.opsForValue().get(token);
            if (ObjectUtils.isEmpty(loginUserDetails)){
                // 如果redis中没有存到信息，那么说明要么没登录，要么过期了，我们抛出异常即可
                throw new RuntimeException("请登录");
            } else {
                // TODO: 2023/8/1 在redis中进行续期
            }
            // TODO: 2023/8/1 下面第三个参数是用户的权限信息，暂时我们没有做权限业务，写为null就可以了
            UsernamePasswordAuthenticationToken usernamePasswordAuthenticationToken = new UsernamePasswordAuthenticationToken(loginUserDetails.getUser()), null, null);
            SecurityContextHolder.getContext().setAuthentication(usernamePasswordAuthenticationToken);
            // 到这一步我们就将用户信息存入到SecurityContextHolder中
            // 到最后一步一定记得放行
            filterChain.doFilter(request,response);
            // 到这里我们的Jwt过滤器就写完了，但是Seucrity是怎么知道要先经过我们这个过滤器呢，我们要去Config中配置一下才可以
        }

到这里过滤器就已经创建完成，接下来我们需要把过滤器加入到Seucrity的过滤链中，我们需要在SeucrityConfig中添加过滤器在指定的位置，具体代码如下：

// 我们自定义的过滤器是要放在最前面的，就放在UsernamePasswordAuthenticationFilter这个过滤器之前
    http.addFilterBefore(myJwtFilter, UsernamePasswordAuthenticationFilter.class);

截至这里我们测试，登录成功之后，拿到返回的token，将token放在请求头中，成功访问，如果没有token就说明请求非法

##### 5.实现退出系统接口 #####

思路就是把当前请求的用户信息拿到，然后我们拿到用户id，将redis中删除就好

@Override
    public void loginout() {
        /**
         * 直接从SeucrityContextHolder中拿到用户信息，找到id,因为这个请求的时候一定会经过我们的过滤链，经过过滤链的时候每次请求的用户信息都会存入到
         * SeucrityContextHolder中，我们直接从里面拿到id，然后将redis的用户信息主动删除，这样下次请求再进来时，就是没有登录
         */
        UsernamePasswordAuthenticationToken usernamePasswordAuthenticationToken = (UsernamePasswordAuthenticationToken) SecurityContextHolder.getContext().getAuthentication();
        User user = (User) usernamePasswordAuthenticationToken.getPrincipal();
        Long id = user.getId();
        redisTemplate.delete(id.toString());
    }

##### 6. 实现权限认证 #####

权限认证的思路其实非常简单，我在登录的时候根据用户查询到权限信息，然后交给SpringSecurity框架，并且存到reids中就可以。

1. 第一步就是查询权限信息，那么我们在什么时候查呢，我们之前登录的时候打了todo,在登录的同时就将权限信息查出来然后教给Security

/**
     *这个类实现了Sucrity框架的一个接口 UserDetailsService，重写UserDetails方法，
     * 将查询出来的User对象存储到UserDetails中（我们自己创建了一个类LoginUserDetails实现了UserDetails接口）
     */
    @Service
    public class LoginUserService implements UserDetailsService {
    
        @Autowired
        private UserMapper userMapper;
    
        /*
        * 这个方法是sucrity框架已经写好的，我们实现UserDetailsService接口重写方法
        * 在登录的时候会先走到这一步，我们在这里检验一下用户名是否存在
        * */
        @Override
        public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
            QueryWrapper<User> userQueryWrapper = new QueryWrapper<>();
            userQueryWrapper.eq("username",username);
            User user = userMapper.selectOne(userQueryWrapper);
            if (ObjectUtils.isEmpty(user)){
                throw new RuntimeException("登录失败，用户名或密码输入错误");
            }
    
            // TODO: 2023/8/23 查询用户权限信息，在这里我暂时写死的，在实际项目中需要根据RBAC模型联表去查权限信息
            ArrayList<String> permissions = new ArrayList<>(Arrays.asList("test","admin"));
            user.setPermission(permissions);
            // 这里需要返回UserDetails类型，UserDetails是个接口，我们需要自己创建一个类去实现它
            // 将user返回之后，sucrity会自己去比较密码是否正确，注意；sucrity比较的时候是将密码加密之后比较，所以在数据库存储时，需要将密码加密
            return new LoginUserDetails(user);
        }

在这里存到之后，我们在JWT认证过滤器里面，之前也打了todo,需要把权限信息存到SecurityContextHolder中

/**
     * 这是我们自定义的Jwt过滤器，来校验token是否正确，保证我们的系统安全
     */
    @Component
    public class MyJwtFilter extends OncePerRequestFilter {
    
        @Resource
        private RedisTemplate<String, Object> redisTemplate;
    
    
        @Override
        protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException {
            // 首先我们要拿到前端传递过来的token,token是放在请求头中的
            String token = request.getHeader("token");
            // 这里我们要判定token是否为空，如果为空，就说明没有登录，或者非法请求
            if (ObjectUtils.isEmpty(token)) {
                // 如果为空我们这里就给放行，不走下面的业务,在Seucrity的框架中后面的过滤器会自己判定
                filterChain.doFilter(request, response);
                // 记住这里一定要return,因为Security在做完判定在以后，过滤链会再返回走一圈，如果我们这里不return,他就又会走下面的业务代码
                return;
            }
            // 如果token存在，那么我们就解密token并在redis中取出用户信息，存到SeucrutyContext中
            try {
                Claims claims = JwtUtil.parseJWT(token);
                token = claims.getSubject();
            } catch (Exception e) {
                e.printStackTrace();
                // 如果这里解析异常报错，就说明token出了问题，我们抛出异常
                throw new RuntimeException("token非法");
            }
            LoginUserDetails loginUserDetails = (LoginUserDetails) redisTemplate.opsForValue().get(token);
            if (ObjectUtils.isEmpty(loginUserDetails)) {
                // 如果redis中没有存到信息，那么说明要么没登录，要么过期了，我们抛出异常即可
                throw new RuntimeException("请登录");
            } else {
                // TODO: 2023/8/1 在redis中进行续期
            }
            // TODO: 2023/8/1 下面第三个参数是用户的权限信息，暂时我们没有做权限业务，写为null就可以了
            UsernamePasswordAuthenticationToken usernamePasswordAuthenticationToken =
                    new UsernamePasswordAuthenticationToken(loginUserDetails.getUser(), null, loginUserDetails.getAuthorities());
            SecurityContextHolder.getContext().setAuthentication(usernamePasswordAuthenticationToken);
            // 到这一步我们就将用户信息存入到SecurityContextHolder中
            // 到最后一步一定记得放行
            filterChain.doFilter(request, response);
        }
    }

然后我们需要在接口方法中添加权限相关注解

@GetMapping
    @PreAuthorize("hasAuthority('test')")
    public String hello(){
        return "hello";
    }

好啦，截止到这里简单的Securitu使用就到这里了，如果对您有帮助，请关注加点赞噢。