java security 详解_Spring Security使用详解（基本用法 ）

Spring Security使用详解(基本用法 )

1，什么是 Spring Security ?

Spring Security 是一个相对复杂的安全管理框架，功能比 Shiro 更加强大，权限控制细粒度更高，对 OAuth 2 的支持也更友好。

由于 Spring Security 源自 Spring 家族，因此可以和 Spring 框架无缝整合，特别是 Spring Boot 中提供的自动化配置方案，可以让 Spring Security 的使用更加便捷。

2，安装配置

org.springframework.boot

spring-boot-starter-security

3、开始测试：

首先在项目添加一个简单的 /hello 接口：

@RestControllerpublic classHelloController {

@GetMapping("/hello")publicString 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=123spring.security.user.roles=admin

基于内存的用户、URL权限配置：

1，用户角色配置：

(1)我们可以通过自定义类继承 WebSecurityConfigurerAdapter，从而实现对 Spring Security 更多的自定义配置。比如下面样例我们就配置了两个用户，以及他们对应的角色(这种方式只适合用于测试、开发环境不适用于生产)

@Configurationpublic class MyWebSecurityConfig extendsWebSecurityConfigurerAdapter {

// 指定密码的加密方式

@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) throwsException {

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) throwsException {

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依赖：

org.springframework.boot

spring-boot-starter-web

org.springframework.boot

spring-boot-starter-jdbc

mysql

mysql-connector-java

com.alibaba

druid-spring-boot-starter

1.1.22

org.mybatis.spring.boot

mybatis-spring-boot-starter

1.3.1

org.springframework.boot

spring-boot-starter-thymeleaf

org.springframework.boot

spring-boot-starter-test

test

org.junit.vintage

junit-vintage-engine

org.springframework.security

spring-security-test

test

View Code

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 classResources {privateInteger id;privateString pattern;private Listroles;

}

public class Role implementsSerializable {private static final long serialVersionUID = 825384782616737527L;privateInteger id;privateString name;privateString description;

}

public class User implementsUserDetails {privateInteger id;privateString userName;privateString password;private booleanenable;private booleanlocked;private ListuserRoles;

@Overridepublic Collection extends GrantedAuthority>getAuthorities() {

List authorities = new ArrayList<>();for(Role role : userRoles) {

authorities.add(newSimpleGrantedAuthority(role.getName()));

}returnauthorities;

}

@OverridepublicString getUsername() {returnuserName;

}

@Overridepublic booleanisAccountNonExpired() {return true;

}

@Overridepublic booleanisAccountNonLocked() {return !locked;

}

@Overridepublic booleanisCredentialsNonExpired() {return true;

}

@Overridepublic booleanisEnabled() {returnenable;

}public voidsetPassword(String password) {this.password =password;

}publicString getPassword() {returnpassword;

}public booleanisEnable() {returnenable;

}public void setEnable(booleanenable) {this.enable =enable;

}publicInteger getId() {returnid;

}public voidsetId(Integer id) {this.id =id;

}publicString getUserName() {returnuserName;

}public voidsetUserName(String userName) {this.userName =userName;

}public booleanisLocked() {returnlocked;

}public void setLocked(booleanlocked) {this.locked =locked;

}public ListgetUserRoles() {returnuserRoles;

}public void setUserRoles(ListuserRoles) {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 接口：

@Repositorypublic interfaceUserMapperDao {publicUser loadUserByUsername(String userName);public ListgetUserRolesByUid(Integer id);

}

(2)接着在 UserMapper 相同的位置创建 UserMapper.xml 文件，内容如下：

/p>

PUBLIC"-//mybatis.org//DTD Mapper 3.0//EN"

"http://mybatis.org/dtd/mybatis-3-mapper.dtd">

select* from user where user_name =#{userName}

select* from role r, user_role ur where r.id = ur.role_id and ur.user_id =#{id}

5，创建 UserService

定义的 UserService 实现 UserDetailsService接口，并实现该接口中的 loadUserByUsername 方法，该方法将在用户登录时自动调用。

loadUserByUsername方法的参数就是用户登录时输入的用户名，通过用户名去数据库中查找用户：

如果没有查找到用户，就抛出一个账户不存在的异常。

如果查找到了用户，就继续查找该用户所具有的角色信息，并将获取到的 user 对象返回，再由系统提供的 DaoAuthenticationProvider类去比对密码是否正确。

@Servicepublic class UserService implementsUserDetailsService {

@AutowiredprivateUserMapperDao userMapperDao;

@AutowiredprivatePasswordEncoder passwordEncoder;

@Overridepublic UserDetails loadUserByUsername(String username) throwsUsernameNotFoundException {

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 userRoles =userMapperDao.getUserRolesByUid(user.getId());

user.setUserRoles(userRoles);returnuser;

}

}

6，配置 Spring Security

Spring Security 大部分配置与前文一样，只不过这次没有配置内存用户，而是将刚刚创建好的 UserService 配置到 AuthenticationManagerBuilder 中。

@Configurationpublic class MyWebSecurityConfig extendsWebSecurityConfigurerAdapter {

@AutowiredprivateUserService userService;//指定密码的加密方式

@BeanpublicPasswordEncoder passwordEncoder() {return newBCryptPasswordEncoder();//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);//}//};

}//配置用户及其对应的角色

@Overrideprotected void configure(AuthenticationManagerBuilder auth) throwsException {

auth.userDetailsService(userService);

}//配置基于内存的 URL 访问权限

@Overrideprotected void configure(HttpSecurity http) throwsException {

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 中添加如下接口进行测试：

@RestControllerpublic classHelloController {

@GetMapping("/admin/hello")publicString admin() {return "hello admin";

}

@GetMapping("/user/hello")publicString user() {return "hello user";

}

@GetMapping("/db/hello")publicString db() {return "hello db";

}

@GetMapping("/hello")publicString hello() {return "hello";

}

}

接下来测试一下，我们使用 admin 用户进行登录，由于该用户具有 ADMIN 和 USER 这两个角色，所以登录后可以访问 /hello、/admin/hello 以及 /user/hello 这三个接口。

虽然前面我们实现了通过数据库来配置用户与角色，但认证规则仍然是使用 HttpSecurity 进行配置，还是不够灵活，无法实现资源和角色之间的动态调整。

要实现动态配置  URL 权限，就需要开发者自定义权限配置，具体步骤如下。

四、基于数据库的URL权限规则配置

下面是基于 resource 表 和  role_resource 表来实现：

(1)首先创建 resourceMapper 接口：

@Repositorypublic interfaceResourceMapperDao {/*** @Author dw

* @Description 获取所有的资源

* @Date 2020/4/15 11:16

* @Param

*@return

*/

public ListgetAllResources();

}

xml:

/p>

PUBLIC"-//mybatis.org//DTD Mapper 3.0//EN"

"http://mybatis.org/dtd/mybatis-3-mapper.dtd">

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

自定义FilterInvocationSecurityMetadataSource

注意：自定义 FilterInvocationSecurityMetadataSource主要实现该接口中的 getAttributes 方法，该方法用来确定一个请求需要哪些角色。

/*** @Author dw

* @ClassName CustomFilterInvocationSecurityMetadataSource

* @Description 要实现动态配置权限，首先需要自定义 FilterInvocationSecurityMetadataSource：

* 自定义 FilterInvocationSecurityMetadataSource 主要实现该接口中的 getAttributes 方法，该方法用来确定一个请求需要哪些角色。

* @Date 2020/4/15 11:36

* @Version 1.0*/@Componentpublic class CustomFilterInvocationSecurityMetadataSource implementsFilterInvocationSecurityMetadataSource {//创建一个AntPathMatcher，主要用来实现ant风格的URL匹配。

AntPathMatcher antPathMatcher = newAntPathMatcher();

@AutowiredprivateResourceMapperDao resourceMapperDao;

@Overridepublic Collection getAttributes(Object object) throwsIllegalArgumentException {//从参数中提取出当前请求的URL

String requestUrl =((FilterInvocation) object).getRequestUrl();//从数据库中获取所有的资源信息，即本案例中的Resources表以及Resources所对应的role//在真实项目环境中，开发者可以将资源信息缓存在Redis或者其他缓存数据库中。

List allResources =resourceMapperDao.getAllResources();//遍历资源信息，遍历过程中获取当前请求的URL所需要的角色信息并返回。

for(Resources resource : allResources) {if(antPathMatcher.match(resource.getPattern(), requestUrl)) {

List roles =resource.getRoles();if(!CollectionUtils.isEmpty(roles)){

List allRoleNames =roles.stream()

.map(role-> newSecurityConfig(role.getName().trim()))

.collect(Collectors.toList());returnallRoleNames;

}

}

}//如果当前请求的URL在资源表中不存在相应的模式，就假设该请求登录后即可访问，即直接返回 ROLE_LOGIN.

return SecurityConfig.createList("ROLE_LOGIN");

}//该方法用来返回所有定义好的权限资源，Spring Security在启动时会校验相关配置是否正确。

@Overridepublic CollectiongetAllConfigAttributes() {//如果不需要校验，那么该方法直接返回null即可。

return null;

}//supports方法返回类对象是否支持校验。

@Overridepublic boolean supports(Class>clazz) {return FilterInvocation.class.isAssignableFrom(clazz);

}

}

自定义AccessDecisionManager

当一个请求走完 FilterInvocationSecurityMetadataSource中的 getAttributes 方法后，接下来就会来到 AccessDecisionManager类中进行角色信息的对比，自定义 AccessDecisionManager 代码如下：

@Componentpublic class CustomAccessDecisionManager implementsAccessDecisionManager {//该方法判断当前登录的用户是否具备当前请求URL所需要的角色信息

@Overridepublic void decide(Authentication auth, Object object, CollectionConfigAttributes){

Collection extends GrantedAuthority> userHasAuthentications =auth.getAuthorities();//如果具备权限，则不做任何事情即可

for(ConfigAttribute configAttribute : ConfigAttributes) {//如果需要的角色是ROLE_LOGIN，说明当前请求的URL用户登录后即可访问//如果auth是UsernamePasswordAuthenticationToken的实例，说明当前用户已登录，该方法到此结束

if ("ROLE_LOGIN".equals(configAttribute.getAttribute())&& auth instanceofUsernamePasswordAuthenticationToken) {return;

}//否则进入正常的判断流程

for(GrantedAuthority authority : userHasAuthentications) {//如果当前用户具备当前请求需要的角色，那么方法结束。

if(configAttribute.getAttribute().equals(authority.getAuthority())) {return;

}

}

}//如果不具备权限，就抛出AccessDeniedException异常

throw new AccessDeniedException("权限不足");

}

@Overridepublic booleansupports(ConfigAttribute attribute) {return true;

}

@Overridepublic boolean supports(Class>clazz) {return true;

}

}

配置 Spring Security

这里与前文的配置相比，主要是修改了 configure(HttpSecurity http) 方法的实现并添加了两个 Bean。至此我们边实现了动态权限配置，权限和资源的关系可以在 role_resource表中动态调整。

修改  MyWebSecurityConfig：

//配置基于数据库的 URL 访问权限

@Overrideprotected void configure(HttpSecurity http) throwsException {

http.authorizeRequests()

.withObjectPostProcessor(new ObjectPostProcessor() {

@Overridepublic O postProcess(O object) {

object.setSecurityMetadataSource(accessMustRoles());

object.setAccessDecisionManager(rolesCheck());returnobject;

}

})

.and().formLogin().loginProcessingUrl("/login").permitAll()//开启表单登录并配置登录接口

.and().csrf().disable(); //关闭csrf

}

@BeanpublicCustomFilterInvocationSecurityMetadataSource accessMustRoles() {return newCustomFilterInvocationSecurityMetadataSource();

}

@BeanpublicCustomAccessDecisionManager rolesCheck() {return newCustomAccessDecisionManager();

}

要配置角色继承关系，只需在 Spring Security 的配置类中提供一个 RoleHierarchy即可。

//配置角色继承关系

@Bean

RoleHierarchy roleHierarchy() {

RoleHierarchyImpl roleHierarchy= newRoleHierarchyImpl();

String hierarchy= "ROLE_DBA > ROLE_ADMIN > ROLE_USER";

roleHierarchy.setHierarchy(hierarchy);returnroleHierarchy;

}

在之前的所有样例中，登录表单一直都是使用 Spring Security 提供的默认登录页，登录成功后也是默认的页面跳转。有时我们想要使用自定义的登录页，或者在前后端分离的开发方式中，前后端的数据交互通过 JSON 进行，这时登录成功后就不是页面跳转了，而是一段 JSON 提示。下面通过样例演示如何进行登录表单的个性化配置。

自定义登录页面、登录接口、登录成功或失败的处理逻辑

首先修改 Spring Security 配置，增加相关的自定义代码：

将登录页改成使用自定义页面，并配置登录请求处理接口，以及用户密码提交时使用的参数名。

自定义了登录成功、登录失败的处理逻辑，根据情况返回响应的 JSON 数据。

@Configurationpublic class MyWebSecurityConfig extendsWebSecurityConfigurerAdapter {//指定密码的加密方式

@SuppressWarnings("deprecation")

@Bean

PasswordEncoder passwordEncoder(){//不对密码进行加密

returnNoOpPasswordEncoder.getInstance();

}//配置用户及其对应的角色

@Overrideprotected void configure(AuthenticationManagerBuilder auth) throwsException {

auth.inMemoryAuthentication()

.withUser("root").password("123").roles("DBA")

.and()

.withUser("admin").password("123").roles("ADMIN")

.and()

.withUser("hangge").password("123").roles("USER");

}//配置 URL 访问权限

@Overrideprotected void configure(HttpSecurity http) throwsException {

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(newAuthenticationSuccessHandler() {

@Overridepublic voidonAuthenticationSuccess(HttpServletRequest req,

HttpServletResponse resp,

Authentication auth)throwsIOException, ServletException {//我们可以跳转到指定页面//resp.sendRedirect("/index");//也可以返回一段JSON提示//获取当前登录用户的信息，在登录成功后，将当前登录用户的信息一起返回给客户端

Object principal =auth.getPrincipal();

resp.setContentType("application/json;charset=utf-8");

PrintWriter out=resp.getWriter();

resp.setStatus(200);

Map map = new HashMap<>();

map.put("status", 200);

map.put("msg", principal);

ObjectMapper om= newObjectMapper();

out.write(om.writeValueAsString(map));

out.flush();

out.close();

}

})//定义登录失败的处理逻辑(可以跳转到某一个页面，也可以返会一段 JSON)

.failureHandler(newAuthenticationFailureHandler() {

@Overridepublic voidonAuthenticationFailure(HttpServletRequest req,

HttpServletResponse resp,

AuthenticationException e)throwsIOException, ServletException {

resp.setContentType("application/json;charset=utf-8");

PrintWriter out=resp.getWriter();

resp.setStatus(401);

Map map = new HashMap<>();//通过异常参数可以获取登录失败的原因，进而给用户一个明确的提示。

map.put("status", 401);if (e instanceofLockedException) {

map.put("msg", "账户被锁定，登录失败!");

}else if(e instanceofBadCredentialsException){

map.put("msg","账户名或密码输入错误，登录失败!");

}else if(e instanceofDisabledException){

map.put("msg","账户被禁用，登录失败!");

}else if(e instanceofAccountExpiredException){

map.put("msg","账户已过期，登录失败!");

}else if(e instanceofCredentialsExpiredException){

map.put("msg","密码已过期，登录失败!");

}else{

map.put("msg","登录失败!");

}

ObjectMapper mapper= newObjectMapper();

out.write(mapper.writeValueAsString(map));

out.flush();

out.close();

}

})

.permitAll()//允许访问登录表单、登录接口

.and().csrf().disable(); //关闭csrf

}

}

(2)在 resource/templates目录下创建一个登录页面login_page.html，内容如下：

Title

用户名

密码

七、注销登录配置

修改 Spring Security 配置

//配置 URL 访问权限

@Overrideprotected void configure(HttpSecurity http) throwsException {

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(newLogoutHandler() {

@Overridepublic voidlogout(HttpServletRequest req,

HttpServletResponse resp,

Authentication auth) {

System.out.println("注销登录，开始清除Cookie。");

}

})//配置一个 LogoutSuccessHandler，开发者可以在这里处理注销成功后的业务逻辑

.logoutSuccessHandler(newLogoutSuccessHandler() {

@Overridepublic voidonLogoutSuccess(HttpServletRequest req,

HttpServletResponse resp,

Authentication auth)throwsIOException, ServletException {//我们可以跳转到登录页面//resp.sendRedirect("/login");//也可以返回一段JSON提示

resp.setContentType("application/json;charset=utf-8");

PrintWriter out=resp.getWriter();

resp.setStatus(200);

Map map = new HashMap<>();

map.put("status", 200);

map.put("msg", "注销成功！");

ObjectMapper om= newObjectMapper();

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 进行测试：

@Servicepublic classMethodService {//访问该方法需要 ADMIN 角色。注意：这里需要在角色前加一个前缀"ROLE_"

@Secured("ROLE_ADMIN")publicString admin() {return "hello admin";

}//访问该方法既要 ADMIN 角色，又要 DBA 角色

@PreAuthorize("hasRole('ADMIN') and hasRole('DBA')")publicString dba() {return "hello dba";

}//访问该方法只需要 ADMIN、DBA、USER 中任意一个角色即可

@PreAuthorize("hasAnyRole('ADMIN','DBA','USER')")publicString user() {return "hello user";

}

}

获取用户信息：

(1)通过 Authentication.getPrincipal() 可以获取到代表当前用户的信息，这个对象通常是 UserDetails 的实例。通过 UserDetails 的实例我们可以获取到当前用户的用户名、密码、角色等信息。

Spring Security 使用一个 Authentication 对象来描述当前用户的相关信息，而 SecurityContext 持有的是代表当前用户相关信息的 Authentication 的引用。

这个 Authentication 对象不需要我们自己去创建，在与系统交互的过程中，Spring Security 会自动为我们创建相应的 Authentication 对象，然后赋值给当前的 SecurityContext。

方式一：

@RestControllerpublic classHelloController {

@GetMapping("/hello")publicString hello() {return "当前登录用户：" +SecurityContextHolder.getContext().getAuthentication().getName();

}

}

方式2：

/*** 获取用户明细

*@paramprincipal

*@return

*/@RequestMapping(value= "getUserInfo", method =RequestMethod.GET)publicPrincipal getUserDetails(Principal principal) {

logger.info("用户名:{}",principal.getName());returnprincipal;

}/*** 获取用户明细

*@paramauthentication

*@return

*/@RequestMapping(value= "getUserInfo2", method =RequestMethod.GET)publicAuthentication getUserInfo2(Authentication authentication) {

logger.info("用户名:{}", authentication);returnauthentication;

}/*** 只获取用户信息

*@paramuserDetails

*@return

*/@RequestMapping(value= "getUser", method =RequestMethod.GET)publicUserDetails getUser(@AuthenticationPrincipal UserDetails userDetails) {

logger.info("用户名:{}",userDetails.getUsername());returnuserDetails;

}