SpringSecurity默认的是采用Session来判断请求的用户是否登录的，但是不方便分布式的扩展
虽然SpringSecurity也支持采用SpringSession来管理分布式下的用户状态，不过现在分布式的还是无状态的Jwt比较主流

一、创建SpringBoot的项目

spring-boot-starter-web
spring-boot-starter-security

二、代码

server.port=8111

# 再配置文件中设置登录系统的账户、密码
spring.security.user.name=jordan
spring.security.user.password=jordan

/**
	通过配置类设置登录系统的账户、密码
*/
@Configuration
public class SecurityConfig extends WebSecurityConfig{
	@Override 
	protected void configure(AuthenticationManagerBuilder auth){
		//密码加密
		BCryptPasswordEncoder passwordEncoder = new BCryptPasswordEncoder();
		String password = passwordEncoder.encode("123");
		
		auth.inMemoryAuthentication().withUser("kobe").password(password).roles("admin");
	}

	@Bean
	PasswordEncoder password(){
		return new BCryptPasswordEncoder();
	}
}	

/**
	自定义配置类，设置用户名、密码
	该配置类设置使用哪个service实现类
*/
@Configuration
public class SecurityConfigTest extends WebSecurityConfigurerAdapter{

	@Autowired
	private UserDetailsService userDetailsService;
	
	@Override
	protected void configure(AuthenticationManagerBuilder auth) throws Exception{
		auth.userDetailsService(userDetailsService).passwordEncoder(password());
	}

	@Bean
	PasswordEncoder password(){
		return new BCryptPasswordEncoder();
	}

	/**
		自定义登录页面
	*/
	@Override
	protected void configure(HttpSecurity http) throws Exception{
		
		//配置没有权限访问跳转自定义页面
		http.exceptionHandling().accessDeniedPage("/unauth.html");

		http.formLogin()//自定义自己编写的页面
			.loginPage("/login.html")//登录页面设置
			.loginProcessingUrl("/user/login")//登录访问路径
			.defaultSuccessUrl("/test/index").permitAll()//登录成功后跳转的路径
			.and().authorizeRequests()
			.antMatchers("/","test/hello","/user/login").permitAll()//设置哪些路径可以直接访问
			
		//	.antMatchers("test/index").hasAuthority("admins")//当前登录用户，只有具有admins角色的权限下才能访问该路径（单个角色）
			.antMatchers("/test/index").hasAnyAuthority("admins,manager")//	多个权限
			
			.antMatchers("/test/index").hasRole("sale") //单个角色
			.antMatchers("index").hasAnyRole("")//多个角色任意一个
			//.anyRequest().authenticated()
			.and().csrf().disable();//关闭csrf防护
	}
}

/**
	service实现类
*/
@Service("userDetailsService")
public class MyUserDetailsService implements UserDetailsService{

	@Override
	public UserDetails loadUserByUsername(String s) throws UsernameNotFoundException{
		//设置权限
		List<GrantedAuthority> auths = AuthorityUtils.commaeparatedStringToAuthorityList("admins,ROLE_sale");//设置权限,和角色（角色必须又前缀ROLE_）
		return new User("james",new BCryptPasswordEncoder().encode("123"),auths);
	}
}

@RestController
@RequestMapping("/test")
public class TestController{
	@GetMapping("hello")
	public String add(){
		return "hello security";
	}
}

三、启动运行

通过浏览器访问http://localhost:8111
进入页面 user 默认密码从控制台中寻找（三种方式设置用户名和密码：配置文件方式、配置类、自定义编写实现类

===========================================================

查询数据库完成认证

一、添加依赖

mybatis-plus-boot-starter
mysql-connector-java
lombok

二、创建数据表（id,username,password）以及对应的实体类，配置文件中添加数据库连接信息

三、编写mapper，以及service

/**
	启动类上必须添加该接口所在的包扫描 @MapperScan("com.xxx.mapper")
*/
@Repository
public interface UsersMapper extends BaseMapper<User>{
	
}

