Spring Security总结

最新推荐文章于 2022-12-13 17:48:22 发布
最新推荐文章于 2022-12-13 17:48:22 发布
阅读量1k 收藏 7
点赞数
文章标签： spring java 后端 数据库 前端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cccccccmmm/article/details/128284232
版权

目录

介绍

项目搭建

Security认证 

        UserDetailsService

        内存认证

        数据库认证

        PasswordEncoder密码解析器

        自定义登录页面

        退出登录

        CSRF防护

        Remember me

Security授权

        RBAC

        权限表设计

        查询访问权限

        配置类设置访问权限

        自定义访问控制逻辑

注解设置访问权限

        @Secured

        @PreAuthorize

前端进行访问控制 

403处理方案

 

 

介绍

Spring Security是Spring项目组提供的安全服务框架，核心功能包括认证和授权。它为系统提供了声明式安全访问控制功能，减少了为系统安全而编写大量重复代码的工作。

认证

认证即系统判断用户的身份是否合法，合法可继续访问，不合法则拒绝访问。常见的用户身份认证方式有：用户名密码登录、二维码登录、手机短信登录、脸部识别认证、指纹认证等方式。

认证是为了保护系统的隐私数据与资源，用户的身份合法才能访问该系统的资源。

授权

授权即认证通过后，根据用户的权限来控制用户访问资源的过程，拥有资源的访问权限则正常访问，没有权限则拒绝访问。 比如在一些视频网站中，普通用户登录后只有观看免费视频的权限，而VIP用户登录后，网站会给该用户提供观看VIP视频的权限。

认证是为了保证用户身份的合法性，授权则是为了更细粒度的对隐私数据进行划分，控制不同的用户能够访问不同的资源。

举个例子：认证是公司大门识别你作为员工能进入公司，而授权则是由于你作为公司会计可以进入财务室，查看账目，处理财务数据。

项目搭建

接下来我们先来搭建一个Spring Security项目

1、准备一个名为mysecurity的Mysql数据库

2、创建SpringBoot项目，添加依赖

<!-- SpringMVC -->
<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-web</artifactId>
</dependency>
<!--Thymeleaf-->
<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-thymeleaf</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>
  <scope>runtime</scope>
</dependency>
<!-- MyBatisPlus -->
<dependency>
  <groupId>com.baomidou</groupId>
  <artifactId>mybatis-plus-boot-starter</artifactId>
  <version>3.5.0</version>
</dependency>
<!-- lombok -->
<dependency>
  <groupId>org.projectlombok</groupId>
  <artifactId>lombok</artifactId>
  <optional>true</optional>
</dependency>
<!-- junit -->
<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-test</artifactId>
  <scope>test</scope>
</dependency>

3、配置数据源、端口

#数据源
spring:
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql:///mysecurity?serverTimezone=UTC
    username: root
    password: root

#端口
server:
  port: 8080

#日志格式
logging:
  pattern:
    console: '%d{HH:mm:ss.SSS} %clr(%-5level) ---  [%-15thread] %cyan(%-50logger{50}):%msg%n'

4、在template文件夹编写main.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>主页</title>
</head>
<body>
    <h1>主页面</h1>
</body>
</html>

5、编写访问页面控制器

@Controller
public class MyController {
    @RequestMapping("/{page}")
    public String getPage(@PathVariable String page){
        return page;
    }
}

6、启动springboot，访问localhost:8080/main，网页自动跳转到一个登录页面，这就是security默认提供的登录页面，用户名为user，密码为控制台输出的一串字符串 

输入过后即可进入main.html

 

 

Security认证 

        UserDetailsService

在实际项目中，认证逻辑是需要自定义控制的。将UserDetailsService接口的实现类放入Spring容器即可自定义认证逻辑。InMemoryUserDetailsManager就是UserDetailsService接口的一个实现类，它将登录页传来的用户名密码和内存中用户名密码做匹配认证。当然我们也可以自定义UserDetailsService接口的实现类。

public interface UserDetailsService{

  UserDetailsloadUserByUsername(String username) throws UsernameNotFoundException;

}

UserDetailsService的实现类必须重写loadUserByUsername方法，该方法定义了具体的认证逻辑，参数username是前端传来的用户名，我们需要根据传来的用户名查询到该用户（一般是从数据库查询），并将查询到的用户封装成一个UserDetails对象，该对象是Spring Security提供的用户对象，包含用户名、密码、权限。Spring Security会根据UserDetails对象中的密码和客户端提供密码进行比较。相同则认证通过，不相同则认证失败。

 

 简单说就是：

1、根据用户名查询用户，将查询结果封装为UserDetails对象

2、Spring Security根据UserDetails的password和客户端表单上传的password比对

 

        内存认证

