Try to load and create an instance of the {@code implClass} service.

@return the service instance if successful, else {@code null}.
346746
private static Class<?> findClass(final String implClass, final Library library, final URL fileUrl) {
        final ClassLoader containerClassLoader = library.getClassLoader();
        final String libID = library.id();
        Class<?> service = null;
        try {
            service = containerClassLoader.loadClass(implClass);
        } catch (final NoClassDefFoundError e) {
            // Happens if any class referenced by the implementation cannot be found
            if (TraceComponent.isAnyTracingEnabled() && tc.isWarningEnabled()) {
                Tr.warning(tc, "bell.no.inter", implClass, fileUrl, libID, e);
            }
        } catch (final ClassNotFoundException e) {
            if (TraceComponent.isAnyTracingEnabled() && tc.isWarningEnabled()) {
                Tr.warning(tc, "bell.no.impl", implClass, fileUrl, libID);
            }
        } catch (final Throwable e) {
            if (TraceComponent.isAnyTracingEnabled() && tc.isWarningEnabled()) {
                Tr.warning(tc, "bell.error.ctor", implClass, fileUrl, libID, e);
            }
        }
        return service;
    }
348527
protected static Factory createConfiguredFactory ()
    {
        String implClass;
        try {
            implClass = System.getProperty("com.samskivert.util.Log");
        } catch (SecurityException se) {
            // in a sandbox
            return null;
        }
        if (!StringUtil.isBlank(implClass)) {
            try {
                return (Factory)Class.forName(implClass).newInstance();
            } catch (Throwable t) {
                System.err.println("Unable to instantiate logging implementation: " + implClass);
                t.printStackTrace(System.err);
            }
        }
        return null;
    }
1150901
public static ReflectionUtil getInstance() {

    if (instance == null) {
      ReflectionUtilImpl impl = null;
      synchronized (ReflectionUtilImpl.class) {
        if (instance == null) {
          impl = new ReflectionUtilImpl();
          instance = impl;
        }
      }
      if (impl != null) {
        // static access is generally discouraged, cyclic dependency forces this ugly initialization to
        // prevent deadlock.
        impl.initialize();
      }
    }
    return instance;
  }
428746
synchronized public boolean load() {
		if (null == this.settingLoader) {
			settingLoader = new SettingLoader(this.groupedMap, this.charset, this.isUseVariable);
		}
		return settingLoader.load(new UrlResource(this.settingUrl));
	}
1074643
@SuppressWarnings("unchecked")
    public synchronized <T> T load(final PluggableService<T> service, final String providerName)
            throws ProviderLoaderException {
        final ProviderIdent ident = new ProviderIdent(service.getName(), providerName);
        debug("loadInstance for " + ident + ": " + pluginJar);

        if (null == pluginProviderDefs.get(ident)) {
            final String[] strings = getClassnames();
            for (final String classname : strings) {
                final Class<?> cls;
                try {
                    cls = loadClass(classname);
                    if (matchesProviderDeclaration(ident, cls)) {
                        pluginProviderDefs.put(ident, cls);
                    }
                } catch (PluginException e) {
                    log.error("Failed to load class from " + pluginJar + ": classname: " + classname + ": "
                            + e.getMessage());
                }
            }
        }
        final Class<T> cls = pluginProviderDefs.get(ident);
        if (null != cls) {
            try {
                return createProviderForClass(service, cls);
            } catch (PluginException e) {
                throw new ProviderLoaderException(e, service.getName(), providerName);
            }
        }
        return null;
    }
