Linux系统Nginx+Tomcat+Codis实现session共享

最新推荐文章于 2021-01-13 16:16:21 发布
最新推荐文章于 2021-01-13 16:16:21 发布
阅读量190 收藏
点赞数
文章标签： 运维 数据库 java
原文链接：https://my.oschina.net/Listening/blog/675678
版权

2019独角兽企业重金招聘Python工程师标准>>> hot3.png

用户：root

Tomcat版本：apache-tomcat-7.0.52

接上篇，本篇是将单机Redis替换为Codis集群实现session共享。

请先配置Codis集群，可参考Linux系统Codis集群安装配置。

修改Redis源码

  • 修改源码使用Eclipse+Maven
  • pom依赖
  • <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/maven-v4_0_0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>listen</groupId>
  <artifactId>com.listen.org</artifactId>
  <packaging>war</packaging>
  <version>0.0.1-SNAPSHOT</version>
  <name>com.listen.org Maven Webapp</name>
  <url>http://maven.apache.org</url>
  <dependencies>
<!--     <dependency> -->
<!--     	<groupId>org.apache.httpcomponents</groupId> -->
<!--     	<artifactId>httpclient</artifactId> -->
<!--     	<version>4.3.1</version> -->
<!--     </dependency> -->
<!--     <dependency> -->
<!-- 		<groupId>redis.clients</groupId> -->
<!-- 		<artifactId>jedis</artifactId> -->
<!-- 		<version>2.8.0</version> -->
<!-- 	</dependency> -->
<!-- 	<dependency> -->
<!-- 		<groupId>junit</groupId> -->
<!-- 		<artifactId>junit</artifactId> -->
<!-- 		<version>4.12</version> -->
<!-- 	</dependency> -->
	<dependency>
	  <groupId>io.codis.jodis</groupId>
	  <artifactId>jodis</artifactId>
	  <version>0.3.0</version>
	</dependency>
	<dependency>
		<groupId>org.apache.curator</groupId>
		<artifactId>curator-framework</artifactId>
		<version>3.1.0</version>
	</dependency>
  </dependencies>
  <build>
    <finalName>com.listen.org</finalName>
  </build>
</project>
  • 第三方依赖，由于修改源码需要gradle编译生成的jar包作为依赖包且这些jar包无法使用pom依赖的方式添加到工程中，所以只能将dist目录下的所有jar包以referenced的方式添加到工程中，且无法使用Maven的install生成class文件，所以只能写一个main方式，运行，以实现class文件的生成，如下图
  • 132240_qswy_39617.png

  •  编辑源码，并编译

  • package com.orangefunction.tomcat.redissessions;

import io.codis.jodis.JedisResourcePool;
import io.codis.jodis.RoundRobinJedisPool;

import java.io.IOException;
import java.util.Arrays;
import java.util.EnumSet;
import java.util.Enumeration;
import java.util.Iterator;
import java.util.Set;

import org.apache.catalina.Lifecycle;
import org.apache.catalina.LifecycleException;
import org.apache.catalina.LifecycleListener;
import org.apache.catalina.LifecycleState;
import org.apache.catalina.Loader;
import org.apache.catalina.Session;
import org.apache.catalina.Valve;
import org.apache.catalina.session.ManagerBase;
import org.apache.catalina.util.LifecycleSupport;
import org.apache.juli.logging.Log;
import org.apache.juli.logging.LogFactory;

import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPoolConfig;
import redis.clients.jedis.Protocol;


public class RedisSessionManager extends ManagerBase implements Lifecycle {
	
	public static void main(String[] a){
		System.out.println("aaa");
	}

  enum SessionPersistPolicy {
    DEFAULT,
    SAVE_ON_CHANGE,
    ALWAYS_SAVE_AFTER_REQUEST;

    static SessionPersistPolicy fromName(String name) {
      for (SessionPersistPolicy policy : SessionPersistPolicy.values()) {
        if (policy.name().equalsIgnoreCase(name)) {
          return policy;
        }
      }
      throw new IllegalArgumentException("Invalid session persist policy [" + name + "]. Must be one of " + Arrays.asList(SessionPersistPolicy.values())+ ".");
    }
  }

  protected byte[] NULL_SESSION = "null".getBytes();

  private final Log log = LogFactory.getLog(RedisSessionManager.class);

  protected int timeout = Protocol.DEFAULT_TIMEOUT;