在实际开发中，用户数量不会只有一个，且密码是自己设置的。所以我们需要自定义配置用户信息。首先我们在内存中创建两个用户，Spring Security会将登录页传来的用户名密码和内存中用户名密码做匹配认证。

编写security配置类，定义内存认证和密码解析器

@Configuration
public class SecurityConfig {
    //定义认证逻辑
    @Bean
    public UserDetailsService userDetailsService(){
        //1、使用内存数据进行认证
        InMemoryUserDetailsManager manager = new InMemoryUserDetailsManager();
        //2、创建两个用户
        UserDetails u1 = User.withUsername("cm").password("123").authorities("admin").build();
        UserDetails u2 = User.withUsername("sxt").password("456").authorities("admin").build();
        //3、将两个用户添加到内存中
        manager.createUser(u1);
        manager.createUser(u2);
        return manager;
    }

    //密码编译器，不解析密码
    @Bean
    public PasswordEncoder passwordEncoder(){
        return NoOpPasswordEncoder.getInstance();
    }
}

启动springboot登录时，就可以使用自己添加的用户名和密码了

 

 

 

        数据库认证

接下来我们连接数据库进行认证：

1、准备数据库

CREATE TABLE `users` (
 `id` int(11) NOT NULL AUTO_INCREMENT,
 `username` varchar(255),
 `password` varchar(255) ,
 `phone` varchar(255) ,
 PRIMARY KEY (`id`)
);

 

 

2、编写用户实体类

@Data
@NoArgsConstructor
@AllArgsConstructor
public class Users {
    private Integer id;
    private String username;
    private String password;
    private String phone;
}

3、编写dao接口

public interface UsersMapper extends BaseMapper<User> {
}

4、在SpringBoot启动类中添加@MapperScan注解，扫描mapper文件夹

@SpringBootApplication
@MapperScan
public class SecurityBlogApplication {

    public static void main(String[] args) {
        SpringApplication.run(SecurityBlogApplication.class, args);
    }

}

5、创建UserDetailsService的实现类，编写自定义认证逻辑

@Service
public class MyUserDetailsService implements UserDetailsService {
    @Autowired
    private UsersMapper usersMapper;

    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
        //1、构建查询条件
        QueryWrapper queryWrapper = new QueryWrapper();
        queryWrapper.eq("username",username);
        //2、查询用户
        Users users = usersMapper.selectOne(queryWrapper);
        //3、封装为UserDetails对象
        UserDetails userDetails = User.withUsername(users.getUsername())
                .password(users.getPassword())
                .authorities("admin")
                .build();
        return userDetails;
    }
}

6、注释之前写过的认证逻辑，因为只能使用一种认证逻辑 

7、启动SpringBoot， 访问localhost:8080/main，跳转到登录页面，输入数据库中对应用户名和密码即可登录 

 

        PasswordEncoder密码解析器

在实际开发中，为了数据安全性，在数据库中存放密码时不会存放原密码，而是会存放加密后的密码。而用户传入的参数是明文密码。此时必须使用密码解析器才能将加密密码与明文密码做比对。Spring Security中的密码解析器是PasswordEncoder。

Spring Security要求容器中必须有PasswordEncoder实例，之前使用的NoOpPasswordEncoder是PasswordEncoder的实现类，意思是不解析密码，使用明文密码。

Spring Security官方推荐的密码解析器是BCryptPasswordEncoder。接下来我们学习BCryptPasswordEncoder的使用。

 1、在junit中测试密码加密

@SpringBootTest
public class TestBCryptPasswordEncoder {
    @Test
    //测试BCryptPasswordEncoder
    public void t1(){
        //创建解析器
        BCryptPasswordEncoder encoder = new BCryptPasswordEncoder();

        //密码加密
        String password = encoder.encode("baizhan");
        System.out.println("加密后:"+password);

        //密码校验
        /**
         * 参数1:明文密码
         * 参数2:加密密码
         * 返回值：是否校验成功
         */
        boolean result = encoder.matches("baizhan","$2a$10$Kv7P7Hz/8fKsMH6LLL6uk.E2bxheW/M1jIwwTVQE6kwPK9IThpXne");
        System.out.println(result);
    }

}

2、将密码解析器设置为BCryptPasswordEncoder

@Configuration
public class SecurityConfig {

    //密码编译器，不解析密码
    @Bean
    public PasswordEncoder passwordEncoder(){
        return new BCryptPasswordEncoder();
    }
}

 3、将数据库中的明文密码改为刚刚测试输出的密文密码

 4、启动springBoot，访问localhost:8080/main，进入登录页面，分别输入用户名baizhan，sxt，和密码baizhan，sxt

 

 

当时输入sxt时就会报错误，这是因为sxt在数据库中的密码还是明文保存的，而BCryptPasswordEncoder会对所有密码进行加密，然后用加密的密码和数据库中的密码进行比对，所以登录报错

 

        自定义登录页面

