Package net.bytebuddy

@ByDefault package net.bytebuddy

Byte Buddy is a library for creating Java classes at runtime of a Java program. For this purpose, the ByteBuddy class serves as an entry point. The following example

Class<?> dynamicType = new ByteBuddy()
   .subclass(Object.class)
   .implement(Serializable.class)
   .intercept(named("toString"), FixedValue.value("Hello World!"))
   .make()
   .load(getClass().getClassLoader(), ClassLoadingStrategy.Default.WRAPPER)
   .getLoaded();
dynamicType.newInstance().toString; // returns "Hello World!"

creates a subclass of the Object class which implements the Serializable interface. The Object.toString() method is overridden to return Hello World!.

Related Packages

Package	Description
net.bytebuddy.agent	The Byte Buddy agent allows the redefinition of classes at runtime.
net.bytebuddy.asm	The ASM package contains classes that are meant for direct interaction with the ASM API.
net.bytebuddy.build	A package for types that allow for applying Byte Buddy transformation during a build process.
net.bytebuddy.description	Classes of this package allow the representation of Java classes, their member and their meta data.
net.bytebuddy.dynamic	This package contains classes and interfaces that are connected to writing the byte stream that represents a Java type that is dynamically created and for loading this type into a running JVM process.
net.bytebuddy.implementation	The implementation package contains any logic for intercepting method calls.
net.bytebuddy.matcher	Contains an API for matching Java byte code entities.
net.bytebuddy.pool	Classes of this package allow for the creating TypeDescriptions without loading any classes.
net.bytebuddy.utility	This package contains utility classes for common use within any Byte Buddy logic.

Class	Description
ByteBuddy	Instances of this class serve as a focus point for configuration of the library's behavior and as an entry point to any form of code generation using the library.
ByteBuddy.EnumerationImplementation	An implementation fo the values method of an enumeration type.
ByteBuddy.EnumerationImplementation.InitializationAppender	A byte code appender for the type initializer of any enumeration type.
ByteBuddy.EnumerationImplementation.ValuesMethodAppender	A byte code appender for the values method of any enumeration type.
ByteBuddy.RecordConstructorStrategy	A constructor strategy for implementing a Java record.
ByteBuddy.RecordConstructorStrategy.Appender	A byte code appender for accessors and the record constructor.
ByteBuddy.RecordObjectMethod	Implements the object methods of the Java record type.
ClassFileVersion	A wrapper object for representing a validated class file version in the format that is specified by the JVMS.
ClassFileVersion.VersionLocator	A locator for the executing VM's Java version.
ClassFileVersion.VersionLocator.Resolved	A version locator for a resolved class file version.
ClassFileVersion.VersionLocator.Resolver	A resolver for the current VM's class file version.
ClassFileVersion.VersionLocator.Unresolved	An unresolved version locator.
NamingStrategy	A naming strategy for determining a fully qualified name for a dynamically created Java type.
NamingStrategy.AbstractBase	An abstract base implementation where the names of redefined and rebased types are retained.
NamingStrategy.PrefixingRandom	A naming strategy that creates a name by prefixing a given class and its package with another package and by appending a random number to the class's simple name.
NamingStrategy.Suffixing	A naming strategy that appends a given suffix to a name, without a randomized element.
NamingStrategy.Suffixing.BaseNameResolver	A base name resolver is responsible for resolving a name onto which the suffix is appended.
NamingStrategy.Suffixing.BaseNameResolver.ForFixedValue	A base name resolver that simply returns a fixed value.
NamingStrategy.Suffixing.BaseNameResolver.ForGivenType	Uses a specific type's name as the resolved name.
NamingStrategy.Suffixing.BaseNameResolver.ForUnnamedType	Uses the unnamed type's super type's name as the resolved name.
NamingStrategy.Suffixing.BaseNameResolver.WithCallerSuffix	A base name resolver that adds the name of the class that is invoking ByteBuddy.
NamingStrategy.SuffixingRandom	A naming strategy that creates a name by concatenating: The super classes package and name A given suffix string A random number Between all these elements, a $ sign is included into the name to improve readability.
NamingStrategy.SuffixingRandom.BaseNameResolver	Deprecated. Use NamingStrategy.Suffixing.BaseNameResolver.
NamingStrategy.SuffixingRandom.BaseNameResolver.ForFixedValue	Deprecated. Use NamingStrategy.Suffixing.BaseNameResolver.ForFixedValue.
NamingStrategy.SuffixingRandom.BaseNameResolver.ForGivenType	Deprecated. Use NamingStrategy.Suffixing.BaseNameResolver.ForGivenType.
NamingStrategy.SuffixingRandom.BaseNameResolver.ForUnnamedType	Deprecated. Use NamingStrategy.Suffixing.BaseNameResolver.ForUnnamedType.
TypeCache<T>	A cache for storing types without strongly referencing any class loader or type.
TypeCache.LookupKey	A key used for looking up a previously inserted class loader cache.
TypeCache.SimpleKey	A simple key based on a collection of types where no type is strongly referenced.
TypeCache.Sort	Determines the storage format for a cached type.
TypeCache.StorageKey	A key used for storing a class loader cache reference.
TypeCache.WithInlineExpunction<S>	An implementation of a TypeCache where obsolete references are cleared upon any call.