spring-session实现多策略同时支持cookie&header验证

最新推荐文章于 2023-03-14 15:52:24 发布
最新推荐文章于 2023-03-14 15:52:24 发布
阅读量1.5k 收藏 6
点赞数
分类专栏： JAVA
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43789433/article/details/105041438
版权

引入依赖

    <dependency>
      <groupId>org.springframework.session</groupId>
      <artifactId>spring-session</artifactId>
      <version>1.3.3.RELEASE</version>
    </dependency>

增加spring-session.xml配置文件

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:jdbc="http://www.springframework.org/schema/jdbc"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
		http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
		http://www.springframework.org/schema/jdbc http://www.springframework.org/schema/jdbc/spring-jdbc.xsd">

    <!-- tag::beans[] -->

    <!--1-->
    <context:annotation-config/>
    <bean class="org.springframework.session.jdbc.config.annotation.web.http.JdbcHttpSessionConfiguration">
        <!--session最长过期时间-->
        <property name="maxInactiveIntervalInSeconds" value="7200"/>
        <!--session策略-->
        <property name="httpSessionStrategy" ref="headerAndCookieHttpSessionStrategy"/>
    </bean>


    <!--自定义实现类,同时支持header和cookie-->
    <bean id="headerAndCookieHttpSessionStrategy" class="com.zhiyun.front.common.interceptor.HeaderAndCookieHttpSessionStrategy"/>


    <!--2-->
<!--    <jdbc:embedded-database id="dataSource" database-name="ZYQJ_MGR" type="H2">
        <jdbc:script location="classpath:org/springframework/session/jdbc/schema-oracle.sql" />
    </jdbc:embedded-database>-->

    <!--3-->
    <bean class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <constructor-arg ref="dataSource"/>
    </bean>
    <!-- end::beans[] -->
</beans>

在整合完成spring-session后,官方默认要么只支持header策略,要么只支持cookie策略,然而在实际项目中,有些场景是不能只局限于cookie的,比如移动端某些前端框架,IOS等,而在浏览器端,使用cookie策略又显得非常的方便,所以有没有一种办法可以将cookie和header相结合达到理想化的效果呢?
在查阅了:

    <!--使用header存储sessionID-->
    <bean id="headerHttpSessionStrategy" class="org.springframework.session.web.http.HeaderHttpSessionStrategy"/>
    <!--使用cookie存储sessionID-->
    <bean id="cookieHttpSessionStrategy" class="org.springframework.session.web.http.CookieHttpSessionStrategy"/>

spring-session这两种策略的实现代码后(HeaderHttpSessionStrategy和CookieHttpSessionStrategy),我决定重新写一个实现类,将这两种策略综合起来

HeaderAndCookieHttpSessionStrategy.java代码如下:

package com.zhiyun.front.common.interceptor;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.session.Session;
import org.springframework.session.web.http.*;
import org.springframework.util.Assert;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpServletResponseWrapper;
import java.io.UnsupportedEncodingException;
import java.net.URLEncoder;
import java.util.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * 同时支持header和cookie策略
 */
public class HeaderAndCookieHttpSessionStrategy implements MultiHttpSessionStrategy, HttpSessionManager {
    private String headerName = "x-auth-token";




    private static final String DEFAULT_DELIMITER = " ";
    private static final String SESSION_IDS_WRITTEN_ATTR = CookieHttpSessionStrategy.class.getName().concat(".SESSIONS_WRITTEN_ATTR");
    static final String DEFAULT_ALIAS = "0";
    static final String DEFAULT_SESSION_ALIAS_PARAM_NAME = "_s";
    private static final Pattern ALIAS_PATTERN = Pattern.compile("^[\\w-]{1,50}$");
    private String sessionParam = "_s";
    private CookieSerializer cookieSerializer = new DefaultCookieSerializer();
    private String deserializationDelimiter = " ";
    private String serializationDelimiter = " ";

    public HeaderAndCookieHttpSessionStrategy() {
    }

    @Override
    public String getRequestedSessionId(HttpServletRequest request) {
        //获取请求头中的session信息
        String header = request.getHeader(this.headerName);
        if(header != null && !"".equals(header)){
            return header;
        }
        //获取cookie中的session信息
        Map<String, String> sessionIds = this.getSessionIds(request);
        String sessionAlias = this.getCurrentSessionAlias(request);
        return (String)sessionIds.get(sessionAlias);
    }

