CODEWITHSUNDEEP
javareflection
engineercoding
engineercoding

Reputation: 832

Approach doing the same stuff on different objects

I am currently making a library which is an utility for me to handle something which is not associated with the question (I am implicitly not saying the subject because it is not really important), however it does use reflection.

I am retrieving all declared and inherited methods from a class, which currently works fine and is not the issue. But the thing is, I need to do this as well for sub-classes since those inherit over like methods do (however you cannot override those like methods).

The problem that I am facing that it will use the same algorithm but there will be on difference, instead of calling clazz.getDeclaredMethods() I need to call clazz.getMethods. What is the best way too approach this, and I kind of need to return Class[] and Method[] in the method signature as well.

Normally I would look for a shared superclass, but in this case I prefer to the have Class[] and Method[] accordingly. For starters, I did some research and found some shared superclasses:

Since I need both Class[] and Method[] arrays I am thinking something like generics, so the method would look like:

public static <T extends GenericDecleration> T[] getT () {

}

As mentioned by dasblinkenlight this will not work since the method doesn't take any arguments and cannot check whether to retrieve Class or Method objects.

But how would I detect whether I need to call getDeclaredMethods or getDeclaredClasses?

What is the best approach on how to do this without duplicating a lot of code? I really tried to explain myself here, but if it is still unclear what I am doing please feel free to ask away!

Thank you very much in advance!

After messing around with this, I have found a solution that totally fits my needs. This is a combination of generics and @dasblinkenlight's solution, like so:

public interface DeclExtractor<T extends GenericDecleration> {
    public T[] extract (Class clazz);
    public Class<? extends T[]) getGenericClass ();

    DeclExtractor<Method> methodExtractor = new DeclExtractor<Method>() {
        @Override
        public Method[] extract (Class clazz) {
            return clazz.getDeclaredMethods();
        }

        @Override
        public Class<? extends Method[]> getGenericClass () {
            return Method[].class;
        }
    }

    // Same for Class
}

Now the method which also will return the correct type so you dont have to manually cast all GenericDeclaration to your original object type. My issue was that I used a collection for it and not the correct array:

public <T> T[] getAll (final DeclExtractor<T> extractor, Class<?> clazz) {
    T[] declaration = extractor.extract (clazz);
    //.. The algorithm..

    // Return an instance of a collection as array (I use a set in my implementation)
    final Object[] objects = myCollection.toArray();
    return Arrays.copyOf(objects, objects.length, extractor.getGenericClass());
}

Technically you do not need the getGenericClass method in the interface, but I am using extract directly in a loop so I cannot pull the class of that, however, you can. Hopefully this helps someone in the future :) Thanks again to @dasblinkenlight for the inspiration!

Upvotes: 2

Views: 54

Answers (1)

Sergey Kalinichenko
Sergey Kalinichenko

Reputation: 726909

Your getT needs to get some input in order to decide what to do.

What about a method which can takes an enum as argument to determine whether it needs to get classes or methods? (from a comment)

There is a better approach: define an interface that performs the appropriate extraction, and make two instances of it - one for extracting classes, and one for extracting methods:

public interface DeclExtractor {
    GenericDecleration[] extract(Class cl);
    final DeclExtractor forClasses = new DeclExtractor() {
        public GenericDecleration[] extract(Class cl) {
            // make an array of GenericDecleration from extracted classes
        }
    };
    final DeclExtractor forMethods = new DeclExtractor() {
        public GenericDecleration[] extract(Class cl) {
            // make an array of GenericDecleration from extracted methods
        }
    };
}

Now you can rewrite your getT to take an "extractor", like this:

public static GenericDecleration[] getT (DeclExtractor extractor, Class cl) {
    ...
    // When it's time to get components of the class, make this call:
    GenericDecleration[] components = extractor.extract(cl);
    ...
}

To initiate a call to getT, pass DeclExtractor.forClasses or DeclExtractor.forMethods:

GenericDecleration[] c = getT(DeclExtractor.forClasses);
GenericDecleration[] m = getT(DeclExtractor.forMethods);

Upvotes: 1

Related Questions