虽然Spring Security给我们提供了登录页面，但在实际项目中，更多的是使用自己的登录页面。Spring Security也支持用户自定义登录页面。用法如下：

  1. 编写登录页面
  2. 在Spring Security配置类自定义登录页面（需要继承WebSecurityConfigurerAdapter)
@Configuration
public class SecurityConfig extends WebSecurityConfigurerAdapter{
  //Spring Security配置
  @Override
  protected void configure(HttpSecurity http) throws Exception {
    // 自定义表单登录
    http.formLogin() 
       .loginPage("/login.html") // 自定义登录页面
       .usernameParameter("username") // 表单中的用户名项
       .passwordParameter("password") // 表单中的密码项
       .loginProcessingUrl("/login") // 登录路径，表单向该路径提交，提交后自动执行UserDetailsService的方法
       .successForwardUrl("/main") //登录成功后跳转的路径
       .failureForwardUrl("/fail"); //登录失败后跳转的路径


    // 需要认证的资源
    http.authorizeRequests()
       .antMatchers("/login.html").permitAll() //登录页不需要认证
       .anyRequest().authenticated(); //其余所有请求都需要认证


    //关闭csrf防护
    http.csrf().disable();
   }


  @Override
  public void configure(WebSecurity web) throws Exception {
    // 静态资源放行
    web.ignoring().antMatchers("/css/**");
   }
}

 3、启动SpringBoot，访问localhost:8080/main，进入自定义登录页面，输入用户名和密码即可进入主界面

 

 

 

        退出登录

在系统中一般都有退出登录的操作。退出登录后，Spring Security进行了以下操作：

  • 清除认证状态
  • 销毁HttpSession对象
  • 跳转到登录页面

在Spring Security中，退出登录的写法如下：

1、在配置类中配置退出登录的路径和退出后跳转的路径

//退出登录配置
        http.logout()
                .logoutUrl("/logout")//退出登录路径
                .logoutSuccessUrl("/main")//退出成功访问路径
                .clearAuthentication(true)//清除认证状态，默认为true
                .invalidateHttpSession(true);//销毁HttpSession对象，默认为true

2、在网页中添加退出登录超链接

<!DOCTYPE html>
<html xmlns:th="http://www.thymeleaf.org"
      xmlns:sec="http://www.thymeleaf.org/thymeleaf-extras-springsecurity5">
<head>
    <meta charset="UTF-8">
    <title>主页面</title>
</head>
<body>
<h1>主页面</h1>
    <a href="/logout">退出登录</a>
</body>
</html>

 

 

 

        CSRF防护

CSRF：跨站请求伪造，通过伪造用户请求访问受信任的站点从而进行非法请求访问，是一种攻击手段。 Spring Security为了防止CSRF攻击，默认开启了CSRF防护，这限制了除了GET请求以外的大多数方法。我们要想正常使用Spring Security需要突破CSRF防护。

解决方法一：关闭CSRF防护：

http.csrf().disable();

解决方法二：突破CSRF防护：

CSRF为了保证不是其他第三方网站访问，要求访问时携带参数名为_csrf值为令牌，令牌在服务端产生，如果携带的令牌和服务端的令牌匹配成功，则正常访问。

<form class="form" action="/login" method="post">

 <!-- 在表单中添加令牌隐藏域 -->

 <input type="hidden" th:value="${_csrf.token}" name="_csrf" th:if="${_csrf}"/>

 <input type="text" placeholder="用户名" name="username">

 <input type="password" placeholder="密码" name="password">

 <button type="submit">登录</button>

</form>

 

        Remember me

Spring Security中Remember Me为“记住我”功能，即下次访问系统时无需重新登录。当使用“记住我”功能登录后，Spring Security会生成一个令牌，令牌一方面保存到数据库中，另一方面生成一个叫remember-me的Cookie保存到客户端。之后客户端访问项目时自动携带令牌，不登录即可完成认证。

1、编写RememberMeConfig配置类(固定写法)


@Configuration
public class RememberMeConfig {
    @Autowired
    private DataSource dataSource;

    //令牌Repository
    @Bean
    public PersistentTokenRepository getPersistentTokenRepository(){
        // 为Spring Security自带的令牌控制器设置数据源
        JdbcTokenRepositoryImpl jdbcTokenRepository = new JdbcTokenRepositoryImpl();
        jdbcTokenRepository.setDataSource(dataSource);
        //自动建表，第一次启动时需要，第二次启动时注释掉
        jdbcTokenRepository.setCreateTableOnStartup(true);
        return jdbcTokenRepository;
    }
}

2、修改security配置类

