dynamic-class-loaders

I have one jar file in my application's class path. At run time, I add new classes to the jar file and sometimes also modify the fields/methods of the existing classes. Currently I am using URLClassLoader to load the classes dynamically. The new classes added dynamically are loaded correctly and I am able to use them at runtime. But it fails to reload the existing classes that are modified at runtime. I read many articles which states we need to explicitly handle reloading because class once loaded will not be reloaded until all the references to the class are destroyed. Also I tried out

I found that mock object in Mockito would throw ClassNotFoundException when used in Spark. Here is a minimal example: import org.apache.spark.{SparkConf, SparkContext} import org.mockito.{Matchers, Mockito} import org.scalatest.FlatSpec import org.scalatest.mockito.MockitoSugar trait MyTrait { def myMethod(a: Int): Int } class MyTraitTest extends FlatSpec with MockitoSugar { "Mock" should "work in Spark" in { val m = mock[MyTrait](Mockito.withSettings().serializable()) Mockito.when(m.myMethod(Matchers.any())).thenReturn(1) val conf = new SparkConf().setAppName("testApp").setMaster("local") val

I am working on a plugin system where plugin modules are loaded like this: def load_plugins(): plugins=glob.glob("plugins/*.py") instances=[] for p in plugins: try: name=p.split("/")[-1] name=name.split(".py")[0] log.debug("Possible plugin: %s", name) f, file, desc=imp.find_module(name, ["plugins"]) plugin=imp.load_module('plugins.'+name, f, file, desc) getattr(plugin, "__init__")(log) instances=instances+plugin.get_instances() except Exception as e: log.info("Failed to load plugin: "+str(p)) log.info("Error: %s " % (e)) log.info(traceback.format_exc(e)) return instances The code works, but

Can anyone point me a good resource or explain me about the concept behind Class Loaders? I found the following resource on class loaders http://www.onjava.com/lpt/a/5586 but still no help. The following questions may look silly but trying to answer them always confuses me. Why do developers write Custom class loaders, why not invoke a Bootstrap class loader to invoke your custom classes? What is the need to define custom class loaders? Why there are so many varieties of class loaders? eg: Bootsrap, Comman, Catalina class loader etc., Thanks in advance. I found the following, valid reasons to

As per the introduction of Custom Class Loading in Dalvik by Fred Chung on the Android Developers Blog: The Dalvik VM provides facilities for developers to perform custom class loading. Instead of loading Dalvik executable (“dex”) files from the default location, an application can load them from alternative locations such as internal storage or over the network. However, not many developers have the need to do custom class loading. But those who do and follow the instructions on that blog post, might have some problems mimicking the same behavior with Gradle, the new build system for Android

The short summary is: How do I build an APK and separate libraries (by which I mean sets of classes (and ideally, resources too) in some form, such as JAR, AAR or DEX files), but not include those libraries in the APK; instead, the app loads them at run time? Detail So my main question is how to build such an app (e.g. Gradle configuration). How do I specify which classes go into which JAR or DEX files? Do I create an Android Studio module for each DEX file I want to end up with? A closely related question is how the Java code should then load the external libraries and access their classes at