码迷,mamicode.com
首页 > 其他好文 > 详细

tomcat(9)Session管理

时间:2016-04-29 17:59:00      阅读:179      评论:0      收藏:0      [点我收藏+]

标签:

【0】README
0.0)本文部分描述转自“深入剖析tomcat”,旨在学习tomcat-Session管理” 的基础知识;
0.1)Catalina通过一个称为Session 管理器的组件来管理建立的Session对象,该组件由org.apache.catalina.Manager接口来表示。(干货——catalina通过Session管理器组件来管理Session对象)
0.2)Session管理器:需要与一个Context容器相关联,且必须与一个Context容器关联;(干货——intro to Session Manager)
0.3)Session管理器:负责创建,更新,销毁Session对象,当有请求到来时,要会返回一个有效的Session对象;
0.4)default case:Session管理器会将其所管理的 Session对象存放在内存中。但在tomcat中,Session管理器也可以将Session 对象进行持久化,存储到文件存储器或通过jdbc写入到database;
0.5)for complete source code, please visit  https://github.com/pacosonTang/HowTomcatWorks/tree/master/chapter9;

【1】Session对象
1)intro to Session object:Session对象由 javax.servlet.http.HttpSession接口表示;
2)UML类图实例:
技术分享
【1.1】Session接口
1)Session接口是作为 Catalina内部的外观类使用的。Session 接口的标准实现 StandardSession类也实现了 javax.servlet.http.HttpSession 接口;
public interface Session {  
    public static final String SESSION_CREATED_EVENT = "createSession";  
    public static final String SESSION_DESTROYED_EVENT = "destroySession";  
    public String getAuthType();    
    public void setAuthType(String authType);  
    public long getCreationTime();  
    public void setCreationTime(long time);  
    public String getId();  
    public void setId(String id);    
    public String getInfo();  
    public long getLastAccessedTime();  
    public Manager getManager();    
    public void setManager(Manager manager);  
    public int getMaxInactiveInterval();   
    public void setMaxInactiveInterval(int interval);     
    public void setNew(boolean isNew);  
    public Principal getPrincipal();    
    public void setPrincipal(Principal principal);  
    public HttpSession getSession();  
    public void setValid(boolean isValid);    
    public boolean isValid();  
    public void access();   
    public void addSessionListener(SessionListener listener);  
    public void expire();     
    public Object getNote(String name);  
    public Iterator getNoteNames();  
    public void recycle();
    public void removeNote(String name);
    public void removeSessionListener(SessionListener listener);
    public void setNote(String name, Object value); 
}
2)Session对象总是存在于Session管理器中的:可以使用 getManager()方法或 setManager() 方法将Session实例和某个 Session管理器相关联;
2.1)对某个Session实例来说:在与其Session 管理器相关联的某个Context实例内,该Session对象有一个唯一的标识符,可以通过 setId() 方法和 getId() 方法来访问该 Session 标识符;
2.2)Session管理器会调用 getLastAccessedTime()方法:根据返回值来判断一个Session对象的有效性;(Session管理器会调用setValid()方法来设置或重置其有效性)
2.3)每当访问一个Session实例时: 会调用其 access()方法 来修改 Session对象的最后访问时间;
2.4)最后:Session管理器会调用Session对象的 expire()方法将其设置为过期, 也可以通过getSession() 方法获取一个经过 Session 外观类包装的 HttpSession 对象;

