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

阿新 • • 發佈：2018-11-19

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

1 緣起

分散式系統中需要一個單點登入系統，所以打算用 redis + cookie + filter 實現單點登入系統

2 大體思路

1 登入的時候


1.0 進行正常使用者登入流程 獲取 User 物件

1.1 生成唯一id （token）可以用 uuid 或者 session.getId()

1.2 
 設定指定的 cookie name 和 cookie value = token ，並且將 cookie 寫給客戶端

1.3 在 redis 中 設定 key = token ，value = user(將使用者物件序列化成json)，並且設定過期時間

2 獲取使用者資訊的時候

1.0 從請求中獲取 cooke ，從 cookie 中 獲取 token

1.1 根據 token ，從 redis 中獲取使用者資訊字串，並且反序列化成物件

3 退出登入的時候


1.0 從請求中獲取 cooke ，從 cookie 中 獲取 token

1.1 刪除 瀏覽器端的 cookie 

1.2 
 刪除 redis 中的 token

4 訪問需要使用者的許可權的藉口的時候延長 token 有效期


1.0 實現過濾器， 或者攔截器， 或者使用切面程式設計

1.1 獲取請求中的 cookie , 從 cookie 中獲取 token，

1.3 延長 token 有效期

3 擼起袖子幹

3.1 登入的時候


...業務程式碼 獲取使用者的 user 物件


 // 將 sessionId (token), 寫一個 cookie 給瀏覽器
 CookieUtil.writeLoginToken(httpServletResponse, session.getId());

 // 將 sessionId (token) ，user 儲存在 redis 中
 RedisPoolUtil.setEx(session.getId(), JsonUtil.objToString(user), Constants.RedisCacheExtime.REDIS_SESSION_EXTIME);

3.2 獲取使用者資訊


 String loginToken = CookieUtil.readLoginToken(request);

 if (StringUtils.isBlank(loginToken)) {
     return ServerResponse.createByErrorMessage("使用者未登入， 無法獲取使用者資訊");
 } else {
     String userJsonStr = RedisPoolUtil.get(loginToken);
     User user = JsonUtil.stringToObj(userJsonStr, User.class);

     if (user != null) {
        return ServerResponse.createBySuccess(user);
     } else {
        return ServerResponse.createByErrorMessage("使用者未登入， 無法獲取使用者資訊");
     }
 }

3.3 退出登入

String token = CookieUtil.readLoginToken(request);
CookieUtil.delLoginToken(request, httpServletResponse);
RedisPoolUtil.del(token);

3.4 在訪問需要使用者許可權的介面前後，延長 token 時效，這裡使用過濾器

public class SessionExpireFilter implements Filter {

    ...

    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        HttpServletRequest httpServletRequest = (HttpServletRequest) servletRequest;

        String token = CookieUtil.readLoginToken(httpServletRequest);

        if (StringUtils.isNotBlank(token)) {
            String userJsonStr = RedisPoolUtil.get(token);
            User user = JsonUtil.stringToObj(userJsonStr, User.class);

            if (user != null) {
                // 重置 session 有效期
                RedisPoolUtil.expire(token, Constants.RedisCacheExtime.REDIS_SESSION_EXTIME);
            }
        }

        filterChain.doFilter(httpServletRequest, servletResponse);
    }

    ...

}

配置 web.xml

<!-- 重置 session 的 filter -->
  <filter>
    <filter-name>sessionExpireFilter</filter-name>
    <filter-class>com.mmall.controller.common.SessionExpireFilter</filter-class>
  </filter>

  <!-- 攔截 .do 結尾的 -->
  <filter-mapping>
    <filter-name>sessionExpireFilter</filter-name>
    <url-pattern>*.do</url-pattern>
  </filter-mapping>

4 需要的工具類

4.1 CookieUtil


import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang.StringUtils;

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

/**
 * Created by jun on 2018/5/21.
 */
@Slf4j
public class CookieUtil {

