Signature System

/**
 * Represents the signature at a join point. This interface parallels
 * java.lang.reflect.Member.
 */
public interface Signature {
    /**
     * Returns the identifier part of this signature (method name, field name, etc.)
     */
    String getName();
    
    /**
     * Returns the modifiers on this signature represented as an int.
     * Use java.lang.reflect.Modifier constants and helper methods.
     */
    int getModifiers();
    
    /**
     * Returns a Class object representing the class, interface, or aspect
     * that declared this member.
     */
    Class getDeclaringType();
    
    /**
     * Returns the fully qualified name of the declaring type (cached for efficiency)
     */
    String getDeclaringTypeName();
    
    String toString();
    String toShortString();
    String toLongString();
}

/**
 * Signature for method execution and call join points
 */
public interface MethodSignature extends MemberSignature {
    /**
     * Returns the return type of this method
     */
    Class getReturnType();
    
    /**
     * Returns the Method object for this signature
     */
    Method getMethod();
    
    /**
     * Returns the parameter types of this method
     */
    Class[] getParameterTypes();
    
    /**
     * Returns the parameter names of this method
     */
    String[] getParameterNames();
    
    /**
     * Returns the exception types declared by this method
     */
    Class[] getExceptionTypes();
}

/**
 * Signature for constructor execution and call join points
 */
public interface ConstructorSignature extends CodeSignature {
    /**
     * Returns the Constructor object for this signature
     */
    Constructor getConstructor();
}

/**
 * Signature for field get and set join points
 */
public interface FieldSignature extends MemberSignature {
    /**
     * Returns the type of the field
     */
    Class getFieldType();
    
    /**
     * Returns the Field object for this signature
     */
    Field getField();
}

/**
 * Signature for advice execution join points
 */
public interface AdviceSignature extends CodeSignature {
    /**
     * Returns the return type of this advice
     */
    Class getReturnType();
    
    /**
     * Returns the exception types declared by this advice
     */
    Class[] getExceptionTypes();
}

@Aspect
public class MethodAnalysisAspect {
    
    @Before("execution(* com.example.service.*.*(..))")
    public void analyzeMethod(JoinPoint joinPoint) {
        Signature sig = joinPoint.getSignature();
        
        if (sig instanceof MethodSignature) {
            MethodSignature methodSig = (MethodSignature) sig;
            
            System.out.println("Method: " + methodSig.getName());
            System.out.println("Return type: " + methodSig.getReturnType().getSimpleName());
            System.out.println("Parameters: " + Arrays.toString(methodSig.getParameterTypes()));
            System.out.println("Parameter names: " + Arrays.toString(methodSig.getParameterNames()));
            System.out.println("Exceptions: " + Arrays.toString(methodSig.getExceptionTypes()));
            System.out.println("Modifiers: " + Modifier.toString(methodSig.getModifiers()));
            System.out.println("Declaring type: " + methodSig.getDeclaringType().getName());
        }
    }
}

@Aspect
public class FieldAccessAspect {
    
    @Before("get(* com.example.model.*.*) || set(* com.example.model.*.*)")
    public void monitorFieldAccess(JoinPoint joinPoint) {
        FieldSignature fieldSig = (FieldSignature) joinPoint.getSignature();
        
        System.out.println("Field access: " + fieldSig.getName());
        System.out.println("Field type: " + fieldSig.getFieldType().getSimpleName());
        System.out.println("Owner: " + fieldSig.getDeclaringType().getSimpleName());
        System.out.println("Access type: " + joinPoint.getKind());
        
        if ("field-set".equals(joinPoint.getKind())) {
            Object[] args = joinPoint.getArgs();
            if (args.length > 0) {
                System.out.println("New value: " + args[0]);
            }
        }
    }
}

@Aspect
public class ConstructorAspect {
    
    @Before("execution(com.example.model.*.new(..))")
    public void beforeConstruction(JoinPoint joinPoint) {
        ConstructorSignature conSig = (ConstructorSignature) joinPoint.getSignature();
        
        System.out.println("Creating: " + conSig.getDeclaringType().getSimpleName());
        System.out.println("Constructor parameters: " + Arrays.toString(conSig.getParameterTypes()));
        System.out.println("Arguments: " + Arrays.toString(joinPoint.getArgs()));
        
        Constructor constructor = conSig.getConstructor();
        System.out.println("Modifiers: " + Modifier.toString(constructor.getModifiers()));
    }
}

// Base interfaces
public interface Signature { /* base signature information */ }
public interface MemberSignature extends Signature { /* member-specific information */ }
public interface CodeSignature extends MemberSignature { /* executable code signatures */ }

// Specific signature types
public interface MethodSignature extends MemberSignature { /* method-specific */ }
public interface ConstructorSignature extends CodeSignature { /* constructor-specific */ }
public interface FieldSignature extends MemberSignature { /* field-specific */ }
public interface AdviceSignature extends CodeSignature { /* advice-specific */ }
public interface InitializerSignature extends CodeSignature { /* initializer-specific */ }
public interface CatchClauseSignature extends CodeSignature { /* exception handler-specific */ }
public interface LockSignature extends Signature { /* synchronization lock-specific */ }
public interface UnlockSignature extends Signature { /* synchronization unlock-specific */ }