spring security学习总结

代码：https://download.csdn.net/download/SICAUliuy/12277906
本博客是对学习《权限管理SpringSecurity(SpringBoot)》的记录

概述

• 是什么

基于spring AOP和servlet过滤器的安全框架，同时在Web请求级（url请求拦截）和方法调用级（controller层中的方法）处理身份确认和授权。

• 功能

认证

验证

安全防护

• 原理技术

filter

servelet

spring DI

spring AOP

初体验

• 依赖

<dependency>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-security</artifactId>
 </dependency>
 <dependency>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-web</artifactId>
 </dependency>

• 示例类

@RestController // 等效 @Controller和@RequestBody
public class loginController {
 @GetMapping("/hello")
 public String hello() {
 return "hello, Spring Security";
 }
}

• 运行效果
  

默认用户名为 user,密码在控制台输出

• 关闭security功能

在启动类中添加 exclude = SecurityAutoConfiguration.class

@SpringBootApplication(exclude = SecurityAutoConfiguration.class)
public class SpringSecurityApplication {
 public static void main(String[] args) {
 SpringApplication.run(SpringSecurityApplication.class, args);
 }
}

• 指定用户名和密码

在application.yml文件中配置

spring:
 security:
 user:
 name: liuyang
 password: 123456

基于内存的认证信息

• 步骤

需要重写WebSecurityConfigurerAdapter的configure(AuthenticationManagerBuilder auth)方法，通过auth对象的inMemoryAuthentication()方法指定认证信息

@Configuration // 表明这是一个配置类
@EnableWebSecurity // 开启spring security
public class WebSecurityConfig extends WebSecurityConfigurerAdapter {
 @Override
 protected void configure(AuthenticationManagerBuilder auth) throws Exception {
 auth.inMemoryAuthentication()
 .withUser("admin")
 .password(new BCryptPasswordEncoder().encode("123456"))
 .roles();
 // 使用自己封装的加密方式
 auth.inMemoryAuthentication()
 .withUser("user")
 .password(passwordEncoder().encode("123456"))
 .roles();
 }
 // 注入封装自己的加密方式
 @Bean
 public PasswordEncoder passwordEncoder() {
 return new BCryptPasswordEncoder();
 }
}

基于内存的角色授权

• 步骤

• WebSecurityConfigurerAdapter继承类上添加 EnableGlobalMethodSecurity注解

• 通过auth对象的inMemoryAuthentication()方法指定角色信息roles(“xxx”)

• 使用 @PreAuthorize(“hasAnyRole(‘xxx’)”)注解配置访问角色

• 示例代码

WebSecurityConfig

@Configuration // 表明这是一个配置类
@EnableWebSecurity // 开启spring security
@EnableGlobalMethodSecurity(prePostEnabled = true) // 会拦截 @preAuthrize配置的角色
public class WebSecurityConfig extends WebSecurityConfigurerAdapter {
 @Override
 protected void configure(AuthenticationManagerBuilder auth) throws Exception {
 auth.inMemoryAuthentication()
 .withUser("admin")
 .password(new BCryptPasswordEncoder().encode("123456"))
 .roles("admin");
 // 使用自己封装的加密方式
 auth.inMemoryAuthentication()
 .withUser("user")
 .password(passwordEncoder().encode("123456"))
 .roles("user");
 }
 // 注入封装自己的加密方式
 @Bean
 public PasswordEncoder passwordEncoder() {
 return new BCryptPasswordEncoder();
 }
}

controller层

@GetMapping("/helloAdmin")
 @PreAuthorize("hasAnyRole('admin')")
 public String helloAdmin() {
 return "hello, Admin";
 }
 @GetMapping("/helloUser")
 @PreAuthorize("hasAnyRole('user','admin')")
 public String helloUser() {
 return "hello, user";
 }

基于内存数据库的身份认证和角色授权

• pom.xml依赖

  <dependency>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-data-jpa</artifactId>
 </dependency>
 <dependency>
 <groupId>org.hsqldb</groupId>
 <artifactId>hsqldb</artifactId>
 <scope>runtime</scope>
 </dependency>

