使用 pojo/java bean 的 getter 方法获取属性/字段名称？

Question

I have a below class and i need to get field name from getter method using java reflection. Is it possible to get field name or property name using getter method?

class A {

    private String name;
    private String salary;

    // getter and setter methods
}

My questions is: can i get field/property name by getter method? If I use getName(), can I get name property? I need name property but not its value. Is it possible through java reflection?

Answer 1

yes it's 100% possible..

public static String getFieldName(Method method)
{
    try
    {
        Class<?> clazz=method.getDeclaringClass();
        BeanInfo info = Introspector.getBeanInfo(clazz);  
        PropertyDescriptor[] props = info.getPropertyDescriptors();  
        for (PropertyDescriptor pd : props) 
        {  
            if(method.equals(pd.getWriteMethod()) || method.equals(pd.getReadMethod()))
            {
                System.out.println(pd.getDisplayName());
                return pd.getName();
            }
        }
    }
    catch (IntrospectionException e) 
    {
        e.printStackTrace();
    }
    catch (Exception e) 
    {
        e.printStackTrace();
    }


    return null;
}

Answer 2

The reflection-util library provides a way to determine the property (name) in a type-safe manner. For example by using the getter method:

String propertyName = PropertyUtils.getPropertyName(A.class, A::getSalary);

The value of propertyName would be "salary" in this case.

Disclaimer : I'm one of the authors of the reflection-util library.

Answer 3

It's not exactly good enough to just remove the "get" or "is" prefix and lower case the first letter. For example, the appropriate bean name for getID would be ID and not iD.

The easiest way to get the bean name is to lop off the get or is prefix and then pass the result into Introspector.decapitalize .

Here's a method I wrote to do this very thing:

private String getBeanName(String methodName)
{
    // Assume the method starts with either get or is.
    return Introspector.decapitalize(methodName.substring(methodName.startsWith("is") ? 2 : 3));
}

Answer 4

You cannot inspect what code does by using reflection.

You can assume that a getName() method read a field called name and does nothing else. However there is no requirement for it to so. eg the field name might be m_name or _name or nameField or not even be a field.

Answer 5

You can

Field[] declaredFields = A.class.getDeclaredFields();
        for(Field f:declaredFields){
            System.out.println(f.getName());
        }

Answer 6

If your bean's follow JavaBean conventions then you use reflection to get all the "get" and "is" methods and remove "get" or "is" prefixes from the retrieved method names and you have the field names.

Update

// Get the Class object associated with this class.
    MyClass myClass= new MyClass ();
    Class objClass= myClass.getClass();

    // Get the public methods associated with this class.
    Method[] methods = objClass.getMethods();
    for (Method method:methods)
    {
        String name=method.getName();
        if(name.startsWith("get") || name.startsWith("is"))
        {
           //...code to remove the prefixes
        }
    }

Answer 7

Using reflections API, POJO fields can be retrieved as below. Inherited class may find an issue here.

TestClass testObject= new TestClass().getClass();
Fields[] fields = testObject.getFields();
for (Field field:fields)
{
    String name=field.getName();
    System.out.println(name);
}

Or by using Reflections API, one can also retrieve all methods in a class and iterate through it to find the attribute names (standard POJO methods start with get/is/set) ... This approach worked for me for Inherited class structure.

TestClass testObject= new TestClass().getClass();
Method[] methods = testObject.getMethods();
for (Method method:methods)
{
    String name=method.getName();
    if(name.startsWith("get"))
    {
        System.out.println(name.substring(3));
    }else if(name.startsWith("is"))
    {
        System.out.println(name.substring(2));
    }
}

However a more interesting approach is below:

With the help of Jackson library, I was able to find all class properties of type String/integer/double, and respective values in a Map class. ( all without using reflections api! )

TestClass testObject = new TestClass();
com.fasterxml.jackson.databind.ObjectMapper m = new com.fasterxml.jackson.databind.ObjectMapper();

Map<String,Object> props = m.convertValue(testObject, Map.class);

for(Map.Entry<String, Object> entry : props.entrySet()){
    if(entry.getValue() instanceof String || entry.getValue() instanceof Integer || entry.getValue() instanceof Double){
        System.out.println(entry.getKey() + "-->" + entry.getValue());
    }
}

Answer 8

You should access through the method. At the moment the getter would return the member name , but that could change in the future . It could lazily instantiate this from a database or webservice, built it from a firstname/surname etc. The name field could quite likely not exist.

So always go through the method (even via reflection)

Answer 9

If you know the name of the method, you only need to remove "get" and convert to lower letter the following letter, so you don´t need reflection.

If the getter method (getName()) returns a property with different name than "name", you can´t obtain the property's name from the method´s name.

If you don´t know the name of the method, by reflection you can obtain all methods and you can obtain all name´s properties too.

Answer 10

You can use lombok's @FieldNameConstants annotation.

Annotate your class:

import lombok.experimental.FieldNameConstants;
import lombok.AccessLevel;

@FieldNameConstants
public class FieldNameConstantsExample {
  private final String name;
  private final int rank;
}

which produces following code on the background:

public class FieldNameConstantsExample {
  private final String name;
  private final int rank;
  
  public static final class Fields {
    public static final String name = "name";
    public static final String rank = "rank";
  }
}

So you can access property name in a following way:

FieldNameConstantsExample.Fields.name

which is string "name"

Answer 11

Try the following

class A{

       private String name;
       private String salary;

   //getter and setter methods

       public void setName(String name){
          this.name = name;
        }

       public void setSalary(String salary){
           this.salary = salary;

         }

        public String getName(){
          return name;
          }

        public String getSalary(){
          return salary;
          }

}

The get method is used to retrieve data dynamically from program method or from database. It will reflect only values not property of the value.