  protected RedisSessionHandlerValve handlerValve;
  protected ThreadLocal<RedisSession> currentSession = new ThreadLocal<>();
  protected ThreadLocal<SessionSerializationMetadata> currentSessionSerializationMetadata = new ThreadLocal<>();
  protected ThreadLocal<String> currentSessionId = new ThreadLocal<>();
  protected ThreadLocal<Boolean> currentSessionIsPersisted = new ThreadLocal<>();
  protected Serializer serializer;

  protected static String name = "RedisSessionManager";

  protected String serializationStrategyClass = "com.orangefunction.tomcat.redissessions.JavaSerializer";

  protected EnumSet<SessionPersistPolicy> sessionPersistPoliciesSet = EnumSet.of(SessionPersistPolicy.DEFAULT);

  /**
   * The lifecycle event support for this component.
   */
  protected LifecycleSupport lifecycle = new LifecycleSupport(this);


  public int getTimeout() {
    return timeout;
  }

  public void setTimeout(int timeout) {
    this.timeout = timeout;
  }

  public void setSerializationStrategyClass(String strategy) {
    this.serializationStrategyClass = strategy;
  }

  public String getSessionPersistPolicies() {
    StringBuilder policies = new StringBuilder();
    for (Iterator<SessionPersistPolicy> iter = this.sessionPersistPoliciesSet.iterator(); iter.hasNext();) {
      SessionPersistPolicy policy = iter.next();
      policies.append(policy.name());
      if (iter.hasNext()) {
        policies.append(",");
      }
    }
    return policies.toString();
  }

  public void setSessionPersistPolicies(String sessionPersistPolicies) {
    String[] policyArray = sessionPersistPolicies.split(",");
    EnumSet<SessionPersistPolicy> policySet = EnumSet.of(SessionPersistPolicy.DEFAULT);
    for (String policyName : policyArray) {
      SessionPersistPolicy policy = SessionPersistPolicy.fromName(policyName);
      policySet.add(policy);
    }
    this.sessionPersistPoliciesSet = policySet;
  }

  public boolean getSaveOnChange() {
    return this.sessionPersistPoliciesSet.contains(SessionPersistPolicy.SAVE_ON_CHANGE);
  }

  public boolean getAlwaysSaveAfterRequest() {
    return this.sessionPersistPoliciesSet.contains(SessionPersistPolicy.ALWAYS_SAVE_AFTER_REQUEST);
  }

  protected Jedis acquireConnection() {
//    Jedis jedis = connectionPool.getResource();
	  JedisPoolConfig poolConfig = new JedisPoolConfig();
		poolConfig.setMaxTotal(4096);
		poolConfig.setMaxIdle(200);
		poolConfig.setMaxWaitMillis(3000);
		poolConfig.setTestOnBorrow(true);
		poolConfig.setTestOnReturn(true);
		poolConfig.setMinIdle(20);
		JedisResourcePool jedisPool = RoundRobinJedisPool.create()
				.curatorClient("192.168.75.141:2181,192.168.75.141:2182,192.168.75.141:2183,192.168.75.141:2184,192.168.75.141:2185", 60000)
				.zkProxyDir("/zk/codis/db_codis/proxy").poolConfig(poolConfig).build();
		Jedis jedis = jedisPool.getResource();
		log.info("current jedis:" + jedisToString(jedis));
		System.out.println("current jedis:" + jedisToString(jedis));
    return jedis;
  }
  
  private String jedisToString(Jedis jedis){
	  StringBuffer sb = new StringBuffer();
	  try{
		  if(jedis != null){
			  sb.append(jedis.info());
		  }
	  }
	  catch (Exception e){
		  e.printStackTrace();
	  }
	  return sb.toString();
  }

  /**
   * Add a lifecycle event listener to this component.
   *
   * @param listener The listener to add
   */
  @Override
  public void addLifecycleListener(LifecycleListener listener) {
    lifecycle.addLifecycleListener(listener);
  }

  /**
   * Get the lifecycle listeners associated with this lifecycle. If this
   * Lifecycle has no listeners registered, a zero-length array is returned.
   */
  @Override
  public LifecycleListener[] findLifecycleListeners() {
    return lifecycle.findLifecycleListeners();
  }


  /**
   * Remove a lifecycle event listener from this component.
   *
   * @param listener The listener to remove
   */
  @Override
  public void removeLifecycleListener(LifecycleListener listener) {
    lifecycle.removeLifecycleListener(listener);
  }