hsqldb: (Hypersonic SQL)是纯Java开发的关系型数据库,并提供JDBC驱动存取数据。支持ANSI-92 标准 SQL语法。而且他占的空间很小。大约只有160K,拥有快速的数据库引擎。在spring boot 中引入依赖，可以不用安装数据库。

• UserInfo实体类

@Entity
public class UserInfo {
 // @Id @GeneratedValue
 private long uid; // 主键
 private String username;//用户名
 private String password;//密码
 @Enumerated(EnumType.STRING)
 private Role role;
 public enum Role{
 admin,normal
 }
 public long getUid() {
 return uid;
 }
 public void setUid(long uid) {
 this.uid = uid;
 }
 public String getUsername() {
 return username;
 }
 public void setUsername(String username) {
 this.username = username;
 }
 public String getPassword() {
 return password;
 }
 public void setPassword(String password) {
 this.password = password;
 }
 public Role getRoles() {
 return roles;
 }
 public void setRoles(Role roles) {
 this.roles = roles;
 }
}

• UserInfoRepository类

public interface UserInfoRepository extends JpaRepository<UserInfo,Long> {
 public UserInfo findByUsername(String username);
}

• UserInfoService接口类

public interface UserInfoService {
 public UserInfo findByUsername(String username);
}

• UserInfoServiceImpl 实现类

@Service
public class UserInfoServiceImpl implements UserInfoService {
 @Autowired
 private UserInfoRepository userInfoRepository;
 @Override
 public UserInfo findByUsername(String username) {
 return userInfoRepository.findByUsername(username);
 }
}

• UserDetailsService实现类

重写loadUserByUsername方法：

1. 通过UserInfoService向数据库查找UserInfo

2. 定义权限列表，并向权限列表添加该用户权限

3. 新建一个user，并返回user.（系统提供的类，实现了UserDetails）

@Service
public class CustomUserDetailService implements UserDetailsService {
 @Autowired
 private UserInfoService userInfoService;
 @Autowired
 private PasswordEncoder passwordEncoder;
 @Override
 public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
 System.out.println("CustomUserDetailService.loadUserByUsername:"+ username);
 // 根据用户名查找用户
 UserInfo userInfo = userInfoService.findByUsername(username);
 System.out.println(userInfo);
 if (userInfo == null) {
 throw new UsernameNotFoundException("没有发现该用户！");
 }
 // 定义权限列表
 List<GrantedAuthority> authorities = new ArrayList<>();
 // 将查询到的用户添加到权限列表
 authorities.add(new SimpleGrantedAuthority("ROLE_" + userInfo.getRole().name()));
 User user = new User(userInfo.getUsername(),userInfo.getPassword(),authorities);
 return user;
 }
}

• 数据初始化定义

通过UserInfoRepository添加2个权限用户,添加的用户存储在hsqldb数据库中

@Service
public class DataInit {
 @Autowired
 private UserInfoRepository userInfoRepository;
 @Autowired
 private PasswordEncoder passwordEncoder;
 /*@PostConstruct服务器加载Servle的时候运行，并且只会被服务器执行一次*/
 @PostConstruct
 public void dataInit() {
 UserInfo admin = new UserInfo();
 admin.setUsername("admin");
 admin.setPassword(passwordEncoder.encode("123"));
 admin.setRole(UserInfo.Role.admin);
 userInfoRepository.save(admin);
 UserInfo user = new UserInfo();
 user.setUsername("user");
 user.setPassword(passwordEncoder.encode("123"));
 user.setRole(UserInfo.Role.normal);
 userInfoRepository.save(user);
 }
}

基于MySQL数据库

在内存数据的基础上，进行一下两部操作

• pom.xml添加依赖

• application.yml进行数据库配置

spring:
 datasource:
 url: jdbc:mysql://localhost:3306/mydb?useUnicode=true&characterEncoding=utf-8&serverTimezone=GMT%2B8
 username: root
 password: 123456
 driver-class-name: com.mysql.cj.jdbc.Driver
 jpa:
 database: mysql
 show-sql: true
 hibernate:
 ddl-auto: update

spring.jpa.hibernate.ddl-auto属性：

