1,什么是 Spring Security ?
- Spring Security 是一个相对复杂的安全管理框架,功能比 Shiro 更加强大,权限控制细粒度更高,对 OAuth 2 的支持也更友好。
- 由于 Spring Security 源自 Spring 家族,因此可以和 Spring 框架无缝整合,特别是 Spring Boot 中提供的自动化配置方案,可以让 Spring Security 的使用更加便捷。
2,安装配置
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-security</artifactId>
</dependency>
3、开始测试:
首先在项目添加一个简单的 /hello 接口:
@RestController
public class HelloController {
@GetMapping("/hello")
public String hello() {
return "欢迎访问 hangge.com";
}
}
接着启动项目,直接访问 /hello 接口则会自动跳转到登录页面(这个登录页面是由 Spring Security 提供的)
(3)我们必须登录后才能访问 /hello 接口。默认用户名是 user,而登录密码则在每次启动项目时随机生成,我们可以在项目启动日志中找到。
(4)登录后则会自动跳转到之前我访问的 /hello 接口:
4,配置用户名和密码
如果对默认的用户名和密码不满意,可以在 application.properties 中配置默认的用户名、密码和角色。这样项目启动后就不会随机生成密码了,而是使用我们配置的用户、密码,并且登录后还具有一个 admin 角色(关于角色的用法再后面的文章会相信介绍)。
spring.security.user.name=hangge
spring.security.user.password=123
spring.security.user.roles=admin
基于内存的用户、URL权限配置:
1,用户角色配置:
(1)我们可以通过自定义类继承 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() // 开启表单登录并配置登录接口
.and().csrf().disable(); // 关闭csrf
}
(2)配置完成后,重启项目,就可以使用这两个用户进行登录了。
- formLogin() 方法表示开启表单登录,即我们之前看到的登录页面。
- loginProcessingUrl() 方法配置登录接口为“/login”,即可以直接调用“/login”接口,发起一个 POST 请求进行登录,登录参数中用户名必须为 username,密码必须为 password,配置 loginProcessingUrl 接口主要是方便 Ajax 或者移动端调用登录接口。
- permitAll() 表示和登录相关的接口都不需要认证即可访问。
三、基于数据库的用户角色配置
maven依赖:
<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>
2,创建数据表:
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;
3,创建实体类
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():当前账户是否可用
(1)用户根据实际情况设置这 7 个方法的返回值。默认情况下不需要开发者自己进行密码角色等信息的比对,开发者只需要提供相关信息即可,例如:
- getPassword() 方法返回的密码和用户输入的登录密码不匹配,会自动抛出 BadCredentialsException 异常
- isAccountNonLocked() 方法返回了 false,会自动抛出 AccountExpiredException 异常。
- 本案例因为数据库中只有 enabled 和 locked 字段,故账户未过期和密码未过期两个方法都返回 true.
(2)getAuthorities 方法用来获取当前用户所具有的角色信息,本案例中,用户所具有的角色存储在 roles 属性中,因此该方法直接遍历 roles属性,然后构造 SimpleGrantedAuthority 集合并返回。
4,创建数据库访问层
(1)首先创建 UserMapper 接口:
@Repository
public interface UserMapperDao {
public User loadUserByUsername(String userName);
public List<Role> getUserRolesByUid(Integer id);
}
(2)接着在 UserMapper 相同的位置创建 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>
5,创建 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;
}
}
6,配置 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
}
7,运行测试
1)首先在 Conctoller 中添加如下接口进行测试:
@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 表来实现:
(1)首先创建 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
}
}
(2)在 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
}
密码加密配置
(1)要配置密码加密只需要修改两个地方。首先要修改 HttpSecurity 配置中的 PasswordEncoder 这个Bean 的实现,这里我们采用 BCryptPasswordEncoder 加密方案。
Spring Security 提供了多种密码加密方案,官方推荐使用 BCryptPasswordEncoder:
BCryptPasswordEncoder 使用 BCrypt 强哈希函数,开发者在使用时可以选择提供 strength 和 SecureRandom 实例。
strength 取值在 4~31 之间(默认为 10)。strength 越大,密钥的迭代次数越多(密钥迭代次数为 2^strength)
(2)接着将用户的密码改成使用 BCryptPasswordEncoder 加密后的密码(如果是数据库认证,库里的密码同样也存放加密后的密码)
@Bean
PasswordEncoder passwordEncoder(){
// 使用BCrypt强哈希函数加密方案,密钥迭代次数设为10(默认即为10)
return new BCryptPasswordEncoder(10);
}
通过注解配置方法安全
1)首先我们要通过 @EnableGlobalMethodSecurity 注解开启基于注解的安全配置:
@EnableGlobalMethodSecurity 注解参数说明:
-
- prePostEnabled = true 会解锁 @PreAuthorize 和 @PostAuthorize 两个注解。顾名思义,@PreAuthorize 注解会在方法执行前进行验证,而 @PostAuthorize 注解会在方法执行后进行验证。
- securedEnabled = true 会解锁 @Secured 注解。
(2)开启注解安全配置后,接着创建一个 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";
}
}
获取用户信息:
(1)通过 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;
}