  /**
   * Start this component and implement the requirements
   * of {@link org.apache.catalina.util.LifecycleBase#startInternal()}.
   *
   * @exception LifecycleException if this component detects a fatal error
   *  that prevents this component from being used
   */
  @Override
  protected synchronized void startInternal() throws LifecycleException {
    super.startInternal();

    setState(LifecycleState.STARTING);

    Boolean attachedToValve = false;
    for (Valve valve : getContainer().getPipeline().getValves()) {
      if (valve instanceof RedisSessionHandlerValve) {
        this.handlerValve = (RedisSessionHandlerValve) valve;
        this.handlerValve.setRedisSessionManager(this);
        log.info("Attached to RedisSessionHandlerValve");
        attachedToValve = true;
        break;
      }
    }

    if (!attachedToValve) {
      String error = "Unable to attach to session handling valve; sessions cannot be saved after the request without the valve starting properly.";
      log.fatal(error);
      throw new LifecycleException(error);
    }

    try {
      initializeSerializer();
    } catch (ClassNotFoundException | InstantiationException | IllegalAccessException e) {
      log.fatal("Unable to load serializer", e);
      throw new LifecycleException(e);
    }

    log.info("Will expire sessions after " + getMaxInactiveInterval() + " seconds");

    setDistributable(true);
  }


  /**
   * Stop this component and implement the requirements
   * of {@link org.apache.catalina.util.LifecycleBase#stopInternal()}.
   *
   * @exception LifecycleException if this component detects a fatal error
   *  that prevents this component from being used
   */
  @Override
  protected synchronized void stopInternal() throws LifecycleException {
    if (log.isDebugEnabled()) {
      log.debug("Stopping");
    }

    setState(LifecycleState.STOPPING);

    // Require a new random number generator if we are restarted
    super.stopInternal();
  }

  @Override
  public Session createSession(String requestedSessionId) {
    RedisSession session = null;
    String sessionId = null;
    String jvmRoute = getJvmRoute();

    Boolean error = true;
    Jedis jedis = null;
    try {
      jedis = acquireConnection();

      // Ensure generation of a unique session identifier.
      if (null != requestedSessionId) {
        sessionId = sessionIdWithJvmRoute(requestedSessionId, jvmRoute);
        if (jedis.setnx(sessionId.getBytes(), NULL_SESSION) == 0L) {
          sessionId = null;
        }
      } else {
        do {
          sessionId = sessionIdWithJvmRoute(generateSessionId(), jvmRoute);
        } while (jedis.setnx(sessionId.getBytes(), NULL_SESSION) == 0L); // 1 = key set; 0 = key already existed
      }

      /* Even though the key is set in Redis, we are not going to flag
         the current thread as having had the session persisted since
         the session isn't actually serialized to Redis yet.
         This ensures that the save(session) at the end of the request
         will serialize the session into Redis with 'set' instead of 'setnx'. */

      error = false;

      if (null != sessionId) {
        session = (RedisSession)createEmptySession();
        session.setNew(true);
        session.setValid(true);
        session.setCreationTime(System.currentTimeMillis());
        session.setMaxInactiveInterval(getMaxInactiveInterval());
        session.setId(sessionId);
        session.tellNew();
      }

      currentSession.set(session);
      currentSessionId.set(sessionId);
      currentSessionIsPersisted.set(false);
      currentSessionSerializationMetadata.set(new SessionSerializationMetadata());

      if (null != session) {
        try {
          error = saveInternal(jedis, session, true);
        } catch (IOException ex) {
          log.error("Error saving newly created session: " + ex.getMessage());
          currentSession.set(null);
          currentSessionId.set(null);
          session = null;
        }
      }
    } finally {
      if (jedis != null) {
      }
    }

    return session;
  }

  private String sessionIdWithJvmRoute(String sessionId, String jvmRoute) {
    if (jvmRoute != null) {
      String jvmRoutePrefix = '.' + jvmRoute;
      return sessionId.endsWith(jvmRoutePrefix) ? sessionId : sessionId + jvmRoutePrefix;
    }
    return sessionId;
  }

  @Override
  public Session createEmptySession() {
    return new RedisSession(this);
  }

  @Override
  public void add(Session session) {
    try {
      save(session);
    } catch (IOException ex) {
      log.warn("Unable to add to session manager store: " + ex.getMessage());
      throw new RuntimeException("Unable to add to session manager store.", ex);
    }
  }

