The property maybe only has get method if its type is collection or map by xml binding specificatio
Otherwise, it will be ignored if not registered by calling this method.

@param cls
438570
public static void registerXMLBindingClassForPropGetSetMethod(final Class<?> cls) {
        if (registeredXMLBindingClassList.containsKey(cls)) {
            return;
        }

        synchronized (entityDeclaredPropGetMethodPool) {
            registeredXMLBindingClassList.put(cls, false);

            if (entityDeclaredPropGetMethodPool.containsKey(cls)) {
                entityDeclaredPropGetMethodPool.remove(cls);
                entityDeclaredPropSetMethodPool.remove(cls);

                entityPropFieldPool.remove(cls);
                loadPropGetSetMethodList(cls);
            }
        }
    }
547724
@SuppressWarnings("rawtypes")
	public static boolean isBesicType(Class cls){
		if (cls == null) return false;
		String type = cls.getName();
		return isBasicType(type);
		
	}
205422
public static boolean isOverriddenMethod(Method methodToFind, Class<?> cls) {
        Set<Class<?>> superClasses = new HashSet<>();
        for (Class<?> class1 : cls.getInterfaces()) {
            superClasses.add(class1);
        }

        if (cls.getSuperclass() != null) {
            superClasses.add(cls.getSuperclass());
        }

        for (Class<?> superClass : superClasses) {
            if (superClass != null && !(superClass.equals(Object.class))) {
                for (Method method : superClass.getMethods()) {
                    if (method.getName().equals(methodToFind.getName()) && method.getReturnType().isAssignableFrom(methodToFind.getReturnType())
                        && Arrays.equals(method.getParameterTypes(), methodToFind.getParameterTypes())
                        && !Arrays.equals(method.getGenericParameterTypes(), methodToFind.getGenericParameterTypes())) {
                        return true;
                    }
                }
                if (isOverriddenMethod(methodToFind, superClass)) {
                    return true;
                }
            }

        }
        return false;
    }
710048
public static final <T extends Recyclable> T get(Class<T> cls)
    {
        return get(cls, null);
    }
510002
@SuppressWarnings("unchecked")
	static <E, M extends BinderMapper<E>> M getMapper(Class<E> cls) {
		M mapper = (M) OBJECT_MAPPERS.get(cls);
		if (mapper == null) {
			// The only way the mapper wouldn't already be loaded into
			// OBJECT_MAPPERS is if it was compiled separately, but let's handle
			// it anyway
			String beanClassName = cls.getName();
			String mapperClassName = cls.getName() + KriptonBinder.MAPPER_CLASS_SUFFIX;
			try {
				Class<E> mapperClass = (Class<E>) Class.forName(mapperClassName);
				mapper = (M) mapperClass.newInstance();
				// mapper.
				OBJECT_MAPPERS.put(cls, mapper);
			} catch (ClassNotFoundException e) {
				e.printStackTrace();
				throw new KriptonRuntimeException(String.format("Class '%s' does not exist. Does '%s' have @BindType annotation?", mapperClassName, beanClassName));
			} catch (InstantiationException e) {
				e.printStackTrace();
			} catch (IllegalAccessException e) {
				e.printStackTrace();
			}
		}
		return mapper;
	}
297561
public <T> T getProperty(final String name, final Class<T> clazz) {
        if (containsProperty(name)) {
            val item = this.properties.get(name);
            if (item == null) {
                return null;
            }
            if (!clazz.isAssignableFrom(item.getClass())) {
                throw new ClassCastException("Object [" + item + " is of type " + item.getClass() + " when we were expecting " + clazz);
            }
            return (T) item;
        }
        return null;
    }
1219063
public static boolean hasProperty(ClassNode classNode, String propertyName) {
        if (classNode == null || !StringUtils.hasText(propertyName)) {
            return false;
        }

        final MethodNode method = classNode.getMethod(GrailsNameUtils.getGetterName(propertyName), Parameter.EMPTY_ARRAY);
        if (method != null) return true;

        // check read-only field with setter
        if( classNode.getField(propertyName) != null && !classNode.getMethods(GrailsNameUtils.getSetterName(propertyName)).isEmpty()) {
            return true;
        }

        for (PropertyNode pn : classNode.getProperties()) {
            if (pn.getName().equals(propertyName) && !pn.isPrivate()) {
                return true;
            }
        }

        return false;
    }
866063
private static Map<String, Getter> getGettersAsMap(Class type) {
		Map<String, Getter> typeGetters = GETTER_CACHE.get(type);
		if (typeGetters == null) {
			typeGetters = new HashMap<>();
			for (Method method : type.getMethods()) {
				if (isGetterMethod(method)) {
					String propertyName = getPropertyName(method);
					Class propertyType = method.getReturnType();
					//noinspection unchecked
					typeGetters.put(propertyName, new Getter(propertyName, propertyType, getSubType(type, propertyName), method));
				}
			}
			GETTER_CACHE.put(type, typeGetters);
		}
		return typeGetters;
	}
1114365
public static Class<?> getGetterPropertyType( Clazz<?> clazz, String name )
	{
		return propertyValues.getGetterPropertyType(clazz, name);
	}
489844
public <T extends UserProperty> T getProperty(Class<T> clazz) {
        for (UserProperty p : properties) {
            if (clazz.isInstance(p))
                return clazz.cast(p);
        }
        return null;
    }
1168264
Class<?> getGetterPropertyType( Clazz<?> clazz, String name )
	{
		String getterName = "get" + capitalizeFirstLetter( name );
		Method getter = clazz.getMethod( getterName );
		if( getter != null )
			return getter.getReturnType();

		// try direct field access
		Field field = clazz.getAllField( name );
		if( field != null )
			return field.getType();

		return null;
	}
1012469
@Override
	public Object getProperty(String property) {
		if (property.equals(PROPERTY_XMLDECL_VERSION)) {
			return version;
		} else if (property.equals(PROPERTY_XMLDECL_STANDALONE)) {
			return standalone;
		} else if (property.equals(PROPERTY_LOCATION)) {
			return location != null ? location : reader.toString();
		} else {
			return null;
		}
	}
1293354
@SuppressWarnings("unchecked")
	protected static <E> Class<? extends E> extractClassFrom(Collection<? extends E> collection) {
		Class<? extends E> clazz = null;
		for (final E elt : collection) {
			clazz = (Class<? extends E>) ReflectionUtil.getCommonType(clazz, elt.getClass());
		}
		return clazz == null ? (Class<E>) Object.class : clazz;
	}
1096772
public <A, E extends SimpleExpression<A>> CollectionPath<A, E> getCollection(String property, Class<A> type, Class<? super E> queryType) {
        validate(property, Collection.class);
        return super.createCollection(property, type, queryType, PathInits.DIRECT);
    }
452392
@Override
  public <T> T get(String name, Class<T> type) {
    return this.properties.get(name, type);
  }
842211
private static Method getMethod(final Class cls, final String methodName, boolean declared) {
		$.checkNotEmpty(methodName);
		List<Method> methods = getMethodsList(cls, declared);
		for (int i = 0; i < methods.size(); i++) {
			if (methodName.equals(methods.get(i).getName())) {
				return methods.get(i);
			}
		}
		return null;
	}
609045
public static MethodInstance getGetterEL(Class clazz, String prop) {
	prop = "get" + StringUtil.ucFirst(prop);
	MethodInstance mi = getMethodInstanceEL(null, clazz, KeyImpl.getInstance(prop), ArrayUtil.OBJECT_EMPTY);
	if (mi == null) return null;
	if (mi.getMethod().getReturnType() == void.class) return null;
	return mi;
    }