【1.2】StandardSession类
1)StandardSession类实现了 java.lang.Serilizable接口,便于序列化Session对象;(干货——StandardSession类实现了 java.lang.Serilizable接口,便于序列化Session对象)
2)StandardSession类的构造函数接收Manager接口的一个实例:迫使一个Session对象必须拥有一个Session管理器实例;(干货——注意迫使二字)
<span style="font-size:18px;">public StandardSession(Manager manager);</span>
3)下面是StandardSession实例的一些比较重要的私有变量,用于维护该StandardSession实例的一些状态。注意,带有transient关键字的变量是无法序列化的;
Attention)在tomcat5中,上述变量是受保护的,而tomcat4中,它们都是私有变量。每个变量都有与之对应的一个访问器和一个转变器(修改器)(get 和 set 方法)
class StandardSession
 implements HttpSession, Session, Serializable { 
    public StandardSession(Manager manager) { 
        super();
        this.manager = manager;
        if (manager instanceof ManagerBase)
            this.debug = ((ManagerBase) manager).getDebug();

    }
    private static final String NOT_SERIALIZED =
 "___NOT_SERIALIZABLE_EXCEPTION___"; 
    private HashMap attributes = new HashMap();
    private transient String authType = null; 
    private transient Method containerEventMethod = null; 
    private static final Class containerEventTypes[] = { String.class, Object.class }; 
    private long creationTime = 0L;   
    private transient int debug = 0;
   
    private transient boolean expiring = false;
    private transient StandardSessionFacade facade = null;
    private String id = null;
    private static final String info = "StandardSession/1.0";
    private long lastAccessedTime = creationTime;
    private transient ArrayList listeners = new ArrayList(); 
    private Manager manager = null;
    private int maxInactiveInterval = -1;
    private boolean isNew = false;
    private boolean isValid = false;
    private transient HashMap notes = new HashMap();
    private transient Principal principal = null;
    private static StringManager sm =
 StringManager.getManager(Constants.Package); 
    private static HttpSessionContext sessionContext = null;
    private transient PropertyChangeSupport support =
 new PropertyChangeSupport(this); 
    private long lastUsedTime = creationTime;
}
4)其中 getSession()方法会通过一个自身实例来创建 StandardSessionFacade 类的一个实例,并将其返回;(干货——如果是单例模式的话,该方法写的就很有问题,当然只是小生我一个小小的猜想)
public HttpSession getSession() {
    if(facade==null){
        facade = new StandardSessionFacade(this);
    }
    return facade;
}
5)设置Session为过期:若Session管理器中的某个Session对象 在某个时间长度内都没有被访问 的话,会被 Session 管理器设置为过期,这个时间长度由变量 maxInactiveInterval 的值来指定;(干货——将一个Session对象设置为过期主要是通过Session接口的expire() 方法来完成的);
 public void expire(boolean notify) {
        // Mark this session as "being expired" if needed
        if (expiring)
            return;
        expiring = true;
        setValid(false);

        // Remove this session from our manager's active sessions
        if (manager != null)
            manager.remove(this);

        // Unbind any objects associated with this session
        String keys[] = keys();
        for (int i = 0; i < keys.length; i++)
            removeAttribute(keys[i], notify);

        // Notify interested session event listeners
        if (notify) {
            fireSessionEvent(Session.SESSION_DESTROYED_EVENT, null);
        }

        // Notify interested application event listeners
        // FIXME - Assumes we call listeners in reverse order
        Context context = (Context) manager.getContainer();
        Object listeners[] = context.getApplicationListeners();
        if (notify && (listeners != null)) {
            HttpSessionEvent event =
              new HttpSessionEvent(getSession());
            for (int i = 0; i < listeners.length; i++) {
                int j = (listeners.length - 1) - i;
                if (!(listeners[j] instanceof HttpSessionListener))
                    continue;
                HttpSessionListener listener =
                    (HttpSessionListener) listeners[j]; 
                try {
                    fireContainerEvent(context, // highlight line.
                                       "beforeSessionDestroyed",
                                       listener);
                    listener.sessionDestroyed(event); // destroy session.
                    fireContainerEvent(context, // also highlight line.
                                       "afterSessionDestroyed",
                                       listener);
                } catch (Throwable t) {
                    try {
                        fireContainerEvent(context,
                                           "afterSessionDestroyed",
                                           listener);
                    } catch (Exception e) {
                        ;
                    }
                    // FIXME - should we do anything besides log these?
                    log(sm.getString("standardSession.sessionEvent"), t);
                }
            }
        }
        // We have completed expire of this session
        expiring = false;
        if ((manager != null) && (manager instanceof ManagerBase)) {
            recycle();
        }    }

 private void fireContainerEvent(Context context,
                                    String type, Object data)
        throws Exception {
        if (!"org.apache.catalina.core.StandardContext".equals
            (context.getClass().getName())) {
            return; // Container events are not supported
        }
        // NOTE:  Race condition is harmless, so do not synchronize
        if (containerEventMethod == null) {
            containerEventMethod =
                context.getClass().getMethod("fireContainerEvent", // terrific line.
                                             containerEventTypes);
        }
        Object containerEventParams[] = new Object[2];
        containerEventParams[0] = type;
        containerEventParams[1] = data;
        containerEventMethod.invoke(context, containerEventParams);
    }

【1.3】StandardSessionFacade类
1)为了传递一个 Session对象给servlet实例,Catalina会实例化 StandardSession 类,填充该Session对象,然后再将其传给 servlet实例;(干货——但是,请注意下面的但是)
2)但是(呵呵):Catalina传递的是Session的 外观类 StandardSessionFacade的实例,该类仅仅实现了 javax.servlet.http.HttpSession接口中的方法;
3)这样,servlet程序员就不能将 HttpSession对象向下转换为  StandardSession 类型,也阻止了 servlet程序员访问一些敏感方法;