    public String getCurrentSessionAlias(HttpServletRequest request) {
        if (this.sessionParam == null) {
            return "0";
        } else {
            String u = request.getParameter(this.sessionParam);
            if (u == null) {
                return "0";
            } else {
                return !ALIAS_PATTERN.matcher(u).matches() ? "0" : u;
            }
        }
    }

    public String getNewSessionAlias(HttpServletRequest request) {
        Set<String> sessionAliases = this.getSessionIds(request).keySet();
        if (sessionAliases.isEmpty()) {
            return "0";
        } else {
            long lastAlias = Long.decode("0");
            Iterator var5 = sessionAliases.iterator();

            while(var5.hasNext()) {
                String alias = (String)var5.next();
                long selectedAlias = this.safeParse(alias);
                if (selectedAlias > lastAlias) {
                    lastAlias = selectedAlias;
                }
            }

            return Long.toHexString(lastAlias + 1L);
        }
    }

    private long safeParse(String hex) {
        try {
            return Long.decode("0x" + hex);
        } catch (NumberFormatException var3) {
            return 0L;
        }
    }

    @Override
    public void onNewSession(Session session, HttpServletRequest request, HttpServletResponse response) {
        response.setHeader(this.headerName, session.getId());//将session信息设置到请求头中
        Set<String> sessionIdsWritten = this.getSessionIdsWritten(request);
        if (!sessionIdsWritten.contains(session.getId())) {
            sessionIdsWritten.add(session.getId());
            Map<String, String> sessionIds = this.getSessionIds(request);
            String sessionAlias = this.getCurrentSessionAlias(request);
            sessionIds.put(sessionAlias, session.getId());
            String cookieValue = this.createSessionCookieValue(sessionIds);
            this.cookieSerializer.writeCookieValue(new CookieSerializer.CookieValue(request, response, cookieValue));
        }
    }

    private Set<String> getSessionIdsWritten(HttpServletRequest request) {
        Set<String> sessionsWritten = (Set)request.getAttribute(SESSION_IDS_WRITTEN_ATTR);
        if (sessionsWritten == null) {
            sessionsWritten = new HashSet();
            request.setAttribute(SESSION_IDS_WRITTEN_ATTR, sessionsWritten);
        }

        return (Set)sessionsWritten;
    }

    private String createSessionCookieValue(Map<String, String> sessionIds) {
        if (sessionIds.isEmpty()) {
            return "";
        } else if (sessionIds.size() == 1 && sessionIds.keySet().contains("0")) {
            return (String)sessionIds.values().iterator().next();
        } else {
            StringBuilder sb = new StringBuilder();
            Iterator var3 = sessionIds.entrySet().iterator();

            while(var3.hasNext()) {
                Map.Entry<String, String> entry = (Map.Entry)var3.next();
                String alias = (String)entry.getKey();
                String id = (String)entry.getValue();
                sb.append(alias);
                sb.append(this.serializationDelimiter);
                sb.append(id);
                sb.append(this.serializationDelimiter);
            }

            sb.deleteCharAt(sb.length() - 1);
            return sb.toString();
        }
    }

    @Override
    public void onInvalidateSession(HttpServletRequest request, HttpServletResponse response) {
        response.setHeader(this.headerName, "");//将header中的session信息删除
        Map<String, String> sessionIds = this.getSessionIds(request);
        String requestedAlias = this.getCurrentSessionAlias(request);
        sessionIds.remove(requestedAlias);
        String cookieValue = this.createSessionCookieValue(sessionIds);
        this.cookieSerializer.writeCookieValue(new CookieSerializer.CookieValue(request, response, cookieValue));
    }

    public void setSessionAliasParamName(String sessionAliasParamName) {
        this.sessionParam = sessionAliasParamName;
    }

    public void setCookieSerializer(CookieSerializer cookieSerializer) {
        Assert.notNull(cookieSerializer, "cookieSerializer cannot be null");
        this.cookieSerializer = cookieSerializer;
    }

    /** @deprecated */
    @Deprecated
    public void setCookieName(String cookieName) {
        DefaultCookieSerializer serializer = new DefaultCookieSerializer();
        serializer.setCookieName(cookieName);
        this.cookieSerializer = serializer;
    }

    public void setDeserializationDelimiter(String delimiter) {
        this.deserializationDelimiter = delimiter;
    }

    public void setSerializationDelimiter(String delimiter) {
        this.serializationDelimiter = delimiter;
    }

