Try :
1. thread class loader
2. application class loader
3. system class loader
@param desc
@return
@throws IOException
@throws ClassNotFoundException
322973
@Override
	protected Class<?> resolveClass(ObjectStreamClass desc) throws IOException, ClassNotFoundException {
        String name = desc.getName();

		try {
			ClassLoader cl = Thread.currentThread().getContextClassLoader();
			return Class.forName(name, false, cl);
		} catch (Throwable ex) {
			logger.debug("Cannot access thread context ClassLoader!", ex);
		}
		
		try {
			ClassLoader cl = MultiClassLoaderObjectInputStream.class.getClassLoader();
			return Class.forName(name, false, cl);
		} catch (Throwable ex) {
			logger.debug("Cannot access application ClassLoader", ex);
		}
		
		try {
			ClassLoader cl = ClassLoader.getSystemClassLoader();
			return Class.forName(name, false, cl);
		} catch (Throwable ex) {
			logger.debug("Cannot access system ClassLoader", ex);
		}

        return super.resolveClass(desc);
    }
485828
@Override
    public void afterClassLoad(Class<?> clazz) {
        super.afterClassLoad(clazz);
        //force <clinit> to be run, while the correct ThreadLocal is set
        //if we do not run this then <clinit> may be run later, perhaps even in
        //another thread
        try {
            Class.forName(clazz.getName(), true, clazz.getClassLoader());
        } catch (ClassNotFoundException e) {
            throw new RuntimeException(e);
        }
    }
879881
@SuppressWarnings("unchecked")
    public static <T> boolean hasClass(Class<T> type, ClassLoader classloader) {
        try {
            loadClass(type.getName(), classloader);
            return true;
        } catch (RuntimeException e) {
            if(e.getCause() instanceof ClassNotFoundException) {
                return false;
            }
            throw e;
        }
    }
1129954
@SuppressWarnings("rawtypes")
    public static @Nonnull
    TypeQualifierValue<?> getValue(ClassDescriptor desc, @CheckForNull  Object value) {
        DualKeyHashMap<ClassDescriptor, Object, TypeQualifierValue<?>> map = instance.get().typeQualifierMap;
        TypeQualifierValue<?> result = map.get(desc, value);
        if (result != null) {
            return result;
        }
        result = new TypeQualifierValue(desc, value);
        map.put(desc, value, result);
        instance.get().allKnownTypeQualifiers.add(result);
        return result;
    }
918763
@SuppressWarnings("unchecked")
    private Class<? extends T> loadClass(ClassLoader classLoader, String generatedName)
            throws ClassNotFoundException {
        return (Class<? extends T>) classLoader.loadClass(generatedName);
    }
1279324
public Object loadObject(InputStream inputStream) throws IOException, ClassNotFoundException {
        ClassLoader classLoader = _classLoader;
        if (classLoader == null) {
            classLoader = getContextClassLoader();
        }

        ObjectInputStream objectInputStream = _serializationService.createObjectInputStream(inputStream, classLoader);
        Object object = null;
        try {
            object = objectInputStream.readObject();
        } catch (Throwable t) {
            FFDCFilter.processException(
                                        t,
                                        "com.ibm.ws.session.SessionLoader.loadObject",
                                        "82",
                                        this);

            if (t instanceof IOException) {
                throw (IOException) t;
            }

            if (t instanceof ClassNotFoundException) {
                throw (ClassNotFoundException) t;
            }
        }

        return object;
    }
60467
public Object lookup(String type, String url)
        throws IOException
    {
        ClassLoader loader = Thread.currentThread().getContextClassLoader();

        try {
            Class api = Class.forName(type, false, loader);

            return factory.create(api, url);
        } catch (Exception e) {
            throw new IOException(String.valueOf(e));
        }
    }
1036831
@Deprecated
  public static <C> Class<? extends C> loadFromClassOrInherit(String handle, Class<C> ifaceClass,
          Map<String, Object> tuples) throws Exception {
    String[] name = handle.split("!");
    if (name[0].equals("class")) {
      return Class.forName(name[1]).asSubclass(ifaceClass);
    } else {
      if (name[0].equals("inherit")) {
        AnyObject yaml = ConfigurationLoader.load(name[1]);
        return getFromClassOrInherit(yaml, ifaceClass, tuples);
      } else {
        throw new IllegalArgumentException(
                "Illegal experiment descriptor, must contain one node of type <class> or <inherit>");
      }
    }
  }
989439
public static IOException getIOException(String desc, int code) {
        return new IOException(desc + ErrorMessageCache.get(code));
    }