create 启动时删数据库中的表，然后创建，退出时不删除数据表

create-drop 启动时删数据库中的表，然后创建，退出时删除数据表 如果表不存在报错 update 如果启动时表格式不一致则更新表，原有数据保留

validate 项目启动表结构进行校验 如果不一致则报错

退出和自定义登录

• 登录配置

http.
.formLogin()
.loginPage(”/login_page”) // 登录页面地址
.loginProcessingUrl(”/login”) // 前后端分离登录请求连接
.usernameParameter(”name”)
.passwordParameter(”passwd”)

• 退出

spring security默认的退出连接为 /logout

动态加载角色

• 在websecurityconfig中配置configure(HttpSecurity http)

http
.formLogin()
 .loginPage(”/login_page”) // 登录页面地址
 .and()
 .authorizeRequests()
 .antMatchers("/login").permitAll() // 允许所有人可以访问登录页面
 .anyRequest().authenticated() // 所有的请求需要在登录之后才能访问

这里需要注意：登录页请求需要先于其他请求配置，这种允许个别连接访问的情况称为白名单。

• 角色表与用户表关系配置

在jpa中配置多对多:用户表中配置

@Entity
public class UserInfo {
 // @Id @GeneratedValue
 private long uid; // 主键
 private String username;//用户名
 private String password;//密码
 // 用户 -- 角色： 多对多的关系
 @ManyToMany(fetch = FetchType.EAGER) // 立即从数据库中进行加载数据
// joinColumns UserInfo数据表对应的表名对应的主键；inverseJoinColumns数据库对应的表名对应的主键
 @JoinTable(name="UserRole", joinColumns = { @JoinColumn(name = "uid")}, inverseJoinColumns = { @JoinColumn(name = "role_id")})
 private List<Role> roles;
 public long getUid() {
 return uid;
 }
 public void setUid(long uid) {
 this.uid = uid;
 }
 public String getUsername() {
 return username;
 }
 public void setUsername(String username) {
 this.username = username;
 }
 public String getPassword() {
 return password;
 }
 public void setPassword(String password) {
 this.password = password;
 }
 public List<Role> getRoles() {
 return roles;
 }
 public void setRoles(List<Role> roles) {
 this.roles = roles;
 }
}

Filter

对web资源进行保护，最好使用Filter；对方法调用进行保护，最好用AOP，spring对web资源的保护，就是靠Filter实现的。

Spring Security提供的Filter不少,有十多个,过滤器顺序从上到下:

1. ChannelProcessingFilter (访问协议控制过滤器)如果你访问的channel错了,那首先就会在channel之间进行跳转,如http变为https。

2. SecurityContextPersistenceFilter ( SecurityContext持久化过滤器)用来创建一个SecurityContext并存储在SecurityContextHolder中,因为后续filter需要用
   SecurityContext存储的认证相关信息,所以需要在请求一开始就要把这些信息设置好 ,这样也能使在认证过程中对SecurityContext的任何修改都可以保存下来,并在请求结束后存储在HttpSession中(以在下次请求时使用)

3. ConcurrentSessionFilter (并发访问控制过滤器)主要是判断session是否过期以及更新最新访问时间。

4. HeaderWriterFilter (请求头部写入过滤器)往该请求的Header中添加相应的信息

5. CsrfFilter ( CSRF过滤器)为了防止跨站提交攻击。

6. LogoutFilter (退出过滤器)退出当前登录的账号。

7. X509AuthenticationFilter ( X509认证过滤器)基于X509证书的认证过滤器。

8. AbstractPreAuthenticatedProcessingFilter处理form登陆的过滤器,与form登陆有关的所有操作都是在此进行的。这个请求应该是用户使用form登陆后的提交地址

9. CasAuthenticationFilter ( CAS认证过滤器)基于CAS的认证过滤器。

10. UsernamePasswordAuthenticationFilter (用户名密码认证过滤器)基于用户名和密码的认证过滤器。

11. BasicAuthenticationFilter ( basic认证过滤器)此过滤器用于进行basic验证,功能与AuthenticationProcessingFilter类似,只是Basic验证方式相比较而言用的不是太多,默认会对密码进行base64加密