@Configuration
public class SecurityConfig extends WebSecurityConfigurerAdapter{
    @Autowired
    private MyUserDetailsService userDetailsService;
    @Autowired
    private PersistentTokenRepository repository;

    //Spring Security配置
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        // 自定义表单登录
        http.formLogin()
                .loginPage("/login.html") // 自定义登录页面
                .usernameParameter("username") // 表单中的用户名项
                .passwordParameter("password") // 表单中的密码项
                .loginProcessingUrl("/login") // 登录路径，表单向该路径提交，提交后自动执行UserDetailsService的方法
                .successForwardUrl("/main") //登录成功后跳转的路径
                .failureForwardUrl("/fail"); //登录失败后跳转的路径

        //退出登录配置
        http.logout()
                .logoutUrl("/logout")//退出登录路径
                .logoutSuccessUrl("/main")//退出成功访问路径
                .clearAuthentication(true)//清除认证状态，默认为true
                .invalidateHttpSession(true);//销毁HttpSession对象，默认为true




        //权限拦截配置
        http.authorizeRequests()
                .antMatchers("/login.html").permitAll() //登录页不需要认证
                .anyRequest().authenticated(); //其余所有请求都需要认证


        //Remember Me
        http.rememberMe()
                .userDetailsService(userDetailsService)//登录逻辑交给哪个对象
                .tokenRepository(repository) //持久层对象
                .tokenValiditySeconds(30); //保存时间，单位：秒

        //关闭csrf防护
//        http.csrf().disable();
    }

3、在登录页面中添加"记住我"复选框

<!doctype html>
<html lang="zh" xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge,chrome=1">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>登录</title>
    <link href="/css/styles.css" rel="stylesheet" >
</head>
<body>
<div class="htmleaf-container">
    <div class="wrapper">
        <div class="container">
            <h1>Welcome</h1>
            <form class="form" action="/login" method="post">
                <input type="hidden" th:value="${_csrf.token}" name="_csrf" th:if="${_csrf}">
                <input type="text" placeholder="用户名" name="username">
                <input type="password" placeholder="密码" name="password">
                <input type="checkbox" name="remember-me" value="true"/>记住我<br/>
                <button type="submit" id="login-button">登录</button>
            </form>
        </div>
        <ul class="bg-bubbles">
            <li></li>
            <li></li>
            <li></li>
            <li></li>
            <li></li>
            <li></li>
            <li></li>
            <li></li>
            <li></li>
            <li></li>
        </ul>
    </div>
</div>
</body>
</html>

重点：

为何要修改 name 属性修改为 remember-me，而不是别的什么名字呢？其实，原因并不复杂，简单点来说，这是Spring Security 框架默认的 记住我 复选框的名称。

 

 

Security授权

        RBAC

授权即认证通过后，系统给用户赋予一定的权限，用户只能根据权限访问系统中的某些资源。RBAC是业界普遍采用的授权方式，它有两种解释：

1、Role-Based Access Control

基于角色的访问控制，即按角色进行授权。比如在企业管理系统中，主体角色为总经理可以查询企业运营报表。逻辑为：

if(主体.hasRole("总经理角色")){

    查询运营报表

}

如果查询企业运营报表的角色变化为总经理和股东，此时就需要修改判断逻辑代码：

if(主体.hasRole总经理角色") ||主体.hasRole("股东角色")){("

    查询运营报表

}

此时我们可以发现，当需要修改角色的权限时就需要修改授权的相关代码，系统可扩展性差。

 

2、Resource-Based Access Control

基于资源的访问控制，即按资源（或权限）进行授权。比如在企业管理系统中，用户必须 具有查询报表权限才可以查询企业运营报表。逻辑为：

if(主体.hasPermission("查询报表权限")){

    查询运营报表

}

这样在系统设计时就已经定义好查询报表的权限标识，即使查询报表所需要的角色变化为总经理和股东也不需要修改授权代码，系统可扩展性强。该授权方式更加常用。

 

        权限表设计

用户和权限的关系为多对多，即用户拥有多个权限，权限也属于多个用户，所以建表方式如下：

这种方式需要指定用户有哪些权限，如：张三有查询工资的权限，即在用户权限中间表中添加一条数据，分别记录张三和查询工资权限ID。但在系统中权限数量可能非常庞大，如果一条一条添加维护数据较为繁琐。所以我们通常的做法是再加一张角色表：

用户角色，角色权限都是多对多关系，即一个用户拥有多个角色，一个角色属于多个用户；一个角色拥有多个权限，一个权限属于多个角色。这种方式需要指定用户有哪些角色，而角色又有哪些权限。

如：张三拥有总经理的角色，而总经理拥有查询工资、查询报表的权限，这样张三就拥有了查询工资、查询报表的权限。这样管理用户时只需管理少量角色，而管理角色时也只需要管理少量权限即可。接下来我们创建五张表：

