websession共享_web集群怎麼共享同步sessionWindows伺服器操作系統

『壹』在JAVA WEB中,不同的客戶端可以共用一個session嗎為什麼

不歷枯可以，每一個新的瀏覽器連接上伺服器後就是一個新的session。每一個瀏覽器連接到伺服器後，實際上都表示各自的session，表示每一位不同的上網者都有各自的屬性，所以新的肢歷洞瀏覽器打開後無法取得其他session設置爛鏈的屬性。

『貳』如何在多台web伺服器上共享session

放倒專門的session服凳掘悉務器里管理散純session
如果是棗乎.net開發的，可以通過web.config配置到外邊共同的一台session伺服器上

『叄』如何在多台web伺服器上共享session

要解決多台web伺服器共享session的問題，至少有以下三種方法：
一、將本該保存在web伺服器磁碟上的session數據保存到cookie中
二、將本該保存在web伺服器磁碟上的session數據保存到MySQL資料庫中
三、將本該保存在web伺服器磁碟上的session數據保存到內存資料庫（memcache或redis）中

『肆』如何實現不同應用之間session共享

實現同一Tomcat下兩個WEB應用之穗族橋間通過session 共享數據。

查看tomcat 關於 HTTP Connector 中有個emptySessionPath 其解釋如下：

If set to true, all paths for session cookies will be set to /. This can be useful for portlet specification implementations. If not specified, this attribute is set to false.
A side effect to setting this to true, is that if Tomcat creates a new session it will attempt to use the cookie session id if supplied by the client.

設置為true 發現沒有用，在網上搜了一下方法，基本是這樣的：

由於每個WEB應用程序都有一個唯一的一個ServletContext 實例對象，自己下面的所有的servlet 共享此ServletContext，利用ServletContext 中的setAttribute() 方法把Session 傳遞過去，然後在另外一個WEB程序中拿到session實例。

1、修改Tomcat---conf----server.xml文件
把
<Host appBase="webapps" autoDeploy="true" name="localhost" unpackWARs="true" xmlNamespaceAware="穗仿false" xmlValidation="false"猜猛></Host>
修改為：
<Host appBase="webapps" autoDeploy="true" name="localhost" unpackWARs="true" xmlNamespaceAware="false" xmlValidation="false">
<Context path="/Project_A" reloadable="false" crossContext="true"></Context>
<Context path="/Project_B" reloadable="false" crossContext="true"></Context>
</Host>

注意 crossContext 屬性：
crossContext： Set to true if you want calls within this application to ServletContext.getContext() to successfully return a request dispatcher for other web applications running on this virtual host. Set to false (the default) in security conscious environments, to make getContext() always return null.
設置為true，說明你可以調用另外一個WEB應用程序，通過ServletContext.getContext() 獲得ServletContext 然後再調用其getAttribute() 得到你要的對象。

2、在 Project_A 中，寫入以下代碼：

//以下內容用於測試同一tomcat下不同項目之間共享session
HttpSession session = req.getSession();
session.setAttribute("name", "testuser");
session.setMaxInactiveInterval(1800);
ServletContext ContextA =req.getSession().getServletContext();
ContextA.setAttribute("session", req.getSession());
//測試
out.println("IN SessionRangleServlet name : "+session.getAttribute("name"));

3、在 Project_B 中，寫入以下代碼取出Session

HttpSession session1 = req .getSession();
ServletContext Context = session1.getServletContext();
// 這裡面傳遞的是 Project_A 的虛擬路徑
ServletContext Context1= Context.getContext("/Project_A");
System.out.println(Context1);
HttpSession session2 =(HttpSession)Context1.getAttribute("session");
System.out.println("base傳過來的user為:"+session2.getAttribute("name"));

然後重新部署。

Tomcat下配置Session Cookie位置

最近部署一個Java應用的時候要求Session Cookie位置為根目錄「/」而不是 /context。在配置Tomcat的時候碰到了一些問題，把我的解決過程寫下來，希望給碰到同樣問題的朋友一些幫助。

很多時候我們要求 Session Cookie的位置在根目錄「/」這樣多個應用可以互相交互。Tomcat的默認設置Session Cookie是在 /context 下。

在Tomcat 6 下，修改非常簡單，只要在Connector 下增加 emptySessionPath="true" 屬性就能解決了。可是到了Tomcat 7 ，這個配置不起作用了。

於是查了 Servlet 3.0 spec，發現Servlet 3.0 是允許 per-context basis 配置的，那麼沒有理由Tomcat 7 不支持啊。

後來仔細研究了一下 Tomcat 7 的配置，原來Tomcat 7 把這個配置單獨出來了，由一個sessionCookiePath屬性了。

<Context ... sessionCookiePath="/" > ... </Context>

最後試驗了一下，一切OK。

你來我們群里說吧

這里是開發者互相學習交流的

有大神

讓他們給你解釋你的疑問 q un號: 188 168040

『伍』在每次訪問web應用的時候都會創建一個session。怎樣能實現session的單例。