  @Override
  public Session findSession(String id) throws IOException {
    RedisSession session = null;

    if (null == id) {
      currentSessionIsPersisted.set(false);
      currentSession.set(null);
      currentSessionSerializationMetadata.set(null);
      currentSessionId.set(null);
    } else if (id.equals(currentSessionId.get())) {
      session = currentSession.get();
    } else {
      byte[] data = loadSessionDataFromRedis(id);
      if (data != null) {
        DeserializedSessionContainer container = sessionFromSerializedData(id, data);
        session = container.session;
        currentSession.set(session);
        currentSessionSerializationMetadata.set(container.metadata);
        currentSessionIsPersisted.set(true);
        currentSessionId.set(id);
      } else {
        currentSessionIsPersisted.set(false);
        currentSession.set(null);
        currentSessionSerializationMetadata.set(null);
        currentSessionId.set(null);
      }
    }

    return session;
  }

  public void clear() {
    Jedis jedis = null;
    Boolean error = true;
    try {
      jedis = acquireConnection();
      jedis.flushDB();
      error = false;
    } finally {
      if (jedis != null) {
      }
    }
  }

  public int getSize() throws IOException {
    Jedis jedis = null;
    Boolean error = true;
    try {
      jedis = acquireConnection();
      int size = jedis.dbSize().intValue();
      error = false;
      return size;
    } finally {
      if (jedis != null) {
      }
    }
  }

  public String[] keys() throws IOException {
    Jedis jedis = null;
    Boolean error = true;
    try {
      jedis = acquireConnection();
      Set<String> keySet = jedis.keys("*");
      error = false;
      return keySet.toArray(new String[keySet.size()]);
    } finally {
      if (jedis != null) {
      }
    }
  }

  public byte[] loadSessionDataFromRedis(String id) throws IOException {
    Jedis jedis = null;
    Boolean error = true;

    try {
      log.trace("Attempting to load session " + id + " from Redis");

      jedis = acquireConnection();
      byte[] data = jedis.get(id.getBytes());
      error = false;

      if (data == null) {
        log.trace("Session " + id + " not found in Redis");
      }

      return data;
    } finally {
      if (jedis != null) {
      }
    }
  }

  public DeserializedSessionContainer sessionFromSerializedData(String id, byte[] data) throws IOException {
    log.trace("Deserializing session " + id + " from Redis");

    if (Arrays.equals(NULL_SESSION, data)) {
      log.error("Encountered serialized session " + id + " with data equal to NULL_SESSION. This is a bug.");
      throw new IOException("Serialized session data was equal to NULL_SESSION");
    }

    RedisSession session = null;
    SessionSerializationMetadata metadata = new SessionSerializationMetadata();

    try {
      session = (RedisSession)createEmptySession();

      serializer.deserializeInto(data, session, metadata);

      session.setId(id);
      session.setNew(false);
      session.setMaxInactiveInterval(getMaxInactiveInterval());
      session.access();
      session.setValid(true);
      session.resetDirtyTracking();

      if (log.isTraceEnabled()) {
        log.trace("Session Contents [" + id + "]:");
        Enumeration en = session.getAttributeNames();
        while(en.hasMoreElements()) {
          log.trace("  " + en.nextElement());
        }
      }
    } catch (ClassNotFoundException ex) {
      log.fatal("Unable to deserialize into session", ex);
      throw new IOException("Unable to deserialize into session", ex);
    }

    return new DeserializedSessionContainer(session, metadata);
  }

  public void save(Session session) throws IOException {
    save(session, false);
  }

  public void save(Session session, boolean forceSave) throws IOException {
    Jedis jedis = null;
    Boolean error = true;

    try {
      jedis = acquireConnection();
      error = saveInternal(jedis, session, forceSave);
    } catch (IOException e) {
      throw e;
    } finally {
      if (jedis != null) {
      }
    }
  }

