Spring Security整合JWT，实现单点登录，So Easy~！

前面整理过一篇 SpringBoot Security前后端分离，登录退出等返回json数据，也就是用Spring Security，基于SpringBoot2.1.4 RELEASE前后端分离的情况下，实现了登陆登出的功能，亮点就在于以JSON的形式接收返回参数。这个是针对单个后台服务的，登录信息都存储在SecurityContextHolder缓存里。如果是两个或两个以上的应用呢，那该怎么办？Session是不能用了，Cookie自然也不能用，毕竟它俩是一对的。

曾想过用OAuth2来解决这个问题，但是OAuth2太复杂，首先理解概念就需要花费一些时间，而且里面的授权服务器、资源服务器、客户端等等让人傻傻分不清，还有四种授权模式，要反复衡量，到底要用哪一种，概念还没有扯清楚就开始纠结使用哪一个了。从概念入手不是个好主意，也不是个轻松的主意。在理解OAuth2的过程中，想到自己的项目是前后端分离的，离不开JSON，无意中遇见JWT。JWT是什么玩意，咦，难道是自己苦苦寻求的吗？！

那么，什么是JWT呢？看看专家介绍阮一峰的网络日志，才知道，JWT 是JSON Web Token的简称，它解决的就是跨域问题。看来，要找的就是它，简单的，但也是管用的。
继续深究，JWT到底是怎样和SpringSecurity结合的呢。下面上代码，在上代码前先说明一下，在本次实例中，涉及到两个项目，一个项目是登录的项目A，另一个项目是根据token进行访问的项目B。其中B项目没有登录，也不会涉及登录，只要有Token就可以访问，Token失效了就访问不了了。

A项目是登录的项目，也是一个只能通过登录进行访问的后台服务。B项目就是一个服务，只要用户在A项目登录了，就可以访问。

在这里插入图片描述

设计图-1

A项目配置，代码如下
第一步，A项目 POM.xml 引入文件

    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-security</artifactId>
    </dependency>
    <dependency>            
        <groupId>io.jsonwebtoken</groupId>            
        <artifactId>jjwt</artifactId>            
        <version>0.9.0</version>        
    </dependency>

第二步，A项目SecurityConfig配置

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
import org.springframework.security.config.http.SessionCreationPolicy;
import org.springframework.security.core.userdetails.UserDetailsService;

import com.example.demo.filter.JWTAuthenticationFilter;
import com.example.demo.filter.JWTLoginFilter;

/**

SpringSecurity的配置
参考网址：https://blog.csdn.net/sxdtzhaoxinguo/article/details/77965226

*/
@Configuration
public class WebSecurityConfig extends WebSecurityConfigurerAdapter {

@Autowired
private UserDetailsService myCustomUserService;

@Autowired
private MyPasswordEncoder myPasswordEncoder;

@Override
protected void configure(HttpSecurity http) throws Exception {
    http
        //关闭跨站请求防护
        .cors().and().csrf().disable()
        //允许不登陆就可以访问的方法，多个用逗号分隔
        .authorizeRequests().antMatchers("/test").permitAll()
        //其他的需要授权后访问
        .anyRequest().authenticated()
        
        .and()         
        //增加登录拦截
        .addFilter(new JWTLoginFilter(authenticationManager()))     
        //增加是否登陸过滤
        .addFilter(new JWTAuthenticationFilter(authenticationManager()))
        // 前后端分离是无状态的，所以暫時不用session，將登陆信息保存在token中。
        .sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS);
    

}

@Override
public void configure(AuthenticationManagerBuilder auth) throws Exception {
    //覆盖UserDetailsService类
    auth.userDetailsService(myCustomUserService)
    //覆盖默认的密码验证类
    .passwordEncoder(myPasswordEncoder);
}

}

第三步，实现配置文件中自定义的类

MyPasswordEncoder类实现了默认的PasswordEncoder 接口，可以对密码加密和密码对比进行个性化定制

import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.stereotype.Component;

/**

自定义的密码加密方法，实现了PasswordEncoder接口
@author 程就人生
@date 2019年5月26日
*/
@Component
public class MyPasswordEncoder implements PasswordEncoder {

@Override
public String encode(CharSequence charSequence) {
//加密方法可以根据自己的需要修改
return charSequence.toString();
}

@Override
public boolean matches(CharSequence charSequence, String s) {
return encode(charSequence).equals(s);
}
}

MyCustomUserService 实现了框架默认的UserDetailsService，可以根据username从数据库获取用户，查看用户是否存在