12. SecurityContextHolderAwareRequestFilter此过滤器用来包装客户的请求。通过查看其源码可以发现其doFilter方法中会创建一个包装类SecurityContextHolderAwareRequestWrapper 对ServletRequest对象进行包装,主要实现了servlet api的一些接口方法isUserInRole、getRemoteUser，为后续程序提供一些额外的数据。即可以从request对象中获取到用户信息

13. JaasApiIntegrationFilter如果SecurityContextHolder中拥有的Authentication是一个JaasAuthenticationToken ,那么该Filter将使用包含在JaasAuthenticationToken中的Subject继续执行FilterChain。

14. RememberMeAuthenticationFilter (记住我认证过滤器)当用户没有登录而直接访问资源时，从cookie里找出用户的信息， 如果Spring Security能够识别出用户提供的remembermecookie, 用户将不必填写用户名和密码，而是直接登录进入系统.它先分析SecurityContext里有没有Authentication对象.如果有，则不做任何操作，直接跳到下一个过滤器.如果没有，则检查request里有没有包含remember- me的cookie信息.如果有，则解析出cookie里的验证信息，判断是否有权限。

15. AnonymousAuthenticationFilter (匿名认证过滤器)用于支持Spring Security的匿名访问, 适用于-些公共资源希望所有人都可以看到。对于匿名访问的用户, Spring Security支持为其建立一个匿名的AnonymousAuthenticationToken存放在SecurityContextHolder中,这就是所谓的匿名认证。这样在以后进行权限认证或者做其它操作时我们就不需要再判断SecurityContextHolder中持有的Authentication对象是否为null了,而直接把它当做-个正常的Authentication进行使用就0K了。

16. SessionManagementFilter根据认证的安全实体信息跟踪session ,保证所有关联一个安全实体的session都能被跟踪到。

17. ExceptionTranslationFilter解决在处理一个请求时产生的指定异常。

18. FilterSecurityInterceptor简化授权和访问控制决定,委托一个AccessDecisionManager完成授权的判断。

19. SwitchUserFilterSwitchUserFilter是用来做账户切换的

认证管理器和决策管理器Spring Security提供了多个Provider的实现类， 如果我们想用
数据库来储存用户的认证数据，那么我们就选择DaoAuthenticationProvider。对于Voter，我们一般选择RoleVoter就够用了，它会根据我们配置文件中的设置来决定是否允许某–个用户访问制定的Web资源。而DaoAuthenticationProvider也是不直接操作数据库的，它把
任务委托给了UserDetailService，如下图:

自定义filter

怎么在Spring Security中的Filter指定位置加入自定义的Filter呐? SpringSecurity的HttpSecurity为此提供了三个常用方法
来配置:

1. addFilterBefore(Filter filter， Class<? extends Filter> beforeFilter)
   在beforeFilter之前添加filter

2. addFilterAfter(Filter filter， Class<? extends Filter> afterFilter)
   在afterFilter之后添加filter

3. addFilterAt(Filter filter, Class<? extends Filter> atFilter)
   在atFilter相同位置添加filter ,此filter不覆盖filter

案例：

BeforeFilter

public class BeforeLoginFilter extends GenericFilterBean {
 @Override
 public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
 System.out.println("this is beforeLoginFilter");
 filterChain.doFilter(servletRequest,servletResponse);
 }
}

AtFilter

public class AtLoginFilter extends GenericFilterBean {
 @Override
 public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
 System.out.println("this is AtLoginFilter");
 filterChain.doFilter(servletRequest,servletResponse);
 }
}

AfterFilter

public class AfterLoginFilter extends GenericFilterBean {
 @Override
 public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
 System.out.println("this is AfterLoginFilter");
 filterChain.doFilter(servletRequest,servletResponse);
 }
}

在configure(HttpSecurity http)配置

添加filter调用方法的第二个参数是参照位置过滤器，这里添加在登录请求发起时。

http.addFilterBefore(new BeforeLoginFilter(),UsernamePasswordAuthenticationFilter.class);
http.addFilterBefore(new AtLoginFilter(),UsernamePasswordAuthenticationFilter.class);
http.addFilterBefore(new AfterLoginFilter(),UsernamePasswordAuthenticationFilter.class);

