Spring Boot整合Spring Security

已于 2024-12-15 14:28:39 修改
阅读量1k 收藏 8
点赞数 2
分类专栏： 常用开源框架、中间件的使用 文章标签： spring spring boot java
于 2023-11-05 23:23:49 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/heyl163_/article/details/133956908
版权

Spring Security是Spring官方推荐的认证、授权框架，功能相比Apache Shiro功能更丰富也更强大，但是使用起来更麻烦。

如果使用过Apache Shiro，学习Spring Security会比较简单一点，两种框架有很多相似的地方。

一、准备工作

1、创建项目

在IntelliJ IDEA中创建一个springboot项目springboot-springsecurity

2、添加依赖

修改pom.xml，添加项目所需的依赖。

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.5.9</version>
        <relativePath />
    </parent>

    <groupId>cn.edu.sgu.www</groupId>
    <artifactId>springboot-springsecurity</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>springboot-springsecurity</name>
    <description>Demo project for Spring Boot</description>

    <properties>
        <java.version>1.8</java.version>
        <jjwt.version>0.9.1</jjwt.version>
        <mysql.version>8.0.28</mysql.version>
        <druid.version>1.1.21</druid.version>
        <lombok.version>1.18.22</lombok.version>
        <mybatis.version>2.2.2</mybatis.version>
        <mybatis-plus.version>3.5.1</mybatis-plus.version>
    </properties>

    <dependencies>
        <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>

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

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

        <!--mysql-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>${mysql.version}</version>
        </dependency>

        <!--druid-->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>${druid.version}</version>
        </dependency>

        <!--lombok-->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>${lombok.version}</version>
        </dependency>

        <!--mybatis-->
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>${mybatis.version}</version>
        </dependency>

        <!--mybatis-plus-->
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>${mybatis-plus.version}</version>
        </dependency>

        <!--jjwt-->
        <dependency>
            <groupId>io.jsonwebtoken</groupId>
            <artifactId>jjwt</artifactId>
            <version>${jjwt.version}</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>

3、修改配置

将配置文件application.properties重命名为application.yml，修改配置文件的内容。

server:
  port: 8080
  servlet:
    context-path: /

spring:
  datasource:
    username: root
    password: root
    url: jdbc:mysql://localhost:3306/spring-security
    driver-class-name: com.mysql.cj.jdbc.Driver
    type: com.alibaba.druid.pool.DruidDataSource

mybatis-plus:
  mapper-locations: classpath:mapper/*Mapper.xml

logging:
  level:
    springfox: error
    cn.edu.sgu.www.security: debug

system:
  login-page: /login.html
  login-url: /user/login
  index-page: /index.html
  logout-url: /user/logout
  parameter:
    username: username
    password: password
  white-url:
    - /js/**
    - /css/**
    - /images/**
    - /user/login
    - /login.html

二、创建相关的类

公共类

ResponseCode.java

响应状态码枚举类

package cn.edu.sgu.www.security.restful;

/**
 * 响应状态码
 * @author heyunlin
 * @version 1.0
 */
public enum ResponseCode {
    /**
     * 请求成功
     */
    OK(200),
    /**
     * 失败的请求
     */
    BAD_REQUEST(400),
    /**
     * 未授权
     */
    UNAUTHORIZED(401),
    /**
     * 禁止访问
     */
    FORBIDDEN(403),
    /**
     * 找不到（该状态不可用）
     */
    NOT_FOUND(404),
    /**
     * 不可访问
     */
    NOT_ACCEPTABLE(406),
    /**
     * 冲突
     */
    CONFLICT(409),
    /**
     * 服务器发生异常
     */
    ERROR(500);

    private final Integer value;

    ResponseCode(Integer value) {
        this.value = value;
    }

    public Integer getValue() {
        return value;
    }

}

GlobalException.java

自定义的全局异常类

package cn.edu.sgu.www.security.exception;

import cn.edu.sgu.www.security.restful.ResponseCode;
import lombok.Data;
import lombok.EqualsAndHashCode;

/**
 * 自定义的全局异常类
 * @author heyunlin
 * @version 1.0
 */