193872
static Class<?> findClassFromClassLoaders(final String className, final Iterable<ClassLoader> classLoaders)
        throws ClassNotFoundException, IllegalArgumentException {
        // Precondition checks
        assert className != null && className.length() > 0 : "Class Name must be specified";
        assert classLoaders != null : "ClassLoaders as search path must be specified";

        // Find the class by searching through the CLs in order
        Class<?> clazz = null;
        for (final ClassLoader cl : classLoaders) {
            try {
                clazz = Class.forName(className, false, cl);
                if (log.isLoggable(Level.FINER)) {
                    log.finer("Found requested class " + clazz.getName() + " from ClassLoader "
                        + clazz.getClassLoader());
                }
            } catch (final ClassNotFoundException cnfe) {
                // Ignore here, try the next
            }

        }
        // If we haven't got a class yet, now we need to show we've got CNFE
        if (clazz == null) {
            throw new ClassNotFoundException("Could not find requested class \"" + className
                + "\" in any of the associated ClassLoaders: " + classLoaders);
        }

        // Return
        return clazz;
    }
1096986
public static ClassLoader getClassLoader(Class<?> cls) {
        ClassLoader cl = null;
        try {
            cl = Thread.currentThread().getContextClassLoader();
        } catch (Throwable ex) {
            // Cannot access thread context ClassLoader - falling back to system
            // class loader...
        }
        if (cl == null) {
            // No thread context class loader -> use class loader of this class.
            cl = cls.getClassLoader();
        }
        return cl;
    }
708338
public static <T> List<T> load(final Class<T> type, final ClassLoader classLoader) {
        final List<T> loaded = new ArrayList<>();
        final Iterator<T> iterator = ServiceLoader.load(type, classLoader).iterator();
        while (hasNextSafely(iterator)) {
            try {
                final T next = iterator.next();
                loaded.add(next);
                LOGGER.debug("Found {}", type);
            } catch (Exception e) {
                LOGGER.error("Could not load {}: {}", type, e);
            }
        }
        return loaded;
    }
1115532
@Override
    @SuppressWarnings("rawtypes")
    @FFDCIgnore(ClassNotFoundException.class)
    public Class loadClass(String name, String codebase, ClassLoader loader) throws ClassNotFoundException {
        try {
            return super.loadClass(name, codebase, loader);
        } catch (ClassNotFoundException e) {
            // Fix #2: use context class loader to allow _Intf_Stub to be
            // loaded from a different loader than Intf (or to be dynamically
            // generated if needed).
            ClassLoader contextClassLoader = threadContextAccessor.getContextClassLoaderForUnprivileged(Thread.currentThread());
            if (contextClassLoader != loader && name.endsWith("_Stub")) {
                if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
                    Tr.debug(tc, "retrying with " + contextClassLoader);
                try {
                    return contextClassLoader.loadClass(name);
                } catch (ClassNotFoundException e2) {
                }
            }
            throw e;
        }
    }
586595
public static Class<?> loadClassByName(String className) throws ClassNotFoundException {
        try {
            return Class.forName(className);
        } catch (ClassNotFoundException e) {
            return Thread.currentThread().getContextClassLoader().loadClass(className);
        }
    }
171766
@Override
  public Class<?> loadClassImpl(String name, boolean resolve)
    throws ClassNotFoundException
  {
    // The JVM has already cached the classes, so we don't need to
    Class<?> cl = findLoadedClass(name);

    if (cl != null) {
      if (resolve)
        resolveClass(cl);
      return cl;
    }
    // System.out.println("ROOT: " + name);
    if (_classNotFoundCache.get(name) != null) {
      return null;
    }
    
    try {
      cl = super.loadClassImpl(name, resolve);
    } catch (ClassNotFoundException e) {
      _classNotFoundCache.put(name, name);
      
      throw e;
    }
    
    if (cl == null) {
      _classNotFoundCache.put(name, name);
    }
    
    return cl;
  }
417638
protected Class resolveClass(ObjectStreamClass classDesc) throws IOException, ClassNotFoundException {
		try {
			return getClass().getClassLoader().loadClass(classDesc.getName());
		} catch (ClassNotFoundException ex) {
			ClassLoader tccl = Thread.currentThread().getContextClassLoader();
			if (tccl != null) {
				return tccl.loadClass(classDesc.getName());
			} else {
				throw ex;
			}
		}
	}
867770
@SuppressWarnings("unchecked")
  public T deserialize() throws ClassNotFoundException {
    try {
      ByteArrayInputStream byteStream = new ByteArrayInputStream(data);
      GZIPInputStream gzipStream = new GZIPInputStream(byteStream);
      try {
        ObjectInputStream objectStream = new ObjectInputStream(gzipStream);
        object = (T) objectStream.readObject();
        return object;
      } finally {
        gzipStream.close();
      }
    } catch (IOException e) {
      throw new UnexpectedException(e);
    }
  }