Programmatic construction of Java class files using the builder pattern. This package provides comprehensive tools for building ClassFile objects, module-info files, and managing mutable constant pools. All builders support fluent method chaining and ensure proper validation of class file structure.
Core builder for constructing standard Java class files with complete control over all class file elements.
/**
* Builder for constructing ClassFile objects programmatically using fluent interface
*/
public class ClassFileBuilder {
/**
* Create new ClassFileBuilder with full parameter specification
* @param access_flags Class access flags (ACC_PUBLIC, ACC_FINAL, etc.)
* @param major_version Class file major version number
* @param minor_version Class file minor version number
* @param this_class Binary name of this class
* @param super_class Binary name of super class (null for java.lang.Object)
* @param interfaces Collection of interface binary names
*/
public ClassFileBuilder(int access_flags, int major_version, int minor_version,
String this_class, String super_class, Collection<String> interfaces);
/**
* Create new ClassFileBuilder with interface array
* @param access_flags Class access flags
* @param major_version Class file major version number
* @param minor_version Class file minor version number
* @param this_class Binary name of this class
* @param super_class Binary name of super class
* @param interfaces Array of interface binary names
*/
public ClassFileBuilder(int access_flags, int major_version, int minor_version,
String this_class, String super_class, String... interfaces);
/**
* Create new ClassFileBuilder with no interfaces
* @param access_flags Class access flags
* @param major_version Class file major version number
* @param minor_version Class file minor version number
* @param this_class Binary name of this class
* @param super_class Binary name of super class
*/
public ClassFileBuilder(int access_flags, int major_version, int minor_version,
String this_class, String super_class);
/**
* Create ClassFileBuilder from existing ClassFile for modification
* @param classFile Existing ClassFile to copy from
*/
public ClassFileBuilder(ClassFile classFile);
// Version control methods
/**
* Get minor version number
* @return Minor version number
*/
public int minor_version();
/**
* Set minor version number
* @param minor_version Minor version number
* @return This builder instance
*/
public ClassFileBuilder minor_version(int minor_version);
/**
* Get major version number
* @return Major version number
*/
public int major_version();
/**
* Set major version number
* @param major_version Major version number
* @return This builder instance
*/
public ClassFileBuilder major_version(int major_version);
// Constant pool management
/**
* Get mutable constant pool
* @return MutableConstantPool instance
*/
public MutableConstantPool constant_pool();
/**
* Set mutable constant pool
* @param constant_pool MutableConstantPool to use
* @return This builder instance
*/
public ClassFileBuilder constant_pool(MutableConstantPool constant_pool);
// Access flags
/**
* Get access flags
* @return Access flags value
*/
public int access();
/**
* Set access flags
* @param access Access flags (ACC_PUBLIC, ACC_FINAL, etc.)
* @return This builder instance
*/
public ClassFileBuilder access(int access);
// Class naming
/**
* Get this class name
* @return Binary name of this class
*/
public String this_class();
/**
* Set this class name
* @param this_class Binary name of this class
* @return This builder instance
*/
public ClassFileBuilder this_class(String this_class);
/**
* Get super class name
* @return Binary name of super class
*/
public String super_class();
/**
* Set super class name
* @param super_class Binary name of super class (null for java.lang.Object)
* @return This builder instance
*/
public ClassFileBuilder super_class(String super_class);
// Interface management
/**
* Get interfaces list
* @return Mutable list of interface binary names
*/
public List<String> interfaces();
/**
* Add single interface
* @param interfc Interface binary name
* @return This builder instance
*/
public ClassFileBuilder interfaces(String interfc);
/**
* Add interface array
* @param interfcs Array of interface binary names
* @return This builder instance
*/
public ClassFileBuilder interfaces(String[] interfcs);
/**
* Add interface collection
* @param interfcs Collection of interface binary names
* @return This builder instance
*/
public ClassFileBuilder interfaces(Collection<String> interfcs);
/**
* Add multiple interfaces
* @param interfc First interface binary name
* @param interfcs Additional interface binary names
* @return This builder instance
*/
public ClassFileBuilder interfaces(String interfc, String... interfcs);
// Field management
/**
* Get fields list
* @return Mutable list of FieldInfo objects
*/
public List<FieldInfo> fields();
/**
* Add or replace field (replaces existing field with same name and descriptor)
* @param field FieldInfo to add
* @return This builder instance
*/
public ClassFileBuilder fields(FieldInfo field);
/**
* Add field array
* @param fields Array of FieldInfo objects
* @return This builder instance
*/
public ClassFileBuilder fields(FieldInfo[] fields);
/**
* Add field collection
* @param fields Collection of FieldInfo objects
* @return This builder instance
*/
public ClassFileBuilder fields(Collection<FieldInfo> fields);
/**
* Add multiple fields
* @param field First FieldInfo
* @param fields Additional FieldInfo objects
* @return This builder instance
*/
public ClassFileBuilder fields(FieldInfo field, FieldInfo... fields);
// Method management
/**
* Get methods list
* @return Mutable list of MethodInfo objects
*/
public List<MethodInfo> methods();
/**
* Add or replace method (replaces existing method with same name and descriptor)
* @param method MethodInfo to add
* @return This builder instance
*/
public ClassFileBuilder methods(MethodInfo method);
/**
* Add method array
* @param methods Array of MethodInfo objects
* @return This builder instance
*/
public ClassFileBuilder methods(MethodInfo[] methods);
/**
* Add method collection
* @param methods Collection of MethodInfo objects
* @return This builder instance
*/
public ClassFileBuilder methods(Collection<MethodInfo> methods);
/**
* Add multiple methods
* @param method First MethodInfo
* @param methods Additional MethodInfo objects
* @return This builder instance
*/
public ClassFileBuilder methods(MethodInfo method, MethodInfo... methods);
// Attribute management
/**
* Get attributes list
* @return Mutable list of Attribute objects
*/
public List<Attribute> attributes();
/**
* Add attribute
* @param attribute Attribute to add
* @return This builder instance
*/
public ClassFileBuilder attributes(Attribute attribute);
/**
* Add attribute array
* @param attributes Array of Attribute objects
* @return This builder instance
*/
public ClassFileBuilder attributes(Attribute[] attributes);
/**
* Add attribute collection
* @param attributes Collection of Attribute objects
* @return This builder instance
*/
public ClassFileBuilder attributes(Collection<Attribute> attributes);
/**
* Add multiple attributes
* @param attribute First Attribute
* @param attributes Additional Attribute objects
* @return This builder instance
*/
public ClassFileBuilder attributes(Attribute attribute, Attribute... attributes);
/**
* Build the final ClassFile object
* @return Constructed ClassFile instance with all configured elements
*/
public ClassFile build();
}Usage Examples:
import aQute.bnd.classfile.builder.ClassFileBuilder;
import aQute.bnd.classfile.builder.MutableConstantPool;
import aQute.bnd.classfile.ClassFile;
import aQute.bnd.classfile.FieldInfo;
import aQute.bnd.classfile.MethodInfo;
// Build a simple public class
ClassFile simpleClass = new ClassFileBuilder(
ClassFile.ACC_PUBLIC, // access flags
61, // major version (Java 17)
0, // minor version
"com/example/GeneratedClass", // this class
"java/lang/Object" // super class
).build();
// Build class with interfaces and members
ClassFileBuilder builder = new ClassFileBuilder(
ClassFile.ACC_PUBLIC | ClassFile.ACC_FINAL,
61, 0,
"com/example/MyClass",
"java/lang/Object",
"java/io/Serializable", "java/lang/Cloneable"
);
// Add a private field
FieldInfo field = new FieldInfo(
ClassFile.ACC_PRIVATE,
"value",
"I", // int type descriptor
new Attribute[0]
);
builder.fields(field);
// Add a public constructor
MethodInfo constructor = new MethodInfo(
ClassFile.ACC_PUBLIC,
"<init>",
"()V", // void no-args constructor
new Attribute[0]
);
builder.methods(constructor);
ClassFile myClass = builder.build();
byte[] bytecode = myClass.write();Specialized builder for constructing module-info class files with complete module system support.
/**
* Builder for constructing module-info ClassFile objects with module system features
*/
public class ModuleInfoBuilder extends ClassFileBuilder {
/**
* Create new ModuleInfoBuilder with default module-info structure
* Automatically sets ACC_MODULE flag, Java 9+ version, and adds java.base dependency
*/
public ModuleInfoBuilder();
// Module metadata
/**
* Get module name
* @return Module name string
*/
public String module_name();
/**
* Set module name
* @param module_name Module name
* @return This builder instance
*/
public ModuleInfoBuilder module_name(String module_name);
/**
* Get module version
* @return Module version string
*/
public String module_version();
/**
* Set module version
* @param module_version Module version string
* @return This builder instance
*/
public ModuleInfoBuilder module_version(String module_version);
/**
* Get module flags
* @return Module flags value
*/
public int module_flags();
/**
* Set module flags
* @param module_flags Module flags (ACC_OPEN, ACC_SYNTHETIC, ACC_MANDATED)
* @return This builder instance
*/
public ModuleInfoBuilder module_flags(int module_flags);
// Module dependencies (requires)
/**
* Get requires list
* @return Mutable list of ModuleAttribute.Require objects
*/
public List<ModuleAttribute.Require> requires();
/**
* Add module dependency without version
* @param moduleName Required module name
* @param flags Require flags (ACC_TRANSITIVE, ACC_STATIC_PHASE, etc.)
* @return This builder instance
*/
public ModuleInfoBuilder requires(String moduleName, int flags);
/**
* Add module dependency with version
* @param moduleName Required module name
* @param flags Require flags
* @param moduleVersion Required module version
* @return This builder instance
*/
public ModuleInfoBuilder requires(String moduleName, int flags, String moduleVersion);
// Package exports
/**
* Get exports list
* @return Mutable list of ModuleAttribute.Export objects
*/
public List<ModuleAttribute.Export> exports();
/**
* Export package to specific modules
* @param binaryPackageName Binary package name to export
* @param flags Export flags
* @param toModules Collection of target module names
* @return This builder instance
*/
public ModuleInfoBuilder exports(String binaryPackageName, int flags, Collection<String> toModules);
/**
* Export package unconditionally (to all modules)
* @param binaryPackageName Binary package name to export
* @param flags Export flags
* @return This builder instance
*/
public ModuleInfoBuilder exports(String binaryPackageName, int flags);
/**
* Export package to single module
* @param binaryPackageName Binary package name to export
* @param flags Export flags
* @param toModule Target module name
* @return This builder instance
*/
public ModuleInfoBuilder exports(String binaryPackageName, int flags, String toModule);
/**
* Export package to multiple modules
* @param binaryPackageName Binary package name to export
* @param flags Export flags
* @param toModules Target module names
* @return This builder instance
*/
public ModuleInfoBuilder exports(String binaryPackageName, int flags, String... toModules);
// Package opens (reflection access)
/**
* Get opens list
* @return Mutable list of ModuleAttribute.Open objects
*/
public List<ModuleAttribute.Open> opens();
/**
* Open package for reflection to specific modules
* @param binaryPackageName Binary package name to open
* @param flags Open flags
* @param toModules Collection of target module names
* @return This builder instance
*/
public ModuleInfoBuilder opens(String binaryPackageName, int flags, Collection<String> toModules);
/**
* Open package for reflection unconditionally
* @param binaryPackageName Binary package name to open
* @param flags Open flags
* @return This builder instance
*/
public ModuleInfoBuilder opens(String binaryPackageName, int flags);
/**
* Open package for reflection to single module
* @param binaryPackageName Binary package name to open
* @param flags Open flags
* @param toModule Target module name
* @return This builder instance
*/
public ModuleInfoBuilder opens(String binaryPackageName, int flags, String toModule);
/**
* Open package for reflection to multiple modules
* @param binaryPackageName Binary package name to open
* @param flags Open flags
* @param toModules Target module names
* @return This builder instance
*/
public ModuleInfoBuilder opens(String binaryPackageName, int flags, String... toModules);
// Service usage
/**
* Get uses list
* @return Mutable list of service interface names
*/
public List<String> uses();
/**
* Add service interface usage
* @param binaryClassName Service interface binary name
* @return This builder instance
*/
public ModuleInfoBuilder uses(String binaryClassName);
/**
* Add multiple service interface usages from collection
* @param binaryClassNames Collection of service interface binary names
* @return This builder instance
*/
public ModuleInfoBuilder uses(Collection<String> binaryClassNames);
/**
* Add multiple service interface usages from array
* @param binaryClassNames Array of service interface binary names
* @return This builder instance
*/
public ModuleInfoBuilder uses(String[] binaryClassNames);
/**
* Add multiple service interface usages
* @param binaryClassName First service interface binary name
* @param binaryClassNames Additional service interface binary names
* @return This builder instance
*/
public ModuleInfoBuilder uses(String binaryClassName, String... binaryClassNames);
// Service provision
/**
* Get provides list
* @return Mutable list of ModuleAttribute.Provide objects
*/
public List<ModuleAttribute.Provide> provides();
/**
* Add service implementation provision
* @param binaryClassName Service interface binary name
* @param binaryWithClassNames Collection of implementation class binary names
* @return This builder instance
*/
public ModuleInfoBuilder provides(String binaryClassName, Collection<String> binaryWithClassNames);
/**
* Add single service implementation provision
* @param binaryClassName Service interface binary name
* @param binaryWithClassName Implementation class binary name
* @return This builder instance
*/
public ModuleInfoBuilder provides(String binaryClassName, String binaryWithClassName);
/**
* Add multiple service implementation provisions
* @param binaryClassName Service interface binary name
* @param binaryWithClassNames Implementation class binary names
* @return This builder instance
*/
public ModuleInfoBuilder provides(String binaryClassName, String... binaryWithClassNames);
// Main class
/**
* Get main class
* @return Main class binary name
*/
public String mainClass();
/**
* Set main class for module
* @param binaryClassName Main class binary name
* @return This builder instance
*/
public ModuleInfoBuilder mainClass(String binaryClassName);
// Package listing
/**
* Get packages list
* @return Mutable list of package binary names
*/
public List<String> packages();
/**
* Add package to module
* @param binaryPackageName Package binary name
* @return This builder instance
*/
public ModuleInfoBuilder packages(String binaryPackageName);
/**
* Add multiple packages from collection
* @param binaryPackageNames Collection of package binary names
* @return This builder instance
*/
public ModuleInfoBuilder packages(Collection<String> binaryPackageNames);
/**
* Add multiple packages from array
* @param binaryPackageNames Array of package binary names
* @return This builder instance
*/
public ModuleInfoBuilder packages(String[] binaryPackageNames);
/**
* Add multiple packages
* @param binaryPackageName First package binary name
* @param binaryPackageNames Additional package binary names
* @return This builder instance
*/
public ModuleInfoBuilder packages(String binaryPackageName, String... binaryPackageNames);
/**
* Build module-info ClassFile with ModuleAttribute, ModulePackagesAttribute, and ModuleMainClassAttribute
* @return Constructed module-info ClassFile
*/
@Override
public ClassFile build();
}Usage Examples:
import aQute.bnd.classfile.builder.ModuleInfoBuilder;
import aQute.bnd.classfile.ModuleAttribute;
import aQute.bnd.classfile.ClassFile;
// Build a simple module
ModuleInfoBuilder moduleBuilder = new ModuleInfoBuilder()
.module_name("com.example.mymodule")
.module_version("1.0.0");
// Add dependencies
moduleBuilder
.requires("java.logging", 0) // standard dependency
.requires("java.desktop", ModuleAttribute.Require.ACC_TRANSITIVE); // transitive
// Export packages
moduleBuilder
.exports("com/example/api", 0) // public API
.exports("com/example/impl", 0, "com.friendly"); // qualified export
// Open packages for reflection
moduleBuilder
.opens("com/example/internal", 0, "com.test.framework");
// Service usage and provision
moduleBuilder
.uses("java/sql/Driver")
.provides("java/sql/Driver", "com/example/db/MyDriver");
// Set main class and build
ClassFile moduleInfo = moduleBuilder
.mainClass("com/example/Main")
.build();
byte[] moduleInfoBytes = moduleInfo.write();Extensible constant pool implementation for building class files with automatic index management.
/**
* Mutable constant pool for building class files with automatic entry management
*/
public class MutableConstantPool extends ConstantPool {
/**
* Create empty mutable constant pool
*/
public MutableConstantPool();
/**
* Create mutable constant pool copying from existing constant pool
* @param constantPool Existing ConstantPool to copy from
*/
public MutableConstantPool(ConstantPool constantPool);
/**
* Get constant pool size
* @return Number of entries in constant pool
*/
@Override
public int size();
/**
* Get entry at specified index
* @param index Entry index
* @return Constant pool entry object
*/
@Override
public <T> T entry(int index);
/**
* Set entry at specified index
* @param index Entry index
* @param entry Entry object to set
* @return Previous entry at index
*/
public <T> T entry(int index, Object entry);
}Usage Examples:
import aQute.bnd.classfile.builder.MutableConstantPool;
import aQute.bnd.classfile.ConstantPool;
// Create new mutable constant pool
MutableConstantPool mcp = new MutableConstantPool();
// The pool automatically manages UTF-8 strings, class references, etc.
// when used with ClassFileBuilder - entries are added as needed
// Copy existing constant pool for modification
ClassFile existing = ClassFile.parseClassFile(inputStream);
MutableConstantPool modified = new MutableConstantPool(existing.constant_pool);
// Use with ClassFileBuilder
ClassFileBuilder builder = new ClassFileBuilder(
ClassFile.ACC_PUBLIC, 61, 0,
"com/example/NewClass", "java/lang/Object"
);
builder.constant_pool(modified);Utility for creating ClassFileBuilder instances from existing Java Class objects via reflection.
/**
* Utility for building ClassFile objects from Java Class instances via reflection.
* Creates ClassFileBuilder instances populated with class metadata, fields, and methods.
* Note: Limited by Java reflection API - cannot access bytecode, local variables, etc.
*/
public class ReflectBuilder {
/**
* Create ClassFileBuilder from Java Class object
* Captures class metadata, declared fields, and declared methods using reflection
* @param c Class object to build from
* @return ClassFileBuilder initialized with class information
*/
public static ClassFileBuilder of(Class<?> c);
}Usage Examples:
import aQute.bnd.classfile.builder.ReflectBuilder;
import aQute.bnd.classfile.builder.ClassFileBuilder;
import aQute.bnd.classfile.ClassFile;
// Build ClassFile from existing Java class
Class<?> stringClass = String.class;
ClassFileBuilder builder = ReflectBuilder.of(stringClass);
// Modify the reflected class structure
builder.fields(new FieldInfo(
ClassFile.ACC_PRIVATE,
"customField",
"Ljava/lang/String;",
new Attribute[0]
));
// Build modified version
ClassFile modifiedString = builder.build();
byte[] bytecode = modifiedString.write();
// Useful for analysis and transformation of built-in classes
ClassFileBuilder listBuilder = ReflectBuilder.of(java.util.ArrayList.class);
System.out.println("ArrayList methods: " + listBuilder.methods().size());// Module flags (for ModuleAttribute and ModuleInfoBuilder)
public class ModuleAttribute {
public static final int ACC_OPEN = 0x0020; // Open module
public static final int ACC_SYNTHETIC = 0x1000; // Synthetic module
public static final int ACC_MANDATED = 0x8000; // Mandated module
// Require flags
public static class Require {
public static final int ACC_TRANSITIVE = 0x0020; // Transitive dependency
public static final int ACC_STATIC_PHASE = 0x0040; // Static phase dependency
public static final int ACC_SYNTHETIC = 0x1000; // Synthetic requirement
public static final int ACC_MANDATED = 0x8000; // Mandated requirement
}
}
// Class access flags (inherited from ClassFile)
public class ClassFile {
public static final int ACC_PUBLIC = 0x0001; // Public class
public static final int ACC_FINAL = 0x0010; // Final class
public static final int ACC_SUPER = 0x0020; // Super class flag
public static final int ACC_INTERFACE = 0x0200; // Interface
public static final int ACC_ABSTRACT = 0x0400; // Abstract class
public static final int ACC_SYNTHETIC = 0x1000; // Synthetic class
public static final int ACC_ANNOTATION = 0x2000; // Annotation type
public static final int ACC_ENUM = 0x4000; // Enum type
public static final int ACC_MODULE = 0x8000; // Module class
}// Core class file types used by builders
public class ClassFile {
public final int minor_version;
public final int major_version;
public final ConstantPool constant_pool;
public final int access;
public final String this_class;
public final String super_class;
public final String[] interfaces;
public final FieldInfo[] fields;
public final MethodInfo[] methods;
public final Attribute[] attributes;
}
public class FieldInfo extends MemberInfo {
public FieldInfo(int access, String name, String descriptor, Attribute[] attributes);
}
public class MethodInfo extends MemberInfo {
public MethodInfo(int access, String name, String descriptor, Attribute[] attributes);
}
public abstract class MemberInfo extends ElementInfo {
public final String name;
public final String descriptor;
}
public abstract class ElementInfo {
public final int access;
public final Attribute[] attributes;
}
public interface Attribute {
String name();
void write(DataOutput out, ConstantPool constant_pool) throws IOException;
int attribute_length();
}
// Module-specific attribute types
public class ModuleAttribute implements Attribute {
public final String module_name;
public final int module_flags;
public final String module_version;
public final Require[] requires;
public final Export[] exports;
public final Open[] opens;
public final String[] uses;
public final Provide[] provides;
public static class Require {
public final String requires;
public final int requires_flags;
public final String requires_version;
}
public static class Export {
public final String exports;
public final int exports_flags;
public final String[] exports_to;
}
public static class Open {
public final String opens;
public final int opens_flags;
public final String[] opens_to;
}
public static class Provide {
public final String provides;
public final String[] provides_with;
}
}
public class ModuleMainClassAttribute implements Attribute {
public final String main_class;
}
public class ModulePackagesAttribute implements Attribute {
public final String[] packages;
}