@EqualsAndHashCode(callSuper = true)
@Data
public class GlobalException extends RuntimeException {

    private ResponseCode responseCode;

    public GlobalException(ResponseCode responseCode, String message) {
        super(message);

        setResponseCode(responseCode);
    }

}

JsonResult.java

自定义的统一响应实体类

package cn.edu.sgu.www.security.restful;

import lombok.Data;

/**
 * 响应实体类
 * @param <T> 响应数据的类型
 * @author heyunlin
 * @version 1.0
 */
@Data
public class JsonResult<T> {

    /**
     * 响应数据
     */
    private T data;

    /**
     * 响应状态码
     */
    private Integer code;

    /**
     * 响应提示信息
     */
    private String message;

    public static JsonResult<Void> success() {
        return success(null);
    }

    public static JsonResult<Void> success(String message) {
        return success(message, null);
    }

    public static <T> JsonResult<T> success(String message, T data) {
        JsonResult<T> jsonResult = new JsonResult<>();

        jsonResult.setCode(ResponseCode.OK.getValue());
        jsonResult.setMessage(message);
        jsonResult.setData(data);

        return jsonResult;
    }

    public static JsonResult<Void> error(String message) {
        JsonResult<Void> jsonResult = new JsonResult<>();

        jsonResult.setCode(ResponseCode.ERROR.getValue());
        jsonResult.setMessage(message);

        return jsonResult;
    }

    public static JsonResult<Void> error(ResponseCode responseCode, Throwable e) {
        return error(responseCode, e.getMessage() != null ? e.getMessage() : "系统发生异常，请联系管理员！");
    }

    public static JsonResult<Void> error(ResponseCode responseCode, String message) {
        JsonResult<Void> jsonResult = new JsonResult<>();

        jsonResult.setCode(responseCode.getValue());
        jsonResult.setMessage(message);

        return jsonResult;
    }

}

GlobalExceptionHandler.java

全局异常处理类

package cn.edu.sgu.www.security.restful.handler;

import cn.edu.sgu.www.security.exception.GlobalException;
import cn.edu.sgu.www.security.restful.JsonResult;
import cn.edu.sgu.www.security.restful.ResponseCode;
import org.springframework.http.HttpStatus;
import org.springframework.validation.BindException;
import org.springframework.validation.BindingResult;
import org.springframework.validation.FieldError;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.ResponseStatus;
import org.springframework.web.bind.annotation.RestControllerAdvice;

import javax.servlet.http.HttpServletResponse;
import java.util.Objects;

/**
 * 全局异常处理类
 * @author heyunlin
 * @version 1.0
 */
@RestControllerAdvice
public class GlobalExceptionHandler {

    /**
     * 处理GlobalException
     * @param e GlobalException
     * @return JsonResult<Void>
     */
    @ExceptionHandler(GlobalException.class)
    public JsonResult<Void> handleGlobalException(HttpServletResponse response, GlobalException e) {
        printMessage(e);

        response.setStatus(e.getResponseCode().getValue());

        return JsonResult.error(e.getResponseCode(), e);
    }

    /**
     * 处理BindException
     * @param e BindException
     * @return JsonResult<Void>
     */
    @ExceptionHandler(BindException.class)
    @ResponseStatus(HttpStatus.BAD_REQUEST)
    public JsonResult<Void> handleBindException(BindException e) {
        printMessage(e);

        BindingResult bindingResult = e.getBindingResult();
        FieldError fieldError = bindingResult.getFieldError();
        String defaultMessage = Objects.requireNonNull(fieldError).getDefaultMessage();

        return JsonResult.error(ResponseCode.BAD_REQUEST, defaultMessage);
    }

    /**
     * 处理Exception
     * @param e Exception
     * @return JsonResult<Void>
     */
    @ExceptionHandler(Exception.class)
    @ResponseStatus(HttpStatus.INTERNAL_SERVER_ERROR)
    public JsonResult<Void> handleException(Exception e) {
        printMessage(e);

        return JsonResult.error(ResponseCode.ERROR, e);
    }

    /**
     * 打印异常信息
     * @param e Exception
     */
    private void printMessage(Exception e) {
        System.out.println(e.getMessage());

        e.printStackTrace();
    }

}

