tessl/maven-org-aspectj--aspectjweaver

The AspectJ weaver applies aspects to Java classes and can be used as a Java agent for load-time weaving (LTW).

—

Pending

Quality

Pending

Does it follow best practices?

Impact

Pending

No eval scenarios have been run

Securityby

Pending

The risk profile of this skill

Overview

Eval results

Files

AspectJ Weaver

Name: tessl/maven-org-aspectj--aspectjweaver
Author: tessl

The AspectJ Weaver applies aspects to Java classes and supports load-time weaving (LTW) during class loading. It provides both Java agent capabilities for transparent weaving and programmatic APIs for embedding weaving into applications. The weaver includes a comprehensive caching system for improved performance and supports multi-classloader and OSGi environments.

Package Information

Package Name: org.aspectj:aspectjweaver
Package Type: maven
Language: Java
Installation:
```
<dependency>
  <groupId>org.aspectj</groupId>
  <artifactId>aspectjweaver</artifactId>
  <version>1.9.24</version>
</dependency>
```

Core Imports

import org.aspectj.weaver.loadtime.Agent;
import org.aspectj.weaver.loadtime.Aj;
import org.aspectj.weaver.tools.WeavingAdaptor;
import org.aspectj.weaver.tools.cache.WeavedClassCache;

Basic Usage

Java Agent Usage

Run your application with the AspectJ weaver as a Java agent:

java -javaagent:aspectjweaver.jar MyApplication

The agent automatically initializes and applies load-time weaving to classes as they are loaded.

Programmatic Usage

import org.aspectj.weaver.tools.WeavingAdaptor;
import java.net.URL;

// Create weaving adaptor
WeavingAdaptor adaptor = new WeavingAdaptor(classLoader);

// Weave a class
byte[] originalBytes = getClassBytes(className);
byte[] wovenBytes = adaptor.weaveClass(className, originalBytes);

// Use the woven bytes
defineClass(className, wovenBytes);

Architecture

The AspectJ Weaver is organized into several key components:

Agent System: Java agent entry point for transparent load-time weaving
Core Weaving: Programmatic weaving APIs and class transformation
Caching System: Performance optimization through class caching
Context Management: Multi-classloader and OSGi environment support

Capabilities

Java Agent Integration

Entry point for using AspectJ weaver as a Java agent with -javaagent parameter.

public static void premain(String options, Instrumentation instrumentation);
public static void agentmain(String options, Instrumentation instrumentation);
public static Instrumentation getInstrumentation();

Java Agent Integration

Programmatic Weaving

Core APIs for embedding AspectJ weaving capabilities into applications.

public WeavingAdaptor(WeavingClassLoader loader);
public byte[] weaveClass(String name, byte[] bytes) throws IOException;
public byte[] weaveClass(String name, byte[] bytes, boolean mustWeave) throws IOException;

Programmatic Weaving

Class Caching

High-performance caching system for weaved and generated classes across JVM restarts.

public static WeavedClassCache createCache(ClassLoader loader, List<String> aspects, 
    GeneratedClassHandler handler, IMessageHandler messageHandler);
public void put(CachedClassReference ref, byte[] classBytes, byte[] weavedBytes);
public CachedClassEntry get(CachedClassReference ref, byte[] classBytes);

Class Caching

Multi-Classloader Support

Support for complex classloader hierarchies, OSGi environments, and multi-module applications.

public interface IWeavingContext {
    Enumeration<URL> getResources(String name) throws IOException;
    String getClassLoaderName();
    boolean isLocallyDefined(String classname);
}

Multi-Classloader Support

Types

Core Interfaces

public interface ClassPreProcessor {
    void initialize();
    byte[] preProcess(String className, byte[] bytes, ClassLoader classLoader, 
        ProtectionDomain protectionDomain);
    void prepareForRedefinition(ClassLoader loader, String className);
}

public interface IClassFileProvider {
    Iterator<UnwovenClassFile> getClassFileIterator();
    IWeaveRequestor getRequestor();
    boolean isApplyAtAspectJMungersOnly();
}

Cache Types

public interface CacheFactory {
    CacheKeyResolver createResolver();
    CacheBacking createBacking(String scope);
}

public interface CacheKeyResolver {
    CachedClassReference generatedKey(String className);
    CachedClassReference weavedKey(String className, byte[] original_bytes);
    String keyToClass(String key);
}

public interface CacheBacking {
    String[] getKeys(String regex);
    void remove(CachedClassReference ref);
    CachedClassEntry get(CachedClassReference ref, byte[] originalBytes);
    void put(CachedClassEntry entry, byte[] originalBytes);
}

Message Handling Types

public interface IMessageHandler {
    boolean handleMessage(IMessage message) throws AbortException;
    boolean isIgnoring(IMessage.Kind kind);
    void dontIgnore(IMessage.Kind kind);
    void ignore(IMessage.Kind kind);
}

public class AbortException extends RuntimeException {
    // Exception thrown to abort weaving operations
}

public interface IMessageHolder {
    boolean hasAnyMessage(IMessage.Kind kind, boolean orGreater);
    int numMessages(IMessage.Kind kind, boolean orGreater);
    IMessage[] getMessages(IMessage.Kind kind, boolean orGreater);
}

public interface IMessage {
    enum Kind { ABORT, ERROR, WARNING, INFO, DEBUG, TASKTAG, USAGE, WEAVEINFO }
    Kind getKind();
    String getMessage();
    ISourceLocation getSourceLocation();
    Throwable getThrown();
}

public interface ISourceLocation {
    java.io.File getSourceFile();
    int getLine();
    int getColumn();
    String getContext();
}

Data Types

public class CachedClassReference {
    // Reference to a cached class with key information
}

public class CachedClassEntry {
    // Represents a cached class entry with type information
}

public class CacheStatistics {
    // Statistics tracking for cache operations
}

public interface GeneratedClassHandler {
    void acceptClass(String name, byte[] originalBytes, byte[] wovenBytes);
}

public class Definition {
    // Represents weaving definition configuration from aop.xml files
}

Error Handling

The AspectJ Weaver throws several types of exceptions:

IllegalClassFormatException: When class transformation fails
IOException: During file operations and weaving
UnsupportedOperationException: When agent is not properly initialized
ExceptionInInitializerError: During ClassPreProcessorAgentAdapter initialization

Example error handling:

try {
    byte[] wovenBytes = adaptor.weaveClass(className, originalBytes);
} catch (IOException e) {
    // Handle weaving failure
    System.err.println("Failed to weave class " + className + ": " + e.getMessage());
}