    public Map<String, String> getSessionIds(HttpServletRequest request) {
        List<String> cookieValues = this.cookieSerializer.readCookieValues(request);
        String sessionCookieValue = cookieValues.isEmpty() ? "" : (String)cookieValues.iterator().next();
        Map<String, String> result = new LinkedHashMap();
        StringTokenizer tokens = new StringTokenizer(sessionCookieValue, this.deserializationDelimiter);
        if (tokens.countTokens() == 1) {
            result.put("0", tokens.nextToken());
            return result;
        } else {
            while(tokens.hasMoreTokens()) {
                String alias = tokens.nextToken();
                if (!tokens.hasMoreTokens()) {
                    break;
                }

                String id = tokens.nextToken();
                result.put(alias, id);
            }

            return result;
        }
    }

    public HttpServletRequest wrapRequest(HttpServletRequest request, HttpServletResponse response) {
        request.setAttribute(HttpSessionManager.class.getName(), this);
        return request;
    }

    public HttpServletResponse wrapResponse(HttpServletRequest request, HttpServletResponse response) {
        return new HeaderAndCookieHttpSessionStrategy.MultiSessionHttpServletResponse(response, request);
    }

    public String encodeURL(String url, String sessionAlias) {
        String encodedSessionAlias = this.urlEncode(sessionAlias);
        int queryStart = url.indexOf("?");
        boolean isDefaultAlias = "0".equals(encodedSessionAlias);
        if (queryStart < 0) {
            return isDefaultAlias ? url : url + "?" + this.sessionParam + "=" + encodedSessionAlias;
        } else {
            String path = url.substring(0, queryStart);
            String query = url.substring(queryStart + 1, url.length());
            String replacement = isDefaultAlias ? "" : "$1" + encodedSessionAlias;
            query = query.replaceFirst("((^|&)" + this.sessionParam + "=)([^&]+)?", replacement);
            String sessionParamReplacement = String.format("%s=%s", this.sessionParam, encodedSessionAlias);
            if (!isDefaultAlias && !query.contains(sessionParamReplacement) && url.endsWith(query)) {
                if (!query.endsWith("&") && query.length() != 0) {
                    query = query + "&";
                }

                query = query + sessionParamReplacement;
            }

            return path + "?" + query;
        }
    }

    private String urlEncode(String value) {
        try {
            return URLEncoder.encode(value, "UTF-8");
        } catch (UnsupportedEncodingException var3) {
            throw new RuntimeException(var3);
        }
    }

    class MultiSessionHttpServletResponse extends HttpServletResponseWrapper {
        private final HttpServletRequest request;

        MultiSessionHttpServletResponse(HttpServletResponse response, HttpServletRequest request) {
            super(response);
            this.request = request;
        }

        private String getCurrentSessionAliasFromUrl(String url) {
            String currentSessionAliasFromUrl = null;
            int queryStart = url.indexOf("?");
            if (queryStart >= 0) {
                String query = url.substring(queryStart + 1);
                Matcher matcher = Pattern.compile(String.format("%s=([^&]+)", HeaderAndCookieHttpSessionStrategy.this.sessionParam)).matcher(query);
                if (matcher.find()) {
                    currentSessionAliasFromUrl = matcher.group(1);
                }
            }

            return currentSessionAliasFromUrl;
        }

        public String encodeRedirectURL(String url) {
            String encodedUrl = super.encodeRedirectURL(url);
            String currentSessionAliasFromUrl = this.getCurrentSessionAliasFromUrl(encodedUrl);
            String alias = currentSessionAliasFromUrl != null ? currentSessionAliasFromUrl : HeaderAndCookieHttpSessionStrategy.this.getCurrentSessionAlias(this.request);
            return HeaderAndCookieHttpSessionStrategy.this.encodeURL(encodedUrl, alias);
        }

        public String encodeURL(String url) {
            String encodedUrl = super.encodeURL(url);
            String currentSessionAliasFromUrl = this.getCurrentSessionAliasFromUrl(encodedUrl);
            String alias = currentSessionAliasFromUrl != null ? currentSessionAliasFromUrl : HeaderAndCookieHttpSessionStrategy.this.getCurrentSessionAlias(this.request);
            return HeaderAndCookieHttpSessionStrategy.this.encodeURL(encodedUrl, alias);
        }
    }


}