@Service("userDetailsService")
public class MyUserDetailsService implements UserDetailService{
	
	@Autowired
	private UsersMapper usersMapper;

	@Override
	public UserDetails loadUserByUsername throws UsernameNotFoundException(String username){
		//调用usersMapper，查询数据库
		QueryWrapper<Users> wrapper = new QueryWrapper();
		wrapper.eq("username",username);//where username=? 
		Users users = usersMapper.selectOne(wrapper);
		
		if(users == null){ //数据库没有用户名，认证失败
			throw new UsernameNotFoundException("用户名不存在");
		}
		List<GrantAuthority> auths = AuthorityUtils.commaSeparatedStringToAuthorityList("roles");
		return new User(users.getUsername(),newBCryptPasswordEncoder().encode(users.getPassword()),auths);
	}
	
}

=====================================================

注解

一、启动类上开启注解@EnableGlobalMethodSecurity(securedEnabled=true)

@SpringBootApplication
@EnableGlobalMethodSecurity(securedEnabled=true,prePostEnabled=true)
public class DemosecurityApplication{

}

二、控制类

@RestController
@RequestMapping("/test")
public class TestController{

	@GetMapping("update")
	@Secured("ROLE_sale","ROLE_manager")//设置角色
	public String update(){
		return "hello update";
	}
}

@RequestMapping("/preAuthorize")
@ResponseBody
@PreAuthorize("hasAnyAuthority('admin')")//进入方法前权限验证，将角色权限参数传到方法中
public String preAuthorize(){
	System.out.printn("preAuthorize");
	return "preAuthorize";
}

/**
	@PostAuthorize("hasAnyAuthority('admins')")//方法后权限验证，主要针对返回值
*/

/**
	@PostFilter 权限验证之后对数据进行过滤，留下用户名是admin1的数据
*/
@RequestMapping("getAll")
@PreAuthorize("hasRole('ROLE_管理员')")
@PostFilter("filterObject.username == 'admin'")
@ResponseBody
public List<UserInfo> getAllUser(){
	ArrayList<UserInfo> list = new ArrayList<>();
	list.add(new UserInfo(1l,"admin1","6666"));
	list.add(new UserInfo(2l,"admin2","888"));
	return list;
}

/**
	@PostFilter 权限验证之后对数据进行过滤，留下用户名是admin1的数据
*/

三、userDetailsService设置用户角色

List<GrantAuthority> auths = AuthorityUtils.commaSeparatedStringToAuthorityList("ROLE_sale");

==============================================================

微服务权限案例

一、数据表

二、父工程，管理依赖版本。子工程以及子工程中的模块

父工程——pom

<properties>
	<!--确定各组件的依赖版本-->
	<java.version>1.8</java.version>
	<mybatis-plus.version>3.0.5</mybatis-plus.version>
</properties>

<dependencyManagement>
	<dependencies>
		<!--对上面的版本进行具体化的依赖-->
		<dependency>
			<groupId>com.baomidou</groupId>
			<artifactId>mybatis-plus-boot-starter</artifactId>
			<version>${mybatis-plus.version}</verison>
		</dependency>
	</dependencies>
</dependencyManagement>

子工程common——pom

<dependencies>
	<!--对父工程的依赖进行去版本处理-->
	<dependency>
		<groupId>io.springfox</groupId>
		<artifactId>springfox-swagger2</artifactId>
		<scope>provided</scope>
	</dependency>
</dependencies>

三、启动redis，启动Nacos注册中心

四、代码

密码处理

@Component
public class DefaultPasswordEncoder implements PasswordEncoder{

	public DefaultPasswordEncoder(){
		
	}
	public DefaultPasswordEncoder(int strength){
		
	}
	
	/**
		对密码进行MD5加密
	*/
	@Override
	public String encode(CharSequence charSequence){
		return MD5.encrypt(charSequence.toString());
	}
	
