springsecurity详解

 介绍

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

认证

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

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

授权

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

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

搭建项目

依赖

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

认证逻辑

UserDetailsService

在实际项目中，认证逻辑是需要自定义控制的。将UserDetailsService接口的实现类放入Spring容器即可自定义认证逻辑

  public interface UserDetailsService {
                UserDetails loadUserByUsername(String username) throws UsernameNotFoundException;
            }

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

InMemoryUserDetailsManager是UserDetailsService的一个实现类，它将登录页传来的用户名密码和内存中用户名密码做匹配认证。

当然我们也可以自定义UserDetailsService接口的实现类

内存认证

在实际开发中，用户数量不会只有一个，且密码是自己设置的。所以我们需要自定义配置用户信息。

首先我们在内存中创建两个用户，Spring Security会将登录页传来的用户名密码和内存中用户名密码做匹配认证

  // Security配置类
            @Configuration
            public class SecurityConfig {
              // 定义认证逻辑
              @Bean
              public UserDetailsService userDetailsService(){
                // 1.使用内存数据进行认证
                InMemoryUserDetailsManager manager = new InMemoryUserDetailsManager();
            
           
                // 2.创建两个用户
                UserDetails user1 = User.withUsername("baizhan").password("123").authorities("admin").build();
                UserDetails user2 = User.withUsername("sxt").password("456").authorities("admin").build();
            
            
                // 3.将这两个用户添加到内存中
                manager.createUser(user1);
                manager.createUser(user2);
            
            
                return manager;
               }
            
            
              //密码编码器，不解析密码
              @Bean
              public PasswordEncoder passwordEncoder(){
                return NoOpPasswordEncoder.getInstance();
               }
            }

数据库认证

实体类

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

@Service
            public class MyUserDetailsService implements UserDetailsService {
              @Autowired
              private UsersMapper usersMapper;
            
            
              // 自定义认证逻辑
              @Override
              public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
                // 1.构造查询条件
                QueryWrapper wrapper = new QueryWrapper().eq("username", username);
                // 2.查询用户
                Users users = usersMapper.selectOne(wrapper);
                // 3.封装为UserDetails对象
                UserDetails userDetails = User
                     .withUsername(users.getUsername())
                     .password(users.getPassword())
                     .authorities("admin")
                     .build();
                // 4.返回封装好的UserDetails对象
                return userDetails;
               }
            }
              
        

数据库认证【包含权限】

 /**
          * 认证授权逻辑
          */
         @Service
         public class MyUserDetailService implements UserDetailsService {
             @Autowired
             private AdminService adminService;
         
         
             @Override
             public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
                 // 1.认证
                 Admin admin = adminService.findByName(username);
                 if (admin == null) {
                     throw new UsernameNotFoundException("用户不存在");
                 }
                 if (!admin.isStatus()) {
                     throw new UsernameNotFoundException("用户不可用");
                 }
         
                 // 2.授权
                 List<Permission> permissions = adminService.findAllPermission(username);
                 List<GrantedAuthority> grantedAuthorities = new ArrayList<>();
                 for (Permission permission : permissions) {
                     grantedAuthorities.add(new SimpleGrantedAuthority(permission.getPermissionDesc()));
                 }
         
         
                 // 3.封装为UserDetails对象
                 UserDetails userDetails = User.withUsername(admin.getUsername())
                         .password(admin.getPassword())
                         .authorities(grantedAuthorities)
                         .build();
         
         
                 // 4.返回封装好的UserDetails对象
                 return userDetails;
             }
         }

认证配置

PasswordEncoder

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

NoOpPasswordEncoder是PasswordEncoder的实现类，意思是不解析密码，使用明文密码

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

Spring Security官方推荐的密码解析器是BCryptPasswordEncoder

在开发中，我们将BCryptPasswordEncoder的实例放入Spring容器即可，并且在用户注册完成后，将密码加密再保存到数据库

 //密码编码器
            @Bean
            public PasswordEncoder passwordEncoder() {
              return new BCryptPasswordEncoder();
            }