动态权限的集中方案

• 使用@PreAuthorize硬编码

• access()的SpEL表达式

.antMatchers("/xxx/xx").access("hasRole('USER') and hasIpAddress('211.143.161.130')")

扩展SpEL表达式

.anyRequest().access("@authService.canAccess(request,authentication)")

其中authService是一个类，canAccess是其中的方法：

@Service
public class AuthService {
 @Autowired
 private PermissionService permissionService;
 public boolean canAccess(HttpServletRequest request, Authentication authentication) {
 System.out.println("canAccess(1)");
 boolean b =false;
 Object principal = authentication.getPrincipal();
 /**
 * 1/未登录的情况下，需要做一个判断或者拦截
 */
 if (principal == null || "anonymousUser".equals(principal)) {
 return b;
 }
 System.out.println("canAccess(2)");
 /**
 * 2/ 匿名的角色 ROLE_ANONYMOUS
 * 这里不涉及
 */
 if(authentication instanceof AnonymousAuthenticationToken){
 // 匿名角色
 // check
 // return
 }
 /**
 * 3/ 通过request对象的url() 获取到权限信息
 */
 Map<String, Collection<ConfigAttribute>> map = permissionService.getPermissionMap();
 /**
 * /hello/helloUser 与 /hello/**无法通过下面的方法进行比较
 */
// Collection<ConfigAttribute> collection = map.get(request.getRequestURI());
 // AntPathRequestMatcher
 Collection<ConfigAttribute> configAttributes = null;
 for(Iterator<String> it = map.keySet().iterator();it.hasNext();) {
 String curUrl = it.next();
 AntPathRequestMatcher matcher = new AntPathRequestMatcher(curUrl);
 if (matcher.matches(request)){
 configAttributes = map.get(curUrl);
 break;
 }
 }
 if(configAttributes == null || configAttributes.size() == 0) {
 return b;
 }
 System.out.println("canAccess(3)");
 /**
 * 4/将获取的权限信息和当前的登录账号的权限信息进行对比
 */
 for(Iterator<ConfigAttribute> it = configAttributes.iterator();it.hasNext();) {
 ConfigAttribute cfa = it.next();
 String role = cfa.getAttribute(); // ROLE_admin | ROLE_normal
 for (GrantedAuthority authority : authentication.getAuthorities()){
 if (role.equals(authority.getAuthority())) {
 b = true;
 break;
 }
 }
 }
 return b;
 }
}

该类的方法通过获取权限信息和当前用户的权限信息进行比对，如果返回true则可以访问。

其中用到的对应类：

权限实体类

@Entity
public class Permission {
 @Id
 @GeneratedValue
 private long id;
 private String name; // 权限名
 private String description;// 描述
 private String url; // 地址
 private long pid;// 父id
 @ManyToMany(fetch = FetchType.EAGER)
 @JoinTable(name = "role_permission",joinColumns= {@JoinColumn(name="permission_id")},
 inverseJoinColumns = {@JoinColumn(name = "role_id")})
 private List<Role> roles;
 public long getId() {
 return id;
 }
 public void setId(long id) {
 this.id = id;
 }
 public String getName() {
 return name;
 }
 public void setName(String name) {
 this.name = name;
 }
 public String getDescription() {
 return description;
 }
 public void setDescription(String description) {
 this.description = description;
 }
 public String getUrl() {
 return url;
 }
 public void setUrl(String url) {
 this.url = url;
 }
 public long getPid() {
 return pid;
 }
 public void setPid(long pid) {
 this.pid = pid;
 }
 public List<Role> getRoles() {
 return roles;
 }
 public void setRoles(List<Role> roles) {
 this.roles = roles;
 }
}

权限业务实现类