	/**
		密码对比
	*/
	@Override
	public boolean matches(CharSequence charSequence,String s){
		return encodedPassword.equals(MD5.encrypt(charSequence.toString()));
	}
}

token管理

@Component
public class TokenManager{

	//设置token有效时常
	private long takenEcpiration = 24*60*60*1000;
	//编码密钥(编码，解码)
	private String tokenSignKey = "123456";
	
	//使用jwt根据用户名生成token
	public String createToken(String username){
		String token = Jwts.builder().setSubject(username)
			.setExpiration(new Date(System.currentTimeMillis()+tokenEcpiration))//设置有效时长
			.signWith(SingatureAlgorithm.HS512,tokenSignKey).compressWith(CompressionCodecs.GZIP).compact();
		
		return token;
	}

	//根据token字符串得到用户信息
	public String getUserInfoFromToken(String token){
		String userinfo = Jwts.parser().setSigningKey(tokenSignKey).parseClaimsJws(token).getBody().getSubject();
		return userinfo;
	}

	//删除token
	public void removeToken(String token){}
}

退出登录

public class TokenLogoutHandler implements LogoutHandler{

	private TokenManager tokenManager;
	private RedisTemplate redisTemplate;

	public TokeLogoutHandler(TokenManager tokenManager,RedisTemplate redisTemplate){
		this.tokenManager = tokenManager;
		this.redisTemplate = redisTemplate;
	}
	
	@Override
	public void logout(HttpServletRequest request,HttpServletResponse response,Authentication authentication){
		//从header里面获取token
		String token = request.getHeader("token");
		if(token != null){
			tokenManager.removeToken(token);

			//从token获取用户名
			String username = tokenManager.getUserInfoFromToken(token);
			redisTemplate.delete(username);
		}
		ResponseUtil.out(response,R.ok());
	}
}

未授权统一处理类

public class UnauthEntryPoint implements AuthenticationEntryPoint{
	
	@Override
	public void commence(HttpServletRequest httpServletRequest,HttpServletResponse httpServletResponse,AuthenticationException e){
		ResponseUtil.out(httpServletResponse,R.error());
	}
}

认证和授权自定义过滤器

public class TokenLoginFilter extends UsernamePasswordAuthentiocationFilter{

	private TokenManager tokenManager;
	private RedisTemplate redisTemplate;
	private AuthenticationManager authenticationManager;

	//有参构造和无参构造（略）
	//构造函数中同时设定
	
	//获取表单提供的用户名和密码
	@Override
	public Authentication attemptAuthentication(HttpServletRequest request,HttpServletResponse response) throws AuthenticationException{
		try{
			User user = new ObjectMapper().readValue(request.getInputStream(),User.class);
			return authenticationManager.authenticate(new UsernamePasswordAuthenticationToken(user.getUsername(),user.getPassword(),new ArrayList<>())	);
		}catch(){}
	}

	//认证成功调用的方法
	@Override
	protected void seccessFulAuthentication(HttpServletRequest requeest,HttpervletResponse response,FilterChain chain,Authentication authResult) throws IOException,ServletException{
		//认证成功，得到用户信息
		SecurityUser user = (SecurityUser)authResult.getPrincipal();
		//根据用户生成token
		String token = tokenManager.createToken(user.getCurrentUerInfo().username());
		
	}

	//认证失败调用的方法
	@Override
	protected void unsuccessfulAuthentication(HttpServletRequest request,HttpServletResponse response,uthenticationException failed)throws IOException,ServletException{

	}
}

=============================================

工具类

public class AuthUtils{
	
	public static Authentication getPrincipal(){
		return SecurityContextHolder.getContext().getAuthentication();
	}
}

/**
	controller中进行应用
*/
@PostMapping("/app/user/coupons")
public Response<List<CouponResponse>> coupons(){
	LoginUser principal = (LoginUser) AuthUtils.getPrincipal().getPrincipal();
	return appDiscountCouponService.queryCoupons(principal.getId());
}

================================================================

