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项目登录了，就可以访问。

Spring Security整合JWT，实现单点登录，So Easy~！_第1张图片

设计图-1

A项目配置，代码如下

第一步，A项目 POM.xml 引入文件

 
        
            org.springframework.boot
            spring-boot-starter-security
        
                    
            io.jsonwebtoken            
            jjwt            
            0.9.0

第二步，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
 * @author 程就人生
 * @date 2019年5月26日
 */
@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 authorities;

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

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

    public void setAuthorities(Collection authorities) {
        this.authorities = authorities;
    }

    @Override
    public Collection 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里，返回给客户端 
 * @author 程就人生
 * @date 2019年5月26日
 */
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 map = new HashMap();
                    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 map = new HashMap();
            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 map = new HashMap();
            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中引入必须的架包


        
            org.springframework.boot
            spring-boot-starter-security
        
                    
            io.jsonwebtoken            
            jjwt            
            0.9.0

第二步，增加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
 * @author 程就人生
 * @date 2019年5月26日
 */
@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;

/**
 * 是否登陆验证方法
 * @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 map = new HashMap();
            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

Spring Security整合JWT，实现单点登录，So Easy~！_第2张图片

测试结果-1

Spring Security整合JWT，实现单点登录，So Easy~！_第3张图片

测试结果-2

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

Spring Security整合JWT，实现单点登录，So Easy~！_第4张图片

测试结果-3

Spring Security整合JWT，实现单点登录，So Easy~！_第5张图片

测试结果-4

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

Spring Security整合JWT，实现单点登录，So Easy~！_第6张图片

测试结果-5

Spring Security整合JWT，实现单点登录，So Easy~！_第7张图片

测试结果-6

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

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

Bearer eyJhbGciOiJIUzUxMiJ9.eyJzdWIiOiJmZW5nIiwiZXhwIjoxNTU4OTUxMjM5fQ.X7lOhHJljxnVcNEckYSX22rgTDN0ToRJLaPb_1dAoPzx6q_eN5B5iOxO2GXoNUllIfQG6SrdJhgYzKZPTMsDIg

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

Spring Security整合JWT，实现单点登录，So Easy~！_第8张图片

微信扫一扫，关注程就人生