2. 程式人生 > >springboot+security+JWT實現單點登入

springboot+security+JWT實現單點登入

阿新 • • 發佈：2018-12-29

　　本次整合實現的目標：1、SSO單點登入2、基於角色和spring security註解的許可權控制。

　　整合過程如下：

　　1、使用maven構建專案，加入先關依賴，pom.xml如下：

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"
 
>
    <modelVersion>4.0.0</modelVersion>

    <groupId>powerx.io</groupId>
    <artifactId>springboot-security-jwt</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <packaging>jar</packaging>

    <name>springboot-security-jwt</name>
 

    <description>Demo project for Spring Boot</description>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.0.5.RELEASE</version>
        <relativePath 
 
/> <!-- lookup parent from repository -->
    </parent>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <java.version>1.8</java.version>
    </properties>

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

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>


</project>

　　2、JWT相關的兩個過濾器：認證過濾器JWTLoginFilter和鑑權過濾器JWTAuthenticationFilter，為了簡單，這裡沒有寫專門的JWTUtils工具類來進行token的一系列操作，只是簡單的利用JWT的第三方jar生成了token。

　　JWTLoginFilter.java

package com.example.demo;

import java.io.IOException;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Date;
import java.util.stream.Collectors;

import javax.servlet.FilterChain;
import javax.servlet.ServletException;
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.core.AuthenticationException;
import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;

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

/**
 * 驗證使用者名稱密碼正確後，生成一個token，並將token返回給客戶端
 * 該類繼承自UsernamePasswordAuthenticationFilter，重寫了其中的2個方法 ,
 * attemptAuthentication：接收並解析使用者憑證。 
 * successfulAuthentication：使用者成功登入後，這個方法會被呼叫，我們在這個方法裡生成token並返回。
 * 
 */
public class JWTLoginFilter extends UsernamePasswordAuthenticationFilter {

    private AuthenticationManager authenticationManager;

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

    @Override
    public Authentication attemptAuthentication(HttpServletRequest request, HttpServletResponse response)
            throws AuthenticationException {
            String username = request.getParameter("username");
            String password = request.getParameter("password");
            return authenticationManager.authenticate(new UsernamePasswordAuthenticationToken(username, password, new ArrayList<>()));
        
    }