/**

登录专用类,用户登陆时，通过这里查询数据库
自定义类，实现了UserDetailsService接口，用户登录时调用的第一类
@author 程就人生
@date 2019年5月26日
*/
@Component
public class MyCustomUserService implements UserDetailsService {

/**
- 登陆验证时，通过username获取用户的所有权限信息
- 并返回UserDetails放到spring的全局缓存SecurityContextHolder中，以供授权器使用
  */
  @Override
  public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
  //在这里可以自己调用数据库，对username进行查询，看看在数据库中是否存在
  MyUserDetails myUserDetail = new MyUserDetails();
  myUserDetail.setUsername(username);
  myUserDetail.setPassword(“123456”);
  return myUserDetail;
  }
  }

MyUserDetails 实现了框架的UserDetails接口，可以在该类中根据需要添加自己必需的属性

import java.util.Collection;

import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.userdetails.UserDetails;

/**

实现了UserDetails接口，只留必需的属性，也可添加自己需要的属性
@author 程就人生
@date 2019年5月26日
*/
public class MyUserDetails implements UserDetails {

private static final long serialVersionUID = 1L;

//登录用户名
private String username;
//登录密码
private String password;

private Collection<? extends GrantedAuthority> authorities;

public void setUsername(String username) {
this.username = username;
}

public void setPassword(String password) {
this.password = password;
}

public void setAuthorities(Collection<? extends GrantedAuthority> authorities) {
this.authorities = authorities;
}

@Override
public Collection<? extends GrantedAuthority> getAuthorities() {
return this.authorities;
}

@Override
public String getPassword() {
return this.password;
}

@Override
public String getUsername() {
return this.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;
}
}

JWTLoginFilter 实现了框架自带的UsernamePasswordAuthenticationFilter 接口，对拦截做处理，以便登录成功后，在头部设置token返回；不管登录成功还是失败，都有JSON数据返回

import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;

import javax.servlet.FilterChain;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.springframework.security.authentication.AuthenticationManager;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.Authentication;
import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;

import com.example.demo.entity.User;
import com.example.demo.security.MyUserDetails;
import com.fasterxml.jackson.databind.ObjectMapper;

import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.SignatureAlgorithm;

/**

验证用户名密码正确后，生成一个token，放在header里，返回给客户端

*/
public class JWTLoginFilter extends UsernamePasswordAuthenticationFilter {

private AuthenticationManager authenticationManager;     

public JWTLoginFilter(AuthenticationManager authenticationManager) { 
    
    this.authenticationManager = authenticationManager;    
    
} 

/**
 * 接收并解析用户凭证，出現错误时，返回json数据前端
 */
@Override    
public Authentication attemptAuthentication(HttpServletRequest req, HttpServletResponse res){        
    try {            
        User user =new ObjectMapper().readValue(req.getInputStream(), User.class);             
        return authenticationManager.authenticate(                    
                new UsernamePasswordAuthenticationToken(                            
                        user.getUsername(),                            
                        user.getPassword(),                            
                        new ArrayList<>())            
                );        
        } catch (Exception e) {
            try {
                //未登錄出現賬號或密碼錯誤時，使用json進行提示
                res.setContentType("application/json;charset=utf-8");
                res.setStatus(HttpServletResponse.SC_UNAUTHORIZED);
                PrintWriter out = res.getWriter();                  
                Map<String,Object> map = new HashMap<String,Object>();
                map.put("code",HttpServletResponse.SC_UNAUTHORIZED);
                map.put("message","账号或密码错误！");
                out.write(new ObjectMapper().writeValueAsString(map));
                out.flush();
                out.close();
            } catch (Exception e1) {
                e1.printStackTrace();
            }
            throw new RuntimeException(e);        
        }    
}

/**
 * 用户登录成功后，生成token,并且返回json数据给前端
 */
@Override    
protected void successfulAuthentication(HttpServletRequest req, HttpServletResponse res,FilterChain chain, Authentication auth){         
    
    //json web token构建
    String token = Jwts.builder()    
            //此处为自定义的、实现org.springframework.security.core.userdetails.UserDetails的类，需要和配置中设置的保持一致
            //此处的subject可以用一个用户名，也可以是多个信息的组合，根据需要来定
            .setSubject(((MyUserDetails) auth.getPrincipal()).getUsername())    
            //设置token过期时间，24小時
            .setExpiration(new Date(System.currentTimeMillis() + 60 * 60 * 24 * 1000)) 
            
            //设置token签名、密钥
            .signWith(SignatureAlgorithm.HS512, "MyJwtSecret")       
            
            .compact();  
    
    //返回token
    res.addHeader("Authorization", "Bearer " + token); 
    
    try {
        //登录成功時，返回json格式进行提示
        res.setContentType("application/json;charset=utf-8");
        res.setStatus(HttpServletResponse.SC_OK);
        PrintWriter out = res.getWriter();                  
        Map<String,Object> map = new HashMap<String,Object>();
        map.put("code",HttpServletResponse.SC_OK);
        map.put("message","登陆成功！");
        out.write(new ObjectMapper().writeValueAsString(map));
        out.flush();
        out.close();
    } catch (Exception e1) {
        e1.printStackTrace();
    }
}

}