SpringSecurity变成前后端分离，采用JWT做认证

什么是有状态：

有状态服务，即服务端需要记录每次会话的客户端信息，从而识别客户端身份，根据用户身份进行请求的处理，典型的设计如 Tomcat 中的 Session。例如登录：用户登录后，我们把用户的信息保存在服务端 session 中，并且给用户一个 cookie 值，记录对应的 session，然后下次请求，用户携带 cookie 值来（这一步有浏览器自动完成），我们就能识别到对应 session，从而找到用户的信息。这种方式目前来看最方便，但是也有一些缺陷，如下：

• 服务端保存大量数据，增加服务端压力
• 服务端保存用户状态，不支持集群化部署

什么是无状态：

微服务集群中的每个服务，对外提供的都使用 RESTful 风格的接口。而 RESTful 风格的一个最重要的规范就是：服务的无状态性，即：

• 服务端不保存任何客户端请求者信息
• 客户端的每次请求必须具备自描述信息，通过这些信息识别客户端身份
• 客户端请求不依赖服务端的信息，多次请求不需要必须访问到同一台服务器
• 服务端的集群和状态对客户端透明
• 服务端可以任意的迁移和伸缩（可以方便的进行集群化部署）
• 减小服务端存储压力

无状态登录的流程：

• 首先客户端发送账户名、密码到服务端进行认证
• 认证通过后，服务端将用户信息加密并且编码成一个 token，返回给客户端
• 以后客户端每次发送请求，都需要携带认证的 token
• 服务端对客户端发送来的 token 进行解密，判断是否有效，并且获取用户登录信息

JWT，全称是 Json Web Token

轻量级的授权和身份认证规范，可实现无状态、分布式的 Web 应用授权：

常用的 Java 实现是 GitHub 上的开源项目 jjwt，地址如下：https://github.com/jwtk/jjw

JWT包含三部分数据：

①、Header：头部，通常头部有两部分信息（对头部进行 Base64Url 编码（可解码），得到第一部分数据）

• 声明类型，这里是JWT
• 加密算法，自定义

②、Payload：载荷，就是有效数据，在官方文档中(RFC7519)，这里给了7个示例信息：（这部分也会采用 Base64Url 编码，得到第二部分数据）

• iss (issuer)：表示签发人
• exp (expiration time)：表示token过期时间
• sub (subject)：主题
• aud (audience)：受众
• nbf (Not Before)：生效时间
• iat (Issued At)：签发时间
• jti (JWT ID)：编号

③、Signature：签名，是整个数据的认证信息。一般根据前两步的数据，再加上服务的的密钥secret（密钥保存在服务端，不能泄露给客户端），通过 Header 中配置的加密算法生成。用于验证整个数据完整和可靠性。

生成的数据格式如下图：（这里的数据通过 . 隔开成了三部分，分别对应前面提到的三部分，另外，这里数据是不换行的，图片换行只是为了展示方便而已）

JWT交互流程

1. 应用程序或客户端向授权服务器请求授权
2. 获取到授权后，授权服务器会向应用程序返回访问令牌
3. 应用程序使用访问令牌来访问受保护资源（如 API）

因为 JWT 签发的 token 中已经包含了用户的身份信息，并且每次请求都会携带，这样服务的就无需保存用户信息，甚至无需去数据库查询，这样就完全符合了 RESTful 的无状态规范

存在的问题：

• 续签问题，这是被很多人诟病的问题之一，传统的 cookie+session 的方案天然的支持续签，但是 jwt 由于服务端不保存用户状态，因此很难完美解决续签问题，如果引入 redis，虽然可以解决问题，但是 jwt 也变得不伦不类了。
• 注销问题，由于服务端不再保存用户信息，所以一般可以通过修改 secret 来实现注销，服务端 secret 修改后，已经颁发的未过期的 token 就会认证失败，进而实现注销，不过毕竟没有传统的注销方便。
• 密码重置，密码重置后，原本的 token 依然可以访问系统，这时候也需要强制修改 secret。
• 基于第 2 点和第 3 点，一般建议不同用户取不同 secret。

