Spring Security
- 什么是spring security
- spring security 是一个相对复杂的安全管理框架，功能比Shiro更强大，权限粒度控制更细更高，对OAuth2的支持也更友好
安装配置
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-security</artifactId>
</dependency>
默认登录用户名是: user
登录密码会在启动时随机生成
-
配置用用户名和密码
可以在配置文件中配置默认的用户名，密码和角色
spring.security.user.name=hangge spring.security.user.password=123 spring.security.user.roles=admin
基于内存的用户、url权限配置
-
用户角色配置
通过自定义类继承WebSecurityConfigurerAdapter，实现对Spring Security更多的自定义配置
样例如下（只适用于测试，生产环境不适用）
@Configuration public class MyWebSecurityConfig extends WebSecurityConfigurerAdapter { // 指定密码的加密方式 @Bean public PasswordEncoder passwordEncoder() { // return new BCryptPasswordEncoder(); return new PasswordEncoder() { @Override public String encode(CharSequence charSequence) { return charSequence.toString(); } @Override public boolean matches(CharSequence charSequence, String s) { return Objects.equals(charSequence.toString(), s); } }; } } // 配置用户及其对应的角色 @Override protected void configure(AuthenticationManagerBuilder auth) throws Exception { auth.inMemoryAuthentication() .withUser("root").password("123").roles("ADMIN", "DBA") .and() .withUser("admin").password("123").roles("ADMIN", "USER") .and() .withUser("hangge").password("123").roles("USER"); } // 配置 URL 访问权限 @Override protected void configure(HttpSecurity http) throws Exception { http.authorizeRequests() // 开启 HttpSecurity 配置 .antMatchers("/admin/**").hasRole("ADMIN") // admin/** 模式URL必须具备ADMIN角色 .antMatchers("/user/**").access("hasAnyRole('ADMIN','USER')") // 该模式需要ADMIN或USER角色 .antMatchers("/db/**").access("hasRole('ADMIN') and hasRole('DBA')") // 需ADMIN和DBA角色 .anyRequest().authenticated() // 用户访问其它URL都必须认证后访问（登录后访问） .and().formLogin().loginProcessingUrl("/login").permitAll() // 开启表单登录并配置登录接口 // formLogin()方法表示开启表单登录 // loginProcessingUrl() 配置登录接口为/login // permitAll（） 表示和登录相关的接口都不需要认证即可访问 .and().csrf().disable(); // 关闭csrf }
基于数据库的用户角色配置
-
相关依赖
<dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency> <!--操作数据库--> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-jdbc</artifactId> </dependency> <!-- MySQL 驱动 --> <dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifactId> </dependency> <!-- Druid 数据库连接池 --> <dependency> <groupId>com.alibaba</groupId> <artifactId>druid-spring-boot-starter</artifactId> <version>1.1.22</version> </dependency> <!-- region MyBatis --> <dependency> <groupId>org.mybatis.spring.boot</groupId> <artifactId>mybatis-spring-boot-starter</artifactId> <version>1.3.1</version> </dependency> <!--模板引擎thmeleaf对HTML的支持--> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-thymeleaf</artifactId> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-test</artifactId> <scope>test</scope> <exclusions> <exclusion> <groupId>org.junit.vintage</groupId> <artifactId>junit-vintage-engine</artifactId> </exclusion> </exclusions> </dependency> <dependency> <groupId>org.springframework.security</groupId> <artifactId>spring-security-test</artifactId> <scope>test</scope> </dependency> -
创建数据表
CREATE TABLE `resources` ( `id` int(11) NOT NULL AUTO_INCREMENT, `pattern` varchar(255) DEFAULT NULL, PRIMARY KEY (`id`) ) ENGINE=InnoDB AUTO_INCREMENT=4 DEFAULT CHARSET=utf8; CREATE TABLE `role` ( `id` int(11) NOT NULL AUTO_INCREMENT, `name` varchar(32) DEFAULT NULL, `description` varchar(255) DEFAULT NULL, PRIMARY KEY (`id`) ) ENGINE=InnoDB AUTO_INCREMENT=4 DEFAULT CHARSET=utf8; CREATE TABLE `role_resource` ( `id` int(11) NOT NULL AUTO_INCREMENT, `role_id` int(11) DEFAULT NULL, `resource_id` int(11) DEFAULT NULL, PRIMARY KEY (`id`) ) ENGINE=InnoDB AUTO_INCREMENT=4 DEFAULT CHARSET=utf8; CREATE TABLE `user` ( `id` int(64) NOT NULL AUTO_INCREMENT, `user_name` varchar(32) DEFAULT NULL, `password` varchar(255) DEFAULT NULL, `enable` tinyint(4) DEFAULT NULL, `locked` tinyint(4) DEFAULT NULL, PRIMARY KEY (`id`) ) ENGINE=InnoDB AUTO_INCREMENT=4 DEFAULT CHARSET=utf8; CREATE TABLE `user_role` ( `id` int(11) NOT NULL AUTO_INCREMENT, `user_id` int(11) DEFAULT NULL, `role_id` int(11) DEFAULT NULL, PRIMARY KEY (`id`) ) ENGINE=InnoDB AUTO_INCREMENT=5 DEFAULT CHARSET=utf8; -
创建实体类
public class Resources { private Integer id; private String pattern; private List<Role> roles; }public class Resources { private Integer id; private String pattern; private List<Role> roles; }public class Role implements Serializable { private static final long serialVersionUID = 825384782616737527L; private Integer id; private String name; private String description; }public class User implements UserDetails { private Integer id; private String userName; private String password; private boolean enable; private boolean locked; private List<Role> userRoles; @Override public Collection<? extends GrantedAuthority> getAuthorities() { List<SimpleGrantedAuthority> authorities = new ArrayList<>(); for (Role role : userRoles) { authorities.add(new SimpleGrantedAuthority(role.getName())); } return authorities; } @Override public String getUsername() { return userName; } @Override public boolean isAccountNonExpired() { return true; } @Override public boolean isAccountNonLocked() { return !locked; } @Override public boolean isCredentialsNonExpired() { return true; } @Override public boolean isEnabled() { return enable; } public void setPassword(String password) { this.password = password; } public String getPassword() { return password; } public boolean isEnable() { return enable; } public void setEnable(boolean enable) { this.enable = enable; } public Integer getId() { return id; } public void setId(Integer id) { this.id = id; } public String getUserName() { return userName; } public void setUserName(String userName) { this.userName = userName; } public boolean isLocked() { return locked; } public void setLocked(boolean locked) { this.locked = locked; } public List<Role> getUserRoles() { return userRoles; } public void setUserRoles(List<Role> userRoles) { this.userRoles = userRoles; } }接着创建用户表对应的实体类。用户实体类需要实现 UserDetails 接口，并实现该接口中的 7 个方法：
- getAuthorities()：获取当前用户对象所具有的角色信息
- getPassword()：获取当前用户对象的密码
- getUsername()：获取当前用户对象的用户名
- isAccountNonExpired()：当前账户是否未过期
- isAccountNonLocked()：当前账户是否未锁定
- isCredentialsNonExpired()：当前账户密码是否未过期
- isEnabled()：当前账户是否可用
用户根据实际情况设置这 7 个方法的返回值。默认情况下不需要开发者自己进行密码角色等信息的比对，开发者只需要提供相关信息即可，例如：
- getPassword() 方法返回的密码和用户输入的登录密码不匹配，会自动抛出 BadCredentialsException 异常
- isAccountNonLocked() 方法返回了 false，会自动抛出 AccountExpiredException 异常。
- 本案例因为数据库中只有 enabled 和 locked 字段，故账户未过期和密码未过期两个方法都返回 true.
getAuthorities 方法用来获取当前用户所具有的角色信息，本案例中，用户所具有的角色存储在 roles 属性中，因此该方法直接遍历 roles属性，然后构造 SimpleGrantedAuthority 集合并返回。
-
创建数据库访问层
-
创建usermapper接口
@Repository public interface UserMapperDao { public User loadUserByUsername(String userName); public List<Role> getUserRolesByUid(Integer id); } -
创建UserMapper.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="example.hellosecurity.dao.UserMapperDao"> <select id="loadUserByUsername" parameterType="string" resultType="example.hellosecurity.entity.User"> select * from user where user_name = #{userName} </select> <select id="getUserRolesByUid" parameterType="int" resultType="example.hellosecurity.entity.Role"> select * from role r, user_role ur where r.id = ur.role_id and ur.user_id = #{id} </select> </mapper> -
创建UserService
定义的 UserService 实现 UserDetailsService 接口，并实现该接口中的 loadUserByUsername 方法，该方法将在用户登录时自动调用。
loadUserByUsername 方法的参数就是用户登录时输入的用户名，通过用户名去数据库中查找用户：
- 如果没有查找到用户，就抛出一个账户不存在的异常。
- 如果查找到了用户，就继续查找该用户所具有的角色信息，并将获取到的 user 对象返回，再由系统提供的 DaoAuthenticationProvider类去比对密码是否正确。
@Service public class UserService implements UserDetailsService { @Autowired private UserMapperDao userMapperDao; @Autowired private PasswordEncoder passwordEncoder; @Override public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException { User user = userMapperDao.loadUserByUsername(username); if (user == null) { throw new UsernameNotFoundException("账户不存在!"); } // 我的数据库用户密码没加密，这里手动设置 String encodePassword = passwordEncoder.encode(user.getPassword()); System.out.println("加密后的密码：" + encodePassword); user.setPassword(encodePassword); List<Role> userRoles = userMapperDao.getUserRolesByUid(user.getId()); user.setUserRoles(userRoles); return user; } } -
配置 Spring Security
Spring Security 大部分配置与前文一样，只不过这次没有配置内存用户，而是将刚刚创建好的 UserService 配置到 AuthenticationManagerBuilder 中。
@Configuration public class MyWebSecurityConfig extends WebSecurityConfigurerAdapter { @Autowired private UserService userService; // 指定密码的加密方式 @Bean public PasswordEncoder passwordEncoder() { return new BCryptPasswordEncoder(); // return new PasswordEncoder() { // @Override // public String encode(CharSequence charSequence) { // return charSequence.toString(); // } // // @Override // public boolean matches(CharSequence charSequence, String s) { // return Objects.equals(charSequence.toString(), s); // } // }; } // 配置用户及其对应的角色 @Override protected void configure(AuthenticationManagerBuilder auth) throws Exception { auth.userDetailsService(userService); } // 配置基于内存的 URL 访问权限 @Override protected void configure(HttpSecurity http) throws Exception { http.authorizeRequests() // 开启 HttpSecurity 配置 .antMatchers("/admin/**").hasRole("ADMIN") // admin/** 模式URL必须具备ADMIN角色 .antMatchers("/user/**").access("hasAnyRole('ADMIN','USER')") // 该模式需要ADMIN或USER角色 .antMatchers("/db/**").access("hasRole('ADMIN') and hasRole('DBA')") // 需ADMIN和DBA角色 .anyRequest().authenticated() // 用户访问其它URL都必须认证后访问（登录后访问） .and().formLogin().loginProcessingUrl("/login").permitAll() // 开启表单登录并配置登录接口 .and().csrf().disable(); // 关闭csrf } -
运行测试
@RestController public class HelloController { @GetMapping("/admin/hello") public String admin() { return "hello admin"; } @GetMapping("/user/hello") public String user() { return "hello user"; } @GetMapping("/db/hello") public String db() { return "hello db"; } @GetMapping("/hello") public String hello() { return "hello"; } }接下来测试，使用admin用户进行登录，由于该用户具有 ADMIN 和 USER 这两个角色，所以登录后可以访问 /hello、/admin/hello 以及 /user/hello 这三个接口。
虽然前面我们实现了通过数据库来配置用户与角色，但认证规则仍然是使用 HttpSecurity 进行配置，还是不够灵活，无法实现资源和角色之间的动态调整。
要实现动态配置 URL 权限，就需要开发者自定义权限配置，具体步骤如下。
-
基于数据库的URL权限规则配置
下面是基于resource表和role_resource 表来实现：
-
首先创建 resourceMapper 接口
@Repository public interface ResourceMapperDao { /** * @Author dw * @Description 获取所有的资源 * @Date 2020/4/15 11:16 * @Param * @return */ public List<Resources> getAllResources(); } -
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="example.hellosecurity.dao.ResourceMapperDao"> <resultMap id="ResourcesMap" type="example.hellosecurity.entity.Resources"> <id column="id" property="id"/> <result column="pattern" property="pattern"/> <collection property="roles" ofType="example.hellosecurity.entity.Role"> <id column="roleId" property="id"/> <result column="name" property="name"/> <result column="description" property="description"/> </collection> </resultMap> <select id="getAllResources" resultMap="ResourcesMap"> SELECT r.*, re.id AS roleId, re.`name`, re.description FROM resources AS r LEFT JOIN role_resource AS rr ON r.id = rr.resource_id LEFT JOIN role AS re ON re.id = rr.role_id </select> </mapper> -
自定义 FilterInvocationSecurityMetadataSource
注意：自定义 FilterInvocationSecurityMetadataSource 主要实现该接口中的 getAttributes 方法，该方法用来确定一个请求需要哪些角色。
/** * @Author dw * @ClassName CustomFilterInvocationSecurityMetadataSource * @Description 要实现动态配置权限，首先需要自定义 FilterInvocationSecurityMetadataSource： * 自定义 FilterInvocationSecurityMetadataSource 主要实现该接口中的 getAttributes 方法，该方法用来确定一个请求需要哪些角色。 * @Date 2020/4/15 11:36 * @Version 1.0 */ @Component public class CustomFilterInvocationSecurityMetadataSource implements FilterInvocationSecurityMetadataSource { // 创建一个AntPathMatcher，主要用来实现ant风格的URL匹配。 AntPathMatcher antPathMatcher = new AntPathMatcher(); @Autowired private ResourceMapperDao resourceMapperDao; @Override public Collection<ConfigAttribute> getAttributes(Object object) throws IllegalArgumentException { // 从参数中提取出当前请求的URL String requestUrl = ((FilterInvocation) object).getRequestUrl(); // 从数据库中获取所有的资源信息，即本案例中的Resources表以及Resources所对应的role // 在真实项目环境中，开发者可以将资源信息缓存在Redis或者其他缓存数据库中。 List<Resources> allResources = resourceMapperDao.getAllResources(); // 遍历资源信息，遍历过程中获取当前请求的URL所需要的角色信息并返回。 for (Resources resource : allResources) { if (antPathMatcher.match(resource.getPattern(), requestUrl)) { List<Role> roles = resource.getRoles(); if(!CollectionUtils.isEmpty(roles)){ List<ConfigAttribute> allRoleNames = roles.stream() .map(role -> new SecurityConfig(role.getName().trim())) .collect(Collectors.toList()); return allRoleNames; } } } // 如果当前请求的URL在资源表中不存在相应的模式，就假设该请求登录后即可访问，即直接返回 ROLE_LOGIN. return SecurityConfig.createList("ROLE_LOGIN"); } // 该方法用来返回所有定义好的权限资源，Spring Security在启动时会校验相关配置是否正确。 @Override public Collection<ConfigAttribute> getAllConfigAttributes() { // 如果不需要校验，那么该方法直接返回null即可。 return null; } // supports方法返回类对象是否支持校验。 @Override public boolean supports(Class<?> clazz) { return FilterInvocation.class.isAssignableFrom(clazz); } } -
自定义 AccessDecisionManager
当一个请求走完 FilterInvocationSecurityMetadataSource 中的 getAttributes 方法后，接下来就会来到 AccessDecisionManager 类中进行角色信息的对比，自定义 AccessDecisionManager 代码如下：
@Component public class CustomAccessDecisionManager implements AccessDecisionManager { // 该方法判断当前登录的用户是否具备当前请求URL所需要的角色信息 @Override public void decide(Authentication auth, Object object, Collection<ConfigAttribute> ConfigAttributes){ Collection<? extends GrantedAuthority> userHasAuthentications = auth.getAuthorities(); // 如果具备权限，则不做任何事情即可 for (ConfigAttribute configAttribute : ConfigAttributes) { // 如果需要的角色是ROLE_LOGIN，说明当前请求的URL用户登录后即可访问 // 如果auth是UsernamePasswordAuthenticationToken的实例，说明当前用户已登录，该方法到此结束 if ("ROLE_LOGIN".equals(configAttribute.getAttribute()) && auth instanceof UsernamePasswordAuthenticationToken) { return; } // 否则进入正常的判断流程 for (GrantedAuthority authority : userHasAuthentications) { // 如果当前用户具备当前请求需要的角色，那么方法结束。 if (configAttribute.getAttribute().equals(authority.getAuthority())) { return; } } } // 如果不具备权限，就抛出AccessDeniedException异常 throw new AccessDeniedException("权限不足"); } @Override public boolean supports(ConfigAttribute attribute) { return true; } @Override public boolean supports(Class<?> clazz) { return true; } } -
配置 Spring Security
这里与前文的配置相比，主要是修改了 configure(HttpSecurity http) 方法的实现并添加了两个 Bean。至此我们边实现了动态权限配置，权限和资源的关系可以在 role_resource表中动态调整。
修改 MyWebSecurityConfig：
// 配置基于数据库的 URL 访问权限 @Override protected void configure(HttpSecurity http) throws Exception { http.authorizeRequests() .withObjectPostProcessor(new ObjectPostProcessor<FilterSecurityInterceptor>() { @Override public <O extends FilterSecurityInterceptor> O postProcess(O object) { object.setSecurityMetadataSource(accessMustRoles()); object.setAccessDecisionManager(rolesCheck()); return object; } }) .and().formLogin().loginProcessingUrl("/login").permitAll()//开启表单登录并配置登录接口 .and().csrf().disable(); // 关闭csrf } @Bean public CustomFilterInvocationSecurityMetadataSource accessMustRoles() { return new CustomFilterInvocationSecurityMetadataSource(); } @Bean public CustomAccessDecisionManager rolesCheck() { return new CustomAccessDecisionManager(); }要配置角色继承关系，只需在 Spring Security 的配置类中提供一个 RoleHierarchy 即可。
// 配置角色继承关系 @Bean RoleHierarchy roleHierarchy() { RoleHierarchyImpl roleHierarchy = new RoleHierarchyImpl(); String hierarchy = "ROLE_DBA > ROLE_ADMIN > ROLE_USER"; roleHierarchy.setHierarchy(hierarchy); return roleHierarchy; }在之前的所有样例中，登录表单一直都是使用 Spring Security 提供的默认登录页，登录成功后也是默认的页面跳转。有时我们想要使用自定义的登录页，或者在前后端分离的开发方式中，前后端的数据交互通过 JSON 进行，这时登录成功后就不是页面跳转了，而是一段 JSON 提示。下面通过样例演示如何进行登录表单的个性化配置。
自定义登录页面、登录接口、登录成功或失败的处理逻辑
首先修改 Spring Security 配置，增加相关的自定义代码：
- 将登录页改成使用自定义页面，并配置登录请求处理接口，以及用户密码提交时使用的参数名。
- 自定义了登录成功、登录失败的处理逻辑，根据情况返回响应的 JSON 数据。
@Configuration
public class MyWebSecurityConfig extends WebSecurityConfigurerAdapter {
// 指定密码的加密方式
@SuppressWarnings("deprecation")
@Bean
PasswordEncoder passwordEncoder(){
// 不对密码进行加密
return NoOpPasswordEncoder.getInstance();
}
// 配置用户及其对应的角色
@Override
protected void configure(AuthenticationManagerBuilder auth) throws Exception {
auth.inMemoryAuthentication()
.withUser("root").password("123").roles("DBA")
.and()
.withUser("admin").password("123").roles("ADMIN")
.and()
.withUser("hangge").password("123").roles("USER");
}
// 配置 URL 访问权限
@Override
protected void configure(HttpSecurity http) throws Exception {
http.authorizeRequests() // 开启 HttpSecurity 配置
.antMatchers("/db/**").hasRole("DBA") // db/** 模式URL需DBA角色
.antMatchers("/admin/**").hasRole("ADMIN") // admin/** 模式URL需ADMIN角色
.antMatchers("/user/**").hasRole("USER") // user/** 模式URL需USER角色
.anyRequest().authenticated() // 用户访问其它URL都必须认证后访问（登录后访问）
.and().formLogin() // 开启登录表单功能
.loginPage("/login_page") // 使用自定义的登录页面，不再使用SpringSecurity提供的默认登录页
.loginProcessingUrl("/login") // 配置登录请求处理接口，自定义登录页面、移动端登录都使用该接口
.usernameParameter("name") // 修改认证所需的用户名的参数名（默认为username）
.passwordParameter("passwd") // 修改认证所需的密码的参数名（默认为password）
// 定义登录成功的处理逻辑（可以跳转到某一个页面，也可以返会一段 JSON）
.successHandler(new AuthenticationSuccessHandler() {
@Override
public void onAuthenticationSuccess(HttpServletRequest req,
HttpServletResponse resp,
Authentication auth)
throws IOException, ServletException {
// 我们可以跳转到指定页面
// resp.sendRedirect("/index");
// 也可以返回一段JSON提示
// 获取当前登录用户的信息，在登录成功后，将当前登录用户的信息一起返回给客户端
Object principal = auth.getPrincipal();
resp.setContentType("application/json;charset=utf-8");
PrintWriter out = resp.getWriter();
resp.setStatus(200);
Map<String, Object> map = new HashMap<>();
map.put("status", 200);
map.put("msg", principal);
ObjectMapper om = new ObjectMapper();
out.write(om.writeValueAsString(map));
out.flush();
out.close();
}
// 定义登录失败的处理逻辑（可以跳转到某一个页面，也可以返会一段 JSON）
.failureHandler(new AuthenticationFailureHandler() {
@Override
public void onAuthenticationFailure(HttpServletRequest req,
HttpServletResponse resp,
AuthenticationException e)
throws IOException, ServletException {
resp.setContentType("application/json;charset=utf-8");
PrintWriter out = resp.getWriter();
resp.setStatus(401);
Map<String, Object> map = new HashMap<>();
// 通过异常参数可以获取登录失败的原因，进而给用户一个明确的提示。
map.put("status", 401);
if (e instanceof LockedException) {
map.put("msg", "账户被锁定，登录失败!");
}else if(e instanceof BadCredentialsException){
map.put("msg","账户名或密码输入错误，登录失败!");
}else if(e instanceof DisabledException){
map.put("msg","账户被禁用，登录失败!");
}else if(e instanceof AccountExpiredException){
map.put("msg","账户已过期，登录失败!");
}else if(e instanceof CredentialsExpiredException){
map.put("msg","密码已过期，登录失败!");
}else{
map.put("msg","登录失败!");
}
ObjectMapper mapper = new ObjectMapper();
out.write(mapper.writeValueAsString(map));
out.flush();
out.close();
}
})
.permitAll() // 允许访问登录表单、登录接口
.and().csrf().disable(); // 关闭csrf
}
}
在 resource/templates 目录下创建一个登录页面 login_page.html，内容如下：
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Title</title>
</head>
<body>
<form action="/login" method="post">
<div>
<label>用户名</label>
<input type="text" name="name"/>
</div>
<div>
<label>密码</label>
<input type="password" name="passwd"/>
</div>
<div>
<input type="submit" value="登陆">
</div>
</form>
</body>
</html>
注销登录配置
修改 Spring Security 配置
// 配置 URL 访问权限
@Override
protected void configure(HttpSecurity http) throws Exception {
http.authorizeRequests() // 开启 HttpSecurity 配置
.antMatchers("/db/**").hasRole("DBA") // db/** 模式URL需DBA角色
.antMatchers("/admin/**").hasRole("ADMIN") // admin/** 模式URL需ADMIN角色
.antMatchers("/user/**").hasRole("USER") // user/** 模式URL需USER角色
.anyRequest().authenticated() // 用户访问其它URL都必须认证后访问（登录后访问）
.and().formLogin().loginProcessingUrl("/login").permitAll() // 开启表单登录并配置登录接口
.and().logout() // 开启注销登录的配置
.logoutUrl("/logout") // 配置注销登录请求URL为"/logout"（默认也就是 /logout）
.clearAuthentication(true) // 清除身份认证信息
.invalidateHttpSession(true) // 使 session 失效
// 配置一个 LogoutHandler，开发者可以在这里完成一些数据清除工做
.addLogoutHandler(new LogoutHandler() {
@Override
public void logout(HttpServletRequest req,
HttpServletResponse resp,
Authentication auth) {
System.out.println("注销登录，开始清除Cookie。");
}
})
// 配置一个 LogoutSuccessHandler，开发者可以在这里处理注销成功后的业务逻辑
.logoutSuccessHandler(new LogoutSuccessHandler() {
@Override
public void onLogoutSuccess(HttpServletRequest req,
HttpServletResponse resp,
Authentication auth)
throws IOException, ServletException {
// 我们可以跳转到登录页面
// resp.sendRedirect("/login");
// 也可以返回一段JSON提示
resp.setContentType("application/json;charset=utf-8");
PrintWriter out = resp.getWriter();
resp.setStatus(200);
Map<String, Object> map = new HashMap<>();
map.put("status", 200);
map.put("msg", "注销成功！");
ObjectMapper om = new ObjectMapper();
out.write(om.writeValueAsString(map));
out.flush();
out.close();
}
})
.and().csrf().disable(); // 关闭csrf
}
密码加密配置
-
要配置密码加密只需要修改两个地方。首先要修改 HttpSecurity 配置中的 PasswordEncoder 这个Bean 的实现，这里我们采用 BCryptPasswordEncoder 加密方案。
Spring Security 提供了多种密码加密方案，官方推荐使用 BCryptPasswordEncoder： BCryptPasswordEncoder 使用 BCrypt 强哈希函数，开发者在使用时可以选择提供 strength 和 SecureRandom 实例。 strength 取值在 4~31 之间（默认为 10）。strength 越大，密钥的迭代次数越多（密钥迭代次数为 2^strength） -
接着将用户的密码改成使用 BCryptPasswordEncoder 加密后的密码（如果是数据库认证，库里的密码同样也存放加密后的密码）
@Bean PasswordEncoder passwordEncoder(){ // 使用BCrypt强哈希函数加密方案，密钥迭代次数设为10（默认即为10） return new BCryptPasswordEncoder(10); }
通过注解配置方法安全
-
首先我们要通过 @EnableGlobalMethodSecurity 注解开启基于注解的安全配置：
@EnableGlobalMethodSecurity 注解参数说明：
- prePostEnabled = true 会解锁 @PreAuthorize 和 @PostAuthorize 两个注解。顾名思义，@PreAuthorize 注解会在方法执行前进行验证，而 @PostAuthorize 注解会在方法执行后进行验证。
- securedEnabled = true 会解锁 @Secured 注解。
-
开启注解安全配置后，接着创建一个 MethodService 进行测试：
@Service public class MethodService { // 访问该方法需要 ADMIN 角色。注意：这里需要在角色前加一个前缀"ROLE_" @Secured("ROLE_ADMIN") public String admin() { return "hello admin"; } // 访问该方法既要 ADMIN 角色，又要 DBA 角色 @PreAuthorize("hasRole('ADMIN') and hasRole('DBA')") public String dba() { return "hello dba"; } // 访问该方法只需要 ADMIN、DBA、USER 中任意一个角色即可 @PreAuthorize("hasAnyRole('ADMIN','DBA','USER')") public String user() { return "hello user"; } }
获取用户信息
-
通过 Authentication.getPrincipal() 可以获取到代表当前用户的信息，这个对象通常是 UserDetails 的实例。通过 UserDetails 的实例我们可以获取到当前用户的用户名、密码、角色等信息。
Spring Security 使用一个 Authentication 对象来描述当前用户的相关信息，而 SecurityContext 持有的是代表当前用户相关信息的 Authentication 的引用。
这个 Authentication 对象不需要我们自己去创建，在与系统交互的过程中，Spring Security 会自动为我们创建相应的 Authentication 对象，然后赋值给当前的 SecurityContext。方式一：
@RestController public class HelloController { @GetMapping("/hello") public String hello() { return "当前登录用户：" + SecurityContextHolder.getContext().getAuthentication().getName(); } }方式2：
/**
* 获取用户明细
* @param principal
* @return
/
@RequestMapping(value = "getUserInfo", method = RequestMethod.GET)
public Principal getUserDetails(Principal principal) {
logger.info("用户名:{}",principal.getName());
return principal;
}
/*
* 获取用户明细
* @param authentication
* @return
*/
@RequestMapping(value = "getUserInfo2", method = RequestMethod.GET)
public Authentication getUserInfo2(Authentication authentication) {
logger.info("用户名:{}", authentication);
return authentication;
}
/**
* 只获取用户信息
* @param userDetails
* @return
*/
@RequestMapping(value = "getUser", method = RequestMethod.GET)
public UserDetails getUser(@AuthenticationPrincipal UserDetails userDetails) {
logger.info("用户名:{}",userDetails.getUsername());
return userDetails;
}
浙公网安备 33010602011771号