    @Override
    protected void successfulAuthentication(HttpServletRequest request, HttpServletResponse response, FilterChain chain,
            Authentication auth) throws IOException, ServletException {
         Claims claims = Jwts.claims();
         claims.put("role", auth.getAuthorities().stream().map(s -> s.getAuthority()).collect(Collectors.toList()));
        String token = Jwts.builder()
                .setClaims(claims)
                .setSubject(auth.getName())
                .setExpiration(new Date(System.currentTimeMillis() + 60 * 60 * 24 * 1000))
                .signWith(SignatureAlgorithm.HS512, "MyJwtSecret11").compact();
        response.setCharacterEncoding("UTF-8");
        response.setContentType("application/json; charset=utf-8");
        String str = "{\"token\":\"" + token + "\"}";
        PrintWriter out;
        try {
            out = response.getWriter();
            out.print(str);
            out.flush();
            out.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

　　JWTAuthenticationFilter.java

package com.example.demo;

import java.io.IOException;
import java.util.List;
import java.util.stream.Collectors;

import javax.servlet.FilterChain;
import javax.servlet.ServletException;
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.authority.SimpleGrantedAuthority;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.security.web.authentication.www.BasicAuthenticationFilter;

import io.jsonwebtoken.Claims;
import io.jsonwebtoken.Jwts;

public class JWTAuthenticationFilter extends BasicAuthenticationFilter {
    public JWTAuthenticationFilter(AuthenticationManager authenticationManager) {
        super(authenticationManager);
    }

    /**
     * 在攔截器中獲取token並解析，拿到使用者資訊，放置到SecurityContextHolder，這樣便完成了springsecurity和jwt的整合。
     */
    @Override
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain chain)
            throws IOException, ServletException {
        String header = request.getHeader("Authorization");
        if (header == null || !header.startsWith("Bearer ")) {
            chain.doFilter(request, response);
            return;
        }
        UsernamePasswordAuthenticationToken authentication = getAuthentication(request);
        SecurityContextHolder.getContext().setAuthentication(authentication);
        chain.doFilter(request, response);
    }

    private UsernamePasswordAuthenticationToken getAuthentication(HttpServletRequest request) {
        String token = request.getHeader("Authorization");
        if (token != null) {
            
            Claims claims = Jwts.parser().setSigningKey("MyJwtSecret11").parseClaimsJws(token.replace("Bearer ", ""))
                    .getBody();
            String user  = claims.getSubject();
            @SuppressWarnings("unchecked")
            List<String> roles = claims.get("role", List.class);
            List<SimpleGrantedAuthority> auth = roles.stream().map(s -> new SimpleGrantedAuthority(s)).collect(Collectors.toList());
            
            if (user != null) {
                return new UsernamePasswordAuthenticationToken(user, null, auth);
            }
            return null;
        }
        return null;
    }

}

　　3、spring security基礎配置和測試的controller。

　　WebSecurityConfig.java

package com.example.demo;

import java.util.ArrayList;
import java.util.Collection;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
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.configuration.EnableWebSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.authority.SimpleGrantedAuthority;
import org.springframework.security.core.userdetails.User;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.security.provisioning.InMemoryUserDetailsManager;

@Configuration
@EnableWebSecurity
@EnableGlobalMethodSecurity(prePostEnabled = true)
public class WebSecurityConfig extends WebSecurityConfigurerAdapter {

    @Autowired
    private MyAuthenticationProvider provider;// 自定義的AuthenticationProvider

    @Bean
    public PasswordEncoder myPasswordEncoder() {
        return new MyPasswordEncoder();//自定義的加密工具
    }

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.authorizeRequests()
        .anyRequest().authenticated()
        .and()
        .formLogin().loginProcessingUrl("/login")
        .and()
        .csrf().disable()
        .addFilter(new JWTLoginFilter(authenticationManager()))
        .addFilter(new JWTAuthenticationFilter(authenticationManager()));
    }

    @Override
    public void configure(AuthenticationManagerBuilder auth) throws Exception {
        auth.authenticationProvider(provider);
        auth.userDetailsService(userDetailsService());
    }

    @Bean
    public UserDetailsService userDetailsService() {
        InMemoryUserDetailsManager iud = new InMemoryUserDetailsManager();
        Collection<GrantedAuthority> adminAuth = new ArrayList<>();
        adminAuth.add(new SimpleGrantedAuthority("ROLE_ADMIN"));
        iud.createUser(new User("zhangsan", "123456", adminAuth));
        return iud;
    }

}

　　MyAuthenticationProvider.java

package com.example.demo;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.authentication.AuthenticationProvider;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.AuthenticationException;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.stereotype.Component;


@Component
public class MyAuthenticationProvider implements AuthenticationProvider {

    @Autowired
    private UserDetailsService userDetailsService;

    /**
     * 自定義驗證方式
     */
    @Override
    public Authentication authenticate(Authentication authentication) throws AuthenticationException {
        String username = authentication.getName();
        String password = (String) authentication.getCredentials();
        UserDetails  user = userDetailsService.loadUserByUsername(username);
        if(user.getPassword().equals(password)) {
            return new UsernamePasswordAuthenticationToken(username, null, user.getAuthorities());
        }
        return null;
    }