@Service
public class PermissionServiceImpl implements PermissionService {
 @Autowired
 private PermissionRepository permissionRepository;
 private Map<String, Collection<ConfigAttribute>> permissionMap = null;
 @PostConstruct
 public void initPermission() {
 // 从数据库中获取所有权限信息，然后遍历，存储到permissionmMap集合中
 permissionMap = new HashMap<>();
 List<Permission> permissions = permissionRepository.findAll();
 for (Permission p : permissions) {
 Collection<ConfigAttribute> collection = new ArrayList<>();
 for (Role role : p.getRoles()) {
 ConfigAttribute configAttribute = new SecurityConfig("ROLE_"+role.getName());
 collection.add(configAttribute);
 }
 permissionMap.put(p.getUrl(),collection);
 }
 System.out.println(permissionMap);
 }
 // 获取权限map
 @Override
 public Map<String, Collection<ConfigAttribute>> getPermissionMap() {
 if(permissionMap == null || permissionMap.size() == 0) {
 initPermission();
 }
 System.out.println(permissionMap);
 return permissionMap;
 }
}

标签sec:authorize的使用

• 步骤1：依赖

<dependency>
 <groupId>org.thymeleaf.extras</groupId>
 <artifactId>thymeleaf-extras-springsecurity5</artifactId>
 </dependency> 

• html中添加命名空间,并使用

<!DOCTYPE html>
<html xmlns:="http://www.w3.org/1999/xhtml"
 xmlns:th="http://www.thymeleaf.org"
 xmlns:sec="http://www.thymeleaf.org/thymeleaf-extras-springsecurity5">
<head>
 <meta charset="UTF-8">
 <title>Spring Security 入门</title>
</head>
<body>
 <h1>欢迎使用Spring Security! <label th:text="${name}"></label></h1>
 <p sec:authorize="hasRole('admin')"><a th:href="@{/helloAdmin}">admin page</a></p>
 <p sec:authorize="hasAnyRole('admin','normal')"><a th:href="@{/helloUser}">user page</a></p>
 <form th:action="@{/login}" method="post">
 <input type="submit" value="退出登录">
 </form>
</body>
</html>

页面获取用户信息

设置最大session数

在WebSecurityConfigurerAdapter类中设置

.sessionManagement().maximumSessions(1)

登录数超过1，会将之前的登录挤掉

@Secured和@PostAuthorize用法

• @Secured

开启注解：在WebSecurityConfigurerAdapter集成类上添加

@EnableGlobalMethodSecurity(securedEnabled = true)

在方法中使用

 @GetMapping("/helloUser")
 @ResponseBody
 //@PreAuthorize("hasAnyRole('normal','admin')")
 @Secured({"ROLE_admin","ROLE_normal"})// 需要在前面加上ROLE_
 public String helloUser() {
 return "hello, user";
 }

• @PostAuthorize

在方法执行后再进行权限验证，适合验证带有返回值的权限，Spring EL提供返回对象能够在表达式语言中获取返回的对象returnObject

开启注解：在WebSecurityConfigurerAdapter集成类上添加

@EnableGlobalMethodSecurity(prePostEnabled= true)

在方法中使用

@GetMapping("/helloUser")
 @ResponseBody
 @PostAuthorize("returnObject !=null && returnObject.username == authentication.name")
 public User helloUser() {
 Object principle = SecurityContextHolder.getContext().getAuthentication().getPrincipal();
 User user;
 if("anonymousUser".equals(principle)) {
 user = null;
 }else {
 user = (User) principle;
 }
 return user;
 }

加密

自定义加密方式

这里以MD5加密方式为例

MD5加密工具类

/**
 * MD5加密工具
 */
public class MD5Util {
// 自定义盐
 private static final String SALT = "liuyang";
 public static String encode(String password) {
 password = password + SALT;
 MessageDigest md5 = null;
 try {
 md5 = MessageDigest.getInstance("MD5");
 } catch (NoSuchAlgorithmException e) {
 throw new RuntimeException(e);
 }
 char[] charArray = password.toCharArray();
 byte[] byteArray = new byte[charArray.length];
 for (int i = 0; i < charArray.length; i++) {
 byteArray[i] = (byte) charArray[i];
 }
 byte[] md5Bytes = md5.digest(byteArray);
 StringBuffer hexValue = new StringBuffer();
 for (int i = 0; i < md5Bytes.length; i++) {
 int val = (int)md5Bytes[i] & 0xff;
 if(val < 16) {
 hexValue.append("0");
 }
 hexValue.append(Integer.toHexString(val));
 }
 return hexValue.toString();
 }
}

