| // |
| // ======================================================================== |
| // Copyright (c) 1995-2017 Mort Bay Consulting Pty. Ltd. |
| // ------------------------------------------------------------------------ |
| // All rights reserved. This program and the accompanying materials |
| // are made available under the terms of the Eclipse Public License v1.0 |
| // and Apache License v2.0 which accompanies this distribution. |
| // |
| // The Eclipse Public License is available at |
| // http://www.eclipse.org/legal/epl-v10.html |
| // |
| // The Apache License v2.0 is available at |
| // http://www.opensource.org/licenses/apache2.0.php |
| // |
| // You may elect to redistribute this code under either of these licenses. |
| // ======================================================================== |
| // |
| |
| package org.eclipse.jetty.nosql.mongodb; |
| |
| import java.io.ByteArrayInputStream; |
| import java.io.ByteArrayOutputStream; |
| import java.io.IOException; |
| import java.io.ObjectInputStream; |
| import java.io.ObjectOutputStream; |
| import java.net.UnknownHostException; |
| import java.util.Date; |
| import java.util.HashMap; |
| import java.util.Map; |
| import java.util.Set; |
| |
| import org.eclipse.jetty.nosql.NoSqlSession; |
| import org.eclipse.jetty.nosql.NoSqlSessionManager; |
| import org.eclipse.jetty.server.SessionIdManager; |
| import org.eclipse.jetty.util.annotation.ManagedAttribute; |
| import org.eclipse.jetty.util.annotation.ManagedObject; |
| import org.eclipse.jetty.util.annotation.ManagedOperation; |
| import org.eclipse.jetty.util.log.Log; |
| import org.eclipse.jetty.util.log.Logger; |
| |
| import com.mongodb.BasicDBObject; |
| import com.mongodb.DBCollection; |
| import com.mongodb.DBObject; |
| import com.mongodb.MongoException; |
| import com.mongodb.WriteConcern; |
| import com.mongodb.WriteResult; |
| |
| |
| /** |
| * MongoSessionManager |
| * |
| * Clustered session manager using MongoDB as the shared DB instance. |
| * The document model is an outer object that contains the elements: |
| * <ul> |
| * <li>"id" : session_id </li> |
| * <li>"created" : create_time </li> |
| * <li>"accessed": last_access_time </li> |
| * <li>"maxIdle" : max_idle_time setting as session was created </li> |
| * <li>"expiry" : time at which session should expire </li> |
| * <li>"valid" : session_valid </li> |
| * <li>"context" : a nested object containing 1 nested object per context for which the session id is in use |
| * </ul> |
| * Each of the nested objects inside the "context" element contains: |
| * <ul> |
| * <li>unique_context_name : nested object containing name:value pairs of the session attributes for that context</li> |
| * </ul> |
| * <p> |
| * One of the name:value attribute pairs will always be the special attribute "__metadata__". The value |
| * is an object representing a version counter which is incremented every time the attributes change. |
| * </p> |
| * <p> |
| * For example: |
| * <code> |
| * { "_id" : ObjectId("52845534a40b66410f228f23"), |
| * "accessed" : NumberLong("1384818548903"), |
| * "maxIdle" : 1, |
| * "context" : { "::/contextA" : { "A" : "A", |
| * "__metadata__" : { "version" : NumberLong(2) } |
| * }, |
| * "::/contextB" : { "B" : "B", |
| * "__metadata__" : { "version" : NumberLong(1) } |
| * } |
| * }, |
| * "created" : NumberLong("1384818548903"), |
| * "expiry" : NumberLong("1384818549903"), |
| * "id" : "w01ijx2vnalgv1sqrpjwuirprp7", |
| * "valid" : true |
| * } |
| * </code> |
| * </p> |
| * <p> |
| * In MongoDB, the nesting level is indicated by "." separators for the key name. Thus to |
| * interact with a session attribute, the key is composed of: |
| * "context".unique_context_name.attribute_name |
| * Eg "context"."::/contextA"."A" |
| * </p> |
| */ |
| @ManagedObject("Mongo Session Manager") |
| public class MongoSessionManager extends NoSqlSessionManager |
| { |
| private static final Logger LOG = Log.getLogger(MongoSessionManager.class); |
| |
| private final static Logger __log = Log.getLogger("org.eclipse.jetty.server.session"); |
| |
| /* |
| * strings used as keys or parts of keys in mongo |
| */ |
| /** |
| * Special attribute for a session that is context-specific |
| */ |
| private final static String __METADATA = "__metadata__"; |
| |
| |
| /** |
| * Session id |
| */ |
| public final static String __ID = "id"; |
| |
| /** |
| * Time of session creation |
| */ |
| private final static String __CREATED = "created"; |
| |
| /** |
| * Whether or not session is valid |
| */ |
| public final static String __VALID = "valid"; |
| |
| /** |
| * Time at which session was invalidated |
| */ |
| public final static String __INVALIDATED = "invalidated"; |
| |
| /** |
| * Last access time of session |
| */ |
| public final static String __ACCESSED = "accessed"; |
| |
| /** |
| * Time this session will expire, based on last access time and maxIdle |
| */ |
| public final static String __EXPIRY = "expiry"; |
| |
| /** |
| * The max idle time of a session (smallest value across all contexts which has a session with the same id) |
| */ |
| public final static String __MAX_IDLE = "maxIdle"; |
| |
| /** |
| * Name of nested document field containing 1 sub document per context for which the session id is in use |
| */ |
| private final static String __CONTEXT = "context"; |
| |
| |
| /** |
| * Special attribute per session per context, incremented each time attributes are modified |
| */ |
| public final static String __VERSION = __METADATA + ".version"; |
| |
| /** |
| * the context id is only set when this class has been started |
| */ |
| private String _contextId = null; |
| |
| |
| /** |
| * Access to MongoDB |
| */ |
| private DBCollection _dbSessions; |
| |
| |
| /** |
| * Utility value of 1 for a session version for this context |
| */ |
| private DBObject _version_1; |
| |
| |
| /* ------------------------------------------------------------ */ |
| public MongoSessionManager() throws UnknownHostException, MongoException |
| { |
| |
| } |
| |
| |
| |
| /*------------------------------------------------------------ */ |
| @Override |
| public void doStart() throws Exception |
| { |
| super.doStart(); |
| String[] hosts = getContextHandler().getVirtualHosts(); |
| |
| if (hosts == null || hosts.length == 0) |
| hosts = new String[] |
| { "::" }; // IPv6 equiv of 0.0.0.0 |
| |
| String contextPath = getContext().getContextPath(); |
| if (contextPath == null || "".equals(contextPath)) |
| { |
| contextPath = "*"; |
| } |
| |
| _contextId = createContextId(hosts,contextPath); |
| _version_1 = new BasicDBObject(getContextAttributeKey(__VERSION),1); |
| } |
| |
| /* ------------------------------------------------------------ */ |
| /** |
| * @see org.eclipse.jetty.server.session.AbstractSessionManager#setSessionIdManager(org.eclipse.jetty.server.SessionIdManager) |
| */ |
| @Override |
| public void setSessionIdManager(SessionIdManager metaManager) |
| { |
| MongoSessionIdManager msim = (MongoSessionIdManager)metaManager; |
| _dbSessions=msim.getSessions(); |
| super.setSessionIdManager(metaManager); |
| |
| } |
| |
| /* ------------------------------------------------------------ */ |
| @Override |
| protected synchronized Object save(NoSqlSession session, Object version, boolean activateAfterSave) |
| { |
| try |
| { |
| __log.debug("MongoSessionManager:save session {}", session.getClusterId()); |
| session.willPassivate(); |
| |
| // Form query for upsert |
| BasicDBObject key = new BasicDBObject(__ID,session.getClusterId()); |
| |
| // Form updates |
| BasicDBObject update = new BasicDBObject(); |
| boolean upsert = false; |
| BasicDBObject sets = new BasicDBObject(); |
| BasicDBObject unsets = new BasicDBObject(); |
| |
| |
| // handle valid or invalid |
| if (session.isValid()) |
| { |
| long expiry = (session.getMaxInactiveInterval() > 0?(session.getAccessed()+(1000L*getMaxInactiveInterval())):0); |
| __log.debug("MongoSessionManager: calculated expiry {} for session {}", expiry, session.getId()); |
| |
| // handle new or existing |
| if (version == null) |
| { |
| // New session |
| upsert = true; |
| version = new Long(1); |
| sets.put(__CREATED,session.getCreationTime()); |
| sets.put(__VALID,true); |
| |
| sets.put(getContextAttributeKey(__VERSION),version); |
| sets.put(__MAX_IDLE, getMaxInactiveInterval()); |
| sets.put(__EXPIRY, expiry); |
| } |
| else |
| { |
| version = new Long(((Number)version).longValue() + 1); |
| update.put("$inc",_version_1); |
| //if max idle time and/or expiry is smaller for this context, then choose that for the whole session doc |
| BasicDBObject fields = new BasicDBObject(); |
| fields.append(__MAX_IDLE, true); |
| fields.append(__EXPIRY, true); |
| DBObject o = _dbSessions.findOne(new BasicDBObject("id",session.getClusterId()), fields); |
| if (o != null) |
| { |
| Integer currentMaxIdle = (Integer)o.get(__MAX_IDLE); |
| Long currentExpiry = (Long)o.get(__EXPIRY); |
| if (currentMaxIdle != null && getMaxInactiveInterval() > 0 && getMaxInactiveInterval() < currentMaxIdle) |
| sets.put(__MAX_IDLE, getMaxInactiveInterval()); |
| if (currentExpiry != null && expiry > 0 && expiry != currentExpiry) |
| sets.put(__EXPIRY, expiry); |
| } |
| } |
| |
| sets.put(__ACCESSED,session.getAccessed()); |
| Set<String> names = session.takeDirty(); |
| if (isSaveAllAttributes() || upsert) |
| { |
| names.addAll(session.getNames()); // note dirty may include removed names |
| } |
| |
| for (String name : names) |
| { |
| Object value = session.getAttribute(name); |
| if (value == null) |
| unsets.put(getContextKey() + "." + encodeName(name),1); |
| else |
| sets.put(getContextKey() + "." + encodeName(name),encodeName(value)); |
| } |
| } |
| else |
| { |
| sets.put(__VALID,false); |
| sets.put(__INVALIDATED, System.currentTimeMillis()); |
| unsets.put(getContextKey(),1); |
| } |
| |
| // Do the upsert |
| if (!sets.isEmpty()) |
| update.put("$set",sets); |
| if (!unsets.isEmpty()) |
| update.put("$unset",unsets); |
| |
| _dbSessions.update(key,update,upsert,false,WriteConcern.SAFE); |
| |
| if (__log.isDebugEnabled()) |
| __log.debug("MongoSessionManager:save:db.sessions.update( {}, {} )", key, update); |
| |
| if (activateAfterSave) |
| session.didActivate(); |
| |
| return version; |
| } |
| catch (Exception e) |
| { |
| LOG.warn(e); |
| } |
| return null; |
| } |
| |
| /*------------------------------------------------------------ */ |
| @Override |
| protected Object refresh(NoSqlSession session, Object version) |
| { |
| __log.debug("MongoSessionManager:refresh session {}", session.getId()); |
| |
| // check if our in memory version is the same as what is on the disk |
| if (version != null) |
| { |
| DBObject o = _dbSessions.findOne(new BasicDBObject(__ID,session.getClusterId()),_version_1); |
| |
| if (o != null) |
| { |
| Object saved = getNestedValue(o, getContextAttributeKey(__VERSION)); |
| |
| if (saved != null && saved.equals(version)) |
| { |
| __log.debug("MongoSessionManager:refresh not needed session {}", session.getId()); |
| return version; |
| } |
| version = saved; |
| } |
| } |
| |
| // If we are here, we have to load the object |
| DBObject o = _dbSessions.findOne(new BasicDBObject(__ID,session.getClusterId())); |
| |
| // If it doesn't exist, invalidate |
| if (o == null) |
| { |
| __log.debug("MongoSessionManager:refresh:marking session {} invalid, no object", session.getClusterId()); |
| session.invalidate(); |
| return null; |
| } |
| |
| // If it has been flagged invalid, invalidate |
| Boolean valid = (Boolean)o.get(__VALID); |
| if (valid == null || !valid) |
| { |
| __log.debug("MongoSessionManager:refresh:marking session {} invalid, valid flag {}", session.getClusterId(), valid); |
| session.invalidate(); |
| return null; |
| } |
| |
| // We need to update the attributes. We will model this as a passivate, |
| // followed by bindings and then activation. |
| session.willPassivate(); |
| try |
| { |
| DBObject attrs = (DBObject)getNestedValue(o,getContextKey()); |
| //if disk version now has no attributes, get rid of them |
| if (attrs == null || attrs.keySet().size() == 0) |
| { |
| session.clearAttributes(); |
| } |
| else |
| { |
| //iterate over the names of the attributes on the disk version, updating the value |
| for (String name : attrs.keySet()) |
| { |
| //skip special metadata field which is not one of the session attributes |
| if (__METADATA.equals(name)) |
| continue; |
| |
| String attr = decodeName(name); |
| Object value = decodeValue(attrs.get(name)); |
| |
| //session does not already contain this attribute, so bind it |
| if (session.getAttribute(attr) == null) |
| { |
| session.doPutOrRemove(attr,value); |
| session.bindValue(attr,value); |
| } |
| else //session already contains this attribute, update its value |
| { |
| session.doPutOrRemove(attr,value); |
| } |
| |
| } |
| // cleanup, remove values from session, that don't exist in data anymore: |
| for (String str : session.getNames()) |
| { |
| if (!attrs.keySet().contains(encodeName(str))) |
| { |
| session.doPutOrRemove(str,null); |
| session.unbindValue(str,session.getAttribute(str)); |
| } |
| } |
| } |
| |
| /* |
| * We are refreshing so we should update the last accessed time. |
| */ |
| BasicDBObject key = new BasicDBObject(__ID,session.getClusterId()); |
| BasicDBObject sets = new BasicDBObject(); |
| // Form updates |
| BasicDBObject update = new BasicDBObject(); |
| sets.put(__ACCESSED,System.currentTimeMillis()); |
| // Do the upsert |
| if (!sets.isEmpty()) |
| { |
| update.put("$set",sets); |
| } |
| |
| _dbSessions.update(key,update,false,false,WriteConcern.SAFE); |
| |
| session.didActivate(); |
| |
| return version; |
| } |
| catch (Exception e) |
| { |
| LOG.warn(e); |
| } |
| |
| return null; |
| } |
| |
| /*------------------------------------------------------------ */ |
| @Override |
| protected synchronized NoSqlSession loadSession(String clusterId) |
| { |
| DBObject o = _dbSessions.findOne(new BasicDBObject(__ID,clusterId)); |
| |
| __log.debug("MongoSessionManager:id={} loaded={}", clusterId, o); |
| if (o == null) |
| return null; |
| |
| Boolean valid = (Boolean)o.get(__VALID); |
| __log.debug("MongoSessionManager:id={} valid={}", clusterId, valid); |
| if (valid == null || !valid) |
| return null; |
| |
| try |
| { |
| Object version = o.get(getContextAttributeKey(__VERSION)); |
| Long created = (Long)o.get(__CREATED); |
| Long accessed = (Long)o.get(__ACCESSED); |
| |
| NoSqlSession session = null; |
| |
| // get the session for the context |
| DBObject attrs = (DBObject)getNestedValue(o,getContextKey()); |
| |
| __log.debug("MongoSessionManager:attrs {}", attrs); |
| if (attrs != null) |
| { |
| __log.debug("MongoSessionManager: session {} present for context {}", clusterId, getContextKey()); |
| //only load a session if it exists for this context |
| session = new NoSqlSession(this,created,accessed,clusterId,version); |
| |
| for (String name : attrs.keySet()) |
| { |
| //skip special metadata attribute which is not one of the actual session attributes |
| if ( __METADATA.equals(name) ) |
| continue; |
| |
| String attr = decodeName(name); |
| Object value = decodeValue(attrs.get(name)); |
| |
| session.doPutOrRemove(attr,value); |
| session.bindValue(attr,value); |
| } |
| session.didActivate(); |
| } |
| else |
| __log.debug("MongoSessionManager: session {} not present for context {}",clusterId, getContextKey()); |
| |
| return session; |
| } |
| catch (Exception e) |
| { |
| LOG.warn(e); |
| } |
| return null; |
| } |
| |
| |
| |
| /*------------------------------------------------------------ */ |
| /** |
| * Remove the per-context sub document for this session id. |
| * @see org.eclipse.jetty.nosql.NoSqlSessionManager#remove(org.eclipse.jetty.nosql.NoSqlSession) |
| */ |
| @Override |
| protected boolean remove(NoSqlSession session) |
| { |
| __log.debug("MongoSessionManager:remove:session {} for context {}",session.getClusterId(), getContextKey()); |
| |
| /* |
| * Check if the session exists and if it does remove the context |
| * associated with this session |
| */ |
| BasicDBObject key = new BasicDBObject(__ID,session.getClusterId()); |
| |
| DBObject o = _dbSessions.findOne(key,_version_1); |
| |
| if (o != null) |
| { |
| BasicDBObject remove = new BasicDBObject(); |
| BasicDBObject unsets = new BasicDBObject(); |
| unsets.put(getContextKey(),1); |
| remove.put("$unset",unsets); |
| _dbSessions.update(key,remove,false,false,WriteConcern.SAFE); |
| |
| return true; |
| } |
| else |
| { |
| return false; |
| } |
| } |
| |
| |
| |
| /** |
| * @see org.eclipse.jetty.nosql.NoSqlSessionManager#expire(java.lang.String) |
| */ |
| @Override |
| protected void expire (String idInCluster) |
| { |
| __log.debug("MongoSessionManager:expire session {} ", idInCluster); |
| |
| //Expire the session for this context |
| super.expire(idInCluster); |
| |
| //If the outer session document has not already been marked invalid, do so. |
| DBObject validKey = new BasicDBObject(__VALID, true); |
| DBObject o = _dbSessions.findOne(new BasicDBObject(__ID,idInCluster), validKey); |
| |
| if (o != null && (Boolean)o.get(__VALID)) |
| { |
| BasicDBObject update = new BasicDBObject(); |
| BasicDBObject sets = new BasicDBObject(); |
| sets.put(__VALID,false); |
| sets.put(__INVALIDATED, System.currentTimeMillis()); |
| update.put("$set",sets); |
| |
| BasicDBObject key = new BasicDBObject(__ID,idInCluster); |
| _dbSessions.update(key,update,false,false,WriteConcern.SAFE); |
| } |
| } |
| |
| |
| /*------------------------------------------------------------ */ |
| /** |
| * Change the session id. Note that this will change the session id for all contexts for which the session id is in use. |
| * @see org.eclipse.jetty.nosql.NoSqlSessionManager#update(org.eclipse.jetty.nosql.NoSqlSession, java.lang.String, java.lang.String) |
| */ |
| @Override |
| protected void update(NoSqlSession session, String newClusterId, String newNodeId) throws Exception |
| { |
| BasicDBObject key = new BasicDBObject(__ID, session.getClusterId()); |
| BasicDBObject sets = new BasicDBObject(); |
| BasicDBObject update = new BasicDBObject(__ID, newClusterId); |
| sets.put("$set", update); |
| _dbSessions.update(key, sets, false, false,WriteConcern.SAFE); |
| } |
| |
| /*------------------------------------------------------------ */ |
| protected String encodeName(String name) |
| { |
| return name.replace("%","%25").replace(".","%2E"); |
| } |
| |
| /*------------------------------------------------------------ */ |
| protected String decodeName(String name) |
| { |
| return name.replace("%2E",".").replace("%25","%"); |
| } |
| |
| /*------------------------------------------------------------ */ |
| protected Object encodeName(Object value) throws IOException |
| { |
| if (value instanceof Number || value instanceof String || value instanceof Boolean || value instanceof Date) |
| { |
| return value; |
| } |
| else if (value.getClass().equals(HashMap.class)) |
| { |
| BasicDBObject o = new BasicDBObject(); |
| for (Map.Entry<?, ?> entry : ((Map<?, ?>)value).entrySet()) |
| { |
| if (!(entry.getKey() instanceof String)) |
| { |
| o = null; |
| break; |
| } |
| o.append(encodeName(entry.getKey().toString()),encodeName(entry.getValue())); |
| } |
| |
| if (o != null) |
| return o; |
| } |
| |
| ByteArrayOutputStream bout = new ByteArrayOutputStream(); |
| ObjectOutputStream out = new ObjectOutputStream(bout); |
| out.reset(); |
| out.writeUnshared(value); |
| out.flush(); |
| return bout.toByteArray(); |
| } |
| |
| /*------------------------------------------------------------ */ |
| protected Object decodeValue(final Object valueToDecode) throws IOException, ClassNotFoundException |
| { |
| if (valueToDecode == null || valueToDecode instanceof Number || valueToDecode instanceof String || valueToDecode instanceof Boolean || valueToDecode instanceof Date) |
| { |
| return valueToDecode; |
| } |
| else if (valueToDecode instanceof byte[]) |
| { |
| final byte[] decodeObject = (byte[])valueToDecode; |
| final ByteArrayInputStream bais = new ByteArrayInputStream(decodeObject); |
| final ClassLoadingObjectInputStream objectInputStream = new ClassLoadingObjectInputStream(bais); |
| return objectInputStream.readUnshared(); |
| } |
| else if (valueToDecode instanceof DBObject) |
| { |
| Map<String, Object> map = new HashMap<String, Object>(); |
| for (String name : ((DBObject)valueToDecode).keySet()) |
| { |
| String attr = decodeName(name); |
| map.put(attr,decodeValue(((DBObject)valueToDecode).get(name))); |
| } |
| return map; |
| } |
| else |
| { |
| throw new IllegalStateException(valueToDecode.getClass().toString()); |
| } |
| } |
| |
| |
| /*------------------------------------------------------------ */ |
| private String getContextKey() |
| { |
| return __CONTEXT + "." + _contextId; |
| } |
| |
| /*------------------------------------------------------------ */ |
| /** Get a dot separated key for |
| * @param key |
| * @return |
| */ |
| private String getContextAttributeKey(String attr) |
| { |
| return getContextKey()+ "." + attr; |
| } |
| |
| /*------------------------------------------------------------ */ |
| @ManagedOperation(value="purge invalid sessions in the session store based on normal criteria", impact="ACTION") |
| public void purge() |
| { |
| ((MongoSessionIdManager)_sessionIdManager).purge(); |
| } |
| |
| |
| /*------------------------------------------------------------ */ |
| @ManagedOperation(value="full purge of invalid sessions in the session store", impact="ACTION") |
| public void purgeFully() |
| { |
| ((MongoSessionIdManager)_sessionIdManager).purgeFully(); |
| } |
| |
| /*------------------------------------------------------------ */ |
| @ManagedOperation(value="scavenge sessions known to this manager", impact="ACTION") |
| public void scavenge() |
| { |
| ((MongoSessionIdManager)_sessionIdManager).scavenge(); |
| } |
| |
| /*------------------------------------------------------------ */ |
| @ManagedOperation(value="scanvenge all sessions", impact="ACTION") |
| public void scavengeFully() |
| { |
| ((MongoSessionIdManager)_sessionIdManager).scavengeFully(); |
| } |
| |
| /*------------------------------------------------------------ */ |
| /** |
| * returns the total number of session objects in the session store |
| * |
| * the count() operation itself is optimized to perform on the server side |
| * and avoid loading to client side. |
| */ |
| @ManagedAttribute("total number of known sessions in the store") |
| public long getSessionStoreCount() |
| { |
| return _dbSessions.find().count(); |
| } |
| |
| /*------------------------------------------------------------ */ |
| /** |
| * MongoDB keys are . delimited for nesting so .'s are protected characters |
| * |
| * @param virtualHosts |
| * @param contextPath |
| * @return |
| */ |
| private String createContextId(String[] virtualHosts, String contextPath) |
| { |
| String contextId = virtualHosts[0] + contextPath; |
| |
| contextId.replace('/', '_'); |
| contextId.replace('.','_'); |
| contextId.replace('\\','_'); |
| |
| return contextId; |
| } |
| |
| /*------------------------------------------------------------ */ |
| /** |
| * Dig through a given dbObject for the nested value |
| */ |
| private Object getNestedValue(DBObject dbObject, String nestedKey) |
| { |
| String[] keyChain = nestedKey.split("\\."); |
| |
| DBObject temp = dbObject; |
| |
| for (int i = 0; i < keyChain.length - 1; ++i) |
| { |
| temp = (DBObject)temp.get(keyChain[i]); |
| |
| if ( temp == null ) |
| { |
| return null; |
| } |
| } |
| |
| return temp.get(keyChain[keyChain.length - 1]); |
| } |
| |
| |
| /*------------------------------------------------------------ */ |
| /** |
| * ClassLoadingObjectInputStream |
| * |
| * |
| */ |
| protected class ClassLoadingObjectInputStream extends ObjectInputStream |
| { |
| public ClassLoadingObjectInputStream(java.io.InputStream in) throws IOException |
| { |
| super(in); |
| } |
| |
| public ClassLoadingObjectInputStream () throws IOException |
| { |
| super(); |
| } |
| |
| @Override |
| public Class<?> resolveClass (java.io.ObjectStreamClass cl) throws IOException, ClassNotFoundException |
| { |
| try |
| { |
| return Class.forName(cl.getName(), false, Thread.currentThread().getContextClassLoader()); |
| } |
| catch (ClassNotFoundException e) |
| { |
| return super.resolveClass(cl); |
| } |
| } |
| } |
| |
| |
| } |