测试加密和验证

 @SpringBootTest
            public class PasswordEncoderTest {
              @Test
              public void testBCryptPasswordEncoder(){
                //创建解析器
                PasswordEncoder encoder = new BCryptPasswordEncoder();
            
            
                //密码加密
                String password = encoder.encode("baizhan");
                System.out.println("加密后:"+password);
            
            
                //密码校验
                /**
                 * 参数1:明文密码
                 * 参数2:加密密码
                 * 返回值：是否校验成功
                 */
                boolean result = encoder.matches("baizhan","$2a$10$/MImcrpDO21HAP2amayhme8j2SM0YM50/WO8YBH.NC1hEGGSU9ByO");
                System.out.println(result);
               }
            }

自定义登录页面

 @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/**");
               }
            }

跨域配置

            //解决跨域
            CorsConfigurationSource configurationSource() {
                List list = new ArrayList();
                list.add("http://127.0.0.1:8020/");
                list.add("http://118.31.60.184:8020/");
                list.add("http://jkw.life:8020/");
                CorsConfiguration corsConfiguration = new CorsConfiguration();
                corsConfiguration.setAllowedHeaders(Collections.singletonList("*"));
                //允许跨域访问的请求方式Arrays.asList("GET","POST")
                corsConfiguration.setAllowedMethods(Collections.singletonList("*"));
                //允许跨域访问的站点Arrays.asList("http://127.0.0.1:5173/")Collections.singletonList("*")
                corsConfiguration.setAllowedOrigins(list);
                // 允许携带凭证
                corsConfiguration.setAllowCredentials(true);
                corsConfiguration.setMaxAge(3600L);
                UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource();
                //对所有URL生效
                source.registerCorsConfiguration("/**", corsConfiguration);
                return source;
            }
            
            // 开启跨域访问
            http.cors().configurationSource(configurationSource());

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> 
        

退出登录

          // 退出登录配置
          http.logout()
             .logoutUrl("/logout") // 退出登录路径
             .logoutSuccessUrl("/login.html") // 退出登录后跳转的路径
             .clearAuthentication(true) //清除认证状态，默认为true
             .invalidateHttpSession(true); // 销毁HttpSession对象，默认为true

Remember Me

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

编写“记住我”配置类

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

修改Security配置类

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

在登录页面添加“记住我”复选框

   name的值为remember-me
          <input type="checkbox" name="remember-me" value="true"/>记住我</br>  

处理器

会话管理

用户认证通过后，有时我们需要获取用户信息，比如在网站顶部显示：欢迎您，XXX。 Spring Security将用户信息保存在会话中，并提供会话管理。

获取用户信息的写法如下

   @RestController
            public class MyController {
              // 获取当前登录用户名
              @RequestMapping("/users/username")
              public String getUsername(){
                // 1.获取会话对象
                SecurityContext context = SecurityContextHolder.getContext();
                // 2.获取认证对象
                Authentication authentication = context.getAuthentication();
                // 3.获取登录用户信息
                UserDetails userDetails = (UserDetails) authentication.getPrincipal();
                return userDetails.getUsername();
               }
            }            
        

登录成功处理器

  /**
            * 登录成功处理器
            */
           public class MyLoginSuccessHandler implements AuthenticationSuccessHandler {
               @Override
               public void onAuthenticationSuccess(HttpServletRequest request, HttpServletResponse response, Authentication authentication) throws IOException, ServletException {
                   response.setContentType("text/json;charset=utf-8");
                   UserDetails userDetails = (UserDetails) authentication.getPrincipal();
           
                   BaseResult result = new BaseResult(200, "登录成功", userDetails);
                   response.getWriter().write(JSON.toJSONString(result));
               }
           }

配置登录成功处理器【替换登录成功跳转的页面】

    http.formLogin()
                    ......
                    .successHandler(new MyLoginSuccessHandler()) // 登录成功处理器
        

登录失败处理器

/**
            * 登录失败处理器
            */
           public class MyLoginFailureHandler implements AuthenticationFailureHandler {
               @Override
               public void onAuthenticationFailure(HttpServletRequest request, HttpServletResponse response, AuthenticationException exception) throws IOException, ServletException {
                   response.setContentType("text/json;charset=utf-8");
                   BaseResult result = new BaseResult(402, "用户名或密码错误", null);
                   response.getWriter().write(JSON.toJSONString(result));
               }
           }