自定义实现PasswordEncoder接口的密码编辑器

public class MD5PasswordEncoder implements PasswordEncoder {
 // 加密
 @Override
 public String encode(CharSequence charSequence) {
 return MD5Util.encode((String) charSequence);
 }
 // 匹配
 @Override
 public boolean matches(CharSequence charSequence, String s) {
 return s.equals(MD5Util.encode((String) charSequence));
 }
}

在WebSecurityConfigurerAdapter配置类中设置加密方式

// 注入封装自己的加密方式
 @Bean
 public PasswordEncoder passwordEncoder() {
// return new BCryptPasswordEncoder();
 return new MD5PasswordEncoder();
 }

使用工厂模式设置加密方式

将密码编码之后的hash值和加密方式一起存储，并提供一个DelegatingPasswordEncoder来作为众多密码编码方式的集合

• 简单方式：在WebSecurityConfigurerAdapter设置

// 注入封装自己的加密方式
 @Bean
 public PasswordEncoder passwordEncoder() {
 return PasswordEncoderFactories.createDelegatingPasswordEncoder();
 }

createDelegatingPasswordEncoder（） 方法

public static PasswordEncoder createDelegatingPasswordEncoder() {
 String encodingId = "bcrypt";
 Map<String, PasswordEncoder> encoders = new HashMap();
 encoders.put(encodingId, new BCryptPasswordEncoder());
 encoders.put("ldap", new LdapShaPasswordEncoder());
 encoders.put("MD4", new Md4PasswordEncoder());
 encoders.put("MD5", new MessageDigestPasswordEncoder("MD5"));
 encoders.put("noop", NoOpPasswordEncoder.getInstance());
 encoders.put("pbkdf2", new Pbkdf2PasswordEncoder());
 encoders.put("scrypt", new SCryptPasswordEncoder());
 encoders.put("SHA-1", new MessageDigestPasswordEncoder("SHA-1"));
 encoders.put("SHA-256", new MessageDigestPasswordEncoder("SHA-256"));
 encoders.put("sha256", new StandardPasswordEncoder());
 encoders.put("argon2", new Argon2PasswordEncoder());
 return new DelegatingPasswordEncoder(encodingId, encoders);
 }

密码格式：

• 进阶：将自己的加密方式添加到工厂模式中,并将其设置为默认加密方式

public class MyPasswordEncoderFactories {
 public static PasswordEncoder createDelegatingPasswordEncoder() {
 String encodingId = "myMD5";
 Map<String, PasswordEncoder> encoders = new HashMap();
 //encoders.put(encodingId, new BCryptPasswordEncoder());
 encoders.put("ldap", new LdapShaPasswordEncoder());
 encoders.put("MD4", new Md4PasswordEncoder());
 encoders.put("MD5", new MessageDigestPasswordEncoder("MD5"));
 encoders.put("noop", NoOpPasswordEncoder.getInstance());
 encoders.put("pbkdf2", new Pbkdf2PasswordEncoder());
 encoders.put("scrypt", new SCryptPasswordEncoder());
 encoders.put("SHA-1", new MessageDigestPasswordEncoder("SHA-1"));
 encoders.put("SHA-256", new MessageDigestPasswordEncoder("SHA-256"));
 encoders.put("sha256", new StandardPasswordEncoder());
 encoders.put("argon2", new Argon2PasswordEncoder());
// 将自己密码方式添加进来
 encoders.put(encodingId, new MD5PasswordEncoder());
 return new DelegatingPasswordEncoder(encodingId, encoders);
 }
 private MyPasswordEncoderFactories() {
 }
}

Remember-Me

• 原理

通常是通过服务端发送一个cookie给客户端浏览器，下次浏览器再访问服务端时服务端能够自动检测客户端的cookie ，根据cookie值触发自动登录操作。对于Spring Security的cookie的默认名称是: remember-me
举例说明:
remember-me : YWRtaW46MTU1NTAOMTYyNTIxOToyYzdkNDIwMWUzNmRmODc5MmMzNDYOMjJmNTdiGJmMA