    private static final String COOKIE_DOMAIN = ".happymmall.com";

    private static final String COOKIE_NAME = "mmall_login_token";

    public static void writeLoginToken(HttpServletResponse response, String token) {
        Cookie cookie = new Cookie(COOKIE_NAME, token);
        cookie.setDomain(COOKIE_DOMAIN);
        cookie.setPath("/");
        // 防止指令碼攻擊，不允許指令碼訪問 cookie
        cookie.setHttpOnly(true);

        // -1 代表永不過期， 單位 秒 如果 maxage cookie 則不會寫入硬碟，只寫入記憶體， 只在當前頁面有效
        cookie.setMaxAge(60 * 60 * 24 * 30);

        log.info("write cookie cookieName:" + cookie.getName() + " cookieValue:" + cookie.getValue());
    }

    public static String readLoginToken(HttpServletRequest request) {
        Cookie[] cookies = request.getCookies();

        if (cookies != null) {
            for (Cookie cookie : cookies) {
                if (StringUtils.equals(cookie.getName(), COOKIE_NAME)) {
                    return cookie.getValue();
                }
            }
        }

        return null;
    }

    public static void delLoginToken (HttpServletRequest request, HttpServletResponse response) {
        Cookie[] cookies = request.getCookies();

        if (cookies != null) {
            for (Cookie cookie : cookies) {
                if (StringUtils.equals(cookie.getName(), COOKIE_NAME)) {
                    cookie.setDomain(COOKIE_DOMAIN);
                    cookie.setPath("/");

                    // 設定為 0 代表刪除
                    cookie.setMaxAge(0);
                    response.addCookie(cookie);

                    return;
                }
            }
        }
    }
}

4.2 RedisPoolUtil

package com.mmall.util;


import com.mmall.common.RedisPool;
import lombok.extern.slf4j.Slf4j;
import redis.clients.jedis.Jedis;

/**
 * Created by jun on 2018/5/3.
 */
@Slf4j
public class RedisPoolUtil {

    /**
     * 設定 key 有效期
     *
     * @param key
     * @param exTime
     * @return
     */
    public static Long expire(String key, int exTime){
        Jedis jedis = null;
        Long result = null;

        try {
            jedis = RedisPool.getJedis();
            result = jedis.expire(key, exTime);
        } catch (Exception e) {
            log.error("jedis expire error", e);
            RedisPool.returnBrokenResource(jedis);
        }

        RedisPool.returnResource(jedis);
        return result;
    }

    /**
     * 帶有過期時間的 set
     * @param key
     * @param value
     * @param exTime 秒
     * @return
     */
    public static String setEx(String key, String value, int exTime){
        Jedis jedis = null;
        String result = null;

        try {
            jedis = RedisPool.getJedis();
            result = jedis.setex(key, exTime, value);
        } catch (Exception e) {
            log.error("jedis setEx error", e);
            RedisPool.returnBrokenResource(jedis);
        }

        RedisPool.returnResource(jedis);
        return result;
    }

    public static String set(String key, String value){
        Jedis jedis = null;
        String result = null;

        try {
            jedis = RedisPool.getJedis();
            result = jedis.set(key, value);
        } catch (Exception e) {
            log.error("jedis set error", e);
            RedisPool.returnBrokenResource(jedis);
        }

        RedisPool.returnResource(jedis);
        return result;
    }

    public static String get(String key){
        Jedis jedis = null;
        String result = null;

        try {
            jedis = RedisPool.getJedis();
            result = jedis.get(key);
        } catch (Exception e) {
            log.error("jedis get error", e);
            RedisPool.returnBrokenResource(jedis);
        }

        RedisPool.returnResource(jedis);
        return result;
    }

    public static Long del(String key){
        Jedis jedis = null;
        Long result = null;

        try {
            jedis = RedisPool.getJedis();
            result = jedis.del(key);
        } catch (Exception e) {
            log.error("jedis del error", e);
            RedisPool.returnBrokenResource(jedis);
        }

        RedisPool.returnResource(jedis);
        return result;
    }
}

