Spring Security使用详解（基本用法 ）
Spring Security使用详解（基本用法 ）
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; }