基于简单加密token方法

用户选择了记住我成功登陆后，spring security将会生成一个cookie发送给客户端浏览器，cookie值由如下方式组成：

base64(username+":"+expirationTime+":"+md5Hex(username+":"+expirationTime+":"+password+":"+key))

expirationTime:失效时间，以毫秒为单位

key:用来防止修改

1. 需要一个rememberMeService方法：使用spring security提供的TokenBaseRememberMeService进行配置@Autowired

private String rememberMeKey = "liuyang20120";
@Autowired
private CustomUserDetailService customUserDetailService;
@Bean
 public RememberMeServices rememberMeServices() {
 TokenBasedRememberMeServices rememberMeServices = new TokenBasedRememberMeServices(
 rememberMeKey, customUserDetailService
 );
 // 过期时间设置，单位秒；默认为2周
 // rememberMeServices.setTokenValiditySeconds(60);
 // checkbox 的name,默认：rember-me
 //rememberMeServices.setParameter("remember-me");
 return rememberMeServices;
 }

2. 在WebSecurityConfigurerAdapter实现类中，进行配置

.and().rememberMe().key(rememberMeKey).rememberMeServices(rememberMeServices());

3. 登陆页面修改

<!-- name="remember-me" 与rememberMeServices.setParameter("remember-me"); 保持一致 -->
 <div>
 <label>记住我：<input type="checkbox" name="remember-me"/></label>
 </div>        

4. 效果

基于持久化token的方法

通过数据库或其他持久化存储机制的保存生成token,会保存用户的基本信息：username、series、token、last_used_

注意几点：

（1）如何开启持久化token方式：可以使用and().rememberMe()进行开启记住我，然后指定tokenRepository()，即指定token持久方式

（2） tokenRepository怎么实现：这里我们可以使用Spring Security提供的JdbcTokenRepositoryImpl即可,这里只需要配置一个数据源即可.
（3）持久化token的数据保存在哪里:这里的数据是保存在persistent_ logins表中。
（4）persistent__logins表生成方式:有两种方式可以生成,第-种就是手动方式,根据表结构自己创建表;第种方式就是使用JdbcTokenRepositoryImpl配置为自动创建,这种方式虽然会自动生成,但是存在的一个小问题就是第二次运行程序的就会保存了,因为persistent__logins已经存在了。使用方式就是第一次执行的时候,打开配置,生成表之后,注释掉配置。

代码方式：

1. 实现tokenRepository方法

@Autowired
 private CustomUserDetailService customUserDetailService;
 @Autowired
 private DataSource dataSource;
@Bean
 public PersistentTokenRepository tokenRepository() {
 JdbcTokenRepositoryImpl jdbcTokenRepository = new JdbcTokenRepositoryImpl();
 jdbcTokenRepository.setDataSource(dataSource);
 // 自动创建表
 jdbcTokenRepository.setCreateTableOnStartup(true);
 return jdbcTokenRepository;
 }

2. 配置

.and().rememberMe().tokenRepository(tokenRepository()).tokenValiditySeconds(60).userDetailsService(customUserDetailService);

3. 前端设置同上

生成表

零散记录

• csrf

csrf就是诱导已登录过的用户在不知情的情况下，使用自己的登录凭据来完成一些不可告人之事。比如利用img标签或者script标签的src属性自动访问一些敏感api，或者是伪造一个form标签，action写的是一些敏感api，通过js自动提交表单等。

在spring security中默认是开启的，需要关闭

• 允许访问文件

http.antMatchers("/res/**/.{js,html}").permitAll() // 允许访问/res下的js和html文件

• 在controller层获取当前登录用户对象

Object principal = SecurityContextHolder.getContext().getAuthentication().getPrincipal();

注意： 未登陆情况下，返回的是一个字符串：anonymousUser；登陆情况下，返回的是在loadUserByUsername 方法中返回的User对象

• SpEL（Spring Expression Language），即Spring表达式语言，是比JSP的EL更强大的一种表达式语言。

注解积累

@PostConstruct : 程序初始化时加载对应方法