业务类

User.java

package cn.edu.sgu.www.security.entity;

import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import com.fasterxml.jackson.annotation.JsonFormat;
import lombok.Data;

import java.io.Serializable;
import java.time.LocalDateTime;

/**
 * @author heyunlin
 * @version 1.0
 */
@Data
@TableName("user")
public class User implements Serializable {
    private static final long serialVersionUID = 18L;

    @TableId(value = "id", type = IdType.INPUT)
    private String id;

    /**
     * 姓名
     */
    private String name;

    /**
     * 性别
     */
    private Integer gender;

    /**
     * 用户名
     */
    private String username;

    /**
     * 密码
     */
    private String password;

    /**
     * 手机号
     */
    private String phone;

    /**
     * 是否启用
     */
    private boolean enable;

    /**
     * 最后一次登录时间
     */
    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8")
    private LocalDateTime lastLoginTime;
}

UserMapper.java

package cn.edu.sgu.www.security.mapper;

import cn.edu.sgu.www.security.entity.User;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import org.springframework.stereotype.Repository;

/**
 * @author heyunlin
 * @version 1.0
 */
@Repository
public interface UserMapper extends BaseMapper<User> {
    
}

UserLoginDTO.java

package cn.edu.sgu.www.security.dto;

import lombok.Data;

import javax.validation.constraints.NotBlank;
import java.io.Serializable;

/**
 * @author heyunlin
 * @version 1.0
 */
@Data
public class UserLoginDTO implements Serializable {
    private static final long serialVersionUID = 18L;

    /**
     * 用户名
     */
    @NotBlank(message = "用户名不允许为空")
    private String username;

    /**
     * 密码
     */
    @NotBlank(message = "密码不允许为空")
    private String password;
}

UserService.java

package cn.edu.sgu.www.security.service;

import cn.edu.sgu.www.security.dto.UserLoginDTO;
import cn.edu.sgu.www.security.entity.User;

/**
 * @author heyunlin
 * @version 1.0
 */
public interface UserService {

    /**
     * 登录认证
     * @param userLoginDTO 用户登录信息
     */
    void login(UserLoginDTO userLoginDTO);

    /**
     * 退出登录
     */
    void logout();

    /**
     * 通过ID查询用户信息
     * @param userId 用户ID
     * @return User 通过ID查询到的用户信息
     */
    User selectById(String userId);
}

UserController.java

package cn.edu.sgu.www.security.controller;

import cn.edu.sgu.www.security.dto.UserLoginDTO;
import cn.edu.sgu.www.security.entity.User;
import cn.edu.sgu.www.security.restful.JsonResult;
import cn.edu.sgu.www.security.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

/**
 * @author heyunlin
 * @version 1.0
 */
@RestController
@RequestMapping(path = "/user", produces = "application/json;charset=utf-8")
public class UserController {

    private final UserService userService;

    @Autowired
    public UserController(UserService userService) {
        this.userService = userService;
    }

    @RequestMapping(value = "/login", method = RequestMethod.POST)
    public JsonResult<Void> login(@Validated UserLoginDTO userLoginDTO) {
        userService.login(userLoginDTO);

        return JsonResult.success("登录成功");
    }

    @RequestMapping(value = "/logout", method = RequestMethod.POST)
    public JsonResult<Void> logout() {
        userService.logout();

        return JsonResult.success("登出成功");
    }

    @RequestMapping(value = "/selectById", method = RequestMethod.GET)
    public JsonResult<User> selectById(@RequestParam(value = "id") String userId) {
        User user = userService.selectById(userId);

        return JsonResult.success(null, user);
    }

}

 UserServiceImpl.java

package cn.edu.sgu.www.security.service.impl;

import cn.edu.sgu.www.security.dto.UserLoginDTO;
import cn.edu.sgu.www.security.entity.User;
import cn.edu.sgu.www.security.mapper.UserMapper;
import cn.edu.sgu.www.security.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.authentication.AuthenticationManager;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.Authentication;
import org.springframework.stereotype.Service;

/**
 * @author heyunlin
 * @version 1.0
 */
