tessl/maven-cglib--cglib

High level API to generate and transform JAVA byte code for dynamic proxy objects and runtime class enhancement.

—

Pending

Overview

Eval results

Files

Bytecode Transformation

Name: tessl/maven-cglib--cglib
Author: tessl

Advanced bytecode transformation utilities for custom class loading and runtime class modification. These components provide lower-level access to CGLib's bytecode generation capabilities for specialized use cases.

Capabilities

ClassTransformer

Base class for implementing custom bytecode transformations during class generation.

/**
 * Base class for bytecode transformations
 */
public abstract class ClassTransformer {
    /**
     * Transform bytecode during class generation
     * @param cv - ClassVisitor for bytecode modification
     * @return Modified ClassVisitor
     */
    public abstract ClassVisitor transform(ClassVisitor cv);
    
    /**
     * Set the next transformer in the chain
     * @param next - Next ClassTransformer
     */
    public void setNext(ClassTransformer next);
    
    /**
     * Get the next transformer in the chain
     * @return Next ClassTransformer or null if none
     */
    public ClassTransformer getNext();
}

Usage Examples:

import net.sf.cglib.transform.ClassTransformer;
import org.objectweb.asm.ClassVisitor;
import org.objectweb.asm.MethodVisitor;

// Custom transformer to add logging to all methods
public class LoggingTransformer extends ClassTransformer {
    @Override
    public ClassVisitor transform(ClassVisitor cv) {
        return new ClassVisitor(Opcodes.ASM7, cv) {
            @Override
            public MethodVisitor visitMethod(int access, String name, 
                                           String descriptor, String signature, 
                                           String[] exceptions) {
                MethodVisitor mv = super.visitMethod(access, name, descriptor, signature, exceptions);
                // Add logging bytecode to method
                return new LoggingMethodVisitor(mv, name);
            }
        };
    }
}

TransformingClassLoader

ClassLoader that applies transformations during class loading, enabling runtime class modification.

/**
 * ClassLoader that applies transformations during class loading
 */
public class TransformingClassLoader extends ClassLoader {
    /**
     * Create TransformingClassLoader with parent ClassLoader
     * @param parent - Parent ClassLoader
     * @param filter - ClassFilter to determine which classes to transform
     * @param transformer - ClassTransformer to apply
     */
    public TransformingClassLoader(ClassLoader parent, ClassFilter filter, 
                                 ClassTransformer transformer);
    
    /**
     * Load and transform class
     * @param name - Class name
     * @return Loaded and transformed Class
     * @throws ClassNotFoundException - If class cannot be found
     */
    @Override
    public Class<?> loadClass(String name) throws ClassNotFoundException;
    
    /**
     * Load class from byte array with transformation
     * @param name - Class name
     * @param b - Original bytecode
     * @param off - Offset in byte array
     * @param len - Length of bytecode
     * @return Loaded Class after transformation
     */
    protected Class<?> loadClass(String name, byte[] b, int off, int len);
}

Usage Examples:

import net.sf.cglib.transform.*;
import net.sf.cglib.core.ClassFilter;

// Create class filter to select which classes to transform
ClassFilter filter = new ClassFilter() {
    @Override
    public boolean accept(String name) {
        return name.startsWith("com.mycompany"); // Only transform our classes
    }
};

// Create transformer chain
ClassTransformer transformer = new LoggingTransformer();

// Create transforming class loader
TransformingClassLoader loader = new TransformingClassLoader(
    getClass().getClassLoader(), filter, transformer);

// Load transformed class
Class<?> transformedClass = loader.loadClass("com.mycompany.MyService");
Object instance = transformedClass.newInstance();

ClassFilter

Interface for determining which classes should be transformed.

/**
 * Interface for filtering classes during transformation
 */
public interface ClassFilter {
    /**
     * Determine if class should be transformed
     * @param name - Class name
     * @return true if class should be transformed, false otherwise
     */
    boolean accept(String name);
}

Types

import org.objectweb.asm.ClassVisitor;
import org.objectweb.asm.MethodVisitor;

Usage Notes

ASM Dependency: Transformation utilities require direct use of ASM (Abstract Syntax Tree Manipulation) framework
Advanced Usage: These classes are for advanced users who need custom bytecode manipulation
Performance: Direct bytecode transformation can be complex but offers maximum flexibility
Integration: Often used with other CGLib components for specialized proxy generation scenarios

Install with Tessl CLI