访问类的字段而不使用反射？

Question

Is there a way to access a specific Field on a class without using reflection?

Consider this class:

class MyType {
    public int theNumber;
}

Where I would like to get access to theNumber 's java.lang.reflect.Field .

This works for sure:

Field f = MyType.class.getDeclaredField("theNumber");

However, I would like compile check on the field name, so ideally something like this instead (but of course my example doesn't compile):

Field f = MyType.class::theNumber;

Is this possible or am I way of wrt the compiler abilities?

Answer 1

Interesting question. No, there's no way to do that without using java.lang.reflect , but given the built-in class pseudo-property on classes, I can see why you'd ask.

Answer 2

You can extend the java compiler with annotation processors. This processors are a way to scan your source code during compile. They were introduced with Annotations but they are able to scan the whole source code not only annotations.

With the scanned Source-Code you can generate accessor classes to any class you compile. This way you can eliminate reflection.

If you only want to get errors while you write code in your IDE you can make use of javax.annotation.processing.ProcessingEnvironment.getMessager().printMessage() (see also javax.tools.DiagnosticListener) to generate Errors the IDE can show.

So the basic Idea is:

1. write an annotation processor which scans the source code you want to reflect
2. extract the field you want to have access to via javax.lang.model.element.ElementVisitor

In case you want to generate type save access to Field:

3.1. generate source that will access this source code

In case you want to ensure, that a reflective call to a field is valid:

3.2. raise an Error via ProcessingEnvironment.getMessager().printMessage()

Of course you have to write the code for checking reflective calls or generating the accessors.

And the information you want to get must be extractable from the sourcecode since all the magic happens during the compile and not at runtime

Answer 3

JPA2 Metamodel (used in typesafe queries "by criteria") has similar concept.

MyType_.theNumber

Is implemented by extra "pre-processors". You can investigate in this area.

Answer 4

No, It's not... but you could achieve it with an interface and a closure

public interface Getter<T, V> {
    V get(T object);
}

public static Getter<MyType, Integer> theNumberGetter = (MyType myType) -> { myType.theNumber };