【2】Manager
1)Catalina通过一个称为Session 管理器的组件来管理建立的Session对象,该组件由org.apache.catalina.Manager接口来表示。
2)Catalina中:org.apache.catalina.session包中有一个名为 ManagerBase的工具类,该类提供了常见功能的实现。ManagerBase类有两个直接子类,分别是 StandardManager 类 和 PersistentManagerBase类;(干货——引入ManagerBase的工具类)
3)当Catalina运行时:StandardManager实例会将Session对象存储在内存中,但是,当Catalina关闭时,它(Manager)会将当前内存中的所有Session对象存储到一个文件中。当再次启动Catalina时,又会将这些Session 对象重新载入到内存中;
4)PersistentManagerBase类:该类会将 Session对象存储到辅助存储器中,其类图如下:(干货——PersistentManagerBase类会将 Session对象存储到辅助存储器中)
技术分享
技术分享
【2.1】Manager接口
1)intro to Manager interface:Session管理器是 Manager接口的实例;
2)Manager接口的源代码
public interface Manager {  
    public Container getContainer();  
    public void setContainer(Container container);  
    public DefaultContext getDefaultContext();  
    public void setDefaultContext(DefaultContext defaultContext);  
    public boolean getDistributable();   
    public void setDistributable(boolean distributable);  
    public String getInfo();   
    public int getMaxInactiveInterval();    
    public void setMaxInactiveInterval(int interval);   
    public void add(Session session);                                                                         
    public Session createEmptySession();  
    public void addPropertyChangeListener(PropertyChangeListener listener);    
    public Session createSession();  
    public Session findSession(String id) throws IOException;    
    public Session[] findSessions();   
    public void load() throws ClassNotFoundException, IOException;  
    public void remove(Session session);     
    public void removePropertyChangeListener(PropertyChangeListener listener);    
    public void unload() throws IOException;
}
对上述代码的分析(Analysis):
A1)getContainer()方法和setContainer()方法:以便将一个Manager实现与一个 Context容器相关联;
A2)createSession()方法:用来创建一个Session实例;
A3)add()方法:会将一个 Session实例添加到 Session池中;
A4)remove()方法:则会将一个 Session实例从 Session池中移除;
A5)getMaxInactiveInterval()方法和 setMaxInactiveInterval()方法:用来获取或设置一个时间长度,单位为秒;
A6)Session管理器: 会以此作为一个Session对象的最长存活时间;
A7)load()方法和unload() 方法:用来将Session对象持久化到辅助存储器中(干货——load方法和unload方法)
A7.1)load方法:该方法会将介质中的Session对象重新载入到内存中;
A7.2)unload方法:该方法会将当前活动的 Session对象存储到 Manager 实现指定的介质中;
【2.2】ManagerBase类(org.apache.catalina.session.ManagerBase)
1)ManagerBase.createSession()方法:该方法会创建一个新的Session对象, 每个Session对象都有一个 唯一的标识符;
2)generateSessionId()方法:可以通过 ManagerBase类受保护的方法generateSessionId() 方法来返回一个唯一的标识符;
Attention)一个活动的Session对象:指的是有效的,还未过期的Session对象;(干货——活动的Session对象的定义)
3)某个Context容器的 Session管理器会管理该 Context容器中所有活动的Session对象。这些活动的Session对象都存储在一个名为sessions 的 HashMap变量中:
protected HashMap sessions = new HashMap();
4)add方法,remove方法,findSession方法
 public void add(Session session) {
        synchronized (sessions) {
            sessions.put(session.getId(), session);
            if( sessions.size() > maxActive ) {
                maxActive=sessions.size();
            }
        }
    }
public void remove(Session session) {
        synchronized (sessions) {
            sessions.remove(session.getId());
        }
    }
public Session[] findSessions() {
        Session results[] = null;
        synchronized (sessions) {
            results = new Session[sessions.size()];
            results = (Session[]) sessions.values().toArray(results);
        }
        return (results);
    }
public Session findSession(String id) throws IOException {
        if (id == null)
            return (null);
        synchronized (sessions) {
            Session session = (Session) sessions.get(id);
            return (session);
        }
    }
【2.3】StandardManger类
1)intro to StandardManager:StandardManager类是Manager接口的标准实现,该类将 Session 存储于内存中;
1.1)该类还实现了Lifecycle接口:这样就可以由与其关联的Context容器来启动和关闭;其中stop方法的实现会调用 unload() 方法,以便将有效的Session对象序列化到一个名为"SESSION.ser"的文件中,而且每个Context容器都会产生这样一个文件;(干货——引入了SESSION.ser文件,unload() 方法持久化Session对象到文件
1.2)SESSION.ser文件:位于环境变量 CATALINA_HOME指定的目录下的work目录中;
看个荔枝)在tomcat4或tomcat5中,如果运行了实例应用程序,就可以在 CATALINA_HOME/work/Standalone/localhost/examples 目录下找到 SESSION.ser文件;
1.3)当StandardManager实例再次启动时:这些Session 对象会通过调用load() 方法重新读入内存中;(干货——load()方法将持久化文件中的Session对象重新读入内存)
2)Session管理器:还要负责销毁那些已经失效的Session对象,在tomcat4中的 StandardManager类中,这项工作是由一个专门的线程来完成的;
 public void run() { //org.apache.catalina.session.StandardManager
        // Loop until the termination semaphore is set
        while (!threadDone) {
            threadSleep();
            processExpires();
        }
    }