5个handler

• 实现AuthenticationEntryPoint接口，当匿名请求需要登录的接口时拦截处理
• AuthentiocationSuccessHandler接口，当登录成功后，该处理类的方法被调用
• AuthenticationFailureHandler接口，当登录失败后，该处理类的方法被调用
• AccessDeniedHandler接口，当登陆后，访问接口没有权限的时候该处理类的方法被调用
• LogoutSuccessHandler接口，注销的时候调用

1个filter OncePerRequestFilter

前端发起请求的时候将token放在请求头中，在过滤器中对请求头进行解析

• 如果有accessToken的请求头，取出token，解析成功，将解析出来的用户信息放到SpringSecurity的上下文中
• 如果有accessToken的请求头，解析失败（无效token，或者过期失效）取不到用户信息，则放行
• 没有accessToken的请求头，放行

AuthenticationEntryPoint

匿名未登录的时候访问，遇到需要登录认证的时候被调用

@Component
public class CustomerAuthenticationEntryPoint implements AuthentiocationEntryPoint{
	
	@Override
	 public void commence(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, AuthenticationException e) throws IOException, ServletException {
     //设置response状态码，返回错误信息等
     ...
        ResponseUtil.out(401, ResultUtil.failure(ErrorCodeConstants.REQUIRED_LOGIN_ERROR));
    }
} 

AuthenticationSuccessHandler

输入用户名和密码认证成功后，调用的方法
获取用户信息，使用JWT生成token，然后返回token

@Slf4j
@Component
public class CustomerAuthentiocationSuccessHandler implements AuthenticationSuccessHandler{
	
	@Override
	public void onAuthenticationSuccess(HttpServletRequest request, HttpServletResponse response, Authentication authentication) throws IOException, ServletException {
		//获取当前用户，拿到用户名或者userId，创建token
		log.info("登录成功……");
		CustomerUserDetails principal = (CustomerUserDetails)authentication.getPrincipal();
		
		//颁发token
		Map<String,Object> emptyMap = new HashMap<>(4);
		emptyMap.put(UserConstants.USER_ID,principal.getId());

		String token = JwtTokenUtil.generateToken(principal.getUsername(),emptyMap);
		ResponseUtil.out(ResultUtil.success(token));
	}
}

AuthenticationFailureHandler

登录失败调用该方法

@Slf4j
@Component
public class CustomerAuthenticationFailHandler implements AuthenticationFailureHandler{
	
	@Override
	public void onAuthenticationFailure(HttpServletRequest request, HttpServletResponse response, AuthenticationException e) throws IOException, ServletException {
	
		//设置response状态码，返回错误信息等
     ....
        ResponseUtil.out(401, ResultUtil.failure(ErrorCodeConstants.LOGIN_UNMATCH_ERROR));
	}
}

LogoutSuccessHandler

退出登录的时候调用
JWT无法主动控制失效，可以采用JWT+session方式，比如删除存在在Redis的token

@Component
public class CustomerLogoutSuccessHandler implements LogoutSuccessHandler {
    @Override
    public void onLogoutSuccess(HttpServletRequest request, HttpServletResponse response, Authentication authentication) throws IOException, ServletException {
        ResponseUtil.out(ResultUtil.success("Logout Success!"));
    }
}

AccessDeniedHandler

登录之后，访问缺失权限的资源会调用

@Component
@Slf4j
public class CustomerRestAccessDeniedHandler implements AccessDeniedHandler {

    @Override
    public void handle(HttpServletRequest request, HttpServletResponse response, AccessDeniedException accessDeniedException) {
        ResponseUtil.out(403, ResultUtil.failure(ErrorCodeConstants.PERMISSION_DENY));
    }

}

OncePerRequestFilter

过滤器,在请求过来的时候,解析请求头中的token,再解析token得到用户信息,再存到SecurityContextHolder中