  protected boolean saveInternal(Jedis jedis, Session session, boolean forceSave) throws IOException {
    Boolean error = true;

    try {
      log.trace("Saving session " + session + " into Redis");

      RedisSession redisSession = (RedisSession)session;

      if (log.isTraceEnabled()) {
        log.trace("Session Contents [" + redisSession.getId() + "]:");
        Enumeration en = redisSession.getAttributeNames();
        while(en.hasMoreElements()) {
          log.trace("  " + en.nextElement());
        }
      }

      byte[] binaryId = redisSession.getId().getBytes();

      Boolean isCurrentSessionPersisted;
      SessionSerializationMetadata sessionSerializationMetadata = currentSessionSerializationMetadata.get();
      byte[] originalSessionAttributesHash = sessionSerializationMetadata.getSessionAttributesHash();
      byte[] sessionAttributesHash = null;
      if (
           forceSave
           || redisSession.isDirty()
           || null == (isCurrentSessionPersisted = this.currentSessionIsPersisted.get())
            || !isCurrentSessionPersisted
           || !Arrays.equals(originalSessionAttributesHash, (sessionAttributesHash = serializer.attributesHashFrom(redisSession)))
         ) {

        log.trace("Save was determined to be necessary");

        if (null == sessionAttributesHash) {
          sessionAttributesHash = serializer.attributesHashFrom(redisSession);
        }

        SessionSerializationMetadata updatedSerializationMetadata = new SessionSerializationMetadata();
        updatedSerializationMetadata.setSessionAttributesHash(sessionAttributesHash);
        log.info("current jedis:" + jedisToString(jedis));
		System.out.println("current jedis:" + jedisToString(jedis));
        jedis.set(binaryId, serializer.serializeFrom(redisSession, updatedSerializationMetadata));

        redisSession.resetDirtyTracking();
        currentSessionSerializationMetadata.set(updatedSerializationMetadata);
        currentSessionIsPersisted.set(true);
      } else {
        log.trace("Save was determined to be unnecessary");
      }

      log.trace("Setting expire timeout on session [" + redisSession.getId() + "] to " + getMaxInactiveInterval());
      jedis.expire(binaryId, getMaxInactiveInterval());

      error = false;

      return error;
    } catch (IOException e) {
      log.error(e.getMessage());

      throw e;
    } finally {
      return error;
    }
  }

  @Override
  public void remove(Session session) {
    remove(session, false);
  }

  @Override
  public void remove(Session session, boolean update) {
    Jedis jedis = null;
    Boolean error = true;

    log.trace("Removing session ID : " + session.getId());

    try {
      jedis = acquireConnection();
      jedis.del(session.getId());
      error = false;
    } finally {
      if (jedis != null) {
      }
    }
  }

  public void afterRequest() {
    RedisSession redisSession = currentSession.get();
    if (redisSession != null) {
      try {
        if (redisSession.isValid()) {
          log.trace("Request with session completed, saving session " + redisSession.getId());
          save(redisSession, getAlwaysSaveAfterRequest());
        } else {
          log.trace("HTTP Session has been invalidated, removing :" + redisSession.getId());
          remove(redisSession);
        }
      } catch (Exception e) {
        log.error("Error storing/removing session", e);
      } finally {
        currentSession.remove();
        currentSessionId.remove();
        currentSessionIsPersisted.remove();
        log.trace("Session removed from ThreadLocal :" + redisSession.getIdInternal());
      }
    }
  }

  @Override
  public void processExpires() {
    // We are going to use Redis's ability to expire keys for session expiration.

    // Do nothing.
  }


  private void initializeSerializer() throws ClassNotFoundException, IllegalAccessException, InstantiationException {
    log.info("Attempting to use serializer :" + serializationStrategyClass);
    serializer = (Serializer) Class.forName(serializationStrategyClass).newInstance();

    Loader loader = null;

    if (getContainer() != null) {
      loader = getContainer().getLoader();
    }

    ClassLoader classLoader = null;

    if (loader != null) {
      classLoader = loader.getClassLoader();
    }
    serializer.setClassLoader(classLoader);
  }

@Override
public void load() throws ClassNotFoundException, IOException {
}

@Override
public void unload() throws IOException {
}


  // Connection Pool Config Accessors

  // - from org.apache.commons.pool2.impl.GenericObjectPoolConfig
}

class DeserializedSessionContainer {
  public final RedisSession session;
  public final SessionSerializationMetadata metadata;
  public DeserializedSessionContainer(RedisSession session, SessionSerializationMetadata metadata) {
    this.session = session;
    this.metadata = metadata;
  }
}

    替换编译后的class字节码文件

  • 将编译后的class文件替换到tomcat-redis-session-manager-master-2.0.0.jar中，是有两个class文件

  • 132546_7fSN_39617.png

  • 替换覆盖jar包

  • 将替换后的tomcat-redis-session-manager-master-2.0.0.jar包覆盖到{tomat_home}/libs中（2个tomcat都要替换）
  • 修改tomcat配置文件content.xml
  • <?xml version='1.0' encoding='utf-8'?>