对上述代码的分析(Analysis):
A1)threadSleep()方法:会使线程休眠一段时间,长度由checkInterval指定,default==60 秒;
A2)processExpir()方法:会遍历由 Session管理器管理的所有Session对象,将Session实例的lastAccessedTime属性值与当前时间进行比较,如果两者之间的差值超过了变量 maxInactiveInterval 指定的数值,则会调用 Session接口的 expire() 方法使这个Session实例过期;
private void processExpires() { // org.apache.catalina.session.StandardManager.processExpires()
        long timeNow = System.currentTimeMillis();
        Session sessions[] = findSessions();

        for (int i = 0; i < sessions.length; i++) {
            StandardSession session = (StandardSession) sessions[i];
            if (!session.isValid())
                continue;
            int maxInactiveInterval = session.getMaxInactiveInterval();
            if (maxInactiveInterval < 0)
                continue;
            int timeIdle = // Truncate, do not round up
                (int) ((timeNow - session.getLastUsedTime()) / 1000L);
            if (timeIdle >= maxInactiveInterval) {
                try {
                    expiredSessions++;
                    session.expire();// highlight line.
                } catch (Throwable t) {
                    log(sm.getString("standardManager.expireException"), t);
                }
            }
        }
    }
Attention)
A1)在tomcat5中,StandardManager类已不再实现 java.lang.Runnable接口。其中的 backgroundporocess() 方法会直接调用 tomcat5 中StandardManager对象的 processExpires()方法;
public voiid backgroundProcess() { //org.apache.catalina.session.StandardManager.backgroundProcess()
    processExpire();
}
public void expire() { //org.apache.catalina.sessoin.StandardManager.expire()
        expire(true);
    }   
    public void expire(boolean notify) { // the same as the above.

        // Mark this session as "being expired" if needed
        if (expiring)
            return;
        expiring = true;
        setValid(false);

        // Remove this session from our manager's active sessions
        if (manager != null)
            manager.remove(this);

        // Unbind any objects associated with this session
        String keys[] = keys();
        for (int i = 0; i < keys.length; i++)
            removeAttribute(keys[i], notify);

        // Notify interested session event listeners
        if (notify) {
            fireSessionEvent(Session.SESSION_DESTROYED_EVENT, null);
        }

        // Notify interested application event listeners
        // FIXME - Assumes we call listeners in reverse order
        Context context = (Context) manager.getContainer();
        Object listeners[] = context.getApplicationListeners();
        if (notify && (listeners != null)) {
            HttpSessionEvent event =
              new HttpSessionEvent(getSession());
            for (int i = 0; i < listeners.length; i++) {
                int j = (listeners.length - 1) - i;
                if (!(listeners[j] instanceof HttpSessionListener))
                    continue;
                HttpSessionListener listener =
                    (HttpSessionListener) listeners[j];
                try {
                    fireContainerEvent(context,
                                       "beforeSessionDestroyed",
                                       listener);
                    listener.sessionDestroyed(event);
                    fireContainerEvent(context,
                                       "afterSessionDestroyed",
                                       listener);
                } catch (Throwable t) {
                    try {
                        fireContainerEvent(context,
                                           "afterSessionDestroyed",
                                           listener);
                    } catch (Exception e) {
                        ;
                    }
                    // FIXME - should we do anything besides log these?
                    log(sm.getString("standardSession.sessionEvent"), t);
                }
            }
        }

        // We have completed expire of this session
        expiring = false;
        if ((manager != null) && (manager instanceof ManagerBase)) {
            recycle();
        }
    }
技术分享
【2.4】PersistentManagerBase类(参见上图)
1)intro to PersistentManagerBase:该类是所有持久化Session管理器的 父类;
1.1)StandardManager实例 和 持久化Session管理器(PersistentManagerBase)的区别:在于后者中存储器的表示形式,即存储Session 对象的辅助存储器的形式,使用Store对象来表示;
2)在持久化Session管理器中:Session对象可以备份,也可以换出;(干货——Session对象可以备份,也可以换出);如果server destroyed,就可以从存储器中获取活动的Session对象;
2.1)当Session对象被换出:他会被移动到存储器中,因为当前活动的Session对象数超过了上限值,或者这个Session对象闲置了过长时间;(干货——换出是为了节省内存空间)
2.2)tomcat4中,PersistentManagerBase类实现了java.lang.Runnable 接口:使用一个专门的线程来执行备份和换出活动Session对象的任务;(run() 方法如下 )(干货——注意是tomcat4,使用一个专门的线程来执行备份和换出活动Session对象的任务)
public void run() { //org.apache.catalina.session.PersistentManagerBase.run()
    while(!threadDone) {
        threadSleep();
        processExpires(); // 检查Session对象是否过期.
        processPersistenceChecks();
    }    
}
public void processPersistenceChecks(){ // org.apache.catalina.session.PersistentManagerBase.processPersistenceChecks()
    processMaxIdleSwaps(); // highlight line.(下面我们只以processMaxIdleSwaps方法为例进行调用过程的分析,其他两个方法类似)
    processMaxActiveSwaps(); // highlight line.
    processMaxIdleBackups(); // highlight line.
}
/**
     * Swap idle sessions out to Store if they are idle too long.若session空闲太久则换出
     */
    protected void processMaxIdleSwaps() {
        if (!isStarted() || maxIdleSwap < 0)
            return;

        Session sessions[] = findSessions();
        long timeNow = System.currentTimeMillis();

        // Swap out all sessions idle longer than maxIdleSwap
        // FIXME: What's preventing us from mangling a session during
        // a request?
        if (maxIdleSwap >= 0) {
            for (int i = 0; i < sessions.length; i++) {
                StandardSession session = (StandardSession) sessions[i];
                if (!session.isValid())
                    continue;
                long lastAccessed = ((StandardSession)session).getLastUsedTime();
                int timeIdle = // Truncate, do not round up
                    (int) ((timeNow - lastAccessed) / 1000L);
                if (timeIdle > maxIdleSwap && timeIdle > minIdleSwap) {
                    if (debug > 1)
                        log(sm.getString
                            ("persistentManager.swapMaxIdle",
                             session.getId(), new Integer(timeIdle)));
                    try {
                        swapOut(session); // highlight line.
                    } catch (IOException e) {
                        ;   // This is logged in writeSession()
                    }
                }
            }
        }
    }