4.3 RedisPool

package com.mmall.common;

import com.mmall.util.PropertiesUtil;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;

/**
 * Created by jun on 2018/5/2.
 */
public class RedisPool {

    // jedis 連線池
    private static JedisPool jedisPool;

    // 最大連線數
    private static Integer maxTotal = Integer.valueOf(PropertiesUtil.getProperty("redis.max.total"));

    // 最大空閒連線數
    private static Integer maxIdle = Integer.valueOf(PropertiesUtil.getProperty("redis.max.idel"));

    // 最小空閒連線數
    private static Integer minIdle = Integer.valueOf(PropertiesUtil.getProperty("redis.min.idel"));

    // 測試jedis例項是否可用，在 borrow 的時候
    private static Boolean testOnBorrow = Boolean.valueOf(PropertiesUtil.getProperty("redis.test.borrow"));

    // 測試jedis例項是否可用，在 return 的時候
    private static Boolean testOnReturn = Boolean.valueOf(PropertiesUtil.getProperty("redis.test.return"));

    // ip
    private static String ip = PropertiesUtil.getProperty("redis.ip");
    // port
    private static Integer port = Integer.valueOf(PropertiesUtil.getProperty("redis.port"));

    public static void initPool() {
        JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();
        jedisPoolConfig.setMaxTotal(maxTotal);
        jedisPoolConfig.setMaxIdle(maxIdle);
        jedisPoolConfig.setMinIdle(minIdle);
        jedisPoolConfig.setTestOnBorrow(testOnBorrow);
        jedisPoolConfig.setTestOnReturn(testOnReturn);

        // 連線耗盡時，是否阻塞，false會丟擲異常，true阻塞直到超時，預設 true
        jedisPoolConfig.setBlockWhenExhausted(true);

        jedisPool = new JedisPool(jedisPoolConfig, ip, port, 1000 * 2);
    }

    static {
        initPool();
    }

    public static Jedis getJedis() {
        return jedisPool.getResource();
    }

    public static void returnResource(Jedis jedis) {
        jedisPool.returnResource(jedis);
    }

    public static void returnBrokenResource(Jedis jedis) {
        jedisPool.returnBrokenResource(jedis);
    }
}

4.4 JsonUtil

package com.mmall.util;

import com.mmall.pojo.User;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang.StringUtils;
import org.codehaus.jackson.map.DeserializationConfig;
import org.codehaus.jackson.map.ObjectMapper;
import org.codehaus.jackson.map.SerializationConfig;
import org.codehaus.jackson.map.annotate.JsonSerialize.Inclusion;
import org.codehaus.jackson.type.JavaType;
import org.codehaus.jackson.type.TypeReference;

import java.io.IOException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.List;

/**
 * Created by jun on 2018/5/15.
 */
@Slf4j
public class JsonUtil {

    private static final String STANDARD_FORMAT = "yyyy-MM-dd HH:mm:ss";

    private static ObjectMapper objectMapper = new ObjectMapper();

    static {
        // 物件的所有欄位全部列入
        objectMapper.setSerializationInclusion(Inclusion.ALWAYS);
        // 取消預設轉換 timestamp 形式
        objectMapper.configure(SerializationConfig.Feature.WRITE_DATE_KEYS_AS_TIMESTAMPS, false);
        // 忽略空 bean 轉 json 的錯誤
        objectMapper.configure(SerializationConfig.Feature.FAIL_ON_EMPTY_BEANS, false);
        // 所有的日期 統一為以下格式
        objectMapper.setDateFormat(new SimpleDateFormat(STANDARD_FORMAT));

        // 忽略 在 json字串中存在， 但是在 Java 物件中不存在對應屬性的情況。防止錯誤。
        objectMapper.configure(DeserializationConfig.Feature.FAIL_ON_UNKNOWN_PROPERTIES, false);
    }