CREATE TABLE `users` (

 `uid` int(11) NOT NULL AUTO_INCREMENT,

 `username` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,

 `password` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,

 `phone` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,

 PRIMARY KEY (`uid`) USING BTREE

) ENGINE = InnoDB AUTO_INCREMENT = 3 CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Dynamic;

INSERT INTO `users` VALUES (1, 'baizhan', '$2a$10$Eqv9PRMl6bPt5BiwgPr2eucgyl.E.xLENt4bvfDvv7DyS5AVPT.U6', '13812345678');





CREATE TABLE `role` (

 `rid` int(11) NOT NULL AUTO_INCREMENT,

 `roleName` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,

 `roleDesc` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,

 PRIMARY KEY (`rid`) USING BTREE

) ENGINE = InnoDB AUTO_INCREMENT = 4 CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Dynamic;

INSERT INTO `role` VALUES (1, '总经理', '管理整个公司');

INSERT INTO `role` VALUES (2, '股东', '参与公司决策');

INSERT INTO `role` VALUES (3, '财务', '管理公司资产');





CREATE TABLE `permission` (

 `pid` int(11) NOT NULL AUTO_INCREMENT,

 `permissionName` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,

 `url` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,

 PRIMARY KEY (`pid`) USING BTREE

) ENGINE = InnoDB AUTO_INCREMENT = 4 CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Dynamic;

INSERT INTO `permission` VALUES (1, '查询报表', '/reportform/find');

INSERT INTO `permission` VALUES (2, '查询工资', '/salary/find');

INSERT INTO `permission` VALUES (3, '查询税务', '/tax/find');





CREATE TABLE `users_role` (

 `uid` int(255) NOT NULL,

 `rid` int(11) NOT NULL,

 PRIMARY KEY (`uid`, `rid`) USING BTREE,

 INDEX `rid`(`rid`) USING BTREE,

 CONSTRAINT `users_role_ibfk_1` FOREIGN KEY (`uid`) REFERENCES `users` (`uid`) ON DELETE RESTRICT ON UPDATE RESTRICT,

 CONSTRAINT `users_role_ibfk_2` FOREIGN KEY (`rid`) REFERENCES `role` (`rid`) ON DELETE RESTRICT ON UPDATE RESTRICT

) ENGINE = InnoDB CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Dynamic;

INSERT INTO `users_role` VALUES (1, 2);

INSERT INTO `users_role` VALUES (1, 3);





CREATE TABLE `role_permission` (

 `rid` int(11) NOT NULL,

 `pid` int(11) NOT NULL,

 PRIMARY KEY (`rid`, `pid`) USING BTREE,

 INDEX `pid`(`pid`) USING BTREE,

 CONSTRAINT `role_permission_ibfk_1` FOREIGN KEY (`rid`) REFERENCES `role` (`rid`) ON DELETE RESTRICT ON UPDATE RESTRICT,

 CONSTRAINT `role_permission_ibfk_2` FOREIGN KEY (`pid`) REFERENCES `permission` (`pid`) ON DELETE RESTRICT ON UPDATE RESTRICT

) ENGINE = InnoDB CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Dynamic;

INSERT INTO `role_permission` VALUES (1, 1);

INSERT INTO `role_permission` VALUES (2, 1);

INSERT INTO `role_permission` VALUES (1, 2);

INSERT INTO `role_permission` VALUES (3, 2);

INSERT INTO `role_permission` VALUES (1, 3);

INSERT INTO `role_permission` VALUES (2, 3);

 

        查询访问权限

1、编写pojo类

// 不要命名为User，避免和Spring Security提供的User混淆
@Data
public class Users {
  private Integer uid;
  private String username;
  private String password;
  private String phone;
}


// 角色
@Data
public class Role {
  private String rid;
  private String roleName;
  private String roleDesc;
}


// 权限
@Data
public class Permission {
  private String pid;
  private String permissionName;
  private String url;
}

2、编写UsersMapper接口

@Repository
public interface UsersMapper extends BaseMapper<Users> {
    List<Permission> findPermissionByUsername(String username);
}

3、在resource目录中编写UsersMapper映射文件

<?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.itbaizhan.security_blog.mapper.UsersMapper">
    <select id="findPermissionByUsername" parameterType="string" resultType="com.itbaizhan.security_blog.domain.Permission">
     SELECT DISTINCT permission.pid,permission.permissionName,permission.url FROM
     users
     LEFT JOIN users_role on users.uid = users_role.uid
     LEFT JOIN role on users_role.rid = role.rid
     LEFT JOIN role_permission on role.rid = role_permission.rid
     LEFT JOIN permission on role_permission.pid = permission.pid
     where username = #{username}
  </select>
</mapper>

4、测试查询方法