protected void swapOut(Session session) throws IOException { //换出操作
        if (store == null ||
                !session.isValid() ||
                isSessionStale(session, System.currentTimeMillis()))
            return;

        ((StandardSession)session).passivate();
        writeSession(session); // highlight line.
        super.remove(session);
        session.recycle();
    }
protected void writeSession(Session session) throws IOException {

        if (store == null ||
                !session.isValid() ||
                isSessionStale(session, System.currentTimeMillis()))
            return;

        try {
            store.save(session); //highlight line.
            sessionSwapIgnore.remove(session.getId());
        } catch (IOException e) {
            log(sm.getString
                ("persistentManager.serializeError", session.getId(), e));
            throw e;
        }
    }

3)tomcat5中,PersistentManagerBase类不再实现 java.lang.Runnable 接口。备份和换出Session对象的任务由其 backgroundProcess() 管理器完成,后者由其相关联的 StandardContext 实例周期性地调用;
(下面分析 换出和备份Session实例的实现过程)

4)PersistentManagerBase类换出Session实例
4.1)换出条件:只有当活动Session对象的数量超过了变量 maxActiveSessions指定的上限值,或者该Session对象闲置了很长时间后,才会被换出;(干货——Session对象被换出的condition)
4.1.1)当活动的Session实例数量过多时:PersistentManagerBase会将Session对象换出直到数量等于 maxActiveSessions;(参见 processMaxActiveSwaps()方法)
4.1.2)当某个Session对象闲置了过长时间:PersistentManagerBase会依据两个变量来决定是否将这个Session换出,这两个变量是minIdleSwap and maxIdleSwap;如果某个Session对象的 lastAccessedTime 属性的值超过了 minIdleSwap 和 maxIdleSwap 的值,就会将这个Session换出;(干货——为了防止换出Session对象,将maxIdleSwap设置为负数,参见 processMaxIdleSwaps() 方法)
4.2)如何查找Session实例:因为Session对象可以被换出,所以他既可能驻留在内存中,也可能驻留在存储器中,因此,findSession(String id ) 方法首先会在内存中查找是否存在该Session对象,若没有找到,才会在存储器中继续find。(PersistentManagerBase.findSession() 方法的源代码如下)(干货——Session对象被换出后,可能驻留在内存中,也可能驻留在存储器中)
public Session findSession(String id) throws IOException { //org.apache.catalina.session.PersistentManagerBase.findSession()
        Session session = super.findSession(id);
        if (session != null)
            return (session);

        // See if the Session is in the Store
        session = swapIn(id); // highlight line.
        return (session);
    }
protected Session swapIn(String id) throws IOException { // the same as the above.
        if (store == null)
            return null;

        if (sessionSwapIgnore.contains(id)) {
            return null;
        }

        Session session = null;
        try {
            session = store.load(id); // highlight line.
        } catch (ClassNotFoundException e) {
            log(sm.getString("persistentManager.deserializeError", id, e));
            throw new IllegalStateException
                (sm.getString("persistentManager.deserializeError", id, e));
        }

        if (session == null) {
            sessionSwapIgnore.put(id,id);
            return (null);
        }

        if (!session.isValid()
                || isSessionStale(session, System.currentTimeMillis())) {
            log("session swapped in is invalid or expired");
            session.expire(); // highlight line.
            store.remove(id); // highlight line.
            sessionSwapIgnore.put(id,id);
            return (null);
        }

        if(debug > 2)
            log(sm.getString("persistentManager.swapIn", id));

        session.setManager(this);
        // To make sure the listener knows about it.
        ((StandardSession)session).tellNew();
        add(session);
        ((StandardSession)session).activate();
        return (session);
    }

5)PersistentManagerBase类备份Session实例
5.1)备份条件:PersistentManagerBase实例 仅仅会备份那些空闲时间超过了变量 maxIdleBackup 的Session对象。
5.2)processMaxIdleBackups()方法:负责对该Session对象进行备份操作;

【2.5】PersistentManager类
1)intro to PersistentManager类:该类继承了 PersistentManagerBase类,仅仅是多添加了两个属性而已;
public final class PersistentManager extends PersistentManagerBase {  //org.apache.catalina.session.PersistentManager 
    private static final String info = "PersistentManager/1.0";   
    protected static String name = "PersistentManager";  
    public String getInfo() {
        return (this.info);
    }  
    public String getName() {
        return (name);
    }
 }