配置登录失败处理器【替换登录失败跳转的页面】

     http.formLogin()
                    ......
                    .failureHandler(new MyLoginFailureHandler()); // 登录失败处理器
           

退出成功处理器

            /**
            * 退出登录成功成功处理器
            */
           public class MyLogoutSuccessHandler implements LogoutSuccessHandler {
               @Override
               public void onLogoutSuccess(HttpServletRequest request, HttpServletResponse response, Authentication authentication) throws IOException, ServletException {
                   response.setContentType("text/json;charset=utf-8");
                   BaseResult result = new BaseResult(200, "注销成功", null);
                   response.getWriter().write(JSON.toJSONString(result));
               }
           }

配置退出成功处理器

   // 退出登录配置
           http.logout()
                   .logoutUrl("/sys/logout") // 退出登录路径
                   .logoutSuccessHandler(new MyLogoutSuccessHandler()) // 登出成功处理器
                   .clearAuthentication(true) // 清除认证数据
                   .invalidateHttpSession(true); // 清除session

异常处理器【未登录/权限不足】

   /**
          * 未登录处理器
          */
         public class MyAuthenticationEntryPoint implements AuthenticationEntryPoint {
             @Override
             public void commence(HttpServletRequest request, HttpServletResponse response, AuthenticationException authException) throws IOException, ServletException {
                 response.setContentType("text/json;charset=utf-8");
                 BaseResult result = new BaseResult(401, "用户未登录,请登录", null);
                 response.getWriter().write(JSON.toJSONString(result));
             }
         }
         
         /**
         * 权限不足处理器
         */
        public class MyAccessDeniedHandler implements AccessDeniedHandler {
            @Override
            public void handle(HttpServletRequest request, HttpServletResponse response, AccessDeniedException accessDeniedException) throws IOException, ServletException {
                response.setContentType("text/json;charset=utf-8");
                BaseResult result = new BaseResult(403, "权限不足", null);
                response.getWriter().write(JSON.toJSONString(result));
            }
        }

配置类中配置

    // 异常处理
        http.exceptionHandling()
                .authenticationEntryPoint(new MyAuthenticationEntryPoint()) // 未登录处理器
                .accessDeniedHandler(new MyAccessDeniedHandler()); // 权限不足处理器
        

授权

RBAC

RBAC是业界普遍采用的授权方式，它有两种解释：

Role-Based Access Control:基于角色的访问控制，即按角色进行授权

Resource-Based Access Control:基于资源的访问控制，即按资源（或权限）进行授权。

权限表设计

数据库

DROP TABLE IF EXISTS `admin`;
CREATE TABLE `admin` (
  `aid` int(32) NOT NULL AUTO_INCREMENT,
  `email` varchar(50) DEFAULT NULL,
  `username` varchar(50) DEFAULT NULL,
  `password` varchar(255) DEFAULT NULL,
  `phoneNum` varchar(20) DEFAULT NULL,
  `status` tinyint(1) DEFAULT NULL,
  `adminImg` varchar(255) DEFAULT NULL,
  PRIMARY KEY (`aid`),
  UNIQUE KEY `email` (`email`)
) ENGINE=InnoDB AUTO_INCREMENT=9 DEFAULT CHARSET=utf8;

