net.bytebuddy.instrumentation

Class ExceptionMethod

java.lang.Object

net.bytebuddy.instrumentation.ExceptionMethod

All Implemented Interfaces:

Instrumentation, ByteCodeAppender

public class ExceptionMethod
extends Object
implements Instrumentation, ByteCodeAppender

This instrumentation causes a Throwable to be thrown when the instrumented method is invoked. Be aware that the Java Virtual machine does not care about exception declarations and will throw any Throwable from any method even if the method does not declared a checked exception.

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
static interface	ExceptionMethod.ConstructionDelegate A construction delegate is responsible for calling a isThrowable's constructor.

Nested classes/interfaces inherited from interface net.bytebuddy.instrumentation.Instrumentation

Instrumentation.Compound, Instrumentation.Context, Instrumentation.ForAbstractMethod, Instrumentation.SpecialMethodInvocation, Instrumentation.Target

Nested classes/interfaces inherited from interface net.bytebuddy.instrumentation.method.bytecode.ByteCodeAppender

ByteCodeAppender.Compound, ByteCodeAppender.Simple, ByteCodeAppender.Size

Constructor Summary

Constructors

Constructor and Description
ExceptionMethod(TypeDescription throwableType, ExceptionMethod.ConstructionDelegate constructionDelegate) Creates a new instance of an instrumentation for throwing throwables.

Method Summary

Modifier and Type	Method and Description
ByteCodeAppender	appender(Instrumentation.Target instrumentationTarget) Creates a byte code appender that determines the implementation of the instrumented type's methods.
boolean	appendsCode() Determines if this byte code appender offers an (possibly empty) implementation of a method.
ByteCodeAppender.Size	apply(org.objectweb.asm.MethodVisitor methodVisitor, Instrumentation.Context instrumentationContext, MethodDescription instrumentedMethod) Applies this byte code appender to a type creation process.
boolean	equals(Object other)
int	hashCode()
InstrumentedType	prepare(InstrumentedType instrumentedType) During the preparation phase of an instrumentation, implementations are eligible to adding fields or methods to the currently instrumented type.
static Instrumentation	throwing(Class<? extends Throwable> throwable) Creates an instrumentation that creates a new instance of the given isThrowable type on each method invocation which is then thrown immediately.
static Instrumentation	throwing(Class<? extends Throwable> throwable, String message) Creates an instrumentation that creates a new instance of the given isThrowable type on each method invocation which is then thrown immediately.
String	toString()

Methods inherited from class java.lang.Object

clone, finalize, getClass, notify, notifyAll, wait, wait, wait

Constructor Detail

ExceptionMethod

public ExceptionMethod(TypeDescription throwableType,
                       ExceptionMethod.ConstructionDelegate constructionDelegate)

Creates a new instance of an instrumentation for throwing throwables.

Parameters:

throwableType - The type of the exception to be thrown.

constructionDelegate - A delegate that is responsible for calling the isThrowable's constructor.

Method Detail

throwing

public static Instrumentation throwing(Class<? extends Throwable> throwable)

Creates an instrumentation that creates a new instance of the given isThrowable type on each method invocation which is then thrown immediately. For this to be possible, the given type must define a default constructor which is visible from the instrumented type.

Parameters:

throwable - The type of the isThrowable.

Returns:

An instrumentation that will throw an instance of the isThrowable on each method invocation of the instrumented methods.

throwing

public static Instrumentation throwing(Class<? extends Throwable> throwable,
                                       String message)

Creates an instrumentation that creates a new instance of the given isThrowable type on each method invocation which is then thrown immediately. For this to be possible, the given type must define a constructor that takes a single String as its argument.

Parameters:

throwable - The type of the isThrowable.

message - The string that is handed to the constructor. Usually an exception message.

Returns:

An instrumentation that will throw an instance of the isThrowable on each method invocation of the instrumented methods.

prepare

public InstrumentedType prepare(InstrumentedType instrumentedType)

Description copied from interface: Instrumentation

During the preparation phase of an instrumentation, implementations are eligible to adding fields or methods to the currently instrumented type. All methods that are added by this instrumentation are required to be implemented by the ByteCodeAppender that is emitted on the call to Instrumentation.appender(net.bytebuddy.instrumentation.Instrumentation.Target) call. On this method call, loaded type initializers can also be added to the instrumented type.

Specified by:

prepare in interface Instrumentation

Parameters:

instrumentedType - The instrumented type that is the basis of the ongoing instrumentation.

Returns:

The instrumented type with any applied changes, if any.

appender

public ByteCodeAppender appender(Instrumentation.Target instrumentationTarget)

Description copied from interface: Instrumentation

Creates a byte code appender that determines the implementation of the instrumented type's methods.

Specified by:

appender in interface Instrumentation

Parameters:

instrumentationTarget - The target of the current instrumentation.

Returns:

A byte code appender for implementing methods delegated to this instrumentation. This byte code appender is also responsible for handling methods that were added by this instrumentation on the call to Instrumentation.prepare(net.bytebuddy.instrumentation.type.InstrumentedType).

appendsCode

public boolean appendsCode()

Description copied from interface: ByteCodeAppender

Determines if this byte code appender offers an (possibly empty) implementation of a method.

Specified by:

appendsCode in interface ByteCodeAppender

Returns:

true if this byte code appender requires this method to be implemented or false if this appender describes an abstract method.

apply

public ByteCodeAppender.Size apply(org.objectweb.asm.MethodVisitor methodVisitor,
                                   Instrumentation.Context instrumentationContext,
                                   MethodDescription instrumentedMethod)

Description copied from interface: ByteCodeAppender

Applies this byte code appender to a type creation process.

Specified by:

apply in interface ByteCodeAppender

Parameters:

methodVisitor - The method visitor to which the byte code appender writes its code to.

instrumentationContext - The instrumentation context of the current type creation process.

instrumentedMethod - The method that is the target of the instrumentation.

Returns:

The required size for the applied byte code to run.

equals

public boolean equals(Object other)

Overrides:

equals in class Object

hashCode

public int hashCode()

Overrides:

hashCode in class Object

toString

public String toString()

Overrides:

toString in class Object