Java Reflection: the fast way to retrieve value from property

Question

I would like to use the fastest way to retrieve value from a property.

Should I use:

public Object getValue(Object obj, Field field) {
    field.setAccessible(true);
    return field.get(obj);
}

or should I use:

public Object getValue(Object obj, Field field) throws Exception {
    StringBuilder methodName = new StringBuilder();
    methodName.append("get");
    methodName.append(field.getName().substring(0, 1).toUpperCase());
    methodName.append(field.getName().substring(1, field.getName().length()));
    for (Method method : methods) {
        if (method.getName().equals(methodName.toString())) {
            return method.invoke(obj);
        }
    }
}

or should I use:

public Object getValue(Object obj, Field field) throws Throwable {
        MethodHandles.Lookup lookup = MethodHandles.lookup();
        StringBuilder methodName = new StringBuilder();
        methodName.append("get");
        methodName.append(field.getName().substring(0, 1).toUpperCase());
        methodName.append(field.getName().substring(1, field.getName().length()));
        for (Method method : methods) {
            if (method.getName().equals(methodName.toString())) {
                MethodHandle mh = lookup.findVirtual(obj.getClass(), methodName.toString(), MethodType.methodType(field.getType()));

                return mh.invoke(obj);
            }
        }
    }

Thanks in advance.

the problem is that you are mixing 2 concepts basically incompatible. If you need high performance, you don't use reflection. You use a well defined api. Reflection is usually less performant from 1-3 magnitude order (any good java book tell that: https://www.amazon.fr/Effective-Java-Joshua-Bloch/dp/0134685997/ref=dp_ob_title_bk) — spi, Jan 18 '18 at 10:23
@spi I indeed with you. Reflection is not the fastest way to retrieve values. But, unfortunately, I can't change this. I must use reflection. But among all the possibilities, I would like to know what is the best one. Thanks for you reply :) — Gilberto, Jan 18 '18 at 15:44

GhostCat · Accepted Answer · 2018-01-18T12:32:26.013

There are different levels in there:

A field access is a field access. A method that access the field will ... access the field, too. Just with much more overhead.
You have to maintain your code over time.

The first point suggests that a "straight forward" field access should always be faster (especially given the fact that this method is pretty short - and the JIT is much better at inlining short methods). Leading to the second point: simply ask yourself which of the three methods is the easiest to read and understand.

The key thing is that reflection calls are expensive. The method handle concept is intended to improve that cost (by avoiding the checks that a method call using reflection is undergoing each time). So if you are really interested in finding the "optimal" code, then the answer might be framed around a solution that computes a method handle once, to then be re-used for subsequent calls. There is absolutely no point in instantiating a method handle just to make a single call. Nothing to be gained from that - method handles are "cheaper" than ordinary reflection only when you repeatedly use the method handle to make calls.

Of course, the real answer is: you step back, you learn how to correctly benchmark java code, and then you do a bit of measuring within your context, environment - your data, your code. To then draw your final conclusion. And I also agree with the comment given by spi - if performance is crucial to you, then reflection is (more or less) a no go.

Mahendra Kapadne · Answer 2 · 2018-01-19T01:22:05.420

1

If you are using Java 8 then

If you want use run reflection then you should go thought LambdaMetaFactory which gives approx equal performance as of direct method call [faster-alternatives-to-javas-reflection]
If you want to make code configurable and but configuration doesn’t change at run time. Then one should go with AnnotationProcessor processor to generate code. It makes perfect combination of configuration, performance, maintenance & ease of use.

[annotation processing] [annotation Processing with maven]

edited Jan 19 '18 at 01:22

answered Jan 18 '18 at 13:17

Mahendra Kapadne

426
1
3
10

Nice answer, too. Especially linking to that other answer is pretty helpful. You might want to also include a link for your second point, though. – GhostCat Jan 18 '18 at 20:00
The link @GhostCat told is a good idea. I would appreciate it. – Gilberto Jan 18 '18 at 21:17

Java Reflection: the fast way to retrieve value from property

2 Answers2