@Component
@Slf4j
public class CustomerJwtAuthenticationTokenFilter extends OncePerRequestFilter{
	
	@Autowired
	CustomerUserDetailService customerUserDetailService;
	
	@Override
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain chain) throws ServletException, IOException {
    	
    	String authHeader = request.getHeader(SecurityConstants.HEADER);

		if(authHeader != null && authHeader.startsWith(SecurityConstants.TOKEN_SPLIT)){
			 UserDetails userDetails = customerUserDetailService.loadUserByUsername(username);
                if (userDetails != null) {
                    UsernamePasswordAuthenticationToken authentication =
                            new UsernamePasswordAuthenticationToken(userDetails, userDetails.getPassword(), userDetails.getAuthorities());
                    authentication.setDetails(new WebAuthenticationDetailsSource().buildDetails(request));
                    SecurityContextHolder.getContext().setAuthentication(authentication);
                }
		}
    }
    
}

配置WebSecurityConfigurerAdapter

将handler和filter注册到SpringSecurity中，同时配置一些放行的url

@Configuration
@EnableWebSecurity
@EnableGlobalMethodSecurity(securedEnabled = true, prePostEnabled = true)// 控制@Secured权限注解
public class WebSecurityConfig extends WebSecurityConfigurerAdapter {

  /**
   * 这里需要交给spring注入,而不是直接new
   */
  @Autowired
  private PasswordEncoder passwordEncoder;
  @Autowired
  private CustomerUserDetailService customerUserDetailService;
  @Autowired
  private CustomerAuthenticationFailHandler customerAuthenticationFailHandler;
  @Autowired
  private CustomerAuthenticationSuccessHandler customerAuthenticationSuccessHandler;
  @Autowired
  private CustomerJwtAuthenticationTokenFilter customerJwtAuthenticationTokenFilter;
  @Autowired
  private CustomerRestAccessDeniedHandler customerRestAccessDeniedHandler;
  @Autowired
  private CustomerLogoutSuccessHandler customerLogoutSuccessHandler;
  @Autowired
  private CustomerAuthenticationEntryPoint customerAuthenticationEntryPoint;


 
  /**
   * 该方法定义认证用户信息获取的来源、密码校验的规则
   *
   * @param auth
   * @throws Exception
   */
  @Override
  protected void configure(AuthenticationManagerBuilder auth) throws Exception {
    //auth.authenticationProvider(myauthenticationProvider)  自定义密码校验的规则

    //如果需要改变认证的用户信息来源，我们可以实现UserDetailsService
    auth.userDetailsService(customerUserDetailService).passwordEncoder(passwordEncoder);
  }


  @Override
  protected void configure(HttpSecurity http) throws Exception {
    /**
     * antMatchers: ant的通配符规则
     * ? 匹配任何单字符
     * * 匹配0或者任意数量的字符，不包含"/"
     * ** 匹配0或者更多的目录，包含"/"
     */
    http
            .headers()
            .frameOptions().disable();

    http
            //登录后,访问没有权限处理类
            .exceptionHandling().accessDeniedHandler(customerRestAccessDeniedHandler)
            //匿名访问,没有权限的处理类
            .authenticationEntryPoint(customerAuthenticationEntryPoint)
    ;

    //使用jwt的Authentication,来解析过来的请求是否有token
    http
            .addFilterBefore(customerJwtAuthenticationTokenFilter, UsernamePasswordAuthenticationFilter.class);


    http
            .authorizeRequests()
            //这里表示"/any"和"/ignore"不需要权限校验
            .antMatchers("/ignore/**", "/login", "/**/register/**").permitAll()
            .anyRequest().authenticated()
            // 这里表示任何请求都需要校验认证(上面配置的放行)


            .and()
            //配置登录,检测到用户未登录时跳转的url地址,登录放行
            .formLogin()
            //需要跟前端表单的action地址一致
            .loginProcessingUrl("/login")
            .successHandler(customerAuthenticationSuccessHandler)
            .failureHandler(customerAuthenticationFailHandler)
            .permitAll()

            //配置取消session管理,又Jwt来获取用户状态,否则即使token无效,也会有session信息,依旧判断用户为登录状态
            .and()
            .sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS)