Session不可能單例。如果使用單例的話就意味著整個應用程序的所有用戶共享同個Session (全局)。而session主要的作用是為每個登錄用戶創建一個會話。這於session的作用相違背
如何lz想要保存全局的數據的話，可以使用Application對象。

『陸』 websphere8.5.5 session共享的配置問題

需要配置，在應用伺服器裡面選擇襲檔襪部署war包的server，右側點擊會話管理-》分布式設置-》分布式會話裡面選擇內存到蠢拿內存拍激，就可以了

『柒』 C# webbrowser控制項 2個窗體2個webbrowser 如何共享SESSION

webBrowser2.DocumentStream = webBrowser1.DocumentStream;
webBrowser2.Document.Cookie = webBrowser1.Document.Cookie;
webBrowser2.Url = webBrowser1.Url;
這樣做就神敬桐稿純可以了，我用163郵游坦箱做了測試，可行的。

『捌』 web集群怎麼共享同步sessionWindows伺服器操作系統

首先向memcached中添加「tokyo」。將「tokyo」傳給客戶端程序庫後，客戶端實現的演算法就會根據「鍵」來決定保存數據的memcached伺服器。伺服器選定後，即命令它保存「tokyo」及其值。

圖2 分布式簡介：添加時
同樣，「kanagawa」「chiba」「saitama」「gunma」都是先選擇伺服器再保存。接下來獲取保存的數據。獲取時也要將要獲取的鍵「tokyo」傳遞給函數庫。函數庫通過與數據保存時相同的演算法，根據「鍵」選擇伺服器。使用的演算法相同，就能選中與保存時相同的伺服器，然後發送get命令。只要數據沒有因為某些原因被刪除，就能獲得保存的值。

圖3 分布式簡介：獲取時
這樣，將不同的鍵保存到不同的伺服器上，就實現了memcached的分布式。 memcached伺服器增多後，鍵就會分散，即使一台memcached伺服器發生故障無法連接，也不會影響其他的緩存，系統依然能繼續運行。
Php+memcache實現分布式：

『玖』兩個在不同機器上的tomcat，分別有兩個不同的java web項目，怎麼實現兩個項目的session共享

單點登錄，集群

『拾』 shirocas怎麼做session共享redis tomcat

第一步：配置WEB.XML
<filter>
<filter-name>shiroFilter</filter-name>
<filter-class>org.springframework.web.filter.DelegatingFilterProxy</filter-class>
<init-param>
<param-name>targetFilterLifecycle<磨嘩/param-name>
<param-value>true</param-value>
</init-param>
</filter>
<filter-mapping>
<filter-name>shiroFilter</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
第二步：SHIRO整合SPRING配置
applicationContext-shiro.xml 偽代碼：


<bean id="sessionManager" class="org.apache.shiro.web.session.mgt.DefaultWebSessionManager">
<property name="globalSessionTimeout" value="3600000"/>
<property name="sessionDAO" ref="zkShiroSessionDAO"/>
<property name="sessionValidationScheler" ref="sessionValidationScheler"/>
<property name="" value="true"/>
<property name="sessionIdCookie" ref="wapsession"/>
</bean>


<bean id="wapsession" class="org.apache.shiro.web.servlet.SimpleCookie">
<constructor-arg name="name" value="WAPSESSIONID"/>
</bean>


<知者bean id="sessionValidationScheler"
class="org.apache.shiro.session.mgt.">
<property name="interval" value="3600000"/>
<property name="sessionManager" ref="sessionManager"/>
</bean>


<bean id="zkShiroSessionDAO" class="b2gonline.incometaxexamine._systembase.shiro.ZKShiroSessionDAO">

<constructor-arg name="useMemCache" value="true"/>
<property name="zookeeperTemplate" ref="zookeeperTemplate"/>
<property name="shiroSessionZKPath" value="/SHIROSESSIONS"/>
<property name="sessionPrefix" value="session-"/>
</bean>


<bean id="securityManager" class="org.apache.shiro.web.mgt.DefaultWebSecurityManager">
...
<property name="sessionManager" ref="sessionManager"/>
</bean>
第三步：Zookeeper對Shiro-SessionDao實現類
ZKShiroSessionDAO.JAVA偽代碼：

import bgonline.foundation.hadoop.zk.IZookeeperTemplate;
import bgonline.foundation.hadoop.zk.ZNode;
import org.apache.shiro.cache.AbstractCacheManager;
import org.apache.shiro.cache.Cache;
import org.apache.shiro.cache.CacheException;
import org.apache.shiro.cache.MapCache;
import org.apache.shiro.session.Session;
import org.apache.shiro.session.UnknownSessionException;
import org.apache.shiro.session.mgt.eis.AbstractSessionDAO;
import org.apache.shiro.session.mgt.eis.CachingSessionDAO;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.util.SerializationUtils;

import java.io.Serializable;
import java.util.Collection;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;

