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.axiom.util.UIDGenerator; import org.apache.axis2.AxisFault; import org.apache.axis2.context.externalize.ActivateUtils; 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.description.AxisServiceGroup; import org.apache.axis2.engine.AxisConfiguration; import org.apache.axis2.i18n.Messages; import org.apache.axis2.util.MetaDataEntry; 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.HashMap; import java.util.Iterator; import java.util.Map; public class ServiceGroupContext extends AbstractContext implements Externalizable, SafeSerializable { /* * setup for logging */ private static final Log log = LogFactory.getLog(ServiceGroupContext.class); private static final String myClassName = "ServiceGroupContext"; /** * @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 = 9014471144479928885L; /** * @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; private transient AxisServiceGroup axisServiceGroup; private String id; private Map<String, ServiceContext> serviceContextMap; //---------------------------------------------------------------- // MetaData for data to be restored in activate after readExternal //---------------------------------------------------------------- /** * Indicates whether the message context has been reconstituted * and needs to have its object references reconciled */ private transient boolean needsToBeReconciled = false; /** * The AxisServiceContext metadata will be used during * activate to match up with an existing object */ private transient MetaDataEntry metaAxisServiceGroup = null; //---------------------------------------------------------------- // end MetaData section //---------------------------------------------------------------- // simple constructor public ServiceGroupContext() { super(null); serviceContextMap = new HashMap<String, ServiceContext>(); } public ServiceGroupContext(ConfigurationContext parent, AxisServiceGroup axisServiceGroup) { super(parent); this.axisServiceGroup = axisServiceGroup; serviceContextMap = new HashMap<String, ServiceContext>(); // initially set the id to the axisServiceGroup if (axisServiceGroup != null) { setId(axisServiceGroup.getServiceGroupName()); } } public AxisServiceGroup getDescription() { checkActivateWarning("getDescription"); return axisServiceGroup; } public String getId() { return id; } /** * Gets a service context. Creates a new one from AxisService. * There is no need to store service context inside serviceGroup * context as well. * * @param service the AxisService for which to get a context * @return Returns ServiceContext. * @throws AxisFault if something goes wrong */ public ServiceContext getServiceContext(AxisService service) throws AxisFault { AxisService axisService = axisServiceGroup.getService(service.getName()); if (axisService == null) { throw new AxisFault(Messages.getMessage("invalidserviceinagroup", service.getName(), axisServiceGroup.getServiceGroupName())); } if (serviceContextMap == null) { serviceContextMap = new HashMap<String, ServiceContext>(); } ServiceContext serviceContext = (ServiceContext) serviceContextMap.get(service.getName()); if (serviceContext == null) { serviceContext = new ServiceContext(service, this); getRootContext().contextCreated(serviceContext); serviceContextMap.put(service.getName(), serviceContext); } return serviceContext; } public Iterator<ServiceContext> getServiceContexts() { if (serviceContextMap == null) { serviceContextMap = new HashMap<String, ServiceContext>(); } if (serviceContextMap.isEmpty()) { return null; } return serviceContextMap.values().iterator(); } public void setId(String id) { this.id = id; } /** * Adds the specified service context object to the * lists of service contexts for this service group * context. * * @param srvctx The ServiceContext object to add */ public void addServiceContext(ServiceContext srvctx) { if (srvctx == null) { return; } AxisService axisService = srvctx.getAxisService(); if (axisService == null) { return; } if (serviceContextMap == null) { serviceContextMap = new HashMap<String, ServiceContext>(); } serviceContextMap.put(axisService.getName(), srvctx); } /** * Finds the service context object that corresponds * to the specified name from the list * of service contexts for this service group * context. * * @param name The name associated with the ServiceContext * @return The ServiceContext associated with the name, * or null, if none can be found */ public ServiceContext findServiceContext(String name) { if (serviceContextMap == null) { return null; } return (ServiceContext) serviceContextMap.get(name); } /** * Finds the service context object that corresponds * to the specified AxisService from the list * of service contexts for this service group * context. * * @param axisSrv the AxisService whose context we're looking for * @return The ServiceContext associated with the AxisService * or null, if none can be found */ public ServiceContext findServiceContext(AxisService axisSrv) { if (axisSrv == null) { return null; } if (serviceContextMap == null) { return null; } return (ServiceContext) serviceContextMap.get(axisSrv.getName()); } /** * This will do a copy of the properties from this context object * to the properties of the specified context object. * * @param context The ServiceGroupContext object to hold the merged properties */ public void putContextProperties(ServiceGroupContext context) { if (context != null) { // get the current properties on this context object Map<String, Object> props = getProperties(); // copy them to the specified context object context.mergeProperties(props); } } /* =============================================================== * Externalizable support * =============================================================== */ /** * Save the contents of this object. * <p/> * NOTE: Transient fields and static fields are not saved. * Also, objects that represent "static" data are * not saved, except for enough information to be * able to find matching objects when the message * context is re-constituted. * * @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 //--------------------------------------------------------- // 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()); if (id == null) { // generate an ID to use when this object is restored id = UIDGenerator.generateUID(); } out.writeObject(id); //--------------------------------------------------------- // properties //--------------------------------------------------------- out.writeMap(getProperties()); //--------------------------------------------------------- // AxisServiceGroup //--------------------------------------------------------- metaAxisServiceGroup = null; if (axisServiceGroup != null) { metaAxisServiceGroup = new MetaDataEntry(axisServiceGroup.getClass().getName(), axisServiceGroup.getServiceGroupName()); } out.writeObject(metaAxisServiceGroup); //--------------------------------------------------------- // parent //--------------------------------------------------------- // the parent is the ConfigurationContext object, which // at this time, is not being saved. // instead, we will need to register this ServiceGroupObject // with the existing ConfigurationContext object when // this object is reconstituted } /** * Restore the contents of the object 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); // set the flag to indicate that the message context is being // reconstituted and will need to have certain object references // to be reconciled with the current engine setup needsToBeReconciled = true; // 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); id = (String) in.readObject(); //--------------------------------------------------------- // properties //--------------------------------------------------------- properties = in.readMap(new HashMap()); //--------------------------------------------------------- // AxisServiceGroup //--------------------------------------------------------- // axisServiceGroup is not usable until the meta data has been reconciled axisServiceGroup = null; metaAxisServiceGroup = (MetaDataEntry) in.readObject(); //--------------------------------------------------------- // parent //--------------------------------------------------------- // the parent is the ConfigurationContext object, whic // at this time, is not being saved. // instead, we will need to register this ServiceGroupObject // with the existing ConfigurationContext object when // this object is reconstituted //--------------------------------------------------------- // other //--------------------------------------------------------- serviceContextMap = new HashMap<String, ServiceContext>(); //--------------------------------------------------------- // done //--------------------------------------------------------- } /** * Some parts of the object restored from the * readExternal deserialization work cannot be completed until * we have a configurationContext. This method checks to see * if additional work needs to be done in order to complete * the object reconstitution. * * @param cc the active ConfigurationContext */ public void activate(ConfigurationContext cc) { // see if there's any work to do if (!needsToBeReconciled) { // return quick return; } // get the axis configuration AxisConfiguration axisConfig = cc.getAxisConfiguration(); // We previously saved metaAxisServiceGroup; restore it if (metaAxisServiceGroup != null) { axisServiceGroup = ActivateUtils.findServiceGroup(axisConfig, metaAxisServiceGroup.getClassName(), metaAxisServiceGroup.getQNameAsString()); } else { axisServiceGroup = null; } // set parent this.setParent(cc); // register with the parent cc.addServiceGroupContextIntoSoapSessionTable(this); //------------------------------------------------------- // done, reset the flag //------------------------------------------------------- needsToBeReconciled = false; } /** * Compares key parts of the state from the current instance of * this class with the specified instance to see if they are * equivalent. * <p/> * This differs from the java.lang.Object.equals() method in * that the equals() method generally looks at both the * object identity (location in memory) and the object state * (data). * <p/> * * @param ctx The object to compare with * @return TRUE if this object is equivalent with the specified object * that is, key fields match * FALSE, otherwise */ public boolean isEquivalent(ServiceGroupContext ctx) { // NOTE: the input object is expected to exist (ie, be non-null) if (!this.axisServiceGroup.equals(ctx.getDescription())) { return false; } String ctxid = ctx.getId(); if ((this.id != null) && (ctxid != null)) { if (!this.id.equals(ctxid)) { return false; } } else if ((this.id == null) && (ctxid == null)) { // keep going } else { // mismatch return false; } // TODO: consider checking the parent objects for equivalency // TODO: consider checking fields from the super class for equivalency return true; } /** * Trace a warning message, if needed, indicating that this * object needs to be activated before accessing certain fields. * * @param methodname The method where the warning occurs */ private void checkActivateWarning(String methodname) { if (needsToBeReconciled) { log.warn(myClassName + ":" + methodname + "(): ****WARNING**** " + myClassName + ".activate(configurationContext) needs to be invoked."); } } public ConfigurationContext getRootContext() { //parent of the ServiceGroupContext is the ConfigurationContext return (ConfigurationContext) this.getParent(); } }