JWTAuthenticationFilter 类实现了BasicAuthenticationFilter 接口，对Controller中需要登录后才能访问的方法进行了拦截，没有登录，则不能访问，返回JSON信息进行提示

import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;

import javax.servlet.FilterChain;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.springframework.security.authentication.AuthenticationManager;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.security.web.authentication.www.BasicAuthenticationFilter;

import com.fasterxml.jackson.databind.ObjectMapper;

import io.jsonwebtoken.Jwts;

/**

是否登陆验证方法
@author 程就人生
@date 2019年5月26日
*/
public class JWTAuthenticationFilter extends BasicAuthenticationFilter {

public JWTAuthenticationFilter(AuthenticationManager authenticationManager) {
super(authenticationManager);
}

/**
- 對請求進行過濾
  */
  @Override
  protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain chain) {
  try {
  //请求体的头中是否包含Authorization
  String header = request.getHeader(“Authorization”);
  //Authorization中是否包含Bearer，有一个不包含时直接返回
  if (header == null || !header.startsWith("Bearer ")) {
  chain.doFilter(request, response);
  responseJson(response);
  return;
  }
  //获取权限失败，会抛出异常
  UsernamePasswordAuthenticationToken authentication = getAuthentication(request);
  //获取后，将Authentication写入SecurityContextHolder中供后序使用
  SecurityContextHolder.getContext().setAuthentication(authentication);
  chain.doFilter(request, response);
  } catch (Exception e) {
  responseJson(response);
  e.printStackTrace();
  }
  }
/**
- 未登錄時的提示
- @param response
  */
  private void responseJson(HttpServletResponse response){
  try {
  //未登錄時，使用json進行提示
  response.setContentType(“application/json;charset=utf-8”);
  response.setStatus(HttpServletResponse.SC_FORBIDDEN);
  PrintWriter out = response.getWriter();
  Map<String,Object> map = new HashMap<String,Object>();
  map.put(“code”,HttpServletResponse.SC_FORBIDDEN);
  map.put(“message”,“请登录！”);
  out.write(new ObjectMapper().writeValueAsString(map));
  out.flush();
  out.close();
  } catch (Exception e1) {
  e1.printStackTrace();
  }
  }
/**
- 通过token，获取用户信息
- @param request
- @return
  */
  private UsernamePasswordAuthenticationToken getAuthentication(HttpServletRequest request) {
  String token = request.getHeader(“Authorization”);
  if (token != null) {
  //通过token解析出用户信息
  String user = Jwts.parser()
  //签名、密钥
  .setSigningKey(“MyJwtSecret”)
  .parseClaimsJws(token.replace("Bearer ", “”))
  .getBody()
  .getSubject();
  //不为null，返回
  if (user != null) {
  return new UsernamePasswordAuthenticationToken(user, null, new ArrayList<>());
  }
  return null;
  }
  return null;
  }

}

在登录过滤器中接收参数的实体类，也可以直接接收，这一个类不是必须的

public class User {

private long id;
private String username;
private String password;

public long getId() {
    return id;
}

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;
}

}

B项目的配置
第一步，在pom中引入必须的架包

    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-security</artifactId>
    </dependency>
    <dependency>            
        <groupId>io.jsonwebtoken</groupId>            
        <artifactId>jjwt</artifactId>            
        <version>0.9.0</version>        
    </dependency>

第二步，增加SecurityConfig配置文件
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
import org.springframework.security.config.http.SessionCreationPolicy;

import com.example.demo.filter.JWTAuthenticationFilter;

