Spring Security介绍
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>