上述代码看似比较繁杂,但是其核心方法无非也就三个方法:

	//获取sessionID
    public String getRequestedSessionId(HttpServletRequest request) {
        //获取请求头中的session信息
        String header = request.getHeader(this.headerName);
        if(header != null && !"".equals(header)){
            return header;
        }
        //获取cookie中的session信息
        Map<String, String> sessionIds = this.getSessionIds(request);
        String sessionAlias = this.getCurrentSessionAlias(request);
        return (String)sessionIds.get(sessionAlias);
    }

	//在session新创建时执行
    public void onNewSession(Session session, HttpServletRequest request, HttpServletResponse response) {
        response.setHeader(this.headerName, session.getId());//将session信息设置到请求头中
        Set<String> sessionIdsWritten = this.getSessionIdsWritten(request);
        if (!sessionIdsWritten.contains(session.getId())) {
            sessionIdsWritten.add(session.getId());
            Map<String, String> sessionIds = this.getSessionIds(request);
            String sessionAlias = this.getCurrentSessionAlias(request);
            sessionIds.put(sessionAlias, session.getId());
            String cookieValue = this.createSessionCookieValue(sessionIds);
            this.cookieSerializer.writeCookieValue(new CookieSerializer.CookieValue(request, response, cookieValue));
        }
    }

	//在session销毁时执行
    public void onInvalidateSession(HttpServletRequest request, HttpServletResponse response) {
        response.setHeader(this.headerName, "");//将header中的session信息删除
        Map<String, String> sessionIds = this.getSessionIds(request);
        String requestedAlias = this.getCurrentSessionAlias(request);
        sessionIds.remove(requestedAlias);
        String cookieValue = this.createSessionCookieValue(sessionIds);
        this.cookieSerializer.writeCookieValue(new CookieSerializer.CookieValue(request, response, cookieValue));
    }

在这三个方法中,我的改造也很简单,只要在操作cookie前,加上操作header的代码就可以了

我使用的spring-session是基于jdbc的,还需要创建相对应的表:

CREATE TABLE SPRING_SESSION (
	SESSION_ID CHAR(36) NOT NULL,
	CREATION_TIME NUMBER(19,0) NOT NULL,
	LAST_ACCESS_TIME NUMBER(19,0) NOT NULL,
	MAX_INACTIVE_INTERVAL NUMBER(10,0) NOT NULL,
	PRINCIPAL_NAME VARCHAR2(100 CHAR),
	CONSTRAINT SPRING_SESSION_PK PRIMARY KEY (SESSION_ID)
);

CREATE INDEX SPRING_SESSION_IX1 ON SPRING_SESSION (LAST_ACCESS_TIME);
CREATE INDEX SPRING_SESSION_IX2 ON SPRING_SESSION (PRINCIPAL_NAME);

CREATE TABLE SPRING_SESSION_ATTRIBUTES (
	SESSION_ID CHAR(36) NOT NULL,
	ATTRIBUTE_NAME VARCHAR2(200 CHAR) NOT NULL,
	ATTRIBUTE_BYTES BLOB NOT NULL,
	CONSTRAINT SPRING_SESSION_ATTRIBUTES_PK PRIMARY KEY (SESSION_ID, ATTRIBUTE_NAME),
	CONSTRAINT SPRING_SESSION_ATTRIBUTES_FK FOREIGN KEY (SESSION_ID) REFERENCES SPRING_SESSION(SESSION_ID) ON DELETE CASCADE
);

CREATE INDEX SPRING_SESSION_ATTRIBUTES_IX1 ON SPRING_SESSION_ATTRIBUTES (SESSION_ID);

配置连接池:

    <!-- 配置连接池 -->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource" destroy-method="close">
        <property name="driverClass" value="${jdbc.driver}" />
        <property name="jdbcUrl" value="${jdbc.url}" />
        <property name="user" value="${jdbc.username}" />
        <property name="password" value="${jdbc.password}" />


        <!--连接池保持的最小连接数-->
        <property name="minPoolSize"><value>5</value></property>
        <!--连接池保持的最大连接数-->
        <property name="maxPoolSize"><value>100</value></property>
        <!--连接的最大空闲时间，如果超过这个时间，某个数据库连接还没有被使用，则会断开掉这个连接如果为0，则永远不会断开连接-->
        <property name="maxIdleTime"><value>1800</value></property>
        <!--当连接池中的连接耗尽的时候c3p0一次同时获取的连接数。Default: 3 -->
        <property name="acquireIncrement"><value>2</value></property>
        <!--JDBC的标准参数，用以控制数据源内加载的PreparedStatements数量-->
        <property name="maxStatements"><value>1000</value></property>
        <!--连接池初始化时创建的连接数（介于maxPoolSize和minPoolSize之间）-->
        <property name="initialPoolSize"><value>5</value></property>
        <!--每隔几秒检查所有连接池中的空闲连接-->
        <property name="idleConnectionTestPeriod"><value>300</value></property>
        <!--定义在从数据库获取新连接失败后重复尝试的次数-->
        <property name="acquireRetryAttempts"><value>30</value></property>
        <!--获取连接失败将会引起所有等待连接池来获取连接的线程抛出异常。但是数据源仍有效 保留，并在下次调用getConnection()的时候继续尝试获取连接。如果设为true，那么在尝试 获取连接失败后该数据源将申明已断开并永久关闭-->
        <property name="breakAfterAcquireFailure"><value>false</value></property>
        <!--如果为true，在连接释放的同事将校验连接的有效性。-->
        <property name="testConnectionOnCheckout"><value>true</value></property>

    </bean>