/**

SpringSecurity的配置
参考网址：https://blog.csdn.net/sxdtzhaoxinguo/article/details/77965226

@Configuration
public class WebSecurityConfig extends WebSecurityConfigurerAdapter {

@Override
protected void configure(HttpSecurity http) throws Exception {
    http
        //关闭跨站请求防护
        .cors().and().csrf().disable()
        //允许不登陆就可以访问的方法，多个用逗号分隔
        .authorizeRequests()
        //其他的需要授权后访问
        .anyRequest().authenticated()
        
        .and()
        //增加是否登陸过滤
        .addFilter(new JWTAuthenticationFilter(authenticationManager()))
        // 前后端分离是无状态的，所以暫時不用session，將登陆信息保存在token中。
        .sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS);

}

}

第三步，在增加对方法是否登录进行拦截的过滤器
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;

import javax.servlet.FilterChain;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.springframework.security.authentication.AuthenticationManager;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.security.web.authentication.www.BasicAuthenticationFilter;

import com.fasterxml.jackson.databind.ObjectMapper;

import io.jsonwebtoken.Jwts;

/**

是否登陆验证方法

*/
public class JWTAuthenticationFilter extends BasicAuthenticationFilter {

public JWTAuthenticationFilter(AuthenticationManager authenticationManager) {
    super(authenticationManager);
}

/**
 * 對請求進行過濾
 */
@Override
protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain chain) {        
    try {
        //请求体的头中是否包含Authorization
        String header = request.getHeader("Authorization");     
        //Authorization中是否包含Bearer，有一个不包含时直接返回
        if (header == null || !header.startsWith("Bearer ")) {
            chain.doFilter(request, response);
            responseJson(response);
            return;        
        } 
        //获取权限失败，会抛出异常
        UsernamePasswordAuthenticationToken authentication = getAuthentication(request); 
        //获取后，将Authentication写入SecurityContextHolder中供后序使用
        SecurityContextHolder.getContext().setAuthentication(authentication); 
        chain.doFilter(request, response);
    } catch (Exception e) {
        responseJson(response);
        e.printStackTrace();
    }     
}

/**
 * 未登錄時的提示
 * @param response
 */
private void responseJson(HttpServletResponse response){
    try {
        //未登錄時，使用json進行提示
        response.setContentType("application/json;charset=utf-8");
        response.setStatus(HttpServletResponse.SC_FORBIDDEN);
        PrintWriter out = response.getWriter();                 
        Map<String,Object> map = new HashMap<String,Object>();
        map.put("code",HttpServletResponse.SC_FORBIDDEN);
        map.put("message","请登录！");
        out.write(new ObjectMapper().writeValueAsString(map));
        out.flush();
        out.close();
    } catch (Exception e1) {
        e1.printStackTrace();
    }
}

/**
 * 通过token，获取用户信息
 * @param request
 * @return
 */
private UsernamePasswordAuthenticationToken getAuthentication(HttpServletRequest request) {        
    String token = request.getHeader("Authorization");        
    if (token != null) {            
        //通过token解析出用户信息            
        String user = Jwts.parser()   
                //签名盐
                .setSigningKey("MyJwtSecret")                    
                .parseClaimsJws(token.replace("Bearer ", ""))                    
                .getBody()                    
                .getSubject();     
        //不为null，返回
        if (user != null) {                
            return new UsernamePasswordAuthenticationToken(user, null, new ArrayList<>());            
        }           
        return null;        
    }        
    return null;    
}

}

从B项目的配置中，可以看出，B项目配置的太简洁了，只需要拦截一下没有登录的请求，连登录也都省了。
A和B项目中分别添加一个Controller，用于测试
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

/**

测试用例
@author 程就人生
@date 2019年5月26日
*/
@RestController
public class IndexController {

@GetMapping("/index")
public Object index(){
```
 return "index";
```
}
}

使用测试工具进行测试
第一步，测试A项目和B项目的index是否能访问，结果都不能访问，测试结果OK

在这里插入图片描述

测试结果-1

在这里插入图片描述

测试结果-2

第二步，通过登录获取token，登录成功后，返回了JSON格式的提示，返回的token在头部，点击响应头，获取token

在这里插入图片描述

测试结果-3

在这里插入图片描述

测试结果-4

第三步，将token拷贝至A项目index的头部，B项目index的头部，测试结果ok，都可以访问，也可以把token时间设置的短一些，测试一下token过期了，是否还能访问。

在这里插入图片描述

测试结果-5

在这里插入图片描述

测试结果-6

最后，感觉一下Token的结构，去掉前面固定的Bearer ，后面的分成三个部分，中间用点隔开，这个就简单了解下吧。

Header（头部）
Payload（负载）
Signature（签名）

Bearer eyJhbGciOiJIUzUxMiJ9.eyJzdWIiOiJmZW5nIiwiZXhwIjoxNTU4OTUxMjM5fQ.X7lOhHJljxnVcNEckYSX22rgTDN0ToRJLaPb_1dAoPzx6q_eN5B5iOxO2GXoNUllIfQG6SrdJhgYzKZPTMsDIg

Spring Security整合JWT，实现单点登录的功能，到此就告一段落了，看起来是不是很简单呢，那就动手试一试吧。

Spring Security整合JWT，实现单点登录，So Easy~！

猜你喜欢