Transformation Utilities

import net.sf.cglib.transform.TransformingClassLoader;
import net.sf.cglib.transform.ClassTransformer;
import net.sf.cglib.transform.ClassFilter;
import net.sf.cglib.transform.ClassTransformerFactory;
import net.sf.cglib.transform.MethodFilter;

/**
 * Class loader that applies transformations to classes as they are loaded
 */
public class TransformingClassLoader extends AbstractClassLoader {
    /**
     * Create transforming class loader
     * @param parent Parent class loader
     * @param filter Filter for classes to transform
     * @param t Factory for creating transformers
     */
    public TransformingClassLoader(ClassLoader parent, ClassFilter filter, ClassTransformerFactory t);
}

// Create filter for classes to transform
ClassFilter filter = new ClassFilter() {
    public boolean accept(String className) {
        return className.startsWith("com.mycompany.");
    }
};

// Create transformer factory
ClassTransformerFactory factory = new ClassTransformerFactory() {
    public ClassTransformer newInstance() {
        return new MyCustomTransformer();
    }
};

// Create transforming class loader
TransformingClassLoader loader = new TransformingClassLoader(
    Thread.currentThread().getContextClassLoader(),
    filter,
    factory
);

// Load and use transformed classes
Class<?> transformedClass = loader.loadClass("com.mycompany.MyClass");
Object instance = transformedClass.newInstance();

/**
 * Abstract base class for class transformations
 */
public abstract class ClassTransformer extends ClassVisitor {
    /**
     * Default constructor
     */
    public ClassTransformer();
    
    /**
     * Constructor with ASM API version
     * @param opcode ASM API version
     */
    public ClassTransformer(int opcode);
    
    /**
     * Set the target visitor for the transformation chain
     * @param target Target class visitor
     */
    public abstract void setTarget(ClassVisitor target);
}

/**
 * Interface for filtering classes during transformation
 */
public interface ClassFilter {
    /**
     * Determine if a class should be processed
     * @param className Fully qualified class name
     * @return true if class should be processed
     */
    boolean accept(String className);
}

// Filter by package prefix
ClassFilter packageFilter = new ClassFilter() {
    public boolean accept(String className) {
        return className.startsWith("com.myapp.");
    }
};

// Filter by class name pattern
ClassFilter patternFilter = new ClassFilter() {
    public boolean accept(String className) {
        return className.endsWith("Service") || className.endsWith("Repository");
    }
};

// Combine filters
ClassFilter combinedFilter = new ClassFilter() {
    public boolean accept(String className) {
        return packageFilter.accept(className) && patternFilter.accept(className);
    }
};

/**
 * Factory for creating class transformers
 */
public interface ClassTransformerFactory {
    /**
     * Create new transformer instance
     * @return New ClassTransformer instance
     */
    ClassTransformer newInstance();
}

/**
 * Interface for filtering methods during transformation
 */
public interface MethodFilter {
    /**
     * Determine if a method should be processed
     * @param access Method access flags
     * @param name Method name
     * @param desc Method descriptor
     * @param signature Method signature (may be null)
     * @param exceptions Exception types thrown (may be null)
     * @return true if method should be processed
     */
    boolean accept(int access, String name, String desc, String signature, String[] exceptions);
}

// Filter public methods only
MethodFilter publicMethodFilter = new MethodFilter() {
    public boolean accept(int access, String name, String desc, String signature, String[] exceptions) {
        return (access & Opcodes.ACC_PUBLIC) != 0;
    }
};

// Filter by method name
MethodFilter nameFilter = new MethodFilter() {
    public boolean accept(int access, String name, String desc, String signature, String[] exceptions) {
        return name.startsWith("get") || name.startsWith("set");
    }
};

// Filter by return type
MethodFilter returnTypeFilter = new MethodFilter() {
    public boolean accept(int access, String name, String desc, String signature, String[] exceptions) {
        return desc.endsWith(")V"); // void return type
    }
};

/**
 * Chains multiple class transformers together
 */
public class ClassTransformerChain extends AbstractClassTransformer {
    /**
     * Create transformation chain
     * @param transformers Array of transformers to chain
     */
    public ClassTransformerChain(ClassTransformer[] transformers);
}

/**
 * Applies method filtering during class transformation
 */
public class MethodFilterTransformer extends AbstractClassTransformer {
    /**
     * Create method filter transformer
     * @param filter Method filter to apply
     * @param transformer Transformer for filtered methods
     */
    public MethodFilterTransformer(MethodFilter filter, MethodTransformer transformer);
}

/**
 * Duplicates class visitor calls to multiple targets
 */
public class ClassVisitorTee extends ClassVisitor {
    /**
     * Create visitor tee
     * @param cv1 First class visitor
     * @param cv2 Second class visitor
     */
    public ClassVisitorTee(ClassVisitor cv1, ClassVisitor cv2);
}

/**
 * Duplicates method visitor calls to multiple targets
 */
public class MethodVisitorTee extends MethodVisitor {
    /**
     * Create method visitor tee
     * @param mv1 First method visitor
     * @param mv2 Second method visitor
     */
    public MethodVisitorTee(MethodVisitor mv1, MethodVisitor mv2);
}

/**
 * Duplicates field visitor calls to multiple targets
 */
public class FieldVisitorTee extends FieldVisitor {
    /**
     * Create field visitor tee
     * @param fv1 First field visitor
     * @param fv2 Second field visitor
     */
    public FieldVisitorTee(FieldVisitor fv1, FieldVisitor fv2);
}

// Create custom transformer
public class LoggingTransformer extends ClassTransformer {
    public void setTarget(ClassVisitor target) {
        // Implementation here
    }
    
    @Override
    public MethodVisitor visitMethod(int access, String name, String desc, 
                                   String signature, String[] exceptions) {
        MethodVisitor mv = super.visitMethod(access, name, desc, signature, exceptions);
        return new LoggingMethodVisitor(mv, name);
    }
}

// Use with transforming class loader
ClassFilter filter = className -> className.startsWith("com.example.");
ClassTransformerFactory factory = () -> new LoggingTransformer();
TransformingClassLoader loader = new TransformingClassLoader(
    getClass().getClassLoader(), filter, factory);

// Filter methods for transformation
MethodFilter filter = (access, name, desc, signature, exceptions) -> {
    return (access & Opcodes.ACC_PUBLIC) != 0 && !name.equals("<init>");
};

// Apply transformation to filtered methods
MethodFilterTransformer transformer = new MethodFilterTransformer(
    filter, 
    new TimingMethodTransformer()
);