    @Override
    public boolean supports(Class<?> arg0) {
        return true;
    }

}

　　MyPasswordEncoder.java

package com.example.demo;

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

public class MyPasswordEncoder implements PasswordEncoder {
    @Override
    public String encode(CharSequence charSequence) {
        return charSequence.toString();
    }

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

　　UserController.java

package com.example.demo;

import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class UserController {

    @RequestMapping("/hello")
    public String hello() {
        return "hello";
    }
    
    @PreAuthorize("hasAuthority('ROLE_USER')")
    @RequestMapping("/test1")
    public String test1() {
        return "test1";
    }
    @PreAuthorize("hasAuthority('ROLE_ADMIN')")
    @RequestMapping("/test2")
    public String test2() {
        return "test2";
    }
}

　　至此，核心程式碼都以經貼上，啟動專案，使用postman訪問http://localhost:8099/login?username=zhangsan&password=123456，響應如下：

　　我們訪問http://localhost:8099/hello，同時在請求頭上加入auth，如下：

　　同樣的url，不加auth則會給我們返回預設的登入頁，如下：

　　訪問http://localhost:8099/test1，則提示許可權不夠，因為我們只為zhangsan使用者分配了ROLE_ADMIN角色，而test1需要ROLE_USER。如下：

　　訪問http://localhost:8099/test2，如下：

　　為了驗證是否實現了單點登入，我們可以複製我們的專案，使用postman在第一個專案中拿到token，發現這個token在第二個專案中也可以使用，也就證明了我們的專案可以實現單點登入功能，在實際開發中，我們只需要在一個專案中去頒發token，而其他的專案中去按照相同的規則去解析這個token，這樣就可以實現單點登入，需要注意的就是在解析token時的簽名密碼要一致或者對應。

　　此外說一下，我在寫demo中遇到的坑，第一個就是springboot2.0版本以上必須要有一個加密工具的實現，不然會報錯；第二個就是在加入我們自己的過濾器後，必須使用預設的登入url即/login，不支援自定義的登入url了，具體原因我也不清楚；第三個就是在生成token時加入角色資訊，不能直接加入auth.getAuthorities()，不然在解析時會出現型別不匹配，具體可參考我的程式碼。

相關推薦

springboot+security+JWT實現單點登入

　　本次整合實現的目標：1、SSO單點登入2、基於角色和spring security註解的許可權控制。 　　整合過程如下： 　　1、使用maven構建專案，加入先關依賴，pom.xml如下： <?xml version="1.0" encoding="UTF-8"?> <project

springBoot整合spring security+JWT實現單點登入與許可權管理前後端分離--築基中期

## 寫在前面 在前一篇文章當中，我們介紹了springBoot整合spring security單體應用版，在這篇文章當中，我將介紹springBoot整合spring secury+JWT實現單點登入與許可權管理。 本文涉及的許可權管理模型是**基於資源的動態許可權管理**。資料庫設計的表有 user

springboot+security+JWT實現單點登錄

tchar dmi void wire pla writer 只為 conf string 　　本次整合實現的目標：1、SSO單點登錄2、基於角色和spring security註解的權限控制。 　　整合過程如下： 　　1、使用maven構建項目，加入先關依賴，pom.xm

Spring Security原始碼分析十二：Spring Security OAuth2基於JWT實現單點登入

單點登入（英語：Single sign-on，縮寫為 SSO），又譯為單一簽入，一種對於許多相互關連，但是又是各自獨立的軟體系統，提供訪問控制的屬性。當擁有這項屬性時，當用戶登入時，就可以獲取所有

Shiro結合JWT實現單點登入

簡述 Apache Shiro是java的一個安全框架，Shiro可以幫助我們完成認證、授權、加密、會話管理、與Web整合、快取等。而且Shiro的API也比較簡單，這裡我們就不進行過多的贅述，想要詳細瞭解Shiro的，推薦看開濤的部落格（點這裡） 在Shiro的強大許可

Security OAuth2 實現單點登入

作者：baeldung譯者：oopsguy1、概述在本教程中，我們將討論如何使用 Spring Security OAuth 和 Spring Boot 實現 SSO（單點登入）。本示例將使用到三個獨立應用一個授權伺服器（中央認證機制）兩個客戶端應用（使用到了 SSO 的應用）簡而言之，當用戶嘗試訪問客戶端應

基於spring-security-oauth2實現單點登入（持續更新）

##基於spring-security-實現資料庫版## 文章程式碼地址：[連結描述][1]可以下載直接執行，基於springb

Springboot 使用Redis+Session實現Session共享 , 實現單點登入

話說在前：   在你開啟我的這篇東西的時候，你應該學會了基於springboot專案使用Redis了，因為我不會在這篇過多去介紹·從redis基本配置。 然後， 你如果登入這模組，使用了shiro 或者說是 security ，沒關係的。 我也是結合shiro一起使用的。

spring boot中spring security實現單點登入，傳統模式(一)

單點登入是什麼？ 一個系統中可能會引用別的很多系統。單點登入就是解決，一次登入，就可以訪問所有的系統。 每次瀏覽器向一個域名傳送http請求，會去查詢域名的cookie資訊拼接到http的header中傳送到伺服器。 cookie不能跨域。這個域是瀏覽器請求的域名，哪怕他們都是訪問一

Spring Security 4.0 CAS實現單點登入

1、各framework版本資訊       JDK 8       Tomcat 7       SpringMVC-4.2.0.RELEASE       Spring Security 4.2.0.RELEASE       CAS-Client 3.3.3       CAS-Serv

spring security整合cas實現單點登入

spring security整合cas 0.配置本地ssl連線 操作記錄如下： =====================1.建立證書檔案thekeystore ，並匯出為thekeystore.crt cd C:\Users\23570\keystore C:\Users\23570\keystore&

PCB CS架構（工程系統）實現單點登入方法

社會的不斷進步發展，分工也越來越細了.而我們工作接觸的範圍也越來越狹小了,但這不是倒退了,而是分工之細讓人們在各個方面深耕細作。PCB企業軟體系統發展路線同樣也如此,隨著我們PCB企業發展不斷壯大,軟體系統也在不斷細分。目的只有一個,讓專業的事情交給專業的系統去做。回想當初起公司用必有德ERP，一個ERP能搞

Spring Boot WebSocket 單節點模擬實現單點登入擠退

1、建立WebSocketServer @ServerEndpoint("/websocket/{sid}") @Component  // 成分、元件 public class WebSocketServer {     //靜態變數，用來記錄當前線上

Java Redis + Cookie + Filter 實現單點登入

Java Redis + Cookie + Filter 實現單點登入 Java Redis + Cookie + Filter 實現單點登入 1 緣起 2 大體思路 3 擼起袖子幹 3

php實現單點登入

SSO即單點登入，是一種控制多個相關但彼此獨立的系統的訪問許可權, 擁有這一許可權的使用者可以使用單一的ID和密碼訪問某個或多個系統從而避免使用不同的使用者名稱或密碼，或者通過某種配置無縫地登入每個系統 。 對於大型系統來說使用單點登入可以減少使用者很多的麻煩。就拿百度來說吧，百度下面有很多的子

CAS實現單點登入（SSO）

什麼是單點登入 單點登入（Single Sign On），簡稱為 SSO，是目前比較流行的企業業務整合的解決方案之一。SSO的定義是在多個應用系統中，使用者只需要登入一次就可以訪問所有相互信任的應用系統。 我們目前的系統存在諸多子系統，而這些子系統是分別部署在不

CAS實現單點登入SSO執行原理探究(終於明白了)

一、不落俗套的開始 1、背景介紹 單點登入：Single Sign On,簡稱SSO，SSO使得在多個應用系統中，使用者只需要登入一次就可以訪問所有相互信任的應用系統。 CAS框架：CAS（Central Authentication Service）是實現S

CAS實現單點登入（sso）搭建流程 伺服器端搭建

一、簡介 1、cas是有耶魯大學研發的單點登入伺服器 2、所用環境 ·        Linux系統 ·        To

Tomcat叢集環境下實現單點登入

一、問題分析 在tomcat叢集環境下，session是不能在tomcat之間共享的，所以會導致如下問題，如圖所示： 通一個瀏覽器傳送多次請求，請求可能會被nginx轉發到不同的tomcat上，因為session不能共享，可能會導致登入成功後，發起其他的請求，返回給使用者的依舊

cas實現單點登入-應用場景和完整配置

Cas 簡介 1、什麼是CAS CAS是一個單點登入（SSO）的框架。單點登入是目前比較流行的服務於企業業務整合的解決方案之一，SSO使得在多個應用系統中，使用者只需要登入一次就可以訪問所有相互信任的應用系統。 2、CAS的主要結構 CAS包括兩部分：