super（）调用Java API的切入点

Question

I'm trying to use AspectJ to hook calls into the Java API. For example, let's say I have an aspect for java.io.File:

import java.io.File;

aspect FileTest {
  File around(String arg0): args(arg0) && call(public File.new(String)) {
    throw new RuntimeException("Example");
  }
}

This hooks calls to the File(String) constructor just fine. However it will not do anything for the following code:

public class FileLoophole extends File {
    public FileLoophole(String filename) {
        super(filename);
    }
}

According to https://eclipse.org/aspectj/doc/next/progguide/language-joinPoints.html , I should use the execution() pointcut to handle super() calls instead. However, this doesn't work because the execution point is in the Java API, which I can't weave code into. Is there a pointcut to capture these super() callsites? Is there a way to do it without knowing about the FileLoophole class beforehand?

Answer 1

You basically have two options:

• Use the pattern File+ in order to match pointcuts including subclasses. There is no need to know their names.
• Use AspectJ binary (post-compile) weaving and inject your aspect code directly into the JDK classes from rt.jar, creating a modified version of it or just packaging the modified JDK classes into a new JAR and prepending it to the boot classpath.

While the former approach is non-intrusive and independent of your ability to modify the JDK in your runtime environment, it is also indirect and not exactly what you asked for. The latter approach is what you asked for but probably not the thing you want to do except for very special cases.

Driver application:

package de.scrum_master.app;

import java.io.File;

public class FileLoophole extends File {
    public FileLoophole(String filename) {
        super(filename);
    }

    public static void main(String[] args) {
        new File("file.txt");
        new FileLoophole("loophole.txt");
    }
}

Aspect:

package de.scrum_master.aspect;

import java.io.File;

public aspect FileInterceptor {
    Object around(String fileName): call(File+.new(String)) && args(fileName) {
        System.out.println(thisJoinPoint + " -> " + fileName);
        return proceed(fileName);
    }

    void around(String fileName): execution(File+.new(String))  && args(fileName) {
        System.out.println(thisJoinPoint + " -> " + fileName);
        proceed(fileName);
    }
}

Console output:

call(java.io.File(String)) -> file.txt
call(de.scrum_master.app.FileLoophole(String)) -> loophole.txt
execution(de.scrum_master.app.FileLoophole(String)) -> loophole.txt

PS: Please note that while call(*.new(..)) returns an object, execution(*.new(..)) does not, which is why the around() advice's return type is void . These semantics are described in the AspectJ documentation .

---

Update: You asked about inner classes in your comment. Well, my pointcut works for static inner classes without any change. But a non-static inner class needs an instance of its surrounding class in its constructor. Check this out, I created a class + debug aspect for you:

package de.scrum_master.app;

import java.io.File;

public class Application {
    private class FileLoophole extends File {
        public FileLoophole(String filename) {
            super(filename);
        }
    }

    public static void main(String[] args) {
        new File("file.txt");
        new Application().new FileLoophole("loophole.txt");
    }
}

package de.scrum_master.aspect;

public aspect FileInterceptor {
    before() : within(de.scrum_master.app.Application) {
        System.out.println(thisJoinPoint);
    }
}

Now look at the console log:

staticinitialization(de.scrum_master.app.Application.<clinit>)
execution(void de.scrum_master.app.Application.main(String[]))
call(java.io.File(String))
call(de.scrum_master.app.Application())
preinitialization(de.scrum_master.app.Application())
initialization(de.scrum_master.app.Application())
execution(de.scrum_master.app.Application())
call(Class java.lang.Object.getClass())
call(de.scrum_master.app.Application.FileLoophole(Application, String))
staticinitialization(de.scrum_master.app.Application.FileLoophole.<clinit>)
preinitialization(de.scrum_master.app.Application.FileLoophole(Application, String))
initialization(de.scrum_master.app.Application.FileLoophole(Application, String))
execution(de.scrum_master.app.Application.FileLoophole(Application, String))

As you can see at the end of the log, an inner class's constructor is converted into something which takes the surrounding class instance as its first parameter, thus the mismatch. Now, knowing that, we can change our original pointcut in order to capture all constructors:

void around(): execution(File+.new(..)) {
    System.out.println(thisJoinPoint);
    proceed();
}

If you still want to capture the file name, it gets a little more complicated:

void around(String fileName): execution(File+.new(*, String)) && args(*, fileName) {
    System.out.println(thisJoinPoint + " -> " + fileName);
    proceed(fileName);
}