Java tutorial
/* * 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. */ package org.apache.axis2.context; import org.apache.axis2.AxisFault; import org.apache.axis2.context.externalize.ExternalizeConstants; import org.apache.axis2.context.externalize.SafeObjectInputStream; import org.apache.axis2.context.externalize.SafeObjectOutputStream; import org.apache.axis2.context.externalize.SafeSerializable; import org.apache.axis2.description.AxisService; import org.apache.axis2.engine.AxisConfiguration; import org.apache.axis2.engine.DependencyManager; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; import java.io.Externalizable; import java.io.IOException; import java.io.ObjectInput; import java.io.ObjectOutput; import java.util.Date; import java.util.HashMap; import java.util.Iterator; import java.util.Map; /** * All the engine components are stateless across the executions and all the states should be kept in the * Contexts, there are three context Global, Session and Message. */ public class SessionContext extends AbstractContext implements Externalizable, SafeSerializable { /** * @serial The serialization version ID tracks the version of the class. * If a class definition changes, then the serialization/externalization * of the class is affected. If a change to the class is made which is * not compatible with the serialization/externalization of the class, * then the serialization version ID should be updated. * Refer to the "serialVer" utility to compute a serialization * version ID. */ private static final long serialVersionUID = -1100610673067568556L; /** * @serial Tracks the revision level of a class to identify changes to the * class definition that are compatible to serialization/externalization. * If a class definition changes, then the serialization/externalization * of the class is affected. * Refer to the writeExternal() and readExternal() methods. */ // supported revision levels, add a new level to manage compatible changes private static final int REVISION_2 = 2; // current revision level of this object private static final int revisionID = REVISION_2; // TODO: investigate whether these collections need to be saved private transient Map<String, ServiceContext> serviceContextMap = new HashMap<String, ServiceContext>(); private transient Map<String, ServiceGroupContext> serviceGroupContextMap = new HashMap<String, ServiceGroupContext>(); private String cookieID; private static final Log log = LogFactory.getLog(SessionContext.class); private static final String myClassName = "SessionContext"; // current time out interval is 30 secs. Need to make this configurable public long sessionContextTimeoutInterval = 30 * 1000; /** * @param parent */ public SessionContext(AbstractContext parent) { super(parent); } public SessionContext() { } public void init(AxisConfiguration axisConfiguration) throws AxisFault { } public ServiceContext getServiceContext(AxisService axisService) { return (ServiceContext) serviceContextMap.get(axisService.getName()); } public void addServiceContext(ServiceContext serviceContext) { serviceContextMap.put(serviceContext.getAxisService().getName(), serviceContext); } public void addServiceGroupContext(ServiceGroupContext serviceGroupContext) { String serviceGroupID = serviceGroupContext.getDescription().getServiceGroupName(); serviceGroupContextMap.put(serviceGroupID, serviceGroupContext); } public ServiceGroupContext getServiceGroupContext(String serviceGroupID) { return (ServiceGroupContext) serviceGroupContextMap.get(serviceGroupID); } public String getCookieID() { return cookieID; } public void setCookieID(String cookieID) { this.cookieID = cookieID; } /** * ServiceContext and ServiceGroupContext are not getting automatically garbage collectible. And there * is no specific way for some one to go and make it garbage collectable. * So the current solution is to make them time out. So the logic is that, there is a timer task * in each and every service group which will check for the last touched time. And if it has not * been touched for some time, the timer task will remove it from the memory. * The touching logic happens like this. Whenever there is a call to addMessageContext in the operationContext * it will go and update operationCOntext -> serviceContext -> serviceGroupContext. */ public void touch() { lastTouchedTime = new Date().getTime(); if (parent != null) { parent.touch(); } } public long getLastTouchedTime() { return lastTouchedTime; } public Iterator<ServiceGroupContext> getServiceGroupContext() { if (serviceGroupContextMap != null) { if (serviceGroupContextMap.isEmpty()) { return null; } return serviceGroupContextMap.values().iterator(); } else { return null; } } protected void finalize() throws Throwable { super.finalize(); if (serviceGroupContextMap != null && !serviceGroupContextMap.isEmpty()) { Iterator<ServiceGroupContext> valuse = serviceGroupContextMap.values().iterator(); while (valuse.hasNext()) { ServiceGroupContext serviceGroupContext = (ServiceGroupContext) valuse.next(); cleanupServiceContextes(serviceGroupContext); } } } private void cleanupServiceContextes(ServiceGroupContext serviceGroupContext) { Iterator<ServiceContext> serviceContecxtes = serviceGroupContext.getServiceContexts(); while (serviceContecxtes.hasNext()) { ServiceContext serviceContext = (ServiceContext) serviceContecxtes.next(); DependencyManager.destroyServiceObject(serviceContext); } } /* =============================================================== * Externalizable support * =============================================================== */ /** * Save the contents of this object. * <p/> * NOTE: Transient fields and static fields are not saved. * * @param out The stream to write the object contents to * @throws IOException */ public void writeExternal(ObjectOutput o) throws IOException { SafeObjectOutputStream out = SafeObjectOutputStream.install(o); // write out contents of this object // NOTES: For each item, where appropriate, // write out the following information, IN ORDER: // the class name // the active or empty flag // the data length, if appropriate // the data //--------------------------------------------------------- // in order to handle future changes to the message // context definition, be sure to maintain the // object level identifiers //--------------------------------------------------------- // serialization version ID out.writeLong(serialVersionUID); // revision ID out.writeInt(revisionID); //--------------------------------------------------------- // various simple fields //--------------------------------------------------------- out.writeLong(getLastTouchedTime()); out.writeLong(sessionContextTimeoutInterval); out.writeObject(cookieID); //--------------------------------------------------------- // properties //--------------------------------------------------------- out.writeMap(getProperties()); //--------------------------------------------------------- // "nested" //--------------------------------------------------------- out.writeObject(parent); } /** * Restore the contents of the MessageContext that was * previously saved. * <p/> * NOTE: The field data must read back in the same order and type * as it was written. Some data will need to be validated when * resurrected. * * @param in The stream to read the object contents from * @throws IOException * @throws ClassNotFoundException */ public void readExternal(ObjectInput inObject) throws IOException, ClassNotFoundException { SafeObjectInputStream in = SafeObjectInputStream.install(inObject); // trace point if (log.isTraceEnabled()) { log.trace( myClassName + ":readExternal(): BEGIN bytes available in stream [" + in.available() + "] "); } // serialization version ID long suid = in.readLong(); // revision ID int revID = in.readInt(); // make sure the object data is in a version we can handle if (suid != serialVersionUID) { throw new ClassNotFoundException(ExternalizeConstants.UNSUPPORTED_SUID); } // make sure the object data is in a revision level we can handle if (revID != REVISION_2) { throw new ClassNotFoundException(ExternalizeConstants.UNSUPPORTED_REVID); } //--------------------------------------------------------- // various simple fields //--------------------------------------------------------- long time = in.readLong(); setLastTouchedTime(time); sessionContextTimeoutInterval = in.readLong(); cookieID = (String) in.readObject(); //--------------------------------------------------------- // properties //--------------------------------------------------------- properties = in.readMap(new HashMap()); //--------------------------------------------------------- // "nested" //--------------------------------------------------------- // parent parent = (AbstractContext) in.readObject(); //--------------------------------------------------------- // done //--------------------------------------------------------- serviceContextMap = new HashMap<String, ServiceContext>(); serviceGroupContextMap = new HashMap<String, ServiceGroupContext>(); } public ConfigurationContext getRootContext() { // Session Context does not live within the hierarchy return null; } }