Java Compiler API with classes that depend on each other

Question

I'm using Java Compiler API to compile in-memory classes. That is, classes are compiled to bytecode (no .classes files stored in disk) and then loaded by reconstructing the bytecode.

Sometimes, I need to compile a class that depends on another, also in-memory compiled, class. For instance: Compile Class A, then compile Class B which depends on Class A.

To solve this, I pass both Class A and Class B as the compilation units needed by the getTask method of the compiler API.

However, I really don't like this solution, as it makes me recompile Class A which was already compiled.

Is there a way to get around this?

EDIT: I found a solution through this link: http://www.ibm.com/developerworks/java/library/j-jcomp/index.html

sorry if i'm being slow, but i don't see how the link you posted solves the issue. i've run into the same problem myself...my API comes out a lot cleaner and easy to manage if i can compile classes separately. i would appreciate it a ton if you could post the solution as an answer. :) — stevevls
– stevevls, Commented Dec 6, 2011 at 14:08
actually, i just got this worked out, so i've posted an answer for posterity's sake. thanks for the great question! — stevevls
– stevevls, Commented Dec 7, 2011 at 13:07

stevevls · Accepted Answer · 2011-12-07 13:07:12Z

2

Yes, this is totally possible as long as you properly implement the ForwardingJavaFileManager. The two most important methods are inferBinaryName() and list(). If you set these two up properly, the compiler will be able to resolve classes that you've previously compiled.

inferBinaryName() must return the class' simple name (e.g. the inferred binary name for com.test.Test would be just Test). Here is my implementation (my subclass of JavaFileObject is called InAppJavaFileObject):

@Override
public String inferBinaryName(Location location, JavaFileObject javaFileObject) {

    if(location == StandardLocation.CLASS_PATH && javaFileObject instanceof InAppJavaFileObject) {
        return StringUtils.substringBeforeLast(javaFileObject.getName(), ".java");
    }

    return super.inferBinaryName(location, javaFileObject);
}

Note that I'm stripping off ".java" from the end. When constructing a JavaFileObject, the file name must end in ".java", but if you don't strip the suffix later, the compiler won't find your class.

list() is a little bit more complicated because you have to be careful to play along nicely with your delegate file manager. In my implementation, I keep a map of fully-qualified class name to my subclass of JavaFileObject that I can iterate over:

@Override
public Iterable<JavaFileObject> list(Location action, String pkg, Set<JavaFileObject.Kind> kind, boolean recurse) throws IOException {

    Iterable<JavaFileObject> superFiles = super.list(action, pkg, kind, recurse);

    // see if there's anything in our cache that matches the criteria.
    if(action == StandardLocation.CLASS_PATH && (kind.contains(JavaFileObject.Kind.CLASS) || kind.contains(JavaFileObject.Kind.SOURCE))) {

        List<JavaFileObject> ourFiles = new ArrayList<JavaFileObject>();
        for(Map.Entry<String,InAppJavaFileObject> entry : files.entrySet()) {
            String className = entry.getKey();
            if(className.startsWith(pkg) && ("".equals(pkg) || pkg.equals(className.substring(0, className.lastIndexOf('.'))))) {
                ourFiles.add(entry.getValue());
            }
        }

        if(ourFiles.size() > 0) {
            for(JavaFileObject javaFileObject : superFiles) {
                ourFiles.add(javaFileObject);
            }

            return ourFiles;
        }
    }

    // nothing found in our hash map that matches the criteria...  return
    // whatever super came up with.
    return superFiles;
}

Once you have those methods properly implemented, the rest just works. Enjoy!

answered Dec 7, 2011 at 13:07

stevevls

10.9k1 gold badge50 silver badges51 bronze badges

Sign up to request clarification or add additional context in comments.

2 Comments

Carrotman42 Over a year ago

The only caveat here is that in whatever custom JavaFileObject that you use (in your example "InAppJavaFileObject"), you must implement openInputStream() to return whatever bytes were stored in the stream returned in openOutputStream(), if that's how you store the class data during compilation. But it worked perfectly for me, thanks!

Laird Nelson Over a year ago

Resuscitating this after lo these many years: a binary name is not a simple name, unless the class in question belongs to the unnamed package. The inferred binary name for a resource like com/foo/Bar.class is com.foo.Bar; for com/foo/Bar$Baz.class it is com.foo.Bar$Baz. See JLS 13.1: docs.oracle.com/javase/specs/jls/se8/html/jls-13.html#jls-13.1. The fact the answer above works is due to some weirdness in the compiler: github.com/openjdk/jdk/blob/jdk-22%2B5/src/jdk.compiler/share/… (note the comment).

Jon Skeet · Accepted Answer · 2010-11-29 10:02:54Z

1

That leads to the obvious question of why you want to compile class A separately first. Why not just compile everything in one go?

answered Nov 29, 2010 at 10:02

Jon Skeet

1.5m893 gold badges9.3k silver badges9.3k bronze badges

2 Comments

halfwarp Over a year ago

I think you're missing the point. I posted an example. Your solution is not actually extendable or modular.

Jon Skeet Over a year ago

@halfwarp: If I'm missing the point, then perhaps that's indicative of you not giving enough information? You haven't explained what you're trying to achieve, nor what extendability or modularity you need.

nanda · Accepted Answer · 2010-11-29 10:25:59Z

0

How if you maintain the modified time of the files and the (in-memory) compiled byte code?

answered Nov 29, 2010 at 10:25

nanda

24.9k13 gold badges73 silver badges91 bronze badges

Comments

Stephen C · Accepted Answer · 2010-11-29 11:32:43Z

0

I don't think you can avoid compiling both classes. In fact, if you don't compile both of them, there is a chance that you will end up with binary compatibility problems, or problems with incorrect inlined constants.

This is essentially the same problem as you'd get if you compiled one class and not the other from the command line.

But to be honest, I wouldn't worry about trying to optimize the compilation like that. (And if your application needs to be able to dynamically compile one class and not the other, it has probably has significant design issues.)

answered Nov 29, 2010 at 11:32

Stephen C

723k95 gold badges849 silver badges1.3k bronze badges

Collectives™ on Stack Overflow

Java Compiler API with classes that depend on each other

4 Answers 4

2 Comments

2 Comments

Comments

Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

4 Answers 4

2 Comments

2 Comments

Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Related