@SpringBootTest
public class UsersMapperTest {
    @Autowired
    private UsersMapper usersMapper;


    @Test
    public void testFindPermissionByUsername(){
        List<Permission> baizhan = usersMapper.findPermissionByUsername("baizhan");
        baizhan.forEach(System.out::println);
    }
}

 

        配置类设置访问权限

1、编写控制器，添加控制器方法 

@RestController
public class MyController {
  @GetMapping("/reportform/find")
  public String findReportForm() {
    return "查询报表";
   }


  @GetMapping("/salary/find")
  public String findSalary() {
    return "查询工资";
   }


  @GetMapping("/staff/find")
  public String findStaff() {
    return "查询员工";
   }
}

2、修改认证逻辑MyUserDetailsService类，认证成功后给用户授权 

// 自定义认证逻辑
@Override
public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
  // 1.构造查询条件
  QueryWrapper<Users> wrapper = new QueryWrapper<Users>().eq("username", username);
  // 2.查询用户
  Users users = userMapper.selectOne(wrapper);
  if (users == null){
    return null;
   }
  // 3.查询用户权限
  List<Permission> permissions = userMapper.findPermissionByUsername(username);
  // 4.将自定义权限集合转为Security的权限类型集合
  List<GrantedAuthority> grantedAuthorities = new ArrayList<>();
  for (Permission permission : permissions) {
    grantedAuthorities.add(new SimpleGrantedAuthority(permission.getUrl()));
   }
  // 5.封装为UserDetails对象
  UserDetails userDetails = User.withUsername(users.getUsername())
     .password(users.getPassword())
     .authorities(grantedAuthorities)
     .build();
  // 6.返回封装好的UserDetails对象
  return userDetails;
}

 3、修改security配置类

// 权限拦截配置
http.authorizeRequests()
     .antMatchers("/login.html").permitAll() // 表示任何权限都可以访问
     .antMatchers("/reportform/find").hasAnyAuthority("/reportform/find") // 给资源配置需要的权限
     .antMatchers("/salary/find").hasAnyAuthority("/salary/find")
     .antMatchers("/staff/find").hasAnyAuthority("/staff/find")
     .anyRequest().authenticated(); //表示任何请求都需要认证后才能访问

 4、测试访问资源，由于没有权限被拦截访问时会抛出403异常

        自定义访问控制逻辑

如果资源数量很多，一条条配置需要的权限效率较低。我们可以自定义访问控制逻辑，即访问资源时判断用户是否具有名为该资源URL的权限。

 

1、自定义访问控制逻辑

@Service

public class MyAuthorizationService {

  // 自定义访问控制逻辑，返回值为是否可以访问资源

  public boolean hasPermission(HttpServletRequest request, Authentication authentication){

    // 获取会话中的登录用户

    Object principal = authentication.getPrincipal();

    if (principal instanceof UserDetails){

      // 获取登录用户的权限

      Collection<? extends GrantedAuthority> authorities = ((UserDetails) principal).getAuthorities();

      // 获取请求的URL路径

      String uri = request.getRequestURI();

      // 将URL路径封装为权限对象

      SimpleGrantedAuthority authority = new SimpleGrantedAuthority(uri);

      // 判断用户的权限集合是否包含请求的URL权限对象

      return authorities.contains(authority);

     }

    return false;

   }

}

2、在配置文件中使用自定义访问控制逻辑

// 权限拦截配置

http.authorizeRequests()

         .antMatchers("/login.html").permitAll() // 表示任何权限都可以访问

        // 任何请求都使用自定义访问控制逻辑

         .anyRequest().access("@myAuthorizationService.hasPermission(request,authentication)");

 

注解设置访问权限

除了配置类，在SpringSecurity中提供了一些访问控制的注解。这些注解默认都是不可用的，需要开启后使用。

 

        @Secured

该注解是基于角色的权限控制，要求UserDetails中的权限名必须以ROLE_开头。

  1. 在配置类开启注解使用 
    @SpringBootApplication
@MapperScan("com.itbaizhan.mysecurity.mapper")
@EnableGlobalMethodSecurity(securedEnabled=true)
public class MysecurityApplication{
  public static void main(String[] args) {
    SpringApplication.run(MysecurityApplication.class, args);
   }
}
  2. 在控制器方法上添加注解 
    @Secured("ROLE_reportform")
@GetMapping("/reportform/find")
public String findReportForm() {
  return "查询报表";
}

        @PreAuthorize

该注解可以在方法执行前判断用户是否具有权限

  1. 在配置类开启注解使用 
    @SpringBootApplication
@MapperScan("com.itbaizhan.mysecurity.mapper")
@EnableGlobalMethodSecurity(prePostEnabled=true)
public class MysecurityApplication{
  public static void main(String[] args) {
    SpringApplication.run(MysecurityApplication.class, args);
   }
}
  2. 在控制器方法上添加注解 
    @PreAuthorize("hasAnyAuthority('/reportform/find')")
