jetspeedhttpstatemanagerservice.java

来自「jetspeed源代码」· Java 代码 · 共 251 行

/*
 * Copyright 2000-2002,2004 The Apache Software Foundation.
 * 
 * Licensed 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.
 */

// package
package org.apache.jetspeed.services.statemanager;

// imports
import java.util.Map;
import java.util.Vector;
import java.util.Enumeration;

import javax.servlet.http.HttpSession;
import javax.servlet.http.HttpSessionBindingListener;
import javax.servlet.http.HttpSessionBindingEvent;

import org.apache.jetspeed.services.statemanager.BaseStateManagerService;

/**
* <p>JetspeedHttpStateManagerService is an implementation of the BaseStateManagerService
* which manages the states stored in the "current" HttpSession.</p>
* <p>Note: This implementation of the StateManagerService takes advantage of the
* Servlet container's management of the HttpSession.
* When the session is invalidated, the states we manage will be automatically cleaned up.
* When this happens, the objects placed into our states will have their
* SessionStateBindingListener mechanism invoked.</p>
* <p>Note: This implementation segments the states by session.  States created in one session will NOT BE AVAILABLE
* from other sessions.</p>
* @version $Revision: 1.4 $
* @see org.apache.jetspeed.services.statemanager.BaseStateManagerService
* @see org.apache.jetspeed.services.statemanager.StateManagerService
* @see org.apache.jetspeed.services.statemanager.SessionState
* @author <a href="mailto:[e-mail]">Glenn R. Golden</a>
*/
public class JetspeedHttpStateManagerService
    extends BaseStateManagerService
{
    /**
    * Initialize the states storage.
    */
    protected void initStates()
    {
    }   // initStates

    /**
    * Cleanup the states storage.
    */
    protected void shutdownStates()
    {
    }   // shutdownStates

    /**
    * Access the current HttpSession.
    */
    private HttpSession getSession()
    {
        // get the current session that was installed for this thread
        HttpSession session = (HttpSession) m_httpSessions.get(Thread.currentThread());
        if (session == null) return null;

        // call isNew just to see if the session has been invalidated already
        try
        {
            session.isNew();
        }
        catch (IllegalStateException e)
        {
            return null;
        }

        return session;

    }   // getSession

    /**
    * Convert the key to a name safe to store directly in the session.
    * @param key The state key.
    * @return a name safe to store directly in the session based on key.
    */
    private String getSessionKey( String key )
    {
        // we want our keys not to conflict with any other session usage...
        return JetspeedHttpStateManagerService.class.getName() + "." + key;

    }   // getSessionKey

    /**
    * Access the Map which is the set of attributes for a state.
    * @param key The state key.
    * @return The Map which is the set of attributes for a state.
    */
    protected Map getState( String key )
    {
        // get the session
        HttpSession session = getSession();
        if (session == null) return null;

        // get this state from our entry in the session
        StateEntry stateEntry = (StateEntry) session.getAttribute(getSessionKey(key));
        if (stateEntry == null) return null;

        return stateEntry.getMap();

    }   // getState

    /**
    * Add a new state to the states we are managing.
    * @param key The state key.
    * @param state The Map which is the set of attributes for the state.
    */
    protected void addState( String key, Map state )
    {
        // get the session
        HttpSession session = getSession();
        if (session == null) return;

        // create a stateEntry to hold our state Map
        StateEntry stateEntry = new StateEntry(key, state);

        // put it in the session
        session.setAttribute(getSessionKey(key), stateEntry);

    }   // addState

    /**
    * Remove a state from the states we are managing.
    * @param key The state key.
    */
    protected void removeState( String key )
    {
        // get the session
        HttpSession session = getSession();
        if (session == null) return;

        // remove the key from the session - the StateEntry will be notified
        session.removeAttribute(getSessionKey(key));

    }   // removeState

    /**
    * Access an array of the keys of all states managed, those that start with the parameter.
    * @param start The starting string used to select the keys.
    * @return an array of the keys of all states managed.
    */
    protected String[] getStateKeys( String start )
    {
        // get the session
        HttpSession session = getSession();
        if (session == null) return null;

        // use this as the test pattern
        String pattern = getSessionKey(start);

        // for those that match, this starts the session key
        int subStart = getSessionKey("").length();

        // collect for return
        Vector rv = new Vector();

        // get the session names
        Enumeration names = session.getAttributeNames();
        while (names.hasMoreElements())
        {
            String sessionName = (String) names.nextElement();
            
            // pick our states, and those whose key starts with the pattern
            if (sessionName.startsWith(pattern))
            {
                rv.add(sessionName.substring(subStart));
            }
        }

        if (rv.size() == 0) return null;

        return (String[]) rv.toArray(new String[rv.size()]);

    }   // getStateKeys

    /**
    * Store the Map for the state, and listen for HttpSessionBinding events
    */
    private class StateEntry
        implements HttpSessionBindingListener
    {
        /** Store the map. */
        private Map m_map = null;
        
        /** The state key. */
        private String m_key = null;

        /**
        * Construct.
        * @param key The state key.
        * @param map The map to hold.
        */
        public StateEntry( String key, Map map )
        {
            m_key = key;
            m_map = map;

        }   // StateEntry
        
        /**
        * Access the map we are holding.
        * @return the Map we are holding.
        */
        public Map getMap()
        {
            return m_map;

        }   // getMap

        /**
        * We don't care about when we are bound...
        */
        public void valueBound( HttpSessionBindingEvent event ) {}

        /**
        * When we are unbound, unbind our state's (map's) attributes
        */
        public void valueUnbound( HttpSessionBindingEvent event )
        {
            // notify all attribute and clear the state
            retireAttributes(m_key, m_map);
            m_map = null;
            m_key = null;
        }

    }   // class StateEntry

}   // JetspeedHttpStateManagerService

/**********************************************************************************
*
* $Header: /home/cvs/jakarta-jetspeed/src/java/org/apache/jetspeed/services/statemanager/JetspeedHttpStateManagerService.java,v 1.4 2004/02/23 03:38:28 jford Exp $
*
**********************************************************************************/