DROP TABLE IF EXISTS `admin_role`;
CREATE TABLE `admin_role` (
  `aid` varchar(32) NOT NULL,
  `rid` varchar(32) NOT NULL,
  PRIMARY KEY (`aid`,`rid`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

DROP TABLE IF EXISTS `permission`;
CREATE TABLE `permission` (
  `pid` int(32) NOT NULL AUTO_INCREMENT,
  `permissionName` varchar(50) DEFAULT NULL,
  `permissionDesc` varchar(50) DEFAULT NULL,
  PRIMARY KEY (`pid`)
) ENGINE=InnoDB AUTO_INCREMENT=22 DEFAULT CHARSET=utf8;

DROP TABLE IF EXISTS `role`;
CREATE TABLE `role` (
  `rid` int(32) NOT NULL AUTO_INCREMENT,
  `roleName` varchar(50) DEFAULT NULL,
  `roleDesc` varchar(50) DEFAULT NULL,
  PRIMARY KEY (`rid`)
) ENGINE=InnoDB AUTO_INCREMENT=12 DEFAULT CHARSET=utf8;

DROP TABLE IF EXISTS `role_permission`;
CREATE TABLE `role_permission` (
  `rid` varchar(32) DEFAULT NULL,
  `pid` varchar(32) DEFAULT NULL
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

java中权限的编写

实体类

/**
 * 用户
 */
@Data
public class Admin implements Serializable {
    @TableId
    private Integer aid;
    private String username;//姓名
    private String password;//密码
    private String phoneNum;//手机号

    private String email;//邮箱

    private String adminImg;//头像

    private boolean status; // 状态 true可用 false禁用
    @TableField(exist = false) // 不是数据库的字段
    private List<Role> roles; // 角色集合
}

/**
 * 权限
 */
@Data
public class Permission implements Serializable {
    @TableId
    private Integer pid;
    private String permissionName; //权限名
    private String permissionDesc;//权限详情
}

/**
 * 角色
 */
@Data
public class Role implements Serializable {
    @TableId
    private Integer rid;
    private String roleName; // 角色名
    private String roleDesc; // 角色介绍
    @TableField(exist = false) // 不是数据库的字段
    private List<Permission> permissions;// 权限集合
}

mapper

public interface AdminMapper extends BaseMapper<Admin> {
    // 根据id查询管理员，包括角色和权限
    Admin findById(Integer id);
    // 删除管理员的所有角色
    void deleteAdminAllRole(Integer id);
    // 给管理员添加角色
    void addRoleToAdmin(@Param("aid") Integer aid, @Param("rid") Integer rid);
    // 根据管理员名查询权限
    List<Permission> findAllPermission(String username);
}

public interface PermissionMapper extends BaseMapper<Permission> {
    // 删除角色_权限表中的相关数据
    void deletePermissionAllRole(Integer pid);
}

public interface RoleMapper extends BaseMapper<Role> {
    // 删除角色_权限中间表的相关数据
    void deleteRoleAllPermission(Integer rid);
    // 删除用户_角色表的相关数据
    void deleteRoleAllAdmin(Integer rid);
    // 根据id查询角色，包括权限
    Role findById(Integer id);
    // 给角色添加权限
    void addPermissionToRole(@Param("rid") Integer rid, @Param("pid")Integer pid);
}

mapper.xml

<?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="jkw.mapper.AdminMapper">
    <resultMap id="adminMapper" type="jkw.pojo.Admin">
        <id property="aid" column="aid"></id>
        <result property="username" column="username"></result>
        <result property="email" column="email"></result>
        <result property="phoneNum" column="phoneNum"></result>
        <result property="status" column="status"></result>
        <result property="adminImg" column="adminImg"></result>
        <collection property="roles" column="aid" ofType="jkw.pojo.Role">
            <id property="rid" column="rid"></id>
            <result property="roleName" column="roleName"></result>
            <result property="roleDesc" column="roleDesc"></result>
            <collection property="permissions" column="rid" ofType="jkw.pojo.Permission">
                <id property="pid" column="pid"></id>
                <result property="permissionName" column="permissionName"></result>
                <result property="permissionDesc" column="permissionDesc"></result>
            </collection>
        </collection>
    </resultMap>

    <delete id="deleteAdminAllRole" parameterType="int">
        DELETE
        FROM admin_role
        WHERE aid = #{id}
    </delete>
    <select id="findById" parameterType="int" resultMap="adminMapper">
        SELECT *
        FROM admin
                 LEFT JOIN admin_role
                           ON admin.aid = admin_role.aid
                 LEFT JOIN role
                           ON admin_role.rid = role.rid
                 LEFT JOIN role_permission
                           ON role.rid = role_permission.rid
                 LEFT JOIN permission
                           ON role_permission.pid = permission.pid
        WHERE admin.aid = #{id}
    </select>
    <insert id="addRoleToAdmin">
        INSERT INTO admin_role
        VALUES (#{aid}, #{rid});
    </insert>
    <select id="findAllPermission" resultType="jkw.pojo.Permission" parameterType="string">
        SELECT DISTINCT permission.*
        FROM admin
                 LEFT JOIN admin_role
                           ON admin.aid = admin_role.aid
                 LEFT JOIN role
                           ON admin_role.rid = role.rid
                 LEFT JOIN role_permission
                           ON role.rid = role_permission.rid
                 LEFT JOIN permission
                           ON role_permission.pid = permission.pid
        WHERE admin.username = #{username}
    </select>

</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="jkw.mapper.PermissionMapper">
    <delete id="deletePermissionAllRole" parameterType="int">
        DELETE
        FROM role_permission
        WHERE pid = #{pid}
    </delete>
</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="jkw.mapper.RoleMapper">
    <resultMap id="roleMapper" type="jkw.pojo.Role">
        <id property="rid" column="rid"></id>
        <result property="roleName" column="roleName"></result>
        <result property="roleDesc" column="roleDesc"></result>
        <collection property="permissions" column="rid" ofType="jkw.pojo.Permission">
            <id property="pid" column="pid"></id>
            <result property="permissionName" column="permissionName"></result>
            <result property="permissionDesc" column="permissionDesc"></result>
        </collection>
    </resultMap>
    <delete id="deleteRoleAllPermission" parameterType="int">
        DELETE
        FROM role_permission
        WHERE rid = #{rid}
    </delete>

    <delete id="deleteRoleAllAdmin" parameterType="int">
        DELETE
        FROM admin_role
        where rid = #{rid}
    </delete>
    <select id="findById" parameterType="int" resultMap="roleMapper">
        SELECT *
        FROM role
                 LEFT JOIN role_permission
                           ON role.rid = role_permission.rid
                 LEFT JOIN permission
                           ON role_permission.pid = permission.pid
        WHERE role.rid = #{id}
    </select>
    <insert id="addPermissionToRole">
        INSERT INTO role_permission
        VALUES (#{rid}, #{pid});
    </insert>
</mapper>

service

public interface AdminService {
    // 新增管理员
    void add(Admin admin);
    // 修改管理员
    void update(Admin admin);
    // 删除管理员【自定义】
    void delete(Integer id);
    //修改状态
    void updateStatus(Integer id);
    // 根据id查询管理员(查询用户详情)【自定义】
    Admin findById(Integer id);
    //分页查询管理员
    Page<Admin> search(int page, int size);
    // 修改管理员角色【自定义】
    void updateRoleToAdmin(Integer aid, Integer[] rids);
    // 根据名字查询管理员
    Admin findByName(String username);
    // 根据名字查询管理员所有权限
    List<Permission> findAllPermission(String username);
}

/**
 * 权限服务接口
 */
public interface PermissionService {
    // 新增权限
    void add(Permission permission);
    // 修改权限
    void update(Permission permission);
    // 删除权限【自定义】
    void delete(Integer id);
    // 根据id查询权限
    Permission findById(Integer id);
    // 查询所有权限
    List<Permission> findAll();
    // 分页查询权限
    Page<Permission> search(int page, int size);
}

/**
 * 角色服务接口
 */
public interface RoleService {
    // 新增角色
    void add(Role role);
    // 修改角色
    void update(Role role);
    // 删除角色
    void delete(Integer id);
    // 根据id查询角色【自定义】
    Role findById(Integer id);
    // 查询所有角色
    List<Role> findAll();
    // 分页查询角色
    Page<Role> search(int page, int size);
    // 修改角色的权限【自定义】
    void addPermissionToRole(Integer rid, Integer[] pids);
}

serviceImpl

@Service
@Transactional
public class AdminServiceImpl implements AdminService {
    @Autowired
    private AdminMapper adminMapper;

    @Override
    public void add(Admin admin) {
        adminMapper.insert(admin);
        //初始化用户，不然添加后什么角色都没有，会报错
        adminMapper.addRoleToAdmin(admin.getAid(), 2);
    }

    @Override
    public void update(Admin admin) {
        // 如果前端传来空密码，则密码还是原来的密码
        if (!StringUtils.hasText(admin.getPassword())) {
            // 查询原来的密码
            String password = adminMapper.selectById(admin.getAid()).getPassword();
            admin.setPassword(password);
        }
        adminMapper.updateById(admin);
    }

    @Override
    public void delete(Integer id) {
        // 删除用户的所有角色
        adminMapper.deleteAdminAllRole(id);
        // 删除用户
        adminMapper.deleteById(id);
    }

    @Override
    public void updateStatus(Integer id) {
        Admin admin = adminMapper.selectById(id);
        admin.setStatus(!admin.isStatus());//状态取反
        adminMapper.updateById(admin);
    }

    @Override
    public Admin findById(Integer id) {
        return adminMapper.findById(id);
    }

    @Override
    public Page<Admin> search(int page, int size) {
        return adminMapper.selectPage(new Page<>(page, size), null);
    }

    @Override
    public void updateRoleToAdmin(Integer aid, Integer[] rids) {
        // 删除用户的所有角色
        adminMapper.deleteAdminAllRole(aid);
        // 重新添加管理员角色
        for (Integer rid : rids) {
            adminMapper.addRoleToAdmin(aid, rid);
        }
    }

    @Override
    public Admin findByName(String username) {
        QueryWrapper<Admin> wrapper = new QueryWrapper();
        wrapper.eq("username", username);
        Admin admin = adminMapper.selectOne(wrapper);
        return admin;
    }

    @Override
    public List<Permission> findAllPermission(String username) {
        return adminMapper.findAllPermission(username);
    }
}

@Transactional
@Service
public class PermissionServiceImpl implements PermissionService {
    @Autowired
    private PermissionMapper permissionMapper;
    @Override
    public void add(Permission permission) {
        permissionMapper.insert(permission);
    }

    @Override
    public void update(Permission permission) {
        permissionMapper.updateById(permission);
    }

    @Override
    public void delete(Integer id) {
        // 删除权限
        permissionMapper.deleteById(id);
        // 删除角色_权限表中的相关数据
        permissionMapper.deletePermissionAllRole(id);
    }

    @Override
    public Permission findById(Integer id) {
        return permissionMapper.selectById(id);
    }

    @Override
    public List<Permission> findAll() {
        return permissionMapper.selectList(null);
    }

    @Override
    public Page<Permission> search(int page, int size) {
        return permissionMapper.selectPage(new Page(page,size),null);
    }
}

@Service
@Transactional
public class RoleServiceImpl implements RoleService {
    @Autowired
    private RoleMapper roleMapper;
    @Override
    public void add(Role role) {
        roleMapper.insert(role);
    }

    @Override
    public void update(Role role) {
        roleMapper.updateById(role);
    }

    @Override
    public void delete(Integer id) {
        // 删除角色
        roleMapper.deleteById(id);
        // 删除角色_权限中间表的相关数据
        roleMapper.deleteRoleAllPermission(id);
        // 删除用户_角色中间表的相关数据
        roleMapper.deleteRoleAllAdmin(id);
    }

    @Override
    public Role findById(Integer id) {
        return roleMapper.findById(id);
    }

    @Override
    public List<Role> findAll() {
        return roleMapper.selectList(null);
    }

    @Override
    public Page<Role> search(int page, int size) {
        return roleMapper.selectPage(new Page(page,size),null);
    }

    @Override
    public void addPermissionToRole(Integer rid, Integer[] pids) {
        // 删除角色的所有权限
        roleMapper.deleteRoleAllPermission(rid);
        // 给角色添加权限
        for (Integer pid : pids) {
            roleMapper.addPermissionToRole(rid,pid);
        }
    }
}

controller

@RestController
@RequestMapping("/sys/admin")
@CrossOrigin
public class AdminController {
    @Autowired
    private AdminService adminService;
    @Autowired
    private PasswordEncoder encoder;

    /**
     * 新增管理员
     *
     * @param admin 管理员
     * @return
     */
    @PostMapping("/add")
    public BaseResult add(Admin admin) {
        String password = admin.getPassword();
        password = encoder.encode(password);
        admin.setPassword(password);
        adminService.add(admin);
        return BaseResult.ok();
    }

    /**
     * 修改管理员（设置空密码则还是原来密码）
     *
     * @param admin 管理员
     * @return
     */
    @PostMapping("/update")
    public BaseResult update(Admin admin) {
        String password = admin.getPassword();
        if (StringUtils.hasText(password)) { // 密码不为空加密
            password = encoder.encode(password);
            admin.setPassword(password);
        }
        adminService.update(admin);
        return BaseResult.ok();
    }

    /**
     * 删除管理员(附带对应的角色)
     *
     * @param aid 管理员id
     * @return
     */
    @DeleteMapping("/delete")
    public BaseResult delete(Integer aid) {
        adminService.delete(aid);
        return BaseResult.ok();
    }

    /**
     * 修改管理员的状态
     *
     * @param aid 管理员id
     * @return
     */
    @PostMapping("/updateStatus")
    public BaseResult updateStatus(Integer aid) {
        adminService.updateStatus(aid);
        return BaseResult.ok();
    }

    /**
     * 根据id查询管理员(详情)
     *
     * @param aid 管理员id
     * @return
     */
    @GetMapping("/findById")
    public BaseResult<Admin> findById(Integer aid) {
        Admin admin = adminService.findById(aid);
        return BaseResult.ok(admin);
    }

    /**
     * 分页查询管理员
     *
     * @param page 当前页
     * @param size 每页条数
     * @return
     */
    @PreAuthorize("hasAnyAuthority('/sys/admin')")
    @GetMapping("/search")
    public BaseResult<Page<Admin>> search(int page, int size) {
        Page<Admin> adminPage = adminService.search(page, size);
        return BaseResult.ok(adminPage);
    }

    /**
     * 修改管理员角色
     *
     * @param aid  管理员id
     * @param rids 角色id
     * @return
     */
    @PostMapping("/updateRoleToAdmin")
    public BaseResult updateRoleToAdmin(Integer aid, Integer[] rids) {
        adminService.updateRoleToAdmin(aid, rids);
        return BaseResult.ok();
    }

    /**
     * 获取登录管理员名
     *
     * @return 管理员名
     */
    @GetMapping("/getUsername")
    public BaseResult<String> getUsername() {
        // 1.获取会话对象
        SecurityContext context = SecurityContextHolder.getContext();
        // 2.获取认证对象
        Authentication authentication = context.getAuthentication();
        // 3.获取登录用户信息
        UserDetails userDetails = (UserDetails) authentication.getPrincipal();
        String username = userDetails.getUsername();
        return BaseResult.ok(username);
    }
    @GetMapping("/findByUsername")
    public BaseResult findByUsername(String username){
        Admin admin = adminService.findByName(username);
        return BaseResult.ok(admin);
    }
}

@RestController
@RequestMapping("/sys/permission")
@CrossOrigin
public class PermissionController {
    @Autowired
    private PermissionService permissionService;

    /**
     * 新增权限
     *
     * @param permission 权限对象
     * @return 执行结果
     */
    @PostMapping("/add")
    public BaseResult add(Permission permission) {
        permissionService.add(permission);
        return BaseResult.ok();
    }


    /**
     * 修改权限
     *
     * @param permission 权限对象
     * @return 执行结果
     */
    @PostMapping("/update")
    public BaseResult update(Permission permission) {
        permissionService.update(permission);
        return BaseResult.ok();
    }


    /**
     * 删除权限(包括中间表对应的角色)
     *
     * @param pid 权限id
     * @return 执行结果
     */
    @DeleteMapping("/delete")
    public BaseResult delete(Integer pid) {
        permissionService.delete(pid);
        return BaseResult.ok();
    }


    /**
     * 根据id查询权限
     *
     * @param pid 权限id
     * @return 查询结果
     */
    @GetMapping("/findById")
    public BaseResult<Permission> findById(Integer pid) {
        Permission permission = permissionService.findById(pid);
        return BaseResult.ok(permission);
    }

    /**
     * 查询所有权限
     *
     * @return 所有权限
     */
    @GetMapping("/findAll")
    public BaseResult<List<Permission>> findAll() {
        List<Permission> all = permissionService.findAll();
        return BaseResult.ok(all);
    }

    /**
     * 分页查询权限
     *
     * @param page 页面
     * @param size 每页条数
     * @return 查询结果
     */
    @PreAuthorize("hasAnyAuthority('/sys/permission')")
    @GetMapping("/search")
    public BaseResult<Page<Permission>> search(int page, int size) {
        Page<Permission> permissionPage = permissionService.search(page, size);
        return BaseResult.ok(permissionPage);
    }


}

@RestController
@RequestMapping("/sys/role")
@CrossOrigin
public class RoleController {
    @Autowired
    private RoleService roleService;

    /**
     * 新增角色
     *
     * @param role 角色对象
     * @return 执行结果
     */
    @PostMapping("/add")
    public BaseResult add(Role role) {
        roleService.add(role);
        return BaseResult.ok();
    }


    /**
     * 修改角色
     *
     * @param role 角色对象
     * @return 执行结c果
     */
    @PostMapping("/update")
    public BaseResult update(Role role) {
        roleService.update(role);
        return BaseResult.ok();
    }


    /**
     * 删除角色(包括中间表的管理员、权限)
     *
     * @param rid 角色id
     * @return 执行结果
     */
    @DeleteMapping("/delete")
    public BaseResult delete(Integer rid) {
        roleService.delete(rid);
        return BaseResult.ok();
    }


    /**
     * 根据id查询角色
     *
     * @param rid
     * @return 查询到的角色
     */
    @GetMapping("/findById")
    public BaseResult<Role> findById(Integer rid) {
        Role role = roleService.findById(rid);
        return BaseResult.ok(role);
    }

    /**
     * 查询所有角色
     *
     * @return 查询结果
     */
    @GetMapping("/findAll")
    public BaseResult<List<Role>> findAll() {
        List<Role> all = roleService.findAll();
        return BaseResult.ok(all);
    }

    /**
     * 分页查询角色
     *
     * @param page 页码
     * @param size 每页条数
     * @return 查询结果
     */
    @PreAuthorize("hasAnyAuthority('/sys/role')")
    @GetMapping("/search")
    public BaseResult<Page<Role>> search(int page, int size) {
        Page<Role> page1 = roleService.search(page, size);
        return BaseResult.ok(page1);
    }


    /**
     * 修改角色的权限
     *
     * @param rid  角色id
     * @param pids 权限id
     * @return 执行结果
     */
    @PostMapping("/updatePermissionToRole")
    public BaseResult updatePermissionToRole(Integer rid, Integer[] pids) {
        roleService.addPermissionToRole(rid, pids);
        return BaseResult.ok();
    }
}

配置类设置访问控制

   // 权限拦截配置
            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(); //表示任何请求都需要认证后才能访问             

自定义设置访问控制

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

自定义访问控制逻辑

   @Service
            public class MyAuthorizationService {
              // 自定义访问控制逻辑，返回值为是否可以访问资源
              public boolean hasPermission(HttpServletRequest request, Authentication authentication){
                // 获取会话中的登录用户
                Object principal = authentication.getPrincipal();
                if (principal instanceof UserDetails){
                  // 获取登录用户的权限
                  Collection authorities = ((UserDetails) principal).getAuthorities();
                  // 获取请求的URL路径
                  String uri = request.getRequestURI();
                  // 将URL路径封装为权限对象
                  SimpleGrantedAuthority authority = new SimpleGrantedAuthority(uri);
                  // 判断用户的权限集合是否包含请求的URL权限对象
                  return authorities.contains(authority);
                 }
                return false;
               }
            }

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

    // 权限拦截配置
            http.authorizeRequests()
                     .antMatchers("/login.html").permitAll() // 表示任何权限都可以访问
                    // 任何请求都使用自定义访问控制逻辑
                     .anyRequest().access("@myAuthorizationService.hasPermission(request,authentication)");

注解设置访问控制-基于角色

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

在配置类开启注解使用 @EnableGlobalMethodSecurity(securedEnabled=true)

在控制器方法上添加注解 @Secured("ROLE_reportform")

注解设置访问控制-基于资源

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

在配置类开启注解使用 @EnableGlobalMethodSecurity(prePostEnabled = true)

在控制器方法上添加注解 @PreAuthorize("hasAnyAuthority('/reportform/find')")

前端设置访问控制

SpringSecurity可以在一些视图技术中进行控制显示效果。例如Thymeleaf中，只有登录用户拥有某些权限才会展示一些菜单

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

 <!--Spring Security整合Thymeleaf-->
             <dependency>
                 <groupId>org.thymeleaf.extras</groupId>
                 <artifactId>thymeleaf-extras-springsecurity5</artifactId>
             </dependency>

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

   <html xmlns:th="http://www.thymeleaf.org"
              xmlns:sec="http://www.thymeleaf.org/thymeleaf-extras-springsecurity5">
              <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>