<!--
  Licensed to the Apache Software Foundation (ASF) under one or more
  contributor license agreements.  See the NOTICE file distributed with
  this work for additional information regarding copyright ownership.
  The ASF licenses this file to You under the Apache License, Version 2.0
  (the "License"); you may not use this file except in compliance with
  the License.  You may obtain a copy of the License at

      http://www.apache.org/licenses/LICENSE-2.0

  Unless required by applicable law or agreed to in writing, software
  distributed under the License is distributed on an "AS IS" BASIS,
  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  See the License for the specific language governing permissions and
  limitations under the License.
-->
<!-- The contents of this file will be loaded for each web application -->
<Context>

    <!-- Default set of monitored resources -->
    <WatchedResource>WEB-INF/web.xml</WatchedResource>

    <!-- Uncomment this to disable session persistence across Tomcat restarts -->
    <!--
    <Manager pathname="" />
    -->

    <!-- Uncomment this to enable Comet connection tacking (provides events
         on session expiration as well as webapp lifecycle) -->
    <!--
    <Valve className="org.apache.catalina.valves.CometConnectionManagerValve" />
    -->

<!--以下为增加的内容-->
<Valve className="com.orangefunction.tomcat.redissessions.RedisSessionHandlerValve" />  
<Manager className="com.orangefunction.tomcat.redissessions.RedisSessionManager"  
         
         maxInactiveInterval="60" />  

</Context>

  • 测试

  • 先启动Codis集群，集群的启动方法可参考Linux系统Codis集群安装配置 。然后重启两个tomcat，别忘了启动Nginx。
  • 测试session共享，先使用Redis客户端连接到Codis集群，查询sessionId是保存在哪台master上的，然后主从切换对应的master，查看session页面是否还能正常显示，结果是可以正常显示。
  • 总结：修改源码其实就是修改Redis连接的获取方式，将之前的单机连接修改为集群获取连接的方式，其他没有改变。

转载于:https://my.oschina.net/Listening/blog/675678