@GetMapping("/reportform/find")
public String findReportForm() {
  return "查询报表";
}

 

前端进行访问控制 

SpringSecurity可以在一些视图技术中进行控制显示效果。

例如Thymeleaf中，只有登录用户拥有某些权限才会展示一些菜单。

 

1、在pom中引入Spring Security和Thymeleaf的整合依赖

<!--Spring Security整合Thymeleaf-->

<dependency>

  <groupId>org.thymeleaf.extras</groupId>

  <artifactId>thymeleaf-extras-springsecurity5</artifactId>

</dependency>

2、在Thymeleaf中使用Security标签，控制前端的显示内容

<!DOCTYPE html>

<html xmlns:th="http://www.thymeleaf.org"

   xmlns:sec="http://www.thymeleaf.org/thymeleaf-extras-springsecurity5">

<head>

  <meta charset="UTF-8">

  <title>主页面</title>

</head>

<body>

<h1>主页面</h1>

<ul>

  <li sec:authorize="hasAnyAuthority('/reportform/find')"><a href="/reportform/find">查询报表</a></li>

  <li sec:authorize="hasAnyAuthority('/salary/find')"><a href="/salary/find">查询工资</a></li>

  <li sec:authorize="hasAnyAuthority('/staff/find')"><a href="/staff/find">查询员工</a></li>

</ul>

<a href="/logout">退出登录</a>

</body>

</html>

3、这样面对不同权限的用户，前端可以显示不同的菜单

 

403处理方案

使用Spring Security时经常会看见403（无权限），

这样的页面很不友好，我们可以自定义403异常处理方案：

 

1、编写权限不足页面noPermission.html

<!DOCTYPE html>

<html lang="en">

<head>

  <meta charset="UTF-8">

  <title>权限不足</title>

</head>

<body>

<h1>您的权限不足，请联系管理员！</h1>

</body>

</html>

2、编写权限不足处理类（需要实现AccessDeniedHandler接口）

public class MyAccessDeniedHandler implements AccessDeniedHandler {

  @Override

  public void handle(HttpServletRequest request, HttpServletResponse response, AccessDeniedException accessDeniedException) throws IOException, ServletException {

    response.sendRedirect("/noPermission.html");

   }

}

3、在Spring Security配置文件中配置异常处理

//异常处理

http.exceptionHandling().

        accessDeniedHandler(new MyAccessDeniedHandler());

 