【2.6】DistributedManager类(应用与集群环境)
1)intro to DistributedManager类:继承自PersistentManagerBase类,用于两个或多个节点的集群环境;
1.1)一个节点表示部署的一台 tomcat server:而集群中的节点 可以在同一台机器上,也可以在不同的machine上
1.2)每个节点必须使用 DistributedManager实例作为其Session管理器:这样才能支持复制 Session对象,这也是DistributedManager的主要功能 ;(干货——DistributedManager的主要功能)
2)DistributedManager会向其他节点发送消息:为了实现copy Session对象的目的,当创建或销毁Session对象时,DistributedManager会向其他节点发送消息;(干货——DistributedManager会向其他节点发送消息)
2.2)而且:集群中的节点也必须能够接受其他节点发送的消息。这样,http 请求才能到达集群中的任意节点;
3)catalina在org.apache.catlina.cluster中提供了一些工具:这些工具用于 与集群中其他节点的DistributedManager实例发送和接收消息;其中,ClusterSender 类用于向集群中的其他节点发送消息,ClusterReceiver 则用于接收集群中其他节点发送的消息;(干货——catalina在org.apache.catlina.cluster中提供了一些工具,如ClusterSender and ClusterReceiver)
4)DistributedManager.createSession()方法: 要创建一个Sesssion对象,存储在当前 DistributedManager 实例中,并使用 ClusterSender实例向其他节点发送消息;
 public Session createSession() {
        Session session = super.createSession(); // step1.
        ObjectOutputStream oos = null;
        ByteArrayOutputStream bos = null;
        ByteArrayInputStream bis = null;
        try {
            bos = new ByteArrayOutputStream();
            oos = new ObjectOutputStream(new BufferedOutputStream(bos));
            ((StandardSession)session).writeObjectData(oos);
            oos.close();
            byte[] obs = bos.toByteArray();
            clusterSender.send(obs); // step2.
            if(debug > 0)
                log("Replicating Session: "+session.getId());
        } catch (IOException e) {
            log("An error occurred when replicating Session: "+session.getId());
        }
        return (session);
    }
对以上代码的分析(Analysis):
step1)调用超类的 createSession()方法为自身创建一个 Session对象;
step2)使用ClusterSender实例,以字节数组的形式将该Session对象发送到集群中的其他节点;
5)DistributedManager类还实现了 java.lang.Runnable 接口: 这样就可以使用一个 专门的thread 来检查 Session对象是否过期,并从集群中的其他节点接收消息;(其run() 方法的源代码如下) 
public void run() { // org.apache.catalina.session.DistributedManager.run()
        // Loop until the termination semaphore is set
        while (!threadDone) {
            threadSleep();
            processClusterReceiver(); // 以该方法为例进行说明.
            processExpires();
            processPersistenceChecks();
        }
    }
/**
     * Called from our background thread to process new received Sessions
     *
     */
    public void processClusterReceiver() { //org.apache.catalina.session.DistributedManager.processClusterReceiver()
        Object[] objs = clusterReceiver.getObjects();
        StandardSession _session = null;
        ByteArrayInputStream bis = null;
        Loader loader = null;
        ClassLoader classLoader = null;
        ObjectInputStream ois = null;
        byte[] buf = new byte[5000];
        ReplicationWrapper repObj = null;

        for(int i=0; i < objs.length;i++) {
            try {
                bis = new ByteArrayInputStream(buf);
                repObj = (ReplicationWrapper)objs[i];
                buf = repObj.getDataStream();
                bis = new ByteArrayInputStream(buf, 0, buf.length);

                if (container != null)
                    loader = container.getLoader();

                if (loader != null)
                    classLoader = loader.getClassLoader();

                if (classLoader != null)
                    ois = new CustomObjectInputStream(bis,
                                                      classLoader);
                else
                    ois = new ObjectInputStream(bis);

                _session = (StandardSession) super.createSession();
                _session.readObjectData(ois);
                _session.setManager(this);

                if (debug > 0)
                    log("Loading replicated session: "+_session.getId());
            } catch (IOException e) {
                log("Error occurred when trying to read replicated session: "+
                    e.toString());
            } catch (ClassNotFoundException e) {
                log("Error occurred when trying to read replicated session: "+
                    e.toString());
            } finally {
                if (ois != null) {
                    try {
                        ois.close();
                        bis = null;
                    } catch (IOException e) {
                        ;
                    }
                }
            }
        }
    }