    /**
     * java 物件轉 字串
     * @param obj
     * @param <T>
     * @return
     */
    public static <T> String objToString(T obj) {
        if (obj == null) {
            return null;
        }

        try {
            return obj instanceof String ? (String) obj : objectMapper.writeValueAsString(obj);
        } catch (Exception e) {
            log.warn("parse error", e);
            return null;
        }
    }

    /**
     * java 物件轉 字串, 返回格式化好的字串
     * @param obj
     * @param <T>
     * @return
     */
    public static <T> String objToStringPretty(T obj) {
        if (obj == null) {
            return null;
        }

        try {
            return obj instanceof String ? (String) obj : objectMapper.writerWithDefaultPrettyPrinter().writeValueAsString(obj);
        } catch (Exception e) {
            log.warn("parse error", e);
            return null;
        }
    }

    /**
     * 字串轉物件
     *
     * @param str
     * @param clazz
     * @param <T>
     * @return
     */
    public static <T> T stringToObj(String str, Class<T> clazz) {
        // 第一個 T 是將方法宣告成泛形方法
        // 第二個 T 是 返回值型別
        // 第三個 T 是 入參型別
        if (StringUtils.isBlank(str) || clazz == null) {
            return null;
        }

        try {
            return clazz.equals(String.class) ? (T) str : objectMapper.readValue(str, clazz);
        } catch (IOException e) {
            log.warn("parse error", e);
            return null;
        }
    }

    /**
     * json 字串轉物件
     * @param str
     * @param typeReference
     * @param <T>
     * @return
     */
    public static <T> T stringToObj(String str, TypeReference<T> typeReference) {
        if (StringUtils.isBlank(str) || typeReference == null) {
            return null;
        }

        try {
            return (T) (typeReference.getType().equals(String.class) ?  str : objectMapper.readValue(str, typeReference));
        } catch (IOException e) {
            log.warn("parse error", e);
            return null;
        }
    }

    /**
     * json 字串轉物件
     * @param str
     * @param collectionClass
     * @param elementClasses
     * @param <T>
     * @return
     */
    public static <T> T stringToObj(String str, Class<?> collectionClass, Class<?>... elementClasses) {
        JavaType javaType = objectMapper.getTypeFactory().constructParametricType(collectionClass, elementClasses);

        try {
            return objectMapper.readValue(str, javaType);
        } catch (IOException e) {
            log.warn("parse error", e);
            return null;
        }
    }
}

4.5 PropertiesUtil 用於讀取配置

package com.mmall.util;


import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Properties;


/**
 * Created by jun on 2018/4/8.
 */
public class PropertiesUtil {

    private static Logger logger = LoggerFactory.getLogger(PropertiesUtil.class);

    private static Properties properties;

    static {
        String fileName = "mmall.properties";
        properties = new Properties();
        try {
            properties.load(new InputStreamReader(PropertiesUtil.class.getClassLoader().getResourceAsStream(fileName), "UTF-8"));
        } catch (IOException e) {
            logger.error("config file read fail");
        }
    }

    public static String getProperty(String key) {
        if (StringUtils.isNotBlank(key)) {
            String value = properties.getProperty(key.trim());

            if (StringUtils.isNotBlank(key)) {
                return value.trim();
            } else {
                return value;
            }
        } else {
            return null;
        }
    }

}

4.6 redis 連線池配置

# redis config start
redis.max.total=20
redis.max.idel=10
redis.min.idel=2
redis.test.borrow=true
redis.test.return=true

redis.ip=localhost
redis.port=6379
# redis config end

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

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

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

1.Redis連線池構建首先maven匯入依賴包 <dependency> <groupId>redis.clients</groupId> <artifactId>jedis</artifactId>

Spring Session+Redis零侵入實現單點登入

Spring Session 實現單點登入此種方式相對於上節所說使用原生（Jedis+Jackson+Cookie+Filter）的方式實現起來更加簡便，同時對業務程式碼的侵入性也十分之小，其原理與原生方式類似，並通過對HttpServletRequest和HttpSer

