Java Metaprogramming

Question

I'm working on my first real project with Java. I'm beginning to get comfortable with the language, although I have more experience with dynamic languages.

I have a class that behave similar to the following:

class Single
{
    public void doActionA() {}
    public void doActionB() {}
    public void doActionC() {}
}

And then I have a SingleList class that acts as a collection of these classes (specifically, it's for a 2D Sprite library, and the "actions" are all sorts of transformations: rotate, shear, scale, etc). I want to be able to do the following:

class SingleList
{
    public void doActionA() {
        for (Single s : _innerList) {
            s.doActionA();
        }
    }

    ... etc ...
}

Is there any way to simply defer a method (or a known list of methods) to each member of the inner list? Any way without having to specifically list each method, then loop through each inner member and apply it manually?

To make things a bit harder, the methods are of varying arity, but are all of return type "void".

I think you can take a look at Java reflection, which allows you to call methods during runtime. — Alvin
– Alvin, Commented Jan 15, 2012 at 7:11
But I would still need to generate all of the method stubs in the SingleList class. I'm looking more for a solution that acts as a catch-all invoked method. Much like call in PHP or python getattr. — efritz
– efritz, Commented Jan 15, 2012 at 7:13
oh you don't need to actuall, with reflection you can do SingleList.get("someAttr"), then the reflection will call the method getSomeAttr() for you. You can Google "org.springframework.beans.BeanUtils", it kind of does what you want. I will write an example as formal answer later if no one beats me to it haha. — Alvin
– Alvin, Commented Jan 15, 2012 at 8:02
Alvin's suggestion will work, but the varying arity will make things a bit messy. You could consider following the "command pattern"; that is, making each operation a different class, with a common abstract base class. Each operation class would have the arguments to the operation as fields, and these would be populated by a constructor. The abstract base class could declare apply( Single ), but also define applyToAll( SingleList ) or even applyToAll( Collection<Single> ). This should be enough information to get you started; post again if you need more help. — Dawood ibn Kareem
– Dawood ibn Kareem, Commented Jan 15, 2012 at 9:18

thkala · Accepted Answer · 2012-01-15 10:01:51Z

Unfortunately Java does not readily support class creation at runtime, which is what you need: the SingleList needs to be automatically updated with the necessary stub methods to match the Single class.

I can think of the following approaches to this issue:

Use Java reflection:
- Pros:
  - It's readily available in the Java language and you can easily find documentation and examples.
- Cons:
  - The SingleList class would not be compatible with the Single class interface any more.
  - The Java compiler and any IDEs are typically unable to help with methods called via reflection - errors that would be caught by the compiler are typically transformed into runtime exceptions.
  - Depending of your use case, you might also see a noticeable performance degradation.
Use a build system along with some sort of source code generator to automatically create the SingleList.java file.
- Pros:
  - Once you set it up you will not have to deal with it any more.
- Cons:
  - Setting this up has a degree of difficulty.
  - You would have to separately ensure that the SingleList class loaded in any JVM - or your IDE, for that matter - actually matches the loaded Single class.
Tackle this issue manually - creating an interface (e.g. SingleInterface) or a base abstract class for use by both classes should help, since any decent IDE will point out unimplemented methods. Proper class architecture would minimize the duplicated code and your IDE might be able to help with generating the boilerplate parts.
- Pros:
  - There is no setup curve to get over.
  - Your IDE will always see the right set of classes.
  - The class architecture is usually improved afterwards.
- Cons:
  - Everything is manual.
Use a bytecode generation library such as Javassist or BCEL to dynamically generate/modify the SingleList class on-the-fly.
- Pros:
  - This method is extremely powerful and can save a lot of time in the long term.
- Cons:
  - Using bytecode generation libraries is typically not trivial and not for the faint-hearted.
  - Depending on how you write your code, you may also have issues with your IDE and its handling of the dynamic classes.

Looks like the manual approach is the way to go. I'll just have to make sure to keep the interface up-to-date if I add any more transformations.

Collectives™ on Stack Overflow

Java Metaprogramming

1 Answer 1

1 Comment

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

1 Answer 1

1 Comment

Your Answer

Sign up or log in

Post as a guest

Related