            //配置登出,登出放行
            .and()
            .logout()
            .logoutSuccessHandler(customerLogoutSuccessHandler)
            .permitAll()
            
            .and()
            .csrf().disable()
    ;
  }


}

实战

一、创建一个项目（添加 Spring Security 依赖，添加 jjwt 依赖）

<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>
<dependency>
    <groupId>io.jsonwebtoken</groupId>
    <artifactId>jjwt</artifactId>
    <version>0.9.1</version>
</dependency>

二、创建用户对象

public class User implements UserDetails {

    private String username;
    private String password;
    private List<GrantedAuthority> authorities;
    
    public String getUsername() {
        return username;
    }
    
    @Override
    public boolean isAccountNonExpired() {
        return true;
    }
    @Override
    public boolean isAccountNonLocked() {
        return true;
    }
    @Override
    public boolean isCredentialsNonExpired() {
        return true;
    }
    @Override
    public boolean isEnabled() {
        return true;
    }
    //省略getter/setter
}

三、Controller接口

设计是 /hello 接口可以被具有 user 角色的用户访问，
而 /admin 接口则可以被具有 admin 角色的用户访问

@RestController
public class HelloController {

    @GetMapping("/hello")
    public String hello() {
        return "hello jwt !";
    }
    @GetMapping("/admin")
    public String admin() {
        return "hello admin !";
    }
}

四、JWT过滤器

• 一个是用户登录的过滤器，在用户的登录的过滤器中校验用户是否登录成功，如果登录成功，则生成一个token返回给客户端，登录失败则给前端一个登录失败的提示。
• 第二个过滤器则是当其他请求发送来，校验token的过滤器，如果校验成功，就让请求继续执行。

public class JwtLoginFilter extends AbstractAuthenticationProcessingFilter{
	
	protected JwtLoginFilter(String defaultFilterProcessesUrl,AuthenticationManager authenticationManager){
		super(new AntPathRequestMatcher(defaultFilterProcessesUrl));
        setAuthenticationManager(authenticationManager);
	}

	/**
		从登录参数中提取出用户名密码，然后调用 AuthenticationManager.authenticate() 方法去进行自动校验
	*/
	@Override
	public Authentication attemptAuthentication(HttpServletRequest req, HttpServletResponse resp) 
	 	throws AuthenticationException, IOException, ServletException {
		
		User user = new ObjectMapper().readValue(req.getInputStream(), User.class);
	    return getAuthenticationManager()
	       .authenticate(new UsernamePasswordAuthenticationToken(user.getUsername(), user.getPassword()));
	}

	/**
		如果校验成功，就会来到 successfulAuthentication 回调中，在 successfulAuthentication 方法中，将用户角色遍历然后用一个 , 连接起来，
		然后再利用 Jwts 去生成 token，按照代码的顺序，生成过程一共配置了四个参数，分别是用户角色、主题、过期时间以及加密算法和密钥，
		然后将生成的 token 写出到客户端
	*/
	@Override
    protected void successfulAuthentication(HttpServletRequest req, 
    										HttpServletResponse resp,
    										FilterChain chain, 
    										Authentication authResult)
     	throws IOException, ServletException {
		
		Collection<? extends GrantedAuthority> authorities = authResult.getAuthorities();

		StringBuffer as = new StringBuffer();
		for(GrantedAuthority authority : authorities){
			as.append(authority.getAuthority())
                    .append(",");
		}

		//Jwts 去生成 token
		String jwt = Jwts.builder()
			.claim("authorities",as)//配置用户角色
			.setSubject(authResult.getName())
			.setExpiration(new Date(System.currentTimeMillis()+ 10 * 60 * 1000))
			.signWith(SignatureAlgorithm.HS512,"sang@123")
            .compact();

		//将生成的 token 写出到客户端
		resp.setContentType("application/json;charset=utf-8");
        PrintWriter out = resp.getWriter();
        out.write(new ObjectMapper().writeValueAsString(jwt));
        out.flush();
        out.close();
	}
	
