springsecurity详解
介绍
Spring Security是Spring项目组提供的安全服务框架，核心功能包括认证和授权。 它为系统提供了声明式安全访问控制功能，减少了为系统安全而编写大量重复代码的工作。
认证
认证即系统判断用户的身份是否合法，合法可继续访问，不合法则拒绝访问。常见的用户身份认证方式有： 用户名密码登录、二维码登录、手机短信登录、脸部识别认证、指纹认证等方式。
认证是为了保护系统的隐私数据与资源，用户的身份合法才能访问该系统的资源。
授权
授权即认证通过后，根据用户的权限来控制用户访问资源的过程，拥有资源的访问权限则正常访问，没有权限则拒绝访问。 比如在一些视频网站中，普通用户登录后只有观看免费视频的权限，而VIP用户登录后，网站会给该用户提供观看VIP视频的权限。
认证是为了保证用户身份的合法性，授权则是为了更细粒度的对隐私数据进行划分，控制不同的用户能够访问不同的资源。
搭建项目
依赖
org.springframework.boot
spring-boot-starter-security
认证逻辑
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 permissions = adminService.findAllPermission(username);
List 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值为令牌，令牌在服务端产生，、 如果携带的令牌和服务端的令牌匹配成功，则正常访问。
退出登录
// 退出登录配置
http.logout()
.logoutUrl("/logout") // 退出登录路径
.logoutSuccessUrl("/login.html") // 退出登录后跳转的路径
.clearAuthentication(true) //清除认证状态，默认为true
.invalidateHttpSession(true); // 销毁HttpSession对象，默认为trueRemember 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
记住我 处理器
会话管理
用户认证通过后，有时我们需要获取用户信息，比如在网站顶部显示：欢迎您，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 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 permissions;// 权限集合
} mapper
public interface AdminMapper extends BaseMapper {
// 根据id查询管理员，包括角色和权限
Admin findById(Integer id);
// 删除管理员的所有角色
void deleteAdminAllRole(Integer id);
// 给管理员添加角色
void addRoleToAdmin(@Param("aid") Integer aid, @Param("rid") Integer rid);
// 根据管理员名查询权限
List findAllPermission(String username);
}
public interface PermissionMapper extends BaseMapper {
// 删除角色_权限表中的相关数据
void deletePermissionAllRole(Integer pid);
}
public interface RoleMapper extends BaseMapper {
// 删除角色_权限中间表的相关数据
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
DELETE
FROM admin_role
WHERE aid = #{id}
INSERT INTO admin_role
VALUES (#{aid}, #{rid});
DELETE
FROM role_permission
WHERE pid = #{pid}
DELETE
FROM role_permission
WHERE rid = #{rid}
DELETE
FROM admin_role
where rid = #{rid}
INSERT INTO role_permission
VALUES (#{rid}, #{pid});
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 search(int page, int size);
// 修改管理员角色【自定义】
void updateRoleToAdmin(Integer aid, Integer[] rids);
// 根据名字查询管理员
Admin findByName(String username);
// 根据名字查询管理员所有权限
List findAllPermission(String username);
}
/**
* 权限服务接口
*/
public interface PermissionService {
// 新增权限
void add(Permission permission);
// 修改权限
void update(Permission permission);
// 删除权限【自定义】
void delete(Integer id);
// 根据id查询权限
Permission findById(Integer id);
// 查询所有权限
List findAll();
// 分页查询权限
Page 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 findAll();
// 分页查询角色
Page 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 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 wrapper = new QueryWrapper();
wrapper.eq("username", username);
Admin admin = adminMapper.selectOne(wrapper);
return admin;
}
@Override
public List 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 findAll() {
return permissionMapper.selectList(null);
}
@Override
public Page 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 findAll() {
return roleMapper.selectList(null);
}
@Override
public Page 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 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> search(int page, int size) {
Page 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 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 findById(Integer pid) {
Permission permission = permissionService.findById(pid);
return BaseResult.ok(permission);
}
/**
* 查询所有权限
*
* @return 所有权限
*/
@GetMapping("/findAll")
public BaseResult> findAll() {
List all = permissionService.findAll();
return BaseResult.ok(all);
}
/**
* 分页查询权限
*
* @param page 页面
* @param size 每页条数
* @return 查询结果
*/
@PreAuthorize("hasAnyAuthority('/sys/permission')")
@GetMapping("/search")
public BaseResult> search(int page, int size) {
Page 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 findById(Integer rid) {
Role role = roleService.findById(rid);
return BaseResult.ok(role);
}
/**
* 查询所有角色
*
* @return 查询结果
*/
@GetMapping("/findAll")
public BaseResult> findAll() {
List all = roleService.findAll();
return BaseResult.ok(all);
}
/**
* 分页查询角色
*
* @param page 页码
* @param size 每页条数
* @return 查询结果
*/
@PreAuthorize("hasAnyAuthority('/sys/role')")
@GetMapping("/search")
public BaseResult> search(int page, int size) {
Page 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的整合依赖
org.thymeleaf.extras
thymeleaf-extras-springsecurity5
在Thymeleaf中使用Security标签，控制前端的显示内容
查询报表
查询工资
查询员工