< prev index next >

src/java.instrument/share/classes/java/lang/instrument/Instrumentation.java

Print this page




 205      * <P>
 206      * This method operates on
 207      * a set in order to allow interdependent changes to more than one class at the same time
 208      * (a retransformation of class A can require a retransformation of class B).
 209      *
 210      * <P>
 211      * If a retransformed method has active stack frames, those active frames continue to
 212      * run the bytecodes of the original method.
 213      * The retransformed method will be used on new invokes.
 214      *
 215      * <P>
 216      * This method does not cause any initialization except that which would occur
 217      * under the customary JVM semantics. In other words, redefining a class
 218      * does not cause its initializers to be run. The values of static variables
 219      * will remain as they were prior to the call.
 220      *
 221      * <P>
 222      * Instances of the retransformed class are not affected.
 223      *
 224      * <P>
 225      * The retransformation may change method bodies, the constant pool and
 226      * attributes (unless explicitly prohibited).
 227      * The retransformation must not add, remove or rename fields or methods, change the
 228      * signatures of methods, or change inheritance.
 229      * The retransformation must not change the <code>NestHost</code>,
 230      * <code>NestMembers</code>, or <code>Record</code> attributes.
 231      * These restrictions may be lifted in future versions.
 232      * The class file bytes are not checked, verified and installed
 233      * until after the transformations have been applied, if the resultant bytes are in
 234      * error this method will throw an exception.
 235      *
 236      * <P>
 237      * If this method throws an exception, no classes have been retransformed.
 238      * <P>
 239      * This method is intended for use in instrumentation, as described in the
 240      * {@linkplain Instrumentation class specification}.
 241      *
 242      * @param classes array of classes to retransform;
 243      *                a zero-length array is allowed, in this case, this method does nothing
 244      * @throws java.lang.instrument.UnmodifiableClassException if a specified class cannot be modified
 245      * ({@link #isModifiableClass} would return <code>false</code>)
 246      * @throws java.lang.UnsupportedOperationException if the current configuration of the JVM does not allow
 247      * retransformation ({@link #isRetransformClassesSupported} is false) or the retransformation attempted
 248      * to make unsupported changes
 249      * @throws java.lang.ClassFormatError if the data did not contain a valid class
 250      * @throws java.lang.NoClassDefFoundError if the name in the class file is not equal to the name of the class
 251      * @throws java.lang.UnsupportedClassVersionError if the class file version numbers are not supported


 296      * <P>
 297      * This method operates on
 298      * a set in order to allow interdependent changes to more than one class at the same time
 299      * (a redefinition of class A can require a redefinition of class B).
 300      *
 301      * <P>
 302      * If a redefined method has active stack frames, those active frames continue to
 303      * run the bytecodes of the original method.
 304      * The redefined method will be used on new invokes.
 305      *
 306      * <P>
 307      * This method does not cause any initialization except that which would occur
 308      * under the customary JVM semantics. In other words, redefining a class
 309      * does not cause its initializers to be run. The values of static variables
 310      * will remain as they were prior to the call.
 311      *
 312      * <P>
 313      * Instances of the redefined class are not affected.
 314      *
 315      * <P>
 316      * The redefinition may change method bodies, the constant pool and attributes
 317      * (unless explicitly prohibited).
 318      * The redefinition must not add, remove or rename fields or methods, change the
 319      * signatures of methods, or change inheritance.
 320      * The redefinition must not change the <code>NestHost</code>,
 321      * <code>NestMembers</code>, or <code>Record</code> attributes.
 322      * These restrictions may be lifted in future versions.
 323      * The class file bytes are not checked, verified and installed
 324      * until after the transformations have been applied, if the resultant bytes are in
 325      * error this method will throw an exception.
 326      *
 327      * <P>
 328      * If this method throws an exception, no classes have been redefined.
 329      * <P>
 330      * This method is intended for use in instrumentation, as described in the
 331      * {@linkplain Instrumentation class specification}.
 332      *
 333      * @param definitions array of classes to redefine with corresponding definitions;
 334      *                    a zero-length array is allowed, in this case, this method does nothing
 335      * @throws java.lang.instrument.UnmodifiableClassException if a specified class cannot be modified
 336      * ({@link #isModifiableClass} would return <code>false</code>)
 337      * @throws java.lang.UnsupportedOperationException if the current configuration of the JVM does not allow
 338      * redefinition ({@link #isRedefineClassesSupported} is false) or the redefinition attempted
 339      * to make unsupported changes
 340      * @throws java.lang.ClassFormatError if the data did not contain a valid class
 341      * @throws java.lang.NoClassDefFoundError if the name in the class file is not equal to the name of the class
 342      * @throws java.lang.UnsupportedClassVersionError if the class file version numbers are not supported




 205      * <P>
 206      * This method operates on
 207      * a set in order to allow interdependent changes to more than one class at the same time
 208      * (a retransformation of class A can require a retransformation of class B).
 209      *
 210      * <P>
 211      * If a retransformed method has active stack frames, those active frames continue to
 212      * run the bytecodes of the original method.
 213      * The retransformed method will be used on new invokes.
 214      *
 215      * <P>
 216      * This method does not cause any initialization except that which would occur
 217      * under the customary JVM semantics. In other words, redefining a class
 218      * does not cause its initializers to be run. The values of static variables
 219      * will remain as they were prior to the call.
 220      *
 221      * <P>
 222      * Instances of the retransformed class are not affected.
 223      *
 224      * <P>
 225      * The supported class file changes are described in
 226      * <a href="{@docRoot}/../specs/jvmti.html#RetransformClasses">JVM TI RetransformClasses</a>.





 227      * The class file bytes are not checked, verified and installed
 228      * until after the transformations have been applied, if the resultant bytes are in
 229      * error this method will throw an exception.
 230      *
 231      * <P>
 232      * If this method throws an exception, no classes have been retransformed.
 233      * <P>
 234      * This method is intended for use in instrumentation, as described in the
 235      * {@linkplain Instrumentation class specification}.
 236      *
 237      * @param classes array of classes to retransform;
 238      *                a zero-length array is allowed, in this case, this method does nothing
 239      * @throws java.lang.instrument.UnmodifiableClassException if a specified class cannot be modified
 240      * ({@link #isModifiableClass} would return <code>false</code>)
 241      * @throws java.lang.UnsupportedOperationException if the current configuration of the JVM does not allow
 242      * retransformation ({@link #isRetransformClassesSupported} is false) or the retransformation attempted
 243      * to make unsupported changes
 244      * @throws java.lang.ClassFormatError if the data did not contain a valid class
 245      * @throws java.lang.NoClassDefFoundError if the name in the class file is not equal to the name of the class
 246      * @throws java.lang.UnsupportedClassVersionError if the class file version numbers are not supported


 291      * <P>
 292      * This method operates on
 293      * a set in order to allow interdependent changes to more than one class at the same time
 294      * (a redefinition of class A can require a redefinition of class B).
 295      *
 296      * <P>
 297      * If a redefined method has active stack frames, those active frames continue to
 298      * run the bytecodes of the original method.
 299      * The redefined method will be used on new invokes.
 300      *
 301      * <P>
 302      * This method does not cause any initialization except that which would occur
 303      * under the customary JVM semantics. In other words, redefining a class
 304      * does not cause its initializers to be run. The values of static variables
 305      * will remain as they were prior to the call.
 306      *
 307      * <P>
 308      * Instances of the redefined class are not affected.
 309      *
 310      * <P>
 311      * The supported class file changes are described in
 312      * <a href="{@docRoot}/../specs/jvmti.html#RedefineClasses">JVM TI RedefineClasses</a>.





 313      * The class file bytes are not checked, verified and installed
 314      * until after the transformations have been applied, if the resultant bytes are in
 315      * error this method will throw an exception.
 316      *
 317      * <P>
 318      * If this method throws an exception, no classes have been redefined.
 319      * <P>
 320      * This method is intended for use in instrumentation, as described in the
 321      * {@linkplain Instrumentation class specification}.
 322      *
 323      * @param definitions array of classes to redefine with corresponding definitions;
 324      *                    a zero-length array is allowed, in this case, this method does nothing
 325      * @throws java.lang.instrument.UnmodifiableClassException if a specified class cannot be modified
 326      * ({@link #isModifiableClass} would return <code>false</code>)
 327      * @throws java.lang.UnsupportedOperationException if the current configuration of the JVM does not allow
 328      * redefinition ({@link #isRedefineClassesSupported} is false) or the redefinition attempted
 329      * to make unsupported changes
 330      * @throws java.lang.ClassFormatError if the data did not contain a valid class
 331      * @throws java.lang.NoClassDefFoundError if the name in the class file is not equal to the name of the class
 332      * @throws java.lang.UnsupportedClassVersionError if the class file version numbers are not supported


< prev index next >