	/**
		校验失败就会来到 unsuccessfulAuthentication 方法中，在这个方法中返回一个错误提示给客户端即可
	*/
	protected void unsuccessfulAuthentication(HttpServletRequest req, HttpServletResponse resp, AuthenticationException failed) 
					throws IOException, ServletException {
        resp.setContentType("application/json;charset=utf-8");
        PrintWriter out = resp.getWriter();
        out.write("登录失败!");
        out.flush();
        out.close();
    }
}

public class JwtFilter extends GenericFilterBean{
	
	@Override
	public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain)
		 throws IOException, ServletException {

		//首先从请求头中提取出 authorization 字段，这个字段对应的 value 就是用户的 token
		HttpServletRequest req = (HttpServletRequest) servletRequest;
        String jwtToken = req.getHeader("authorization");
        System.out.println(jwtToken);
        
        //将提取出来的 token 字符串转换为一个 Claims 对象
        Claims claims = Jwts.parser().setSigningKey("sang@123").parseClaimsJws(jwtToken.replace("Bearer",""))
                .getBody();
        String username = claims.getSubject();//获取当前登录用户名
        List<GrantedAuthority> authorities = AuthorityUtils.commaSeparatedStringToAuthorityList((String) claims.get("authorities"));//获取用户角色

		//创建一个 UsernamePasswordAuthenticationToken 放到当前的 Context 中，然后执行过滤链使请求继续执行下去
        UsernamePasswordAuthenticationToken token = new UsernamePasswordAuthenticationToken(username, null, authorities);
        SecurityContextHolder.getContext().setAuthentication(token);
        filterChain.doFilter(req,servletResponse);
	}
}

五、SpringSecurity配置

@Configuration
public class WebSecurityConfig extends WebSecurityConfigurerAdapter{
	
	/**
		未对密码进行加密，因此配置了 NoOpPasswordEncoder 的实例
	*/
	@Bean
	PasswordEncoder passwordEncoder(){
		return NoOpPasswordEncoder.getInstance();
	}

	/**
		未连接数据库，在内存中配置了两个用户，两个用户具备不同的角色。
	*/
	@Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        auth.inMemoryAuthentication().withUser("admin")
                .password("123").roles("admin")
                .and()
                .withUser("sang")
                .password("456")
                .roles("user");
    }

	/**
		配置路径规则时， /hello 接口必须要具备 user 角色才能访问， /admin 接口必须要具备 admin 角色才能访问，
		POST 请求并且是 /login 接口则可以直接通过，其他接口必须认证后才能访问。
	*/
	 @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.authorizeRequests()
                .antMatchers("/hello").hasRole("user")
                .antMatchers("/admin").hasRole("admin")
                .antMatchers(HttpMethod.POST, "/login").permitAll()
                .anyRequest().authenticated()
                .and()
                .addFilterBefore(new JwtLoginFilter("/login",authenticationManager()),UsernamePasswordAuthenticationFilter.class)
                .addFilterBefore(new JwtFilter(),UsernamePasswordAuthenticationFilter.class)
                .csrf().disable();//最后配置上两个自定义的过滤器并且关闭掉 csrf 保护
    }
}

六、测试

登录成功后返回的字符串就是经过 base64url 转码的 token，一共有三部分，通过一个 . 隔开，我们可以对第一个 . 之前的字符串进行解码，即 Header，如下：

再对两个 . 之间的字符解码，即 payload：

设置信息，由于 base64 并不是加密方案，只是一种编码方案，因此，不建议将敏感的用户信息放到 token 中
接下来再去访问 /hello 接口，注意认证方式选择 Bearer Token，Token 值为刚刚获取到的值，如下：