SSO 基於Cookie+fliter實現單點登入（SSO）：工作原理

SSO的概念：單點登入SSO（Single Sign-On）是身份管理中的一部分。SSO的一種較為通俗的定義是：SSO是指訪問同一伺服器不同應用中的受保護資源的同一使用者，只需要登入

單點登入使用redis模擬session實現單點登入

redis就是一個公共的伺服器，所有的子系統都能連線redis進行訪問 1. 登入在登入模組實現使用者名稱密碼的校驗之後，通過u

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

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

Windows 下Maven+Tomcat 8 使用JAVA以及 Json Web Token 實現單點登入demo

0.準備工作如果你本地環境都OK，可以跳過。 1.簡介 json web token(JWT)是一種新的使用者認證方式,不同與以前的Session. JWT不需要伺服器端儲存使用者資訊,當用戶登入後,伺服器將使用者資訊放入加密放入t

關於redis實現單點登入的一點思路

先簡單說一下單點登入：把登入的部分單獨拿出來作為一個專案,專門用來登入。當我想訪問某個子專案或者模組的時候，會先請求登入的部分，如果登入過了，就不需要再登入了。這個和單獨專案時，把userId放到session中道理是一樣的。因為多個子專案在不同的tomcat，無法

用Redis實現Session功能，實現單點登入

0.什麼是Redis Redis是一個開源的使用ANSI C語言編寫、支援網路、可基於記憶體亦可持久化的日誌型、Key-Value資料庫，並提供多種語言的API ---維基百科 1.與其他使用者狀態儲存方案比較一般開發中使用者狀態使用session或者cookie

redis實現session共享，實現單點登入

所需環境：兩臺伺服器A和B模擬叢集(兩臺電腦），一個mysql5.7，redis伺服器，demo分別部署在A和B中，A中名為demo1,B中名為demo2（為了加以區分） mysql5.7和redis都是在B中開啟的測試原理：demo1在A中訪問login.jsp頁面登入

cookie跨域，實現單點登入

Cookie 跨域，實現單點登入 Table title 最近在做一個單點登入的系統整合專案，之前我們使用控制元件實現單點登入(以後可以介紹一下)。但現在為了滿足客戶需求，在不使用控制元件情況下實現單點登入，先來介紹一下單點登入。單點登入：多個不同系統整合

Redis實現單點登入

單點登入功能分析請求的url：/user/login 請求的方法：POST 引數：username、password，表單提交的資料。可以使用方法的形參接收。返回值：json資料，包含一個token。業務邏輯：登入的業務流程：登入

.NET基於Redis快取實現單點登入SSO的解決方案

一、基本概念最近公司的多個業務系統要統一整合使用同一個登入，這就是我們耳熟能詳的單點登入，現在就NET基於Redis快取實現單點登入做一個簡單的分享。單點登入（Single Sign On），簡稱為 SSO，是目前比較流行的企業業務整合的解決方案之一。SSO的定義

單點登入-基於Redis+MySQL實現單點登入（SSO）

1. 為什麼要用單獨登入？主要便於公司內部多系統統一認證授權管理，一次登入可訪問多個跨域系統，也同時更加方便統一管理使用者登入

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

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

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

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

php實現單點登入

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

Shiro結合JWT實現單點登入

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

CAS實現單點登入（SSO）

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

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

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

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

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

1 緣起

2 大體思路

3 擼起袖子幹

3.1 登入的時候

3.2 獲取使用者資訊

3.3 退出登入

3.4 在訪問需要使用者許可權的介面前後，延長 token 時效，這裡使用過濾器

4 需要的工具類

4.1 CookieUtil

4.2 RedisPoolUtil

4.3 RedisPool

4.4 JsonUtil

4.5 PropertiesUtil 用於讀取配置

4.6 redis 連線池配置

相關推薦