在web.xml增加spring-session相应的配置

    <filter>
        <filter-name>springSessionRepositoryFilter</filter-name>
        <filter-class>org.springframework.web.filter.DelegatingFilterProxy</filter-class>
    </filter>
    <filter-mapping>
        <filter-name>springSessionRepositoryFilter</filter-name>
        <url-pattern>/*</url-pattern>
        <dispatcher>REQUEST</dispatcher>
        <dispatcher>ERROR</dispatcher>
    </filter-mapping>

完成了上述配置之后,spring-session基本上就已经整合完成了

weixin_43789433
关注
  • 0
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
记一次springsession使用的坑，cookie策略与header策略
m0_46649280的博客
06-17 1682
公司项目前后端分离，开始的时候用的httpsession，没啥毛病，后来项目上线，服务器遭不住了，加入了集群，并用redis共享session，于是使用了springsession，此时出现了问题，set-cookie 前端死活设置不上，百度了各种方式后无果，最后找到springsession 的 header传递策略解决。 springsession 默认的cookie策略，修改header新增一个配置 //过期时间 @EnableRedisHttpSession(maxInactiveIntervalI
Springboot http session支持分布式；同时支持 cookie 和 header 传递；websocket 连接 共享 http session
chunzhenzyd的专栏
03-27 2236
这里有三个问题： 1. http session支持分布式； 2. session 同时支持 cookie 和 header 传递； 3. websocket 连接 共享 http session。 对于第一个问题，很简单： implementation 'org.springframework.boot:spring-boot-starter-data-redis' implemen...
【Spring 系列】Spring Session 深度解析
wenxueliu的博客
01-01 1438
JSR340是Java Servlet 3.1的规范提案，其中定义了大量的api，包括：servlet、servletRequest/HttpServletRequest/HttpServletRequestWrapper、servletResponse/HttpServletResponse/HttpServletResponseWrapper、Filter、Session等，是标准的web容器需要遵循的规约，如tomcat/jetty/weblogic等等。
Filter和Interceptor
西瓜游侠的博客
09-20 548
转载：https://www.zifangsky.cn/710.html 多个过滤器与多个拦截器的代码执行顺序 如果一个项目中同时有多个Filter，并且有多个Interceptor，那么它们的调用顺序是什么样的呢？ Filter1.java package com.tao.springstarter.web.filter; import org.springframework.web.fi...
springboot自定义cookieHttpSessionIdResolver
qq_41358574的博客
03-14 1026
在上面的代码中，SessionConfig 类定义了一个名为 httpSessionIdResolver 的 Spring Bean，这是我们自定义的 Session ID 解析器。HttpSessionIdResolver 可以获取该会话 ID，并将其用于各种目的，例如在集群环境中跟踪用户会话，处理会话 ID 上的安全性等。这样一来，通过配置我们的 CustomSessionIdResolver，我们已成功实现了 Spring Boot 中自定义 Session ID 的场景。
SpringSession header/cookie/attribute 存放 SessionID（死磕）
架构师尼恩
12-13 2330
SpringSession header/cookie/attribute存放 SessionID（死磕） 疯狂创客圈 Java 高并发【 亿级流量聊天室实战】实战系列 【博客园总入口 】 架构师成长+面试必备之 高并发基础书籍 【Netty Zookeeper Redis 高并发实战 】 疯狂创客圈 高并发 环境 视频，陆续上线： Windows Redis 安装（带视频） Li...
SpringSession同时支持Cookie和header策略
04-27
首先，我们来看标题提及的“SpringSession同时支持Cookie和header策略”。在Web应用中，session是用于跟踪用户状态的重要机制。传统上，session信息存储在服务器端，通过Cookie在客户端和服务端之间传递session ID。...
spring-session简介及实现原理源码分析
08-28
Spring-Session 还提供了 RESTful API，不依赖于 Cookie，并且可以通过 Header 传递 JSESSIONID。 Spring-Session 的实现原理 Spring-Session 的实现原理可以分为以下几个步骤： 1. 自定义个 Filter，实现 ...
5、redis session 实现Nginx负载均衡多ip同步1
08-08
Redis Session 实现 Nginx 负载均衡多 IP 同步 Redis Session 是一种基于 Redis 的会话管理机制，通过使用 Redis 来存储会话数据，实现了会话的持久化和共享。Nginx 负载均衡是通过使用 Nginx 服务器来实现多个...
cookie设置httpOnly和secure属性实现及问题
01-03
该文档整合了cookie的httponly和secure的简介，已经设置该属性时会遇到的问题，以及设置属性的方式
Spring Session Strategy 详解
pass
12-27 520
Spring Session Strategy 详解 https://www.jianshu.com/p/ecc39ec62340[参考] HttpSessionStrategy HttpSessionStrategy 定了三个方法如下： /** *从提供的{@link javax.servlet.http.HttpServletRequest}获取请求的会话ID。 * 例如，会话ID可能来自Cookie或请求标头。 */ String getRequestedSessionId(HttpServletRe
工作纪实_22-搭建分布式项目时使用spring-session替代token
~单人舞~的博客
01-21 710
分布式微服务`解决方案 分布式环境下，用户登录后的状态信息，一般有两种解决方案： 1.Token 步骤： 使用公钥、私钥对token进行相应的解密和加密操作，再通过网关层将用户信息通过header传递到各个服务，客户端服务接收到请求时候，解析header即可 2.服务之间的feign远程调用，通过网关层传递的请求中的header信息，解析出用户信息的同时，利用fein将用户信息透传到其他服务 2.分布式Session 单体服务下，session可以很好的帮助我们解决用户身份的会话状态问题，因为此刻我们只
header的安全配置指南
07-16 350
0x00 背景 在统计了Alexa top 100万网站的header安全分析之后（2012年11月 - 2013年3月 - 2013年11月），我们发现其实如何正确的设置一个header并不是一件容易的事情。尽管有数不胜数的网站会使用大量有关安全方面的header，但 并没有一个像样的平台能够为开发者们提供必要的信息，以辨别那些常见的错误设置。或者说，即使这些安全方面的heade...
springsession使用请求头获取sessionid，得到session对象
woshihedayu的博客
03-11 2604
如果客户端是手机app，非浏览器，就不能通过cookie来访问session对象，因此需要在登录成功后，将sessionid添加到响应数据中，下次用户访问，就在请求头当中带上sessionid，后端通过从请求头获取sessionid，得到session对象。springsecurity中的相关配置如下 @Bean public HttpSessionIdResolver sessionIdResolver(){ return new HeaderHttpSessionIdResolver("Auth
springsession自定义sessionid存放位置
java技术博客
10-17 1041
如果客户端不支持 cookie , 那么 springsession 默认配置不可以使用如果客户端是手机app，非浏览器，就不能通过 cookie 来访问 session 对象。
spring-session实现分布式session共享及自定义sessionid
热门推荐
小法的博客
02-08 1万+
spring-session实现分布式session共享及自定义sessionid
springsession源码分析四之CookieHttpSessionStrategy
jannal专栏
06-13 3223
CookieHttpSessionStrategy CookieHttpSessionStrategy 源码分析 public final class CookieHttpSessionStrategy implements MultiHttpSessionStrategy, HttpSessionManager { private static fi...
SpringBoot Redis Session Header 的身份验证
至今、的专栏
09-15 1196
背景 项目中采用前后端分离架构，正常的sessionId都是存储在cookie中；SpringBoot默认就支持。但是移动端接入时不太适用。一般的做法会使用token验证或者JWT等认证；springboot中session策略支持把sessionId从cookie获取转移到header中。 一、基于spring-session-redis的配置 引入依赖 <dependency> <groupId>org.springframework.boot&l
spring-session-data-redis自定义sessionId
最新发布
08-21
在使用spring-session-data-redis时，可以自定义sessionId生成策略。默认情况下，sessionId是使用java.util.UUID生成的随机字符串。要自定义sessionId，需要创建一个实现了`org.springframework.session.web....
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值