1247284
@SuppressWarnings("unchecked")
	public T get() {
		T result;

		if (uri != null) {
			if (classLoader == null) {
				classLoader = clazz.getClassLoader();
			}

			Endpoint clientEndpoint = new HTTPClientEndpoint(uri);
			if (logger != null) {
				clientEndpoint = new LoggerEndpoint(clientEndpoint, logger);
			}

			result = new FacadeEndpoint<T>(clientEndpoint, //
					classLoader, clazz, typeConverter, //
					additionalInterfaces.toArray(new Class<?>[additionalInterfaces.size()])) //
					.newProxy();
		} else {
			ObjectEndpoint endpoint = new ObjectEndpoint();
			endpoint.faultMapper(faultMapper);
			endpoint.typeConverter(typeConverter);
			endpoint.export(server, clazz);
			for (Class<?> i : additionalInterfaces) {
				endpoint.export(server, i);
			}
			result = (T) new HTTPServerEndpoint(endpoint);
		}

		return result;
	}
170645
public static Object tryInstance(String clsName,ClassLoader loader)
	{
		try
		{
			return instance(clsName,loader);
		}
		catch (Exception ex)
		{
			return null;
		}
	}
446987
public static TransferObjectUtil getInstance() {

    if (instance == null) {
      synchronized (TransferObjectUtilImpl.class) {
        if (instance == null) {
          TransferObjectUtilImpl impl = new TransferObjectUtilImpl();
          impl.initialize();
          instance = impl;
        }
      }
    }
    return instance;
  }
1209792
public Object create(Class<?> iface, ClassLoader proxyLoader) {
		return create(new Class[]{iface}, proxyLoader);
	}
1075030
public Object newInstance(String clazz) {
        try {
            return Class.forName(clazz).newInstance();
        } catch (Exception e) {
            error(e);
            return null;
        }
    }
694716
public static <T> T newInstance(Class<T> clazz) throws ClassInstantiationException {
        if (clazz == null) {
            return null;
        }

        try {
            return clazz.newInstance();
        } catch (Exception e) {
            throw new ClassInstantiationException("Failed to instantiate class: " + clazz.getName(), e);
        }
    }
904648
public static AnnotationUtilImpl getInstance() {

    if (instance == null) {
      synchronized (AnnotationUtilImpl.class) {
        if (instance == null) {
          AnnotationUtilImpl util = new AnnotationUtilImpl();
          util.setReflectionUtil(ReflectionUtilImpl.getInstance());
          instance = util;
        }
      }
    }
    return instance;
  }
924905
public synchronized Configuration loadConfiguration() {
    if (configurationBuffer.position(0).readByte() == 1) {
      return new Configuration(
          configurationBuffer.readLong(),
          configurationBuffer.readLong(),
          configurationBuffer.readLong(),
          serializer.readObject(configurationBuffer)
      );
    }
    return null;
  }
576302
public static StaxUtil getInstance() {

    if (instance == null) {
      synchronized (StaxUtilImpl.class) {
        if (instance == null) {
          StaxUtilImpl util = new StaxUtilImpl();
          util.initialize();
          instance = util;
        }
      }
    }
    return instance;
  }
539849
@SuppressWarnings("unchecked")
    @Override
    public <S> S getService(ServiceReference<S> reference) {
        return (S) serviceImplementations.get(reference);
    }
246570
public Object createInstanceQuietly() {
      try {
         return clazz.newInstance();
      } catch (InstantiationException e) {
         log.finest(e);
         return null;
      } catch (IllegalAccessException e) {
         log.finest(e);
         return null;
      }
   }
1168568
ExtensionLoader createDefaultExtensionLoader() {
        // First find the right Class/ClassLoader
        final Class<?> extensionLoaderImplClass;
        try {
            extensionLoaderImplClass = ClassLoaderSearchUtil.findClassFromClassLoaders(EXTENSION_LOADER_IMPL,
                getClassLoaders());
        } catch (final ClassNotFoundException cnfe) {
            throw new IllegalStateException(
                "Could not find extension loader impl class in any of the configured ClassLoaders", cnfe);
        }

        // Return
        return SecurityActions.newInstance(extensionLoaderImplClass, new Class<?>[] { Iterable.class },
            new Object[] { this.getClassLoaders() }, ExtensionLoader.class);
    }