@Service
public class UserServiceImpl implements UserService {

    private final UserMapper userMapper;
    private final AuthenticationManager authenticationManager;

    @Autowired
    public UserServiceImpl(UserMapper userMapper, AuthenticationManager authenticationManager) {
        this.userMapper = userMapper;
        this.authenticationManager = authenticationManager;
    }

    @Override
    public void login(UserLoginDTO userLoginDTO) {
        Authentication authentication = new UsernamePasswordAuthenticationToken(
                userLoginDTO.getUsername(),
                userLoginDTO.getPassword()
        );

        authenticationManager.authenticate(authentication);
    }

    @Override
    public void logout() {
        // todo
    }

    @Override
    public User selectById(String userId) {
        return userMapper.selectById(userId);
    }

}

配置类

SystemProperties.java

创建配置读取类SystemProperties

package cn.edu.sgu.www.security.config;

import lombok.Data;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;

import java.util.List;
import java.util.Map;

/**
 * @author heyunlin
 * @version 1.0
 */
@Data
@Component
@ConfigurationProperties(prefix = "system")
public class SystemProperties {

    /**
     * 登录页面
     */
    private String loginPage;

    /**
     * 登录的请求地址
     */
    private String loginUrl;

    /**
     * 登录成功后跳转的页面
     */
    private String indexPage;

    /**
     * 退出登录的请求地址
     */
    private String logoutUrl;

    /**
     * 白名单
     */
    private List<String> whiteUrl;

    /**
     * 登录的参数
     */
    private Map<String, String> parameter;
}

MybatisPlusConfig.java

package cn.edu.sgu.www.security.config;

import com.baomidou.mybatisplus.annotation.DbType;
import com.baomidou.mybatisplus.extension.plugins.MybatisPlusInterceptor;
import com.baomidou.mybatisplus.extension.plugins.inner.BlockAttackInnerInterceptor;
import com.baomidou.mybatisplus.extension.plugins.inner.PaginationInnerInterceptor;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * Mybatis-Plus配置类
 * @author heyunlin
 * @version 1.0
 */
@Configuration
@MapperScan(basePackages = "cn.edu.sgu.www.security.mapper")
public class MybatisPlusConfig {

    @Bean
    public MybatisPlusInterceptor mybatisPlusInterceptor() {
        MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();

        // 防全表更新与删除插件
        interceptor.addInnerInterceptor(new BlockAttackInnerInterceptor());
        // 分页插件
        interceptor.addInnerInterceptor(new PaginationInnerInterceptor(DbType.MYSQL));

        return interceptor;
    }

}

Spring Security相关的类

UserDetailsServiceImpl.java

UserDetailsService接口是Spring Security中非常重要的接口，在登录认证的时候会通过这个接口的loadUserByUsername()方法获取用户的信息，来完成登录的用户名、密码校验，完成登录流程。

package com.example.security.security;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.example.security.entity.User;
import com.example.security.exception.GlobalException;
import com.example.security.mapper.UserMapper;
import com.example.security.restful.ResponseCode;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.authentication.BadCredentialsException;
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.Component;

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

/**
 * @author heyunlin
 * @version 1.0
 */
@Component
public class UserDetailsServiceImpl implements UserDetailsService {

    private final UserMapper userMapper;

    @Autowired
    public UserDetailsServiceImpl(UserMapper userMapper) {
        this.userMapper = userMapper;
    }

    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
        // 查询用户信息
        User user = selectByUsername(username);

        if (user == null) {
            throw new BadCredentialsException("登录失败，用户名不存在！");
        } else {
            List<String> permissions = selectPermissions(username);

            return org.springframework.security.core.userdetails.User.builder()
                    .username(user.getUsername())
                    .password(user.getPassword())
                    .accountExpired(false)
                    .accountLocked(false)
                    .disabled(!user.getEnable())
                    .credentialsExpired(false)
                    .authorities(permissions.toArray(new String[] {}))
                    .build();
        }
    }

    /**
     * 通过用户名查询用户信息
     * @param username 用户名
     * @return User
     */
    private User selectByUsername(String username) {
        QueryWrapper<User> wrapper = new QueryWrapper<>();

        wrapper.eq("username", username);

        List<User> list = userMapper.selectList(wrapper);

        if (list.size() == 1) {
            return list.get(0);
        }

        return null;
    }

    /**
     * 通过用户名查询用户权限
     * @param username 用户名
     * @return List<String>
     */
    private List<String> selectPermissions(String username) {
        if (username == null) {
            throw new GlobalException(ResponseCode.BAD_REQUEST, "用户名不能为空");
        }

        List<String> permissions = new ArrayList<>();

        permissions.add("/user/login");
        permissions.add("/user/logout");
        permissions.add("/user/selectById");

        return permissions;
    }

}