【3】存储器(存储器是org.apache.catalina.Store接口的实例)
1)intro to 存储器是为Session管理器管理的 Session对象提供持久化存储器的一个组件;(干货——intro to 存储器——org.apache.catalina.Store接口的实例)
2)Store接口的源代码如下:
public interface Store { // org.apache.catalina.Store
    public String getInfo(); 
    public Manager getManager(); 
    public void setManager(Manager manager); 
    public int getSize() throws IOException; 
    public void addPropertyChangeListener(PropertyChangeListener listener); 
    public String[] keys() throws IOException; 
    public Session load(String id) 
        throws ClassNotFoundException, IOException;
    public void remove(String id) throws IOException; 
    public void clear() throws IOException; 
    public void removePropertyChangeListener(PropertyChangeListener listener); 
    public void save(Session session) throws IOException; 
} 
3)Store接口中有两个方法:save()方法和 load() 方法(干货——注意save方法和 load方法,它们的作用分别是什么)
3.1)save方法:用于将指定的 Session对象存储到某种持久性存储器中;
3.2)load方法:会从存储器中,依据Session对象 的标识符将该Session对象载入(加载)到内存中;
补充)keys()方法:会以字符串数组的形式返回所有 Session 对象的标识符;
4)其UML 类图如下所示:
技术分享
技术分享
【3.1】StoreBase类图(见上图)
1)intro to StoreBase:该类是一个抽象类,提供了一些基本功能,有两个子类;
2)StoreBase类:并没有实现Store接口的save()方法 和 load()方法,因为,这两个方法依赖于持久化Session对象的存储器的类型;
3)在tomcat4中:StoreBase类使用另一个线程周期性地检查 Session对象:从活动的Session的集合中移除过期的Session对象;(下面是 tomcat4 中 StoreBase.run()方法的源代码,注意是tomcat4
 public void run() { // org.apache.catalina.session.StoreBase.run()
        // Loop until the termination semaphore is set
        while (!threadDone) {
            threadSleep();
            processExpires();
        }
    }
对以上代码的分析(Analysis):
A1)processExpires方法:会获取所有活动的 Session对象,检查 每个Session对象的 lastAccessedTime属性值,删除那些长时间不活动的Session对象;源代码如下:(干货——再次提及了processExpires方法,注意其功能)
protected void processExpires() {// org.apache.catalina.session.StoreBase.processExpires()
        long timeNow = System.currentTimeMillis();
        String[] keys = null;
        if(!started) {
            return;
        }
        try {
            keys = keys();
        } catch (IOException e) {
            log (e.toString());
            e.printStackTrace();
            return;
        }
        for (int i = 0; i < keys.length; i++) {
            try {
                StandardSession session = (StandardSession) load(keys[i]);
                if (session == null) {
                    continue;
                }
                if (!session.isValid()) {
                    continue;
                }
                int maxInactiveInterval = session.getMaxInactiveInterval();
                if (maxInactiveInterval < 0) {
                    continue;
                }
                int timeIdle = // Truncate, do not round up
                    (int) ((timeNow - session.getLastUsedTime()) / 1000L);
                if (timeIdle >= maxInactiveInterval) {
                    if ( ( (PersistentManagerBase) manager).isLoaded( keys[i] )) {
                        // recycle old backup session
                        session.recycle();
                    } else {
                        // expire swapped out session
                        session.expire();
                    }
                    remove(session.getId());
                }
            } catch (Exception e) {
                log ("Session: "+keys[i]+"; "+e.toString());
                try {
                    remove(keys[i]);
                } catch (IOException e2) {
                    log (e2.toString());
                    e2.printStackTrace();
                }
            }
        }
    }

Attention)在tomcat5中,不再使用专用的线程调用 processExpire()方法 ,而是,相关联的 PersistentManagerBase实例的 backgroundProcess()方法会周期性地调用 processExpires() 方法;

【3.2】FileStore类
1)intro to FileStore:FileStore类会将 Session对象存储到某个文件中,文件名会使用Session对象的 标识符再加上一个后缀 ".session" 构成;(干货——FileStore类的作用)
2)文件位于临时的工作dir下:可以调用FileStore.setDirectory() 方法进行修改临时目录的位置;
(干货——理清FileStore.save and FileStore.load方法的作用)
3)save方法:使用 java.io.ObjectOutputStream类将 Session对象进行序列化,故所有存储在Session实例中的对象都要实现 java.lang.Serializable接口;
4)load方法:该方法使用 java.io.ObjectInputStream 类实现 Session 对象的反序列化;

【3.3】JDBCStore类
1)intro to JDBCStore:该类将Session对象通过JDBC 存入 db中;(干货——JDBCStore类的作用)

【4】app program
1)intro to app program该应用程序中的Context容器使用StandardManager实例来管理Session对象,为了测试该应用程序,可以使用第3个示例servlet:SessionServlet;
public class SessionServlet extends HttpServlet {
  public void doGet(HttpServletRequest request, HttpServletResponse response)
    throws ServletException, IOException {
    System.out.println("SessionServlet -- service");
    response.setContentType("text/html");
    PrintWriter out = response.getWriter();
    out.println("<html>");
    out.println("<head><title>SessionServlet</title></head>");
    out.println("<body>");
    String value = request.getParameter("value");
    HttpSession session = request.getSession(true);
    out.println("<br>the previous value is " +
      (String) session.getAttribute("value"));
    out.println("<br>the current value is " + value);
    session.setAttribute("value", value);
    out.println("<br><hr>");
    out.println("<form>");
    out.println("New Value: <input name=value>");
    out.println("<input type=submit>");
    out.println("</form>");
    out.println("</body>");
    out.println("</html>");
  }
} 