/**
* ZOOKEEPER實現SHIRO集群SESSION存儲
*
* @author aliencode
* @date 13-7-10
*/
public class ZKShiroSessionDAO extends CachingSessionDAO {

public ZKShiroSessionDAO() {
}

private boolean useMemCache = false;

/**
* SESSION ZK DAO 實例
* 如果開戶緩存
* 用戶登錄時自動緩存, 用戶登錄超時自動刪除
* 由於shiro的cacheManager是全局的, 所以這里使用setActiveSessionsCache直接設置Cache來本地緩存, 而不使用全局zk緩存.
* 由於同一用戶可能會被路由到不同伺服器,所以在doReadSession方法里也做了緩存增加.
*
* @param useMemCache 是否使用內存緩存登錄信息
*/
public ZKShiroSessionDAO(boolean useMemCache) {
this.useMemCache = useMemCache;
if (useMemCache) {
setActiveSessionsCache(
new MapCache<>(this.ACTIVE_SESSION_CACHE_NAME, new ConcurrentHashMap<Serializable, Session>())
);
}
}

Logger logger = LoggerFactory.getLogger(this.getClass());

/**
* ZK操作類
*/
private IZookeeperTemplate zookeeperTemplate;

/**
* 緩存根路徑, 結尾不加/
*/
private String shiroSessionZKPath = "/SHIROSESSIONS";

/**
* 緩存項前綴
*/
private String sessionPrefix = "session-";

/**
* 設置Shiro Session 前綴默認 session-
*
* @param sessionPrefix
*/
public void setSessionPrefix(String sessionPrefix) {
this.sessionPrefix = sessionPrefix;
}

public void setZookeeperTemplate(IZookeeperTemplate zookeeperTemplate) {
this.zookeeperTemplate = zookeeperTemplate;
}

/**
* 設置Shiro在ZK伺服器存放根路徑
*
* @param shiroSessionZKPath 默認值：/SHIROSESSIONS/
*/
public void setShiroSessionZKPath(String shiroSessionZKPath) {
this.shiroSessionZKPath = shiroSessionZKPath;
}

/**
* session更新
*
* @param session
* @throws UnknownSessionException
*/
@Override
public void update(Session session) throws UnknownSessionException {
if (session == null || session.getId() == null) {
logger.error("session argument cannot be null.");
}
saveSession(session, "update");
}

@Override
protected void doUpdate(Session session) {
}

/**
* session刪除
*
* @param session
*/
@Override
public void delete(Session session) {
if (session == null || session.getId() == null) {
logger.error("session argument cannot be null.");
}
logger.debug("delete session for id: {}", session.getId());
zookeeperTemplate.deleteNode(getPath(session.getId()));
if (useMemCache) {
this.uncache(session);
}
}

@Override
protected void doDelete(Session session) {
}

/**
* 獲取當前活躍的session, 當前在線數量
*
* @return
*/
@Override
public Collection<Session> getActiveSessions() {
ZNode zNode = new ZNode();
zNode.setPath(shiroSessionZKPath);
Set<Session> sessions = new HashSet<Session>();
//讀取所有SessionID , 返回形如: session-9e3b5707-fa80-4d32-a6c9-f1c3685263a5
List<String> ss = zookeeperTemplate.getChildren(zNode);
for (String id : ss) {
if (id.startsWith(sessionPrefix)) {
String noPrefixId = id.replace(sessionPrefix, "");
Session session = doReadSession(noPrefixId);
if (session != null) sessions.add(session);
}
}
logger.debug("shiro getActiveSessions. size: {}", sessions.size());
return sessions;
}

/**
* 創建session, 用戶登錄
*
* @param session
* @return
*/
@Override
protected Serializable doCreate(Session session) {
Serializable sessionId = this.generateSessionId(session);
this.assignSessionId(session, sessionId);
saveSession(session, "create");
return sessionId;
}

/**
* session讀取
*
* @param id
* @return
*/
@Override
protected Session doReadSession(Serializable id) {
if (id == null) {
logger.error("id is null!");
return null;
}
logger.debug("doReadSession for path: {}", getPath(id));

Session session;
byte[] byteData = zookeeperTemplate.getData(getPath(id)).getByteData();
if (byteData != null && byteData.length > 0) {
session = (Session) SerializationUtils.deserialize(byteData);
if (useMemCache) {
this.cache(session, id);
logger.debug("doReadSession for path: {}, add cached !", getPath(id));
}
return session;
} else {
return null;
}
}

/**
* 生成全路徑
*
* @param sessID
* @return
*/
private String getPath(Serializable sessID) {
return shiroSessionZKPath + '/' + sessionPrefix + sessID.toString();
}

/**
* session讀取或更新
*
* @param session
* @param act update/save
*/
private void saveSession(Session session, String act) {
Serializable sessionId = session.getId();
ZNode sessionNode = new ZNode();
sessionNode.setByteData(SerializationUtils.serialize(session));
sessionNode.setPath(getPath(sessionId));
logger.debug("save session for id: {}, act: {}", sessionId, act);
if (act == "update")
zookeeperTemplate.setData(sessionNode);
else
zookeeperTemplate.createNode(sessionNode);
}

}

websession共享

與websession共享相關的內容