LoginSuccessHandler.java

登录成功的处理器

package cn.edu.sgu.www.security.security;

import cn.edu.sgu.www.security.config.SystemProperties;
import org.springframework.security.core.Authentication;
import org.springframework.security.web.authentication.AuthenticationSuccessHandler;

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

/**
 * @author heyunlin
 * @version 1.0
 */
public class LoginSuccessHandler implements AuthenticationSuccessHandler {

    private final SystemProperties systemProperties;

    public LoginSuccessHandler(SystemProperties systemProperties) {
        this.systemProperties = systemProperties;
    }

    @Override
    public void onAuthenticationSuccess(HttpServletRequest request, HttpServletResponse response, Authentication authentication) throws IOException {
        response.sendRedirect(systemProperties.getIndexPage());
    }

}

LoginFailHandler.java

登录失败的处理器

package cn.edu.sgu.www.security.security;

import cn.edu.sgu.www.security.exception.GlobalException;
import cn.edu.sgu.www.security.restful.ResponseCode;
import org.springframework.security.core.AuthenticationException;
import org.springframework.security.web.authentication.AuthenticationFailureHandler;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

/**
 * @author heyunlin
 * @version 1.0
 */
public class LoginFailHandler implements AuthenticationFailureHandler {

    @Override
    public void onAuthenticationFailure(HttpServletRequest request, HttpServletResponse response, AuthenticationException e) {
        throw new GlobalException(ResponseCode.BAD_REQUEST, "登录失败，用户名或密码错误~");
    }

}

SecurityConfig.java

在项目根包下创建security的配置类config.SecurityConfig

package cn.edu.sgu.www.security.config;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.authentication.AuthenticationManager;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
import org.springframework.security.crypto.password.PasswordEncoder;

/**
 * @author heyunlin
 * @version 1.0
 */
@Configuration
public class SecurityConfig extends WebSecurityConfigurerAdapter {

    private final SystemProperties systemProperties;

    @Autowired
    public SecurityConfig(SystemProperties systemProperties) {
        this.systemProperties = systemProperties;
    }

    @Bean
    public PasswordEncoder passwordEncoder() {
        return new PasswordEncoder() {
            @Override
            public String encode(CharSequence charSequence) {
                return (String) charSequence;
            }

            @Override
            public boolean matches(CharSequence charSequence, String s) {
                return charSequence.equals(s);
            }
        };
    }

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

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        // 禁用防跨域攻击
        http.csrf().disable();

        // 配置各请求路径的认证与授权
        http.formLogin()
                .loginPage(systemProperties.getLoginPage()) // 自定义登录页面的地址
                .loginProcessingUrl(systemProperties.getLoginUrl()) // 处理登录的接口地址
                .usernameParameter(systemProperties.getParameter().get("username")) // 用户名的参数名
                .passwordParameter(systemProperties.getParameter().get("password")) // 密码的参数名
                .successHandler(new LoginSuccessHandler(systemProperties))
                //.successForwardUrl("/index.html") // 登录成功跳转的地址
                .failureHandler(new LoginFailHandler()); // 登录失败的处理器

        // 退出登录相关配置
        http.logout()
                .logoutUrl(systemProperties.getLogoutUrl()) // 退出登录的接口地址
                .logoutSuccessUrl(systemProperties.getLoginUrl()); // 退出登录成功跳转的地址

        // 配置认证规则
        String[] toArray = systemProperties.getWhiteUrl().toArray(new String[]{});
        http.authorizeRequests()
                .antMatchers(toArray).permitAll() // 白名单，也就是不需要登录也能访问的资源
                .anyRequest().authenticated();
    }

}