【4.1】Bootstrap类
1)源代码如下
public static void main(String[] args) {
    //invoke: http://localhost:8080/myApp/Session
    System.setProperty("catalina.base", System.getProperty("user.dir"));
    Connector connector = new HttpConnector();
    Wrapper wrapper1 = new SimpleWrapper();
    wrapper1.setName("Session");
    wrapper1.setServletClass("SessionServlet");

    Context context = new StandardContext();
    // StandardContext's start method adds a default mapper
    context.setPath("/myApp");
    context.setDocBase("myApp");

    context.addChild(wrapper1);

    // context.addServletMapping(pattern, name);
    // note that we must use /myApp/Session, not just /Session
    // because the /myApp section must be the same as the path, so the cookie will
    // be sent back.
    context.addServletMapping("/myApp/Session", "Session");
    // add ContextConfig. This listener is important because it configures
    // StandardContext (sets configured to true), otherwise StandardContext
    // won't start
    LifecycleListener listener = new SimpleContextConfig();
    ((Lifecycle) context).addLifecycleListener(listener);

    // here is our loader
    Loader loader = new WebappLoader();
    // associate the loader with the Context
    context.setLoader(loader);

    connector.setContainer(context);

    // add a Manager
    Manager manager = new StandardManager(); // highlight line.
    context.setManager(manager); // highlight line.

    try {
      connector.initialize();
      ((Lifecycle) connector).start();

      ((Lifecycle) context).start();

      // make the application wait until we press a key.
      System.in.read();
      ((Lifecycle) context).stop();
    }
    catch (Exception e) {
      e.printStackTrace();
    }
  }
}
【4.2】SimpleWrapperValve类
1)servlet示例可以调用javax.servlet.http.HttpServletRequest接口的getSession() 方法获取Session对象:当调用 getSession() 方法时,request对象必须调用与Context 容器相关联的Session管理器。Session管理器组件要么创建一个新的session 对象,要么返回一个已经存在的session对象。request对象为了能够访问Session管理器,他必须能够访问Context容器。
2)为了达到这个目的:在 SimpleWrapperValve类的invoke方法中,需要调用 org.apache.catalina.Request接口的setContext()方法,并传入 Context实例;
Attention)SimpleWrapperValve.invoke方法会调用被请求的servlet实例的service方法,所以,必须在调用service方法之前设置 Context实例;
 public void invoke(Request request, Response response, ValveContext valveContext)
    throws IOException, ServletException {
    SimpleWrapper wrapper = (SimpleWrapper) getContainer();
    ServletRequest sreq = request.getRequest();
    ServletResponse sres = response.getResponse();
    Servlet servlet = null;
    HttpServletRequest hreq = null;
    if (sreq instanceof HttpServletRequest)
      hreq = (HttpServletRequest) sreq;
    HttpServletResponse hres = null;
    if (sres instanceof HttpServletResponse)
      hres = (HttpServletResponse) sres;

    //-- new addition -----------------------------------
    Context context = (Context) wrapper.getParent(); // highlight line.
    request.setContext(context); // highlight line.
    //-------------------------------------
    // Allocate a servlet instance to process this request
    try {
      servlet = wrapper.allocate();
      if (hres!=null && hreq!=null) {
        servlet.service(hreq, hres);
      }
      else {
        servlet.service(sreq, sres);
      }
    }
    catch (ServletException e) {
    }
  }
补充)org.apache.catalina.connector.HttpRequestBase类的私有方法:doGetSession() 会调用Context接口的 getManager() 方法来获取 Session管理器对象:(当获取了Session管理器对象之后,就可以获取到Session对象了,或直接创建一个新Session)
Manager manager = null;
if(contect != null)
    manager = context.getManager();

【4.3】打印结果
1)console info
E:\bench-cluster\cloud-data-preprocess\HowTomcatWorks\src>java -cp .;lib/servlet.jar;lib/catalina_4_1_24.jar;lib/catalina-5.5.4.jar;lib/naming-common.
jar;lib/commons-collections.jar;lib/naming-resources.jar;lib/;lib/catalina.jar;E:\bench-cluster\cloud-data-preprocess\HowTomcatWorks\webroot com/tomca
t/chapter9/startup/Bootstrap
HttpConnector Opening server socket on all host IP addresses
HttpConnector[8080] Starting background thread
WebappLoader[/myApp]: Deploying class repositories to work directory E:\bench-cluster\cloud-data-preprocess\HowTomcatWorks\src\work\_\_\myApp
Starting Wrapper Session
StandardManager[/myApp]: Seeding random number generator class java.security.SecureRandom
StandardManager[/myApp]: Seeding of random number generator has been completed
SessionServlet -- service
SessionServlet -- service
SessionServlet -- service
SessionServlet -- service
2)访问信息
技术分享


tomcat(9)Session管理

标签:

原文地址:http://blog.csdn.net/pacosonswjtu/article/details/51231894

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!