Runtime Component Replacement In Java

It is now well known that a software system undergoes many changes during its life time. These changes take place to remove latent errors that are detected during operation, or to enhance the system. In either case, a software in operation has to be replaced by a new version. The most common approach to performing this version change is to shut down the system and then install the new version. This necessitates a sometimes unacceptable delay during which service is denied to the users of the software. For systems such as banking and telecommunication software, the cost of downtime can be prohibitive. The situation is even worse for systems such as air-traffic controllers and life-support software, for which a shut-down is in general not an option. In those cases, the use of some form of on-the-fly program modification is required. In this paper, we present and implement a new approach for dynamic updating of Java software. Updating logic unit is component and atom is class during runtime. The difficulty of dynamic updating is state transfer. New components can continue to compute based on the work that have done by old components with state transfer. This prevent from compute degradation. In traditional method, state transfer need that new and old components provide related interfaces, so it is necessary that prepare state transfer interfaces in advance. We implement the approach which performs automatically state transforming leaving out preparing interfaces. Objects' states are defined by static data fields. The old and new components can keep state consistency and implement state transfer without performance losing by sharing the static data fields. During the implementation of this approach, class is the smallest updating unit and class sequences created by dependence relationship of classes in component implement updating of components. It is not perfect that JVM support dynamic updating of classes. JVM related part of runtime is appropriately modified and extended in this approach so that it can support classes and class sequences updating. Modifying JVM during runtime can adapt the running program in JVM. Namely, dynamic updating can perform without preparing interfaces. Version control exists in every updating, which resolve the name conflicts and ensure the consistency and validity at next updating. A cast tool is provided in this paper. This tool can implement the update with new component and update specification.The updating time need wait because updating can perform when old components have not active calls in traditional method. It is possible the proper time is always not arrive so new components can't work. The advantage of this approach is that updating works at once. Existing objects call use existing objects, new objects call use new objects. It is the transition stage of old and new components. When all old objects end their lifetime, new objects work. The entire updating process ends eventually.