Get class field/property : Field « Reflection « Java

1. Java
2. Reflection
3. Field

Get class field/property

      
/**
 * This software is provided as IS by Antilia-Soft SL.
 * Copyright 2006-2007.
 */
//package com.antilia.common.util;

import java.lang.reflect.Field;
import java.lang.reflect.ParameterizedType;

public class ReflectionUtils {
  
  public static final String NESTED_PROPERTY_SEPARATOR = ".";
  
  public static Field getPropertyField(Class<?> beanClass,String property) throws NoSuchFieldException {  
    if (beanClass == null)
      throw new IllegalArgumentException("beanClass cannot be null");
    
    Field field = null;
    try {
      field = beanClass.getDeclaredField(property);
    } catch (NoSuchFieldException e) {
      if (beanClass.getSuperclass() == null)
        throw e;
      // look for the field in the superClass
      field = getPropertyField(beanClass.getSuperclass(),property);
    }
    return field;
  }
  
  public static Field getField(Class<?> beanClass,String propertyPath) throws NoSuchFieldException {    
     if (beanClass == null)
      throw new IllegalArgumentException("beanClass cannot be null");
    
    if (propertyPath.indexOf("[") != -1)
      propertyPath = propertyPath.substring(0,propertyPath.indexOf("["));
    
    // if the property path is simple then look for it directly on the class.
    if (propertyPath.indexOf(NESTED_PROPERTY_SEPARATOR) == -1) {
      // look if the field is declared in this class.
      return getPropertyField(beanClass,propertyPath);
    } else {
      // if the property is a compound one then split it and look for the first field.
      // and recursively locate fields of fields.
      String propertyName = propertyPath.substring(0,propertyPath.indexOf(NESTED_PROPERTY_SEPARATOR));
      Field field = getField(beanClass,propertyName);

      // try to locate sub-properties
      return getField(getTargetType(field),propertyPath.substring(propertyPath.indexOf(NESTED_PROPERTY_SEPARATOR)+1));
    }
  }
  
  public static Class<?> getTargetType(Field field) {
    //  Generic type, case when we have a Collection of ?
    if (field.getGenericType() instanceof ParameterizedType) {
      ParameterizedType type = (ParameterizedType)field.getGenericType();
      if (type.getActualTypeArguments().length == 1 && type.getActualTypeArguments()[0] instanceof Class)
      return (Class<?>)type.getActualTypeArguments()[0];
    }
    
    return field.getType();
  }
  
  public static Class<?> getPropertyClass(Class<?> beanClass,String propertyPath) {
    try {
      Field field = getField(beanClass, propertyPath);
      return(getTargetType(field));
    } catch (NoSuchFieldException e) {
      throw new IllegalArgumentException(propertyPath+" is not a property of "+beanClass.getName());
    }
  }
  
  public static boolean isFieldDeclared(Class<?> beanClass,String propertyPath) {
    try {
      return getField(beanClass, propertyPath) != null;
    } catch(NoSuchFieldException e) {
      return false;
    }
  }
  
  public static Object getPropertyValue(Object bean,String propertyPath) throws NoSuchFieldException {
    if (bean == null)
        throw new IllegalArgumentException("bean cannot be null");
      Field field = ReflectionUtils.getField(bean.getClass(), propertyPath);
      field.setAccessible(true);
      try {
        return(field.get(bean));
      } catch (IllegalAccessException e) {
        return(null);
    }
  }
}

   
    
    
    
    
    
  

Related examples in the same category

1.	Field Reflection
2.	How to set public field objects
3.	Class Reflection: field information
4.	Object Reflection: get field value
5.	Object Reflection: set value
6.	Get field of a class object and set or get its value
7.	All Fields Snippet
8.	Field modifiers: isSynthetic, isEnumConstant
9.	Field with annotations
10.	Set private field value
11.	Get fields of a class object
12.	Get all object accessible public fields
13.	Getting the Field Objects of a Class Object: By obtaining a list of all declared fields.
14.	Getting the Field Objects of a Class Object: By obtaining a list of all public fields, both declared and inherited.
15.	Getting the Field Objects of a Class Object: By obtaining a particular Field object.
16.	Get all declared fields from a class
17.	Retrieving a Predefined Color by Name
18.	Get a variable value from the variable name
19.	Fetches all fields of all access types from the supplied class and super classes
20.	Checks whether the specified class contains a field matching the specified name.
21.	whether given field is a "public static final" constant
22.	Process bean properties getter by applying the JavaBean naming conventions.
23.	Fetches the property descriptor for the named property of the supplied class
24.	Find Field
25.	Return a list of all fields (whatever access status, and on whatever superclass they were defined) that can be found on this class.
26.	Get all fields of a class.
27.	Find field 2
28.	Accessible Field Iterator
29.	Adds all Fields (from Class.getFields) to the list
30.	Retrieve a value from a property
31.	Set the value of the field of the object to the given value.
32.	Fast Property accessor for a single class.