前言:现在开发中,记住我这个功能是普遍的,用户不可能每次登录都要输入用户名密码。昨天准备用spring security的记住我功能,各种坑啊,吐血 。

先看下具体实现吧。

spring security 对remember-me 进行了封装 ,大概流程是 首先用户的表单必须有这个记住我的字段。

1.安全配置

以下是代码 (红色字体注释是关键)

package com.ycmedia.security;

import javax.servlet.http.HttpServletRequest;
import javax.sql.DataSource; import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.authentication.AuthenticationDetailsSource;
import org.springframework.security.authentication.AuthenticationProvider;
import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder;
import org.springframework.security.config.annotation.method.configuration.EnableGlobalMethodSecurity;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.builders.WebSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.web.authentication.WebAuthenticationDetails;
import org.springframework.security.web.authentication.rememberme.JdbcTokenRepositoryImpl;
import org.springframework.security.web.authentication.rememberme.PersistentTokenRepository;
import org.springframework.security.web.util.matcher.AntPathRequestMatcher; import com.ycmedia.constants.MySQLConfig; @Configuration
@EnableWebSecurity
public class SecurityConfiguration extends WebSecurityConfigurerAdapter { @Autowired
@Qualifier("customUserDetailsService")
UserDetailsService userDetailsService; @Autowired
private AuthenticationProvider authenticationProvider;
//注入数据源
@Autowired
@Qualifier("mysqlDS")
private DataSource dataSource; @Autowired
private AuthenticationDetailsSource<HttpServletRequest, WebAuthenticationDetails> authenticationDetailsSource;
@Override
protected void configure(HttpSecurity http) throws Exception {
//允许所有用户访问”/”和”/home”
http.authorizeRequests().
antMatchers( "/css/**", "/js/**", "/images/**",
"/lib/**", "/skin/**"
, "/bootstrap/**"
, "/build/**"
, "/documentation/**"
, "/pages/**"
)
.permitAll()
//其他地址的访问均需验证权限
.anyRequest().authenticated()
.and()
.formLogin()
//指定登录页是”/login”
.loginPage("/login")
.permitAll()
//登录成功后可使用loginSuccessHandler()存储用户信息,可选。
.successHandler(loginSuccessHandler())//code3
.and()
.logout()
.logoutRequestMatcher(new AntPathRequestMatcher("/logout"))
//退出登录后的默认网址是”/home”
.logoutSuccessUrl("/home")
.permitAll()
.invalidateHttpSession(true)
.and()
//登录后记住用户,下次自动登录
//数据库中必须存在名为persistent_logins的表
//建表语句见code15 // 这里是核心
.rememberMe()
.tokenValiditySeconds(1209600)
//指定记住登录信息所使用的数据源
.tokenRepository(tokenRepository());//code4 } // @Override
// protected void configure(HttpSecurity http) throws Exception {
// //允许访问静态资源
// http.authorizeRequests()
// .antMatchers( "/css/**", "/js/**", "/images/**",
// "/resources/**", "/lib/**", "/skin/**", "/template/**"
// , "/bootstrap/**"
// , "/build/**"
// , "/documentation/**"
// , "/pages/**"
// , "/plugins/**"
// , "/skin/**")
// .permitAll()
// //登录和注册页面不需要权限验证
// .antMatchers("/login", "/registration","/registrationUser").permitAll()
// //其他地址的访问均需验证权限
// .anyRequest().authenticated().
// //访问失败页url
// and().formLogin()
// //.failureUrl("/login?error").
// //默认访问页
// .loginPage("/login")
// .permitAll().successHandler(loginSuccessHandler()).
// and().logout()
// .logoutRequestMatcher(new AntPathRequestMatcher("/logout"))
// //退出登录后的默认网址是”/home”
// .logoutSuccessUrl("/home").
// // 注销会删除cookie
// deleteCookies("remember-me")
// .invalidateHttpSession(true)
// //注销失败跳转到登录页面
// .permitAll().and()
// .rememberMe()
// .tokenValiditySeconds(1209600)
// //指定记住登录信息所使用的数据源
// .tokenRepository(tokenRepository());//code4
//
//
//
// //设置session
//// http.sessionManagement().maximumSessions(1);
//// http.sessionManagement().invalidSessionUrl("/login");
// } @Override
public void configure(WebSecurity web) throws Exception {
web.ignoring().antMatchers("/resources/**");
web.ignoring().antMatchers("/webjars/**");
} // @Override
// protected void configure(AuthenticationManagerBuilder auth)
// throws Exception {
// //采用自定义验证
// auth.authenticationProvider(authenticationProvider);
//
// //需要采用加密
//// auth.userDetailsService(userDetailsService).passwordEncoder(passwordEncoder());
// } @Bean
public BCryptPasswordEncoder passwordEncoder() {
return new BCryptPasswordEncoder(4);
}
//spring security 内部都写死了,这里要把 这个DAO 注入
@Bean
public JdbcTokenRepositoryImpl tokenRepository(){
JdbcTokenRepositoryImpl j=new JdbcTokenRepositoryImpl();
j.setDataSource(dataSource);
return j;
}
/**
* 用户或者管理员登录日志
*/
@Bean
public LoginSuccessHandler loginSuccessHandler(){
return new LoginSuccessHandler();
}
@Autowired
public void configureGlobalSecurity(AuthenticationManagerBuilder auth) throws Exception {
auth.authenticationProvider(authenticationProvider);
auth.userDetailsService(userDetailsService);
} }

2 前端页面, 这个简单

   <div class="checkbox">
<label><input type="checkbox" id="rememberme" name="remember-me"/> Remember Me</label>
</div>

3 、数据库表,因为 spring security 内部把表写死了, 可以看源码