weixin_34000916
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
基于redis的集群session共享jar包
06-16
基于redis的集群session共享jar包
tomcat+redis实现session共享配置之路 支持Tomcat 8
能量守恒洛的专栏
11-22 4342
1、网上查找资料，大部分从下面网址下载java代码，因是几年前实现的（大概2,3年前吧），不支持tomcat8  https://github.com/jcoleman/tomcat-redis-session-manager 2、在myeclipse 新建一个maven项目【maven-archetype-quickstart】  源文件新建包名com.orangefunction.t
windows+nginx+tomcat实现集群负载均衡（生产环境必读）
weixin_34235457的博客
08-17 174
概念理解（原文链接） 　　集群：多个tomcat服务器运行同一个web服务就能称之为集群 　　负载均衡：apache按照一定方式将不同的客户端访问分配到不同的tomcat服务器 简单负载均衡实现： 网上参考了好多文章，都写的不全，拿来直接用时存在这样或那样的问题，花了好长时间摸索细致整理了一下希望能帮助像我这样的新手 集群搭建： tomcat复制改8080端口为8081,800...
tomcat-redis-session-manager源码修改之tomcat9支持
博客简介
01-13 1273
几年前用的tomcat8，当时只修改了两行代码就搞定。换到了tomcat9，改动还是比较大的，LifecycleSupport类、getMaxInactiveInterval等方法被移除...... 硬着头皮修改了一波源码，勉强在tomcat9上跑起来了，session也能正常共享，不知道有没有坑，让我们拭目以待。 RedisSessionManager.java package com.orangefunction.tomcat.redissessions; import java.io.IO.
Nginx+Tomcat负载平衡，Redis管理session存储
a64540339的专栏
11-17 383
本文的环境：               1.CentOs6.4 minimal               2.jdk1.7.0_71               3.Tomcat7.0.65               4.Nginx1.8               5.Redis3.0.5               6.vm11 环境配置不多说了，假设环境都已经装好。我...
nginx+tomcat+redis完成session共享
08-31
这个小例子"nginx+tomcat+redis完成session共享"旨在演示如何通过这三种技术实现跨服务器的用户会话共享，以提升用户体验并简化系统管理。以下是这些技术及其在会话共享中的作用： 1. **Nginx**：Nginx是一款高性能...
nginx+tomcat集群+redis实现session共享
12-15
目前只支持tomcat8.5，其它版本的tomcat还没测试，自己配置过很多nginx+tomcat集群+redis实现session共享的系统，经过仔细总结得出这些，可以说是知识的结晶，欢迎大家来下载，不好的地方可以多提，有问题看到的话会...
nginx+Redis+tomcat实现session共享jar
01-30
包含的jar包如下： commons-pool2-2.0.jar jedis-2.5.2.jar tomcat-juli-adapters.jar tomcat-juli.jar tomcat-redis-session-manager1.2.jar
Nginx+tomcat 实现负载均衡session共享demo
01-05
本教程将详细讲解如何通过`Nginx`实现`Tomcat`集群的负载均衡，并实现`session`共享。 首先，我们要理解负载均衡的基本概念。负载均衡是通过将工作负载分散到多个计算资源，以优化资源使用、最大化吞吐量、最小化...
nginx+tomcat集群+memcached实现session共享（适用tc7、tc8）
09-01
兼容Tomcat7 与tomcat8 +memcached做session共享 ， 解决了tomcat7与Tomcat8的 java.lang.NoSuchFieldError: attributes 错误。
CentOS7下Nginx+Tomcat负载均衡及Redis共享Session解决方案
07-31
CentOS7下Nginx+Tomcat负载均衡及Redis共享Session解决方案
彻底解决Tomcat7+JDK7+redis session共享问题
11-14
我上一个就别下载了，不能用我也删不掉，这个完全没问题，亲测，不明白的可以加我微信：740949744
tomcat共享session tomcat-redis-session-manager-2.0.0.jar包下载
07-23
tomcat-redis-session-manager-2.0.0.jar包，不用自己打包了，tomcat共享session到redis中，解决分布式应用的状态问题。
Nginx集群配置与redis的session共享策略
李章勇的博客
01-28 391
Nginx集群配置与redis的session共享策略 　　一.什么是Nginx？ 　　Nginx (engine x) 是一个高性能的HTTP和反向代理服务器，也是一个IMAP/POP3/SMTP服务器。Nginx是由伊戈尔·赛索耶夫为俄罗斯访问量第二的Rambler.ru站点（俄文：Рамблер）开发的，第一个公开版本0.1.0发布于2004...
配置FindBugs和常见FindBugs错误
weixin_30354675的博客
07-26 1108
配置FindBugs: 在这里可以对FindBugs规则等进行详细设置。 　　选择你的项目，右键 => Properties => FindBugs => 1 Run Automatically开关 当此项选中后，FindBugs将会在你修改Java类时自动运行，如你设置了Eclipse自动编译开关后，当你修改完Java文件保存，FindBugs就会运行，并将相...
session失效的原因以及从session中取到的对象为null
monkeylvjava
02-14 8880
待完成
我的tomcat+redis实现session共享配置之路
热门推荐
Hokuto·Liu
07-21 1万+
tomcat集群通过redis实现session共享
nginx +redis+tomcat实现session共享
最新发布
08-09
要实现nginx、redis和tomcat的session共享，可以采用以下步骤： 1. 首先，配置nginx反向代理服务器，将客户端的请求分发给多个tomcat服务器。 2. 在tomcat服务器上，需要进行一些配置来将session数据存储到redis中。可以使用Tomcat的RedisSessionManager插件来实现这一功能。需要将该插件的jar包放置在tomcat的lib目录下，并修改tomcat的server.xml文件，配置Redis资源和RedisSessionManager。 3. 在nginx服务器上，需要进行一些配置来将session请求转发到tomcat服务器。可以使用Nginx的HttpUpstreamModule模块来实现负载均衡和转发功能。需要在nginx.conf配置文件中定义upstream和server部分，指定tomcat服务器的地址和端口。 4. 在应用代码中，需要将session数据存储到redis中。可以使用Servlet的HttpSession接口提供的方法来实现。在创建session时，将session的存储方式设置为redis，使得session数据存储到redis中。 通过以上步骤的配置和代码修改，就可以实现nginx、redis和tomcat的session共享。当客户端发送请求时，nginx会根据负载均衡策略将请求转发给tomcat服务器。Tomcat服务器将session数据存储到redis中，实现了多个tomcat服务器之间的session共享。这样就可以在集群环境中实现session的统一管理和共享，提高了系统的可扩展性和性能。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值