c_mmmmmmm
关注
  • 0
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
springsecurity：Spring安全学习总结
01-29
spring security 学习总结暑假的时候在学习了Spring安全并成功运用到了项目中。在实践中摸索出了一套结合JSON +智威汤逊（JSON网络令牌）+Spring引导+ Spring Security的技术的权限方案趁着国庆假期记录一下。 内容 ...
springSecurity总结及示例代码
03-28
springSecurity总结，另有示例代码。
spirng框架之spring security（二）使用access()方法实现RBAC权限模型（另包涵简单动态菜单实现）
u011529483的博客
03-27 1480
spirng框架之spring security（二） 使用access()方法实现RBAC权限模型（另包涵简单动态菜单实现）
springSecurity总结
weixin_34110749的博客
06-23 284
springSecurity总结： 一、Spring security框架简介 1、简介 一个能够为基于Spring的企业应用系统提供声明式的安全訪问控制解决方式的安全框架（简单说是对访问权限进行控制嘛），应用的安全性包括用户认证（Authentication）和用户授权（Authorization）两个部分。用户认证指的是验证某个用户是否为系统中的合法主体...
权限验证不迷茫---Spring Security入门-01
m0_48372951的博客
10-07 166
这里写自定义目录标题欢迎使用Markdown编辑器新的改变功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 欢迎使用Markdown编辑器 你好！ 这是你第一次使用 Markdown编辑器 所展示的欢迎页。如果你想学习如何使用Mar
spring security 学习总结
zwjapple的专栏
07-02 354
spring security 学习
SpringSecurity简单使用的总结
m0_51972565的博客
08-03 268
SpringSecurity的作用：实现对web应用的访问进行认证与授权认证：验证当前访问系统的用户是不是合法的用户，并且确认具体的身份授权：在经过认证以后，判断当前用户是否具有权限进行某个操作。本文对简单使用SpringSecurity做了一些总结......
Spring security实现登陆和权限角色控制
09-09
Spring Security 是一个强大的安全框架，主要用于Java应用的安全管理，包括认证和授权。在这个场景中，我们将探讨如何使用Spring Security来实现登录和权限角色控制。首先，确保你正在使用的Spring版本为4.3.2....
Spring Security学习总结一
06-06
Spring Security学习总结
spring security环境搭建
08-29
Spring Security 环境搭建详解 Spring Security 是一个功能强大且灵活的安全框架，用于保护基于 Java 的 Web 应用程序。今天，我们将详细介绍如何搭建 Spring Security 环境，包括 Maven 依赖项的设置、web.xml ...
Spring Security 使用总结
u011277123的博客
10-09 2751
Java团长 2017-10-06 22:41 暑假的时候在学习了 Spring Security 并成功运用到了项目中。 在实践中摸索出了一套结合 json + jwt(json web token) + Spring Boot + Spring Security 技术的权限方案趁着国庆假期记录一下。 以下所有步骤的源码可以从我的 github 上取得。如果要了解，请阅读 readm
SpringSecurity学习总结
qq_44185887的博客
04-12 930
一、spring security 简介 认证：（你是谁）身份认证，使用系统的任何用户，系统对于他来讲必须要能够进行识别，这个识别的过程我们就称之为认证。在此过程中牵涉到两个表，用户表和角色表，他们能够确定用户的权限。 授权（你能干什么）：对于一个指定的用户，系统必须能够知道他具体有什么权限。权限表能够确定用户拥有什么权限。一个完整的系统，必须能够进行认证和鉴权，否则系统不具有安全性，系统的功能也不具有任何意义！ 攻击防护：（防止伪造身份） <!--设置不拦截这个页面！-->
Spring Security 总结
凡的博客
03-21 6400
Spring Security 总结
SpringSecurity利用RAS加密对登录账号密码请求明文加密
wangtao753的博客
06-21 2866
1:场景 在用户登录时,只要对浏览网页有点基础的人都知道,打开浏览器控制台,可以在请求抓包块中可以获取到post请求的头部信息,而我们用户登录的账号密码恰恰就保存在这里,加入没有加密的话,别人可以爬取到用户的信息,一点都不安全,所以纠结问题,我们在请求中对账号密码全部加密传后台解密,这样这个问题就解决了,思路就是这么个逻辑,而具体怎么实现就是我们接下来要讲的问题;如下 2:技术点 采用springsecurity实现用户认证和授权,RAS非对称加密对数据进行加密 3:技术描述 RAS简称非对称加密,安全系数
SpringSecurity学习（二）：Web权限简单使用
m0_49499183的博客
04-15 1094
一、设置登录系统的账号密码 1、在application文件中设置 spring.security.user.name=tom spring.security.user.password=123 但是密码明文写在文档中，总归是不好的。 2、编写类实现接口 @Configuration public class SecurityConfig extends WebSecurityConfigurerAdapter { @Ov...
SpringSecurity用户认证、授权、注销和记住我
tian_彡
06-09 1367
视频讲解可关注B站 狂神说Java Spring Security是针对Spring项目的安全框架,也是Spring Boot底层安全模块默认的技术选型,他可以实现强大的Web安全控制，对于安全控制，我们仅需要引入spring boot-starter-security模块,进行少量的配置，即可实现强大的安全管理! 记住几个类: ●WebSecurityConfigurerAdapter: 自定义Security策略 ●AuthenticationManagerBuilder: 自定义认证策略 ●@Enab
SpringSecurity —— 2、web 权限方案
Mr_zhangyj的博客
04-24 945
1、设置登录系统的账号、密码 1.1、方法一：在配置文件 application.properties 中设置 spring.security.user.name=zyj spring.security.user.password=123456 1.2、方法二：通过配置类 @Configuration public class SecurityConfig extends WebSecurityConfigurerAdapter { @Override protected v
Spring Security入门（三）：密码加密
热门推荐
程序猿DD
01-17 2万+
前文导读- Spring Security入门（一）：登录与退出- Spring Security入门（二）：基于数据库验证Github 地址https://github.com/ChinaSilence/any-spring-security 本文对应 security-login-db-encryptPWD摘要解决2个问题：注册时密码加密后存入数据库登录时密码加密校验运行程序1、clone 代
Spring Security入门学习
lmfxiaohuo的博客
12-13 358
认识Spring Security Spring Security 是为基于 Spring 的应用程序提供声明式安全保护的安全性框架。Spring Security 提供了完整的安全性解决方案，它能够在 Web 请求级别和方法调用级别处理身份认证和授权。因为基于 Spring 框架，所以 Spring Security 充分利用了依赖注入（dependency injection， DI）和面向切面的技术。 核心功能 对于一个权限管理框架而言，无论是 Shiro 还是 Spring Security，最最核
Spring Security
最新发布
09-13
Spring Security是Spring家族中的一...总结起来，Spring Security是一个功能丰富且广泛使用的安全管理框架，适用于中大型项目。在Spring Boot项目中使用Spring Security非常简单，只需引入相应的依赖即可实现入门案例。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值