 * @author Luke Taylor
* @since 2.0
*/
public class JdbcTokenRepositoryImpl extends JdbcDaoSupport implements
PersistentTokenRepository {
// ~ Static fields/initializers
// ===================================================================================== /** Default SQL for creating the database table to store the tokens */
public static final String CREATE_TABLE_SQL = "create table persistent_logins (username varchar(64) not null, series varchar(64) primary key, "
+ "token varchar(64) not null, last_used timestamp not null)";
/** The default SQL used by the <tt>getTokenBySeries</tt> query */
public static final String DEF_TOKEN_BY_SERIES_SQL = "select username,series,token,last_used from persistent_logins where series = ?";
/** The default SQL used by <tt>createNewToken</tt> */
public static final String DEF_INSERT_TOKEN_SQL = "insert into persistent_logins (username, series, token, last_used) values(?,?,?,?)";
/** The default SQL used by <tt>updateToken</tt> */
public static final String DEF_UPDATE_TOKEN_SQL = "update persistent_logins set token = ?, last_used = ? where series = ?";
/** The default SQL used by <tt>removeUserTokens</tt> */
public static final String DEF_REMOVE_USER_TOKENS_SQL = "delete from persistent_logins where username = ?";

这个表名必须 是persistent_logins

CREATE TABLE `persistent_logins` (
  `username` varchar(64) NOT NULL,
  `series` varchar(64) NOT NULL,
  `token` varchar(64) NOT NULL,
  `last_used` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
  PRIMARY KEY (`series`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8; ==========================================================================================其实到这里基本是没问题的,如果用 springsecurity 默认 授权验证 springsecurity 默认都是用户名+密码登录, 但是现在系统很多都是用户手机号+手机验证码登录,我这里就是这么实现的,手机验证码必须从第三方短信获取, 所以必须自定义授权验证 先看下我的自定义验证类
package com.ycmedia.security;

import java.util.ArrayList;
import java.util.Collection;
import java.util.List; import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.core.env.Environment;
import org.springframework.security.authentication.AuthenticationProvider;
import org.springframework.security.authentication.BadCredentialsException;
import org.springframework.security.authentication.RememberMeAuthenticationToken;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.AuthenticationException;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.authority.SimpleGrantedAuthority;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.stereotype.Component; import com.alibaba.fastjson.JSONObject;
import com.ycmedia.constants.Constants;
import com.ycmedia.entity.Customer;
import com.ycmedia.entity.Role;
import com.ycmedia.service.UserService;
import com.ycmedia.utils.HttpRequest; /**
* @author 自定义验证
*
*/
@Component
public class YcAnthencationProder implements AuthenticationProvider {
@Autowired
private UserService userService;
BCryptPasswordEncoder passwordEncoder = new BCryptPasswordEncoder();
@Autowired
private Environment env; @Override
public Authentication authenticate(Authentication authentication)
throws AuthenticationException {
// CustomWebAuthenticationDetails details = (CustomWebAuthenticationDetails) authentication
// .getDetails(); // 如上面的介绍,这里通过authentication.getDetails()获取详细信息
// 用户名
String username = authentication.getName();
// 验证码
String password = (String) authentication.getCredentials();
Customer user = userService.getUserByname(username);
List<SimpleGrantedAuthority> auths = new ArrayList<>(); System.out.println("用户"+authentication.getName()+"正在获取权限");
//游客=》提示用户去注册
if(user==null){
//授权
auths.add(new SimpleGrantedAuthority(Role.ROLE_TOURIST.toString()));
auths.add(new SimpleGrantedAuthority(username));
auths.add(new SimpleGrantedAuthority(password));
return new UsernamePasswordAuthenticationToken(new Customer(), password,
auths);
}else{
//存在此用户,调用登录接口
String data = HttpRequest.sendGet(env.getProperty("login.url"),
"mobile=" + username+"&smsCode="+password);
JSONObject json = JSONObject.parseObject(data);
if(json.getBoolean("success")==true)){
//验证码和手机号码正确,返回用户权限
switch(user.getRole()){
case 0:auths.add(new SimpleGrantedAuthority(Role.ROLE_USER.toString()));
case 1:auths.add(new SimpleGrantedAuthority(Role.ROLE_CHANNEL.toString()));
case 2:auths.add(new SimpleGrantedAuthority(Role.ROLE_ADMIN.toString()));
}
}else{
//验证消息放到权限里面, 页面提示
auths.add(new SimpleGrantedAuthority(Role.ROLE_WRONGCODE.toString()));
auths.add(new SimpleGrantedAuthority(username));
auths.add(new SimpleGrantedAuthority(password));
}
} return new RememberMeAuthenticationToken(username, user, auths);
// return new UsernamePasswordAuthenticationToken(user, password,
// auths); } @Override
public boolean supports(Class<?> authentication) {
return authentication.equals(UsernamePasswordAuthenticationToken.class);
} }
实现 这个接口就行AuthenticationProvider, 
但是,结果
        return new UsernamePasswordAuthenticationToken(user, password,
                auths);
返回一个 UsernamePasswordAuthenticationToken 对象, 这个对象,是继承了 AbstractAuthenticationToken
aaarticlea/png;base64,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" alt="" />
而AbstractAuthenticationToken 又是 Authentication 的子类, 

aaarticlea/png;base64,iVBORw0KGgoAAAANSUhEUgAAAysAAAERCAIAAAD0S6/pAAAgAElEQVR4nO3dX4gc553uccHe5SL4YiGEg28aiW6NZkbj0WjQrNOJO5EW25qZ42nZciLZWAwdLAkk5dh0a+bCEdZNDdFa0cBRcAmNMLEOkYVzEThH9lmO2oQTB12YeDdhDd4ENQdhXywO+CKITbJsn4uqrnrft973raqe6qruma/4YJipf2/VzHQ9/r1v1bvj3/7t37q9f//v84eBO//nI++b+9zul19+af9vuVLKzb//+7/neTgAAIDM7YhNYLHxa5/bzbPFJDAAADDq4hMYNTAAAIBsUQMDAADIGzUwAACAvG35Gliz3b27UvRVhm/1bvDL1l4tujEAABQnjxpYteG4wr9W3bxOayG2xQkTWH3jfmdjsVxptjvX6pXSSjvFLf/Uu+c//czz4qkMrnLt7c/Of/puTf7mtHPv/KefnXYW8vgxr7S70r92M58jdjYWdUubbRIYAGB7y70GVm+6rtOoyt+sLjuu46xlmcC823y3c7fdvtvudLtJK2G1tz87/+m9Z56ulMqV0tOXT2cQws6++OkwJLAwdTXbxmyUlWa7e//6xt1u51rd8KMhgQEAtrP8x4EttNQy2FxjzXUac0utbBNYqVwplY9c63TvXz+SdP1T7yp1r9rbn51vX57e1FUeugSmfpm9VS97mZIWCQwAsN3lXQOrNhx3bbmqfMdtLlVKWSewxesdoQamL8bIFp5pf3a+fXk67IW894zzrh+enr58utc1qXRQKlmq9nZvaWST80IU6211+cXeIimNCT2hYU0uaMbbZ8OdJwmIUuQ6cq2jBCBheJYS1Dobi0IPZtIRdd6G6nFDhgSmbcaRa52u+ONbvJ6iogkAwJDKqQYmDAVTuiDDkli2CayPcWB+n+PCM20hLZ161w9AmjjlB6PNJDDLDhV+4PMT2LsvCoviC2nKODCxC7K+cV8INIvXO2H68bfyv0zed9lsB3XH1bu6tKRJYJZmiIeWVwMAYFTlPg6suuy4rtOY874UU9dAeiHTPAvpha1Tl09/+tlpZ8EfPh8kMHnlMGZZEpi/sq0XMti5sJW3frgHb9H5t8+WyhW19OWVymLLYNFxYL0vF6935FwlZKY++y5XheFf0XpbrwHyN23NCPfTvttN06cMAMDQKuB9YGFHZL3p9T963x9MAktu2rknRi5/BJiQwPwkFKlLbSaB6baKrO+lLi9m+QlMEwpt1PAU5pum8pSk2NvYXwKTV1OqWZ5oArM1Q2gzo8cAAFtEAe8DC5LWUsvV/gsqZFoDS2By0csfE/ZM70USSq4y1sB647c2ncCsNbC0DwfYE5gp1vSVwBJkKUMCs6Ur74mKVW1FDQCA0ZN7DUz7NopKqTxUNTC51tW+PK0rgCkJTD9sq1wJEpVhJL6mcmYZIpZJApNGdFlGVvWTwKIDvzQdkbHjwGRHrnWCBq/SEQkA2AryqIHJta6w21GzWuEJrFf9+vSzF99+V34OUQhS7cs1556mTKVbVCorDzbGJ7CSGsIMPZLJKSPxdelHXCyMxE+ZwHTrhB2R6othu9LK+mZ4D0gqzaASBgAYccwLGXraH4Nf/E8FAABsbVt+XshUpBfilyulU5fTDXgHAABIghqYQh7vlfKRQwAAgCSogQEAAOSNGhgAAEDeqIEBAADkjRoYAABA3qiBAQAA5G3L18BSzMwNRX3jfjjH9nDy3tfa5R2tAIARk0cNrNpwxJfit+rGRaYJi0QJE1h9435nY7FcabY71+qV0ko7xR1aeIW99Gr7ftXe/ix2XsgB8+ZVTDmZT8YJ7Mi1Tjf6L5MphuKmlQQAYMgUPC9kteG4a8vVNC1OXANrtrvdbuduu3233eka5xxUSS9lffry6QxCWKKZuQdsGBLY5hpjRQIDAIyY/MeBLbSEMtggE1ipXEl9sz/1rlL3qr2dfhJGFQksi8ZYkcAAACMm7xqYErkGmcAWr3eEGliSJLHwTPuz8+3L02Ev5L1nnHf98ORNiS1QZtHWzLEd2UQ3M/flYMJvKY1Jk3kLr+b39vn22XDniQKiOfRYpt+WEpjfhyjsRBiDFTtjd6LGiDuUjyulq9W7kb5LfQKTpvoWfwFW73Y71+pelZQxZACAIuRUAxPGe0kjvSxDxEwGNw7M73NceKYtpKVT7/oBSBOn/GC0mQRm2aHCD3x+Anv3RWFRgkLa5hJYfeO+EnrqG/eFjt3F6500IUzbmCPXOuEemm0h1a20pfykNDhYX/n5rrS7aguDnfhRz2+DfC4AAOQh93Fg1WXHdZ3GnGZRvemaFgkG9yykF7ZOXT796WennQV/+HyQwOSVw5hlSWD+yrZeyGDnwlbe+uEe/Kkq3z5bKlfU0pdXKosvg/WdwKIFpErJCzSdjcXwO6t3U4SYBL2QUqvEopd+20gCi1bOxA2VKlr2vaIAAMQo4H1glp7HpZbrthbsmw/sfWDTzj0xcvkjwIQEJk/anU0C020VWd9LXV7M8hNY2inDN1EDW4kUwMpC/53wb5MJbPF6R95f2Kow8NU37uuKbdoEZu6pTJUXAQAYgALeB2aOWXONtQITmFz08seEPdN7kYSSq4w1sN74rU0nMGsNLPXDAZvrhVxpyyPANjnyXdMYuZcw2tUYjtzSnkUfNTASGACgSLnXwOS3UYiqDSfD94GlJ9TA5FpX+/K0rgCmJDD9sK1yJUhUhpH4msqZZYhY9glMHAW10paKT+JIfHlY1ebGTpkSmNTtqAz2Wrze6bbbdw2jzZKNA5P2TwIDABQpjxrYUkscbd9cMi1K9lDkYBNYr/r16Wcvvv2u/ByiEKTal2vOPU2ZSreoVFYebIxPYCU1hBl6JFOIvg01LDgJXYrtptjNJ7+Nwu8lDIKO9KShGphiG6MbiS+0bSXS2+gdThezTH2X8lKlokYCAwAUinkhQ0/7Y/CL/6kgagSmSAIAILEtPy9kKtIL8cuV0qnLKQe8Y0Ci47oAABhl1MAU8nivtI8cImtBXyfxCwCwlVADAwAAyBs1MAAAgLxRAwMAAMgbNTAAAIC8UQMDAADI25avgcXOzB2ZZBoAgOG2OLbr+HhZcXK8cmVqIurkeCW68uLYrsLPYpvLowZWbTjiS/Fb9cg69aZtqSxhAqtv3O9sLJYrzXZvZkP96wx4PToAYGh40ao5sdsLTx/OTH84M/3F7OxfDxwYtC9mZ73DeYduTuwmqA1U4fNCzjXW1KmK7BLXwJrtbrfbudtu3213uqaYtdKmAAYAyFVtbOfx8fLFyT1XpibeeWzyw5np387syyFjbcZvZ/Z9ODP9zmOTV6YmLk7uOT5enin6Mo66/MeBLbTEQle9mXA6yEC6XkjzjNTxSwEAyEJtbKfXRZhJQeuPs7O/3jcddXt67/re8ajb03u16/9x0y3xymZeR2dtbGfh13m05F0DqzYcMXIttVynMZeqxYkT2OL1jlAD000pWI9M/wwAwOYtju1qTuy+kT5yiVnq4uSeF/aUX9iTU7VpplLyDndxco+Y2/oIZM2J3XRfxsqpBiYMBVO7IFv1hVY4SCy+OzK7cWDNNnPdAAAycnK84kWuhEUsr0DVmhx7Yc8IDLdaHNv1wp5ya3LMa3bCEtqHM9M3piZOjlcKb/8Qyn0cWHXZcYO6l5e9wtS11HJjOyUzexaSMfgAgM2pje1sTux+b3rKHkQ6s/u9yHVqa/XW1cZ2nhqveIGsM7vffhHem55qTuzeSqe/SQW8D0zoiJTHhFW8fCYWyTQyeh8YL6EAAPRpcWzXlakJy/D5zuz+96en1veO59aHOAy8fsz1vePvT09ZAtlvZ/ZdmZoY/rLfoBXwPrClluu2FsqVktcLKY0DU5+U1MgmgTEGHwCQxkyldHK88s5jk6ZxXb+b2XdjamJbRa7YK/bCnvKNqYnfGaJqZ//MO49NnhyvbM8rlnsNTMlY0pdzjbUgnBllksBW2l3G4AMAkjg5XrH0M74/PdWaHKNzza42tvPi5J73zZfxvemp7TZcLI8a2JIw0j461l58X2uS5yKzSGCMwQcAxKiN7bwxNaGteHVm99+e3ntqmyWGrJwar9ye3qvtpvxidvbG1MQ2ibPbcV7I+sZ97cspAAAoV0rNid2/2veYtp9xfe84A5iysji2a33vuLaP8lf7HtvyJbEtPy9kFGPwAQB6zYndnf0z0YrXlW1TmClEbWznlamJaFWss3+mObG78OYNyHasgQEAoPjx3vFo9qKrMWdeB2U0h/1473jhbcvcNqyBAQAQenm8omSvP87OXpma2J4P6A2DmUrpytSE8sbXzv6Zl7dWGh7hGtjxY4tAhj5ydwBbz83/8Yub/+MXhf99DaeVI0/99lvfEG/zn3/j7956+juN5w8X3jY0nj/81tPf+fwbfye9S+xb31g58lThbcvECNfACr922GIKv1MCg0ACM3nnyW+Lt/Yv5w78ZOFQ4a1C1FtPf+fLOalf8p0nv114qzaPGhjgK/xOCQwCCSzq7HOH//WbUunr9lPUvYZa4/nDt5/6jvgj+9dvfuPsc6P9I6MGBvgKv1MCg0ACU/xk/tCXc3Nhr9YT1VG/kW8fZ587/NsnqkLZcu7Sf/37wlvVN2pggM9+G3vrRK124uuF302HRAFX47XJJ5544ti5r261Y+m8d+5AbWnXexntjQQm+sn8IbGO8tbT3ymqJd99/2H9/Uu5HvTSL+sPHj770zOjfqy3npaKYT+ZH9W+4zxqYOJb711pKu4F6W353j9/0u7BJbDnf/G3F7o7zv9iQbN0dd/57o4Lvr99eTW6ee2ccVFmbC2M89JHOy50d76Uy29PlseKv/KDF9yx3jpRi96A+88cr03WapNv5XPzth5Le1797XAgCcx+obJNRfkc69KuY7XaE/K/Wu3Ajy7FbFhAAsvuk20Y/pZ71M8oMX79/puP9zGg+7vvP0wdLC79sv7gl9/V7irzBGY4lrA0u1SU57EiVo489ftvPj7qIazoeSEl6eaF7PecN5XA/BWGNoF5H6P5JLBMjzUMn9q9O9bXX60d+NG5SeUWOPoJTH9e/e2wgAQ2usdyvSgWH7wC+SewDD/ZhuFv2Sd/Rinxq69RX5eee/CH53/6y/pvfva95FsNTwIb3WPpNJ4/POohLP9xYAstqQyWMJzllMB8Cy9/XuRnx3ZMYMNw5cN789Ku99yvv1qrvfpaeBsb+QRmOK/+dkgCS2foE1j2Cv4UXTx+TPqMWjnyVDD26963v9nnoPtLXva69NyDh89dSrMVCWwwGs+Hw8K+nJsbubdU5F0DqzYcQz9jogKYnMC8pHLuqvdntkNMLUqIeemjHRe6O85dFRfVXv5c3apH99kR9z923iF8n+97PvbSSzsMmxffwqs7xa0ufFTT7u2CGI+8pR/VwtWCFpqbYTwv+7HiWC9U7JWPtFB7NWIXaXm3q7dO1LzuJyVkeF++d+5Ary9Jun8H3xcXid8M/oV9W0Ik8hZJwei1yXCH6s34qz9aqik7jDlW3HlFv7TvUL0aSgvFxss7P3buq15naKoLFXxTlx01V8NyDTdzLOmnLJyy6bxiE5hph1ICu7TrWK0m9V2mvLz2BGb6ZFvdd76749xH/h/RuV/4q3mfRZbPXtvfsulw1mNZGmlshvKh8Z9/s/qXqSfE6lfaDwfPd9/3u9WU8GT68ns//UP9wUNF0DHnrRauo9TVLv0y3Ere+bM/PeN1htYfPAwykP1Y4t502fHM87/RbaU0o9fCzRxL2lY4ZdN5xRIrYZ89/nej9UBrTjUwYSiYocqVrACmS2AKOWYZE5h2K9tnhy2BLQRRaTMJLNitrYXKB0e6BLbznLBU/1ElnZ3hvPpPYLEXKlECC1cwXQ37IpOP3B1+V92lXkISbqXeja13w/vqj5aE4BI3qEi/9LXJJ4RRQe+dOxCudmnXsfDO+vVXa2JIUr5MdizreVkCmaUGJlyNr79aqwUhRjoR+UJZtoq/jPrqnflq2K5hP8d660RNPa9eSIo5L0MCs+wwSGDvnTugjBvr4/JuIoFFP4i8v9ksPkWFI1qPlfKjUrfD//gvx4M3fp177uk+PhyOH1v0uyBfXTx+TC3/2AOZrQYWpqtLzwkh5ns//YOwyZnnfxPu0LKV5VjCKURT0aXnHhiqca/+7Nnw+5HV0h/ru+8/VM+rF8Jizsvq3HNPB28LG633hOU+Dqy67Liu05jrrwCmT2D+vd//8qPaYqIEptmqx1I/1y3y/5431R+XtIW9zw6lUtVj6BlUSl/eTnQxUWxG3Hml74WMv1DxPRe6FuquRsyF0vFvzHLtIbgN26LJa5OG8kxMApNuruaOKvHQMf1TlmMlO6/kCcyw1Vd/tGTMVf0dy5KKkvfWbfZY8kVTfl4x56X94Vp3aCwu9nV5E/VCRv70vA+Nz/c9H/6le+vsfKnfT1Hvj1f5WD7/iwX7sYxbhc3wjyJ9OASfUf+583jQ/+gNFerjw+H4saALcvH4scXjr/7sWSFe9J/A9Fudef43xlzV37F6NKnoez/9Q8JhbZs9lnzRet/xQ23MecUJBvl9OTc3QmWwAt4HpumIrC47yQpgugSmVqqF/0Wz9kJqtupdl3QJrO9hW1J/XDdpC5X/7ZOPa09g+mSTtBmq1Ams7xF4phbar4b1QulE7mFqgSFyC1fyU03TERaTwEwhQOpZEzubYgZgJQpMtvPadAILO1XDxg8sgVmvhvEa9pvAlHwcrtNvAjPu0EuWb0UKYP1d3k0ksPO/WPD/0j+qLQqPFvb1KRopgQd/mLZjmbeyfs6Hn1H/MXHYuzf/8xPVvj8cjquZIFKXyjKBXXou0sc3uARmzTpS72R9kzUwIW9F19lkAjt+bPGfewPCbhw+mGrDAhXwPrClllruWmrFv4QiQQLz79PRGpj8fzyWrXr6SWBpa2DKh4UlI+paeCx6XovHj8UksNiil7UUF9FnAktbA7O0MO5qJFgkSnV7M97CL+06lrBzzRgCpA4p5dBvnailr4Fln4rsCcxUDhxIAtNfDds17DeB5VoD8xr/1gl5BFhfl3fwCSzhp6hSzVI+oEzHMm6VMIH9Zd83vRvzPyxqXt2ZuB6WfSqyJzDTSP+BJDB9DUzqJczgWIOsgR0/tvgPi3/vvyu/+niqDQuUew0sOt6ruuyYno7sYxxY/FAqy1aawUPW0WO9v/zaOXVRfC6J1nX6baH4Gae0RB4HZk5ghgqT/bwMx7Ix79B85W0ttFyNmAulo7krC7dJ+famG+sj3PulRdF7bZIEJgwyk+o30YRnaLDtQMJq4rgieSCRrfGWzCEPVEqTwEwXyhI+jFfDeg37OpZm2FbCOqI2gVl3KPauyqv1c3mtCcz4yZYggaX9FDX+VVqPZflbjk9g//k3q8HbCmyfNrHPbEbThpAnxGFb8ngmdU2RJXPI48CSbmU5Vo8u2736s2f1g66kOp8/vn5zx9KMA0tYR7QNngkFP+tR6YjMowa2JL13tbkUHQGWuAAWk8CkEBDeuT/f95L/yMyxRftWfSawY5ECe8o40n8LIx8c0grxCczSjPjz0h4rhmGHlk9tSwstVyP2QkXpurTC+6LyDJ14e1YWRQOBuIL0LKSpDCP0afq9UZH0YDpc9Fj28xIrZN7jjcrK2sbbM4dyQZInFdOx1AJekqthv4Z9HUtcmuR5UnsCs+xQHt/md6cGv3JpL28eCSzRp2j4WZQqgZm2ik9gxxb/5+6T/l1599PGT5sEHw66kowYIIQKmfd4o7yy+ACg8iyk6RDq84aJk4rxWA/M/Ymv/uxZ7VON4vd/87PvJj8v87GkpQmeJ1VvVdYf1j/1OiK19c4hNNLzQm7m3fGASpOEgNE3gPeBjcxn762nvu3dkm89NUqPyEHnpY/iEtjI/bhHel7IkfkUwEgo/E4JDAIJbIRuyTAJ3mppWWfkftzUwABf4XdKYBBIYCN0S4aO5WkMycj9uEe6Blb85cNWUvidEhiEYmYlGg7B83H/FL6KAlsW48DyS2AAAFjMVErB83GFNwaDFvysZ4puSUIjXAMDAMDun2b2eXflk+OVwhuDwTk5XvHrnTP7Cm9MQtTAAABb1uW9496N+f/ue6zwxmBwgqj9+uSewhuTEDUwAMCWNVMp/XF21rs3Nyd2F94eDEJzYrf3I/7j7OyodEGWqYFtT7O3H9ZvvzLYo5y9U3/w8PAb86nW9xw8W/wlyuOUB2bp2r/8+S9/+vNf/sVNPNUEsIUFZbAvZmdru3cW3h5kq7Z75xe9kH1573jh7UkujxpYteGIL8VXJiCS3pif4OX42yaBzVfvPRxQKMkmgZ29U39wZ9a2tI848srB1Ceb9YWyn1fMhkOQwM7/L7IXIJqplDr7Z4JBQiNUI0GsGaH/sbN/ZrR+uAXPCynPyT3XWFMn7Y7aHgnslYMPpJA0e7uvTGCQRwLbxImnSVEDuFADOa/8LF37lz///r8vDf5AwAhZHNsV9EX+at9jo3WfhslMpfSrfY8F/Y+LY7sKb1Iq+Y8DW2iFZTA1clUbTmwZbDsksNnbD+v3rk4OdP9bIoEN5EKRwICtKBgqRCVsaxCrXyM6yC/vGpiasepN1+2FsHoz2kcZtQ0S2CsHLZ1ZZ+/U712d9Go/0X43YTSVmrHERcpSw1aztx8efmN+9nawlZ9LJt/4RJ14VWywfUSXeCxNeNInMPmIQTyyXihlK+FYfZ6XpfHmUzYdK+bnZf8pW5HAABMlhI1cyQSBxbFdox6/yrnVwIShYGEXZM9CbyRYM8ltY+snsPmrhy13XP+e/Ul1vlT2Q4MYIIIb/Hz1XnhTlxdJNTDLVn5u8L+MxJ2YWpEuS81fPRzmDLUD0biV6UDWCzV7+6F6Xr3M1Od59dV4y7EsV97yU47V+sc//fkf/9vAf0uB0SSGsL8eOHBxdN5cgMCPe49WjHT8KhcwDqy67Liu05iLfukNyacGliCB+Tfm3srel/PVe6YkoSYDIYFZtlI7K9W+yz4SmEzXGWpKYLpdWS5UdFF4oTZ5Xukabz6W7cqbf8o2rX/805//8qf/fT67X0VgK3p5vBKMCfOGhdXGeEByNNTGdgYDv7yxXy+P8ot2C3gfmNARqY4DW2rFV8JIYIZ8EPZYqR12kR0KOcC81UASmPTcoqar1JTb5q8ejnYLxiQwJbKEe+73vPppvPlYtiu/ibFo8+7vqYEBMWpjO/9Z6MP664EDP947zsiwYTYTKX19ODM96tG5gPeBLbWC1LXQEuthFW8o2LZPYHKXmcqawAy5zVIDs1Wqsk5g6nklrYGJ5q8eDkOY+UJlXwPrs/H2BJY+Z8djHBiQ0JWpCfGO/sXs7Oj2Z21tFyf3fCGULf964MCVqYnCW7V5udfApLdRzDXWxKLXXGMt/pVg2yCB9YYBaV+yYL43W0YLCc8M9go5hiFi6laWpGKv1ZkSmDLUKW0CUzrvzBdKMw5MHN+W+rz6bLzlWLbRXSQwIBeLY7s+nJkWb+2d/TMXJ/dQDxsGM5XSxck9wbvcgtLXlnmEIo8amPTOVbXE5YWw4G2tMS8DK2+TBFYpKb1U4X3dem9Wn+ZTRo73evEm3/hEjAWmrWKSirxhkIqE5/4izRA6E+v3rs4KzbBspTQv8vCj4UIp+zSfSMLz6q/x9mMZf14kMCBHL49XOrP7lXoY/ZIF8voclbpXZ3b/SI/6imJeSGBLIYEB/WlNjik57K8HDrzz2OTJrXXXH3InxyvvPDap/BQ6s/tbk2OFty1zzAsJbC3MSgRsgjaHdfbP/Hjv+KiP+x5mtbGdP947rnQ4buHs5aEGBmw1zMwNbNKp8YoyPszz25l9V6Ymtsw4pMItju26MjXxW/m51GC816mtXn2kBgYAgEZtbOeNqYk/yqORgqqY10HJWLG0ZnpdjV/oLuwfZ2dvTE1sk3IjNTAAAGxOjVfen56KxgXPe9NTFyf3bJPQ0Lfa2M6Lk3veM1/G96entnzRS0ENDACAeDOV0qnxyu3pvdGBYkEf5Y2piePjZQpjwRU7Pl6+Yehn9IZ53Z7ee2q7lhKpgQEAkM7i2K71veO/MwQLr5vyvempK9sskHmR68rUxHvTU9Fh9YHfzexb3zvOcDpqYAAA9Kk2trM1Ofb+9JR2uJj4grEPZ6avTE2cHK9spf7K2tjOk+OVK1MTH85Ma8d1iQO83p+eak2ObaXT3yRqYP1ZvN7pdjYWUy7Cpqy0g19V+Qqv3lW/Y7d6N9hPezXuiO1m4ScOYCScGq/cmJr49T7NQ5TaQHZjauLK1ERzYvfx8fLwF4QWx3YdHy83J3ZfmZq4kSByeX69b/rG1MR2G+CVUB41sGrDEV+K36obl7YSPDw/FAls9W63e3cl7aIsiClEk0UyP52hUd+4b73mfVyHZpsEBmAwFsd2tSbH1veO/3rftL08Fh1M9uHM9DuPTV6Zmrg4uef4eDm3fkyvD9HrRrwyNfHOY5MfzkybhnCZCl2/3je9vnf81Hhl+DNl4YqdF7K01BImgqwuOwlC2DAksJW28X5vWZSlI9c63fvXj2S0t1FIYAMIQyQwADmpje08NV7pI5CZfDgzHeXltigvS0Vtvhmd2f1B5KJ7Ma38x4EttIKYFYlc1YYTOzVk8QnMkn6yDUb9taEPI5DAFq93SGAAtoiZSumFPeWLk3vW947fnt77633TSfoui+U18vb03vW94xcn97ywZxs9YTAgedfAqg1HLnqF9bByxauQNe1T2hWewOob9013ZcuijOkSmFd+E7oppVBV37gvdF36i+RvGodY9RZcqyc7lh+YYneY5FqJ60faHzOiK+ZYhgSmHFHYUHsNASBDi2O7XthT9nowvZpZVmWzWF4folfTWt873poce2HPCAxQG1051cCEwV5i5JprrLlh0au67Lju0CcwS+EkvqYi6sWXIEilGcJvSGBCYmi2xehjr3KZlh651gnzR7MtxF+lWXMAABtkSURBVBHbseQ1RfJYrlRlLfvKmiuf4FixW8k1sBGoFALYLrygpvA6OqNOjVeiKxOtCpf7OLDqsuO6TmOu952FVjAOf215qeEMewLLagx+sPLq3V79Jk2AMyUwIWRE0oN558laLu7Qcqz6xn2xWiaIRMwUVyxtAktyrOhW6ndSXEMAANIo4H1gUkdkdNFQjwPL7CUUUkw5cq2TvFcu3CRNAhOPEn1s0JiEpM5EsYWWY5nHTjUjz3Em78tLm8CSHCuy1ZFrHUsCs19DAADSKOB9YEst1xCzhEH6ZkUmsGEYg28+XEwCk7ZNUotavN5Rx34lTWD6Gli6XlpNY1ImsLhjpayB2a8hAABp5F4Dk99GEfIGgcUVwMqFJjDLk3F5PzS3mQQWLddFaj/BakofXJIEZkkntnd6xdjkOLCkWwnxsVf/S3gNAQBII48a2FJLeB+rPMzLMELfprgEltkY/M2wvJE1ZmyWbpOAuEK4VOh063aurQhPeibv8VQOpz59ubmR+NGrYX50MfIYgX6rsPuys7EoPtwaew0BAEiOeSGTMg8wty0CAACIYl7IhJgIEgAAZIYaGAAAQN6ogQEAAOSNGhgAAEDeqIEBAADkjRoYAABA3qiBAQAA5I0aWH94OQUAAOhfrjUw/w34ytRD9aYbvhd/LnYnQ5HAjFNZWxcBAABUSuVca2DVZcd1nDU5gYnTRFaXnQQhbBgS2ErbWOWyLAIAAPDkVgOba6y5TmNuqSUmMP+bwWrVhqNMHBlVfALTzYodvwgAAKAnpxpYEK2kBFZddsQJuavLToIpugtPYOJszckXAQAABPKpgS20XLdVL5WVBCZ0QS61XNd1GvVlp7emSdEJrNnudturaRfpV1b/+dN7s4hFLGIRi1jEoi2+KI8amJi6NAmsvuwEw/OrQ5/AGIMPAAA2bfA1sHpTHNoV6YWUux2VfkmdQhMYL6EAAAAZGHgNbKnlav85jTmvd1Idib+2XLW2uMgEluUY/CEqhLKIRSxiEYtYxKKh64XM9p348rOQ3gh96W0U9i7IYhPYSrtrGmhvWQQAAKDI+534SgIrB69pdV03QfwqF5nAmu1sxuADAIDtjnkhk6pv3O8VD1MsAgAAiGJeyIQYgw8AADJDDQwAACBv1MAAAADyRg0MAAAgb9TAAAAA8kYNDAAAIG/UwAAAAPJGDQwAACBvudbA/Nffy+/Et3xfiwQGAABGXY41sOqy4zrOmpK0vMm5l1skMAAAsG3kVgOba6y5TmNOmRdyqeXNBblAAgMAANtHTjWwasNx3eaSbmbucqVEAgMAANtKPjWwhZbr1bpIYAAAALnUwMTURQIDAAAYfA2s3vT6H70vSWAAAAADr4EttVztP6cxJ6xGAgMAANtI3u/EpwYGAACQ9zvxlQTmv4tV/Le2XLXugQQGAABGHfNCAgAA5I15IQEAAPJGDQwAACBv1MAAAADyRg0MAAAgb9TAAAAA8kYNDAAAIG/UwAAAAPJGDQxGs7cf1m+/ErfaKwcfPKzfuzpZdGvLldL313/+8frRwR7lxMWPP/j5ndVq9JuejRPFXwcAwPDLtQbmvwFfnn1ImDjSaVTjdzKSCezR5e6OC92vPFvPZocH2zsudB85mFnzzt6pP3joEyJX3gns7J36gzuzm9hDigR24uLHH1z8fh9H0SYw39ENEhgAIJkca2DVZcd1nLXIrES9L6sNJ0kIG8UEVv/aD7JMYF6eyyiBTb7xiZB7XjkohLBkCSw7I5HAbEhgAICkcquBzTXWXKcxZ5iZu1SueBHNbdVjdjWKCSxjGSaw+auHHzw8eFb5zifV+VKZBJYaCQwAkFRONbBqw3Hd5lJkZm7JUCewmetfudDdsbzipZ8dF7o7fnC95C/1SlztR3u1rh0XOl+bERf5hBqY/30hRYnfkbbacaG7Y3klurdAdCeRwxlpQs8rBx88PPzGfLmXwCbf+KTXRxmuOXv7YdhxGe2FNHRrliulcmW+ei/c0DuQcAh1UTxhDNbHH8gJTFzU+/6Tq29K63/wc7VXUdzq1pkndd83xCx9ApOPqMY+70cW/MIAALaJfGpgC61etLIksOHuhfQS2AVLMGo/siws8vOZORIdbAt76O1ft5WwrT2BmbaynNfkG59EhnDNV+8JCSyMUPPVe/qS2OxtKYHJ3ZrKVlIvpyp9DezJ1TfFTCPWwORF1ddvRcOZrgZ26MydcLWjGx9Ei2qWQpduUVyxjQQGANtTHjUwMXUZE1i96bqu05iLbXHBCcyPO/6X7UdL5Ypa+lp55IJ6Ty0924nkoaByVq7YOxaVrGZa2VstqMwpX+rFJzAxLRkSkpzAws2jW+kOV4rdv5maeIQEVn39VrSyJSShZL2Qum7NPhIYXZMAANXga2D1ptf/6H2pT2D1ZvQZSZNCE5ja8+jFrPiB9roEJn5z5RElLXn5SVNvK1cMCczbmypBAtP1Qnojw3QJzB8iJpIT2CsHI/2JwSFiBpalTWCHztwxJrCjG5GuxmQJrPr6rZ8buzV7e07VC+m1U9PdCQDYxgZeAxNeNiH9C8td1WUncfwqD0sC8xOSWAOzdSRpE1gYvA62paVK0au/Glgy0ZH4QszqqwYWBrgopb9SlWUNLG5QvD6BVV+/JY39yqAGJjp05g4hDABQKZXzfye+WgNLGb/KhfdC6kZZmROYdvSYEJJKz3Z2XOh8ReiOrJR0BTBdAouMA/N6P1ONAyv7g72kt1EEfYhyApMWqXswjgOTzV89bBliH42Dcb6/HgSmXu1KPw4sIlI/Kwc7CSKXN/Q+wwQW7RvVPZMBANgO8n4nvpzA5hpr0epY2GWpNSwJLPIEYj8JLFhBiUpCxup87aD/GKawghS2TM9CJn4DmfhgoxiAlEcUk1e21GcbxULa/NXD5gcexQ2TPQsZ9jbeWa0+ufqmGJjUxx7lLCUuDVOR0GP48a0z3xd2+P31SLdmgkVKGzQFML/7WPr5AgC2POaFTEgdB4ZA3q8N22pmogkbALDlMS9kQiQw0SsHg8iVvusQkkeXeRsFAGxD1MASIoHJhHeuEr/6Jb3TBACwrVADAwAAyBs1MAAAgLxRAwMAAMgbNTAAAIC8UQMDAADIGzUwbFGWpzXzf5Dz7J3E75jdRl764c0PflgfsZ0ffe2DmzdvnX688KuXFd3UW1k4cbGfiVD72woYTbnWwKoNR5mB2/9O71+rHr+TkUxg3jvuk72hPoGD7eznsZFe3y+9HyG7xkuv7E+3w/nqvfi38+tY5qm0TWGZmn1Sy/wSWH395s0PetaPDvJYR1/74OZrL21iD9GQ9NIPb6bON4Zm5J3ANn01Bs4wG33eCczQjJitgK0oxxpYddlxHWfNPAtkvem6TqMas59RTGB+8sgqgeln5t4MdfYkMYFl2Ph+E9grB+WpjWZvJ5/AezgS2ICUnu2IL9NXw8Hjq+uDzATZJ7D6+s311dOvfbB+8tCmmzHQAls2V6P0bCfPVwzmnMBSNgPYhnKrgc011lynMafOzC1ZaCUog41iAstY9gnMmws8r4lxvJkQEyew6LyTaWzdBKa+TP/x1fWhzxwyNSQd9bJXfT1V9W50E1hvgtecXslLAgOGTE41sGrD8abctiSwasNx15arcbsq9J34yyvhnNnh/7x6pZ32o2GNJ7gvmqo+/vejk2o/clDdSshGke9bZ+ZOEnGEKcCjG5r3Fn81oo0PpUtgrxy09t9Js4Brglr6BCaMEovMdyl1hnqtUqchV6YVt445MzV+9vbDw2/MCzOmq9ku+JULv3n0tQ9urq9+y3AZhXCj6aA8+lrQcSnWn1764c1bpx/3egY/uHkzSBiHTq9/IPR1eqSOOXGHSgwSF8lLvcOVI+HJ9KW9Gd5q4TpyXU3aVlxkuVBCy8WrZ2vGt07e0lxq6cfk/SjTTUt14uLHwvzxT/a+r2Sp4Et1inp5knhvtXAdYYfqtuKiExc/vnXmycrRjd7SjROa5oXfjGuGaSvNKct5Ud6tmu36ubxAXvKpgYXFrWgCE4aCxXdBlgtOYBe02cK/HT4iphk/kZhDjFJ2kmY90iStrzxbj0tgpq1s57WpBJZgK20zUiUw67yTs7fFdDJfvRcNYekS2OQbn6g7DEOY2hkqiamBaY5labyfvfxjqRl05RHNBFmHTq/bajB+evDv/dLK3zp5K8w39XUhFfnZy/+yvq6JWZojyi2RKnNKI+VoVV8Poom8Z3sgs9XADI1/6Yc31RYGIcxyoYRLpCnRWZohh1pNZc77i0hY1T505k4YQY5uCInElMB8lhpYuJOjG0o4Czepvn5LCGF+JHrz9UOlsh+DlJ0f3TBmKUsNTLOVvPPq67eE84qrqJHAMMzyqIGJqcvWC1lddlzXaczZ91ZwAvM/JaUZ/ZTSl9ezIP3N6zKHVMawdSxGugj1K3urBTdm5Us7ay+kpvG9q+F/07K5blFWCSy6aP7q4QefVOfF1VIlsPnqPbneJuSqyTc+sXWGpk1g1sbP3lbGvQVf9qqPkUOIWUGoyvQygVJ6+dbJW4aCmRgR+oo+j6+um4Kaml2kHR4Vhn/JpaP+E5h2q2hdSrwa8RcqXQKTdmi+7P5fSvrRlmLM6j+Babc6dOaOEoYOnbnTi1zlExeD+KUu8mWVwKqv35LH5ot7OHFRXzMDRsHga2D1ptf/6H1pHQeWqCNySGbmFv/XKn6sujZzCN+MVDW84GLoy9MmMG9vqoEmMCXtBZtbG2+6GiYxCSw2b6VKYK8cjPQnBrlKSUWqfhKYsfHmBFYqG2pgml5IMRPYRik9vrp+U9sz2Ff0kR7GlIJgJPqY055UORtAAjOHqvjhXCkTmBBJD51e1w9NS1UD84pAYl/eABOYOVTFD+fKKoGFHZ363sZDZ+5E+zSBUTDwGthSy9X+09a67PnMMxwJzA8ZYg3MVug2ZI7erVT5319toElbA0slwwQW13jz1TDQ9i2WypVB1MBsY/NjHgjIqQbm04wDs/cSWvOBqZus7wRmGEdvqYGZc1sBNbBsE5g4tkxXAFOfqLCTuwILroHll8ASVbkOnblDCMNIyfud+LaMNdRvo4gf+aT7DNWOHhNCUunZzo4Lna8od9NoDUmXwCLjwLzez3TjwKQjKgnM0vjYBKZvvKaFSR7A9Aaz695GoRlKpZapNjMOTDZ/9bDlmQDreLWk48B6jY9NYMGvgfhb53U+yiPHkyUwsSsweQ0sGmXCZuiziDAoqld483YYbZ6wc3GH8uguWzMsjdeMA5OuQF8JzNCM4BDrP3wtWgBL/yxkdBRU+KU4Xkoe3VUqV3SJKljTkNs048ASD8AyJidDMyxb6QaZGS+OksCizzwBwyPvd+IrCUyukIWdlRbDksAiTyD2k8DUAVU9QsbqfO1gdOiPFGVMz0IWk8Bsje8zgVVKSv+gGGWEBwYjqUXpTxTzjWFROfpsoxh95q8e1j7wGNkwWGQ/lq3xsQmsEnkfWMXPAdEyki1YiJusn3xJ6CmLSWDyY4Bi+U19PFAZ6d9bP+iV041PF4ORUCHzHm9M0Iz4Byq1T2uaL5S0ie4xT9PVKEfDcfjjS1+0FjrdPr515vurb36sDMzvdU0+KS0qleXHBpVnIYN1NF9qH0I0JzBpk7inF+VR/8at1OcopdCpe7JSusjJP2eAXDEvZELqODAASOjQ6fV0r5lFZowPrwCFY17IhEhgAPpi66DEgKUbZgfkihpYQiQwAOkE/ZLEryJI7wwChhA1MAAAgLxRAwMAAMgbNTAAAIC8UQMDAADIGzUwAACAvFEDAxJR53jJwYmLQzXVXQFXAAC2rlxrYNWG47r6WYksixQjmcC818QnfUN9rIPtzObZyP4tG9J7+TM75Rwlmz5voMcSlmaXwOKnkYmRSwKTZmKIfY/AyP+yAdjGcqyBVZcd13HWdDHLsihiFBOYf5/I6g6hn5m7PySwiOFJYEN2rMEnMHUiLBIYgC0stxrYXGPNdRpzupm5LYs0RjGBZWy4E5jPm45tFG+KJDCDwScw7fykCYzuLxuAbSynGli14XgTb0djlmWRVqHvxF9eCaedDlOL9z/i7UfD/yMPJsEw/T+6//3opNqPHFS3Eu5Jke9bZ+ZOdEPqJbBHvflr1TQmzaUt79CyqFwx3hRjLohmxm7blY9x4uLHwhzGT/a+b5qKWJ39VzeBcbiOsEP1WPLO76xWhVmH/QxkP5a4t40T0VOrvn7LMBux7pRjjmVuvLooujQrwmzu0V8P8+9GzC+bMhO8WFGz/6V4S5nKBsBA5VMDW2i5bqteKmtilmWRXqEJ7IL2TuAnsEfEu4ifEswf9Mr/7ku1KE3S+sqz9bgEZtqq3/Pqb1GP7qZoaaF5ke5YScLloTN3wrhwdENID6YE5rPUwMKdHN0QQsyTq28Km1RfvyUfy7CV5VhisyMJTDqXhKdsOZal8fKihDUw7xc75c8rXQKL7FD3y6bELzGBxe6QBAYgB3nUwMRopcQsyyKTghOYH3ekGceU0pf30S99fJvjiH9XsHUsRrpm9Ct7qwX1IeXL9Ofl3xSD4/p31phFtlNO3kLxlHst9HfVZ0eVmB76T2D6raqv3zLmqv6O1aNJYE+uvqmW3xKcsvlYlsarRx+OXkjdOrYEFt1bf38pAJCxwdfA6k2vk9H7UopZlkVmQzIzt/h/yfED7bW9JMI3Vx5R7gHRQkJcAisF3YiihAlMd16RoyRaZDnlmBaaTllpYfIEJnXVfZxJDUy/1dGNSB/f4BKYNQYZT9l8LHPjD525MywJzPrnoP1lC39zIr9pff6lAEDGBl4DW2q52n/+0HvDIssOhyOBSVWf+D4L2ziVH1wvHWxLS5X7UH81sE2f18BrYNHGa0+5vwRWff2WcezXIBKYbrRW/8fqMSQwfQ3MdsrmY1ka318NrK9eSP2vQezvhuWXTSLXwyh6ARgKeb8T31LoGoUamG2cii6BacdLCR/9pWc7Oy50vvIDOb7o7mHRBBboRbHowJc+x4HFD8CyXQ1NM3qNN7fQcsqbSGBBXPCGk+uGN8njtErliqb2Uw7WNGQpZbxUwq0sx+rRxaNDZ+7oXxJmO2XLsWIa70e6XnWtgBqY7c+hr1+2+L+U6IMyAJC5vN+Jv3USmL0PzrSV+j/fyiCnHiFjdb520H8YUFhBuoWYnoXsL4FJdx15abJFlpuirYXGU+63F/LQmTvCU4HfX31TSA9C15v3eKMcLMSHB5VnIYN1lC/V5w0T1tssx/rA3J8onpqYxmynbDyWpfHihbqzWo1eqKwZfrjmP4cUCcz+UIh2hEAf78UAgMSYFzKhgb03C8DQmYn+bw8AZIt5IRMigQHbxqPLhqo2AGSGGlhCJDBgO5BeNAMAg0MNDAAAIG/UwAAAAPJGDQwAACBv1MAAAADyRg0MAAAgb9TAAAAA8pZrDazacFxXevG9/x1xTshqzE5IYAAAYNTlWAOrLjuu46xFEtjacjVNi0lgAABg1OVWA5trrLlOY06Z/JEEBgAAtqGcamDVhuO6zaXI9NskMAAAsA3lUwNbaLluq14qaxOY8M9bx44EBgAARl0eNTAxdSkJTFJvuq7rNObseyOBAQCAUTf4Gli96fU/el/aEljcUg8JDAAAjLqB18CWWq72n67WNddYI4EBAICtL+934luqXNWGw/vAAADAdpD3O/GVBCZVyJI9FEkCAwAAo455IQEAAPLGvJAAAAB5owYGAACQN2pgAAAAeaMGBgAAkDdqYAAAAHmjBgYAAJA3amAAAAB5owbWn8XrnW5nYzHlIgAAgFI55xpYteG4rm5WonozeDF+qx6zk6FIYKt3u927K2kXZWbxeif4oXXbqwWd6UgfCwCAQuVYA6suO67jqHNvzzXWXNdtLiVu8TAksJW2scplWZSRZrvb7babwhEHmVpIYAAADEBuNbC5xprrNObUmbnrzYTTQQaKT2BHrnW6968fSbkoIyvtbrdzrZ7byZLAAAAYgJxqYNWG4xW6ojNzO425VC0uPIHVN+6LJaiEizLSbHdtNbb6xv2we1IIal5lbqUdLJOCjrRVb5H8zd4ug0Ov3u12rtW9gpzcGbrSVkp0XfmaSF2o3g5jjmU+L0szTOcFAMAwyKcGttDqDfCSE9hcY81t1RdawSiwBN2RRSewZts49MqySKOXh4KaWYIh/EeudcyHWGmLOWPxeicMK/6x/CQkxzh75cm0dPWu2Pj6xv1gNWsCU7tQkxzLcl6WZlBRAwAMszxqYGLqkhOYl73C1LXUcmM7JQtOYFmNwQ9WXr3bq9wkCHCWBBZdJHSJ2lJR2IA0J7V6tyv2tyY7Vn3jvq0LVXss63lZmhFzXgAAFGrwNbB6U81YcgKTHn6sLjuu06jaWlxoAsvsJRRSFjlyze+Xi+3BjElgyhC0MNLF9AwGDYh2cdoSmD5uWo4V6ZFMsE/recWkXst5AQBQqIHXwJaELkbxn9OYC4bnh+vXm+4wJ7BCx+CXKyW1D05tQF81sMhOpLCSeQLLvgaWoO4YPS8AAAqV9zvxNc9ChpFrrqG+q0KjwARmKeHEVHcy5I180r2NQjNeylB8Mrc2UskzVd3M0UcdEya21p6EDMeynFfinl9ekwsAGC55vxNfTWDBa1rDwljMHopLYJmNwc+kJcE/8bgr0gJj5FLHZgn/ojFFXCHZ+H2hee2m+nyo0DMYPZz+WObziguCtvMCAKBAzAuZlGUUecwAcwAAABnzQibERJAAACAz1MAAAADyRg0MAAAgb9TAAAAA8kYNDAAAIG/UwAAAAPJGDQwAACBv1MD6w8spAABA/3Ktgfmvv5dn5lb/rS1XrTsZigRmeSN80nlyAADA9pVjDay67LiOY5v5cdjnhQystI1VLssiAAAAT241sLnGmus05qLzQoakWbqNik9gR651uvevH0m5CAAAoCenGli14bhuc0k3M3dPogJYeQgSmDrVdLJFAAAAgXxqYAst123VS2VLAktWACsXn8Ca7W63vZp2kX5l9Z8/vTeLWMQiFrGIRSza4ovyqIGJqcuQwJIWwIpPYIzBBwAAmzb4Gli96fU/el/qE1h12UlWACsXnMB4CQUAAMjAwGtgS5oXTriu6zqNOWmduJdQBIpMYFmOwR+iQiiLWMQiFrGIRSwaul7IbN+Jr6mBVZed3iixIU9gK+2uaaC9ZREAAIAi73fiRxLYXGMtRQGsXGQCa7azGYMPAAC2O+aFTKq+cb9XPEyxCAAAIIp5IRNiDD4AAMgMNTAAAIC8UQMDAADIGzUwAACAvFEDAwAAyBs1MAAAgLxRAwMAAMgbNTAAAIC85VoDqzYc11VnJZImjkzwcnwSGAAAGHX/Hzb20q++4IzUAAAAAElFTkSuQmCC" alt="" />

这个UsernamePasswordAuthenticationToken  看下他的源码

/* Copyright 2004, 2005, 2006 Acegi Technology Pty Limited
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/ package org.springframework.security.authentication; import java.util.Collection; import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.SpringSecurityCoreVersion; /**
* An {@link org.springframework.security.core.Authentication} implementation that is
* designed for simple presentation of a username and password.
* <p>
* The <code>principal</code> and <code>credentials</code> should be set with an
* <code>Object</code> that provides the respective property via its
* <code>Object.toString()</code> method. The simplest such <code>Object</code> to use is
* <code>String</code>.
*
* @author Ben Alex
*/
public class UsernamePasswordAuthenticationToken extends AbstractAuthenticationToken { private static final long serialVersionUID = SpringSecurityCoreVersion.SERIAL_VERSION_UID; // ~ Instance fields
// ================================================================================================ private final Object principal;
private Object credentials; // ~ Constructors
// =================================================================================================== /**
* This constructor can be safely used by any code that wishes to create a
* <code>UsernamePasswordAuthenticationToken</code>, as the {@link #isAuthenticated()}
* will return <code>false</code>.
*
*/
public UsernamePasswordAuthenticationToken(Object principal, Object credentials) {
super(null);
this.principal = principal;
this.credentials = credentials;
setAuthenticated(false);
} /**
* This constructor should only be used by <code>AuthenticationManager</code> or
* <code>AuthenticationProvider</code> implementations that are satisfied with
* producing a trusted (i.e. {@link #isAuthenticated()} = <code>true</code>)
* authentication token.
*
* @param principal
* @param credentials
* @param authorities
*/
public UsernamePasswordAuthenticationToken(Object principal, Object credentials,
Collection<? extends GrantedAuthority> authorities) {
super(authorities);
this.principal = principal;
this.credentials = credentials;
super.setAuthenticated(true); // must use super, as we override
} // ~ Methods
// ======================================================================================================== public Object getCredentials() {
return this.credentials;
} public Object getPrincipal() {
return this.principal;
} public void setAuthenticated(boolean isAuthenticated) throws IllegalArgumentException {
if (isAuthenticated) {
throw new IllegalArgumentException(
"Cannot set this token to trusted - use constructor which takes a GrantedAuthority list instead");
} super.setAuthenticated(false);
} @Override
public void eraseCredentials() {
super.eraseCredentials();
credentials = null;
}
}

发现上springsecurity 的问题主要是

   private final Object principal; 

 principal  是个 object 类型的, 可以存的信息有两种,第一这个用户对象, 第二, 用户名。 spring security 默认存的是  用户对象。
    @RequestMapping(value = "/order-list")
    public ModelAndView addSystemUser(Model model) {
        
        Customer user= (Customer) AuthUtils.getAuthenticationObject().getPrincipal();
        model.addAttribute("role", user.getRole());
        model.addAttribute("username", user.getMobile());
        return new ModelAndView("order-list");
    }
这是我的一个 controller 方法,  Customer user= (Customer) AuthUtils.getAuthenticationObject().getPrincipal(); 返回客户所有, 包括角色 ,权限,然后扔给前端,,这样看起来没错 啊。 最最坑的 的地方来了 这里是重点。
先看下这个类 PersistentTokenBasedRememberMeServices
看名字, 持久化 token 记住我 service;
再看他的类前部分
//继承了 AbstractRememberMeServices 
public class PersistentTokenBasedRememberMeServices extends AbstractRememberMeServices {
// 还记得之前安全配置注入的DAo吗, 在这里
private PersistentTokenRepository tokenRepository = new InMemoryTokenRepositoryImpl();
private SecureRandom random; public static final int DEFAULT_SERIES_LENGTH = 16;
public static final int DEFAULT_TOKEN_LENGTH = 16; private int seriesLength = DEFAULT_SERIES_LENGTH;
private int tokenLength = DEFAULT_TOKEN_LENGTH; public PersistentTokenBasedRememberMeServices(String key,
UserDetailsService userDetailsService,
PersistentTokenRepository tokenRepository) {
super(key, userDetailsService);
random = new SecureRandom();
this.tokenRepository = tokenRepository;
}
=====================================这里看起来正常
再看看核心方法
// 当一个用户登录成功, 并使用记住我会调用这个份方法    

protected void onLoginSuccess(HttpServletRequest request,
HttpServletResponse response, Authentication successfulAuthentication) {
//这里就是spring security 有BUG的地方, 因为 Authentication successfulAuthentication 这个对象默认存的是 用户对象, getName() 返回的就是一个这个对象的地址值
String username = successfulAuthentication.getName(); logger.debug("Creating new persistent login for user " + username);
//这里是存储这个token到数据库
PersistentRememberMeToken persistentToken = new PersistentRememberMeToken(
username, generateSeriesData(), generateTokenData(), new Date());
try {
tokenRepository.createNewToken(persistentToken);
addCookie(persistentToken, request, response);
}
catch (Exception e) {
logger.error("Failed to save persistent token ", e);
}
}

aaarticlea/png;base64,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" alt="" />

这是数据库的数据, username 是一个对象

,当用户关闭浏览器的后,

再次打开浏览器进入网址 ,立即报错

2016-11-23 12:18:44.056 [http-nio-7070-exec-1] DEBUG c.y.dao.UserDao.findUserByMobile - ==> Parameters: com.ycmedia.entity.Customer@42feadb2(String)
2016-11-23 12:18:44.087 [http-nio-7070-exec-1] DEBUG c.y.dao.UserDao.findUserByMobile - <==      Total: 0
2016-11-23 12:18:44.087 [http-nio-7070-exec-1] ERROR o.a.c.c.C.[.[.[.[dispatcherServlet] - Servlet.service() for servlet [dispatcherServlet] in context with path [] threw exception
java.lang.NullPointerException: null

第二次登录的时候根据这个名字去查 ,因为不是用户名, 而是用户名地址值, 肯定报错!

好吧, 用 UsernamePasswordAuthenticationToken  这个 子类做    记住我, 感觉不靠谱,

看下他还有别的兄弟没

aaarticlea/png;base64,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" alt="" />

发现, 大概只有一个兄弟, 感觉有点靠谱, 点进去

这是他的构造

    public RememberMeAuthenticationToken(String key, Object principal,
Collection<? extends GrantedAuthority> authorities) {
super(authorities); if ((key == null) || ("".equals(key)) || (principal == null)
|| "".equals(principal)) {
throw new IllegalArgumentException(
"Cannot pass null or empty values to constructor");
} this.keyHash = key.hashCode();
this.principal = principal;
setAuthenticated(true);
}

三个参数吧, key , Object principal  用户信息 authorities 用户权限。

但是, 即使这里我把 key 设置成  用户名,principal   保存用户的对象,

//        return new RememberMeAuthenticationToken(username, user, auths);

但是, aaarticlea/png;base64,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" alt="" />

这里依然还是调用  获取 principal    而不是, key

看下去头都大了

最后没办法, 你改变不了他, 只能适应他

return new UsernamePasswordAuthenticationToken(username, password,
                auths);
把 用户名存进去。

当别的 接口要获取 要多做一步查询根据用户名去查权限

    @RequestMapping(value = "/customer-list")
public ModelAndView addSystemUser(Model model) {
String userName= (String) AuthUtils.getAuthenticationObject().getPrincipal();
Customer user=userService.getUserByname(userName);
model.addAttribute("role", user.getRole());
model.addAttribute("username", user.getMobile());
return new ModelAndView("customer-list");
}

而不是比较方便的

    @RequestMapping(value = "/customer-list")
public ModelAndView addSystemUser(Model model) {
Customer user= (Customer) AuthUtils.getAuthenticationObject().getPrincipal();
model.addAttribute("role", user.getRole());
model.addAttribute("username", user.getMobile());
return new ModelAndView("customer-list");
}

综上 我感觉 spring security 的 Authentication  对象,      Object getPrincipal();  获取用户的信息, 要么就是一个对象 , 要么新加一个字段存用户名, 这样搞成object类型。



springsecurity4+springboot 实现remember-me 发现springsecurity 的BUG的更多相关文章

  1. SpringBoot使用Nacos服务发现

    本文介绍SpringBoot应用使用Nacos服务发现. 上一篇文章介绍了SpringBoot使用Nacos做配置中心,本文介绍SpringBoot使用Nacos做服务发现. 1.Eureka闭源 相 ...

  2. 假设说这个世界不是真实存在的,仅仅是一段代码,迄今为止你发现了哪些bug?

    给这个世界写代码的不是一个人,而是一个团队(这么大的项目,一个人开发不了).并且严重怀疑这个一个开源项目.开发人员被我们觉得是神,所以一神论是不正确的,众神论才是真理,且凡人是有机会成为神的(參悟神道 ...

  3. java框架之SpringBoot(15)-安全及整合SpringSecurity

    SpringSecurity介绍 Spring Security 是针对 Spring 项目的安全框架,也是 Spring Boot 底层安全模块默认的技术选型.它可以实现强大的 Web 安全控制.对 ...

  4. (七) SpringBoot起飞之路-整合SpringSecurity(Mybatis、JDBC、内存)

    兴趣的朋友可以去了解一下前五篇,你的赞就是对我最大的支持,感谢大家! (一) SpringBoot起飞之路-HelloWorld (二) SpringBoot起飞之路-入门原理分析 (三) Sprin ...

  5. 【SpringBoot】Springboot2.x整合SpringSecurity

    一.Spring Security是什么?有什么作用(核心作用)?以及如何阅读本篇文章 1.是什么 Spring Security是Spring家族的一个强大的安全框架,与Springboot整合的比 ...

  6. Spring-Boot服务注册与发现

    关于Eureka服务注册与发现的示例可以参见:http://blog.didispace.com/springcloud1/ 服务注册管理器原理如下图所示: 1.建立eureka服务器 @Enable ...

  7. SpringBoot安全管理--(一)SpringSecurity基本配置

    简介: Spring Boot针对Spring Security提供了自动化配置方案,因此可以使Spring Security非常容易地整合进Spring Boot项目中,这也是在Spring Boo ...

  8. springboot中json转换LocalDateTime失败的bug解决过程

    环境:jdk1.8.maven.springboot 问题:前端通过json传了一个日期:date:2019-03-01(我限制不了前端开发给到后端的日期为固定格式,有些人就是这么不配合),      ...

  9. springboot + mybatis-pagehelper 参数查询不分页的bug。。。

    mmp,搞了很久 官方git上给出的配置是这样的: 这样做分页,如果仅仅支持一个查询,没问题,但是如果你带参数查询了,那就分页会出问题 把这行注释了即可 reasonable是指的让分页更加的合理化, ...

随机推荐

  1. python 输出小数控制

    一.要求较小的精度 将精度高的浮点数转换成精度低的浮点数. 1.round()内置方法round()不是简单的四舍五入的处理方式. >>> round(2.5) 2 >> ...

  2. 双数组Trie树 (Double-array Trie) 及其应用

    双数组Trie树(Double-array Trie, DAT)是由三个日本人提出的一种Trie树的高效实现 [1],兼顾了查询效率与空间存储.Ansj便是用DAT(虽然作者宣称是三数组Trie树,但 ...

  3. 意犹未尽而来的第一篇Android 逆向

    游戏:咕噜王国大冒险 平台:android 目标: 1. 去除乱七八糟提示(本篇目标) 2. 去除google弹窗 3. 破解“all stages” 破文开始: 1. 使用APKIDE反编译:搜索字 ...

  4. C#之装箱与拆箱

    C#中值类型和和引用类型实质上是同源的,所以不但可以从值类型和引用类型之间进行转换,也可以在值类型和引用类型之间进行转换.,但是两者使用的内存类型不同,使他们的转换变得复杂. 1.装箱: 在C#中通常 ...

  5. 【UVA 11865】 Stream My Contest (二分+MDST最小树形图)

    [题意] 你需要花费不超过cost元来搭建一个比赛网络.网络中有n台机器,编号0~n-1,其中机器0为服务器,其他机器为客户机.一共有m条可以使用的网线,其中第i条网线的发送端是机器ui,接收端是机器 ...

  6. Eclipse下设置github开发环境

    1.按照github上的指南配置(http://help.github.com/win-set-up-git/)基础的git环境. 2.在github上创建一个Repository. 3.在Eclip ...

  7. windows笔记-一个简单的windows GUI应用程序

    #include<windows.h> // 编写Windows程序必须包含的头文件 LRESULT CALLBACK WndProc(HWND,UINT,WPARAM,LPARAM); ...

  8. leetcode面试准备:Minimum Size Subarray Sum

    leetcode面试准备:Minimum Size Subarray Sum 1 题目 Given an array of n positive integers and a positive int ...

  9. BZOJ_1015_星球大战_[JSOI2008]_(并查集)

    描述 http://www.lydsy.com/JudgeOnline/problem.php?id=1015 n 个点,被 m 条边相连.进行k次删点操作,问第一次操作前和每次操作后的集合数(直接或 ...

  10. (转载)Linux下IPTABLES配置详解

    (转载)http://www.cnblogs.com/JemBai/archive/2009/03/19/1416364.html 如果你的IPTABLES基础知识还不了解,建议先去看看. 开始配置 ...