项目的包结构

文章就分享到这里了，文章的代码已上传到Gitee，可按需获取~

Spring Boot整合Spring Security案例项目icon-default.png?t=O83Ahttps://gitee.com/muyu-chengfeng/springboot-springsecurity.git

springBoot整合springSecurity
子笙的博客
01-10 1711
springBoot整合springSecurity介绍以及代码
Spring Boot：整合Spring Security
m0_68850571的博客
05-07 576
综合概述 Spring Security 是 Spring 社区的一个顶级项目，也是 Spring Boot 官方推荐使用的安全框架。除了常规的认证（Authentication）和授权（Authorization）之外，Spring Security还提供了诸如ACLs，LDAP，JAAS，CAS等高级特性以满足复杂场景下的安全需求。另外，就目前而言，Spring Security和Shiro也是当前广大应用使用比较广泛的两个安全框架。 Spring Security 应用级别的安全主要包含两个主要部
SpringBoot集成SpringSecurity并实现自定义认证
milk_yan的博客
11-11 2215
Spring Security登录认证主要涉及两个重要的接口 UserDetailService和UserDetails接口。 UserDetailService接口主要定义了一个方法 loadUserByUsername(String username)用于完成用户信息的查 询，其中username就是登录时的登录名称，登录认证时，需要自定义一个实现类实现UserDetailService接 口，完成数据库查询，该接口返回UserDetail。 UserDetail主要用于封装认证成功时的用户信息。
SpringBoot进阶：整合SpringSecurity方式及案例
2401_86224057的博客
03-17 658
Spring Security是一个为Java应用程序提供全面安全服务的框架，其主要作用包括
Spring Security（二）自定义用户名密码认证
Lyndon的专栏
10-23 7805
SpringBoot整合Spring Security实现ajax登录
Springboot——整合SpringSecurity
qq_41297145的博客
12-30 3637
认证过程主要是实现AuthenticationManager， AuthenticationManager最重要的实现类是ProviderManager， 通过ProviderManager，可以管理AuthenticationProvider， 每个AuthenticationProvider都对应一种认证方式， 当所有认证方式不支持时，调用ProviderManager的parent认证。如果想要自定义配置，如自定义登录界面、自定义验证过程，或者想要整合一些工具，如Jwt，这个时候需要在。
微服务整合Spring Security实现用户的认证和授权
u014496893的博客
01-31 5996
一、Spring Security介绍 1、框架介绍 Spring 是一个非常流行和成功的 Java 应用开发框架。Spring Security 基于 Spring 框架，提供了一套 Web 应用安全性的完整解决方案。一般来说，Web 应用的安全性包括用户认证（Authentication）和用户授权（Authorization）两个部分。 （1）用户认证指的是：验证某个用户是否为系统中的合法主体，也就是说用户能否访问该系统。用户认证一般要求用户提供用户名和密码。系统通过校验用户名和密码来完成认证过程。
Spring Boot整合Spring Security的示例代码
08-27
主要介绍了Spring Boot整合Spring Security的示例代码，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
Spring Boot与Spring Security的整合
聚娃科技开发者博客
07-12 1075
Spring Security是一个功能强大且高度可定制的身份验证和访问控制框架，它是基于Spring框架的一个扩展，专注于为Java应用程序提供身份验证和授权功能。在现代Web应用中，安全性是至关重要的一环，Spring Security能够帮助我们轻松地集成各种认证机制和授权策略，保护应用程序免受恶意攻击和数据泄露。通过本文的介绍，我们学习了如何在Spring Boot应用中集成Spring Security，并实现基本的用户认证和授权功能。确保用户能够按预期访问和操作受保护的资源。
Spring Boot整合Spring Security：构建安全的Web应用
weixin_65175398的博客
01-04 1579
本文将介绍如何在Spring Boot应用程序中整合Spring Security，以构建一个安全可靠的Web应用。这只是一个简单的Spring Security配置，实际项目中可能需要更复杂的配置，包括数据库认证、角色控制等。但通过这个简单的例子，你可以了解到如何快速集成Spring Security，并建立一个基本的安全框架。
Spring Boot整合Spring Security：构建高安全的分布式系统
最新发布
weixin_42593797的博客
04-26 1338
在微服务架构中，系统安全面临两大核心挑战：‌认证分散化‌（多服务统一登录）和‌授权动态化‌（实时权限控制）。Spring Security作为Spring生态的官方安全框架，凭借其‌模块化设计‌、‌深度整合能力‌以及‌对OAuth2的天然支持‌，成为企业级安全方案的首选。本文基于‌与‌，深度解析其核心原理，并通过代码演示如何实现‌分布式认证‌、‌动态权限管理‌和‌无状态API保护‌。实现@Service@Autowired@Override。
SpringBoot整合SpringSecurity
qq_44749491的博客
06-28 9650
SpringSecurity整合基础
springboot整合security
weixin_47260194的博客
06-16 773
如果你不希望使用内存中的用户信息，而是希望将用户信息存储在数据库或其他地方，可以实现java复制代码import org.springframework.beans.factory.annotation.Autowired;@Autowired@Override@Bean@Overridehttp.and().and().logout()你可以通过指定来自定义登录页面的路径，还可以实现和接口来处理成功或失败的登录尝试。
springboot整合springSecurity
Zxs4212的博客
12-28 337
以及用于用户校验操作的UserDetailsService接口，实现方法 public UserDetails loadUserByUsername(String username)继承类WebSercuityConfigurerAdapter，对serurity进行配置,可实现其中的三个配置方法。目前只使用一个作为入门操作。springSecurity默认采用BCryptPasswordEncoder作为密码的加密操作；需要在启动类获取配置类上打上@EnableWebSecurity注解。
SpringBoot 整合 SpringSecurity
一个95后开发者，热爱编程，喜欢玩游戏. 希望可以结识更多的小伙伴...
07-03 1518
SpringBoot整合Spring Security
sout-lanys
09-23 6471
Spring Security 是 Spring 家族中安全管理框架，相比于 Shiro ，它提供了更丰富的功能，社区资源比 Shiro 丰富。 一般大部分中大型项目都是使用 Security ,小项目使用 Shiro 比较多。因为相对于 Security,Shiro 上手更简单。 一般Web应用的需要进行认证和授权。 认证：验证是否是本系统用户。 授权：经过登录，判断当前用户拥有的权限。 controller 启动 测试 账号：user 密码：项目启动时随机生成 二、 初探原理 登陆校验流程
SpringBoot 整合Spring Security（简单版）
Zhangmaoyang的博客
11-26 6419
1 写在前面 关于spring security的介绍，网上一大堆，这里就不介绍了，这里直接使用springboot开始整合 2 整个流程 spring security授权和认证的流程大致和shiro差不多，其实跟我们自己基于RBAC的思想然后自定义拦截器进行权限拦截是一样的。 2.1 认证 认证的过程就是客户端用户登录，然后服务端将用户登录信息缓存起来，最后服务端将用户信息（基本信息、权限、token等）返回给客户端。 2.2 授权 授权的过程，首先客户端发起请求，携带token，服务端解
spring boot整合spring security
05-10
Spring Boot是一个快速开发框架，能够帮助我们快速构建Spring应用程序，而Spring Security是Spring的安全框架，用于保护应用程序的安全性。将它们结合起来可以为我们的应用程序提供强大的身份认证和授权机制。 Spring Boot整合Spring Security的过程可以简单概括为以下几个步骤： 1. 添加Spring Security依赖：在pom.xml文件中添加Spring Security依赖。 2. 配置Spring Security：创建一个配置类，配置Spring Security相关的信息，例如登录页面、用户角色等。 3. 配置登录页面：在配置类中设置登录页面，并配置用户角色和权限。 4. 配置用户认证：在配置类中配置用户的认证方式，例如基于内存、数据库、LDAP等方式。 5. 配置访问控制：在配置类中配置用户的访问控制规则，例如哪些URL需要进行身份认证、哪些URL需要特定的角色等。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

沐雨橙风ιε

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

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

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

打赏作者

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

抵扣说明：

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

余额充值