public boolean test(ReflectField object) { return object.getName().equals(name); } });
private String getTranditionalPropertyName(ReflectField field) { String name = null; if(field.hasSetter()){ name = field.getSetter().getName().substring(SETTER_PREFIX.length()); }else if(field.hasGetter()){ name = field.getGetter().getName(); if(name.startsWith(IS_PREFIX)){ name = name.substring(IS_PREFIX.length()); }else{ name = name.substring(GETTER_PREFIX.length()); } }else{ name = field.getName().startsWith("_") ? field.getName().substring(1) : field.getName(); } return name.length() == 1 ? name.toLowerCase() : Character.toLowerCase(name.charAt(0)) + name.substring(1); }
public static ElConstantField of(ReflectField field) { if(!field.isFinal()){ return null; } Class<?> cls = field.getDeclaringClass(); String name = field.getName(); synchronized (lock) { Map<String, ElConstantField> cache = constants.get(cls); if(null == cache){ cache = new WeakHashMap<String, ElConstantField>(); constants.put(cls, cache); } ElConstantField f = cache.get(name); if(null == f){ f = new ElConstantField(field); cache.put(name, f); } return f; } }
public Object getValue(Object instance,boolean useGetter) { try { if(useGetter && null != getter){ if(getterAccessorIndex != -1){ return accessor.invokeMethod(instance, getterAccessorIndex, Arrays2.EMPTY_OBJECT_ARRAY); }else{ return getter.invoke(instance, Arrays2.EMPTY_OBJECT_ARRAY); } }else{ if(fieldAccessorIndex != -1){ return accessor.getFieldValue(instance, fieldAccessorIndex); }else { return field.get(instance); } } } catch (Throwable e) { if(e instanceof InvocationTargetException){ e = e.getCause(); } if(e instanceof RuntimeException){ throw (RuntimeException)e; } throw new ReflectException(Strings.format("Error getting value of field '{0}'",getName()),e); } }
protected void validateField(BeanDefinition d, Object bean, ReflectField field) { if((field.isAnnotationPresent(NotNull.class) || field.isAnnotationPresent(M.class)) && null == field.getValue(bean)){ throw new BeanException("Field '" + field.getName() + "'(" + field.getType() + ") must not null in bean " + (null == d ? bean : d)); } if((field.isAnnotationPresent(NotEmpty.class) || field.isAnnotationPresent(R.class) ) && Objects2.isEmpty(field.getValue(bean))){ throw new BeanException("Field '" + field.getName() + "' must not empty in bean " + (null == d ? bean : d)); } }
@Override public void injectStatic(Class<?> cls) throws BeanException { BeanDefinitionBase bd = createBeanDefinition(cls); ReflectClass rc = ReflectClass.of(cls); BeanFactory factory = null != beanFactory ? beanFactory : this; for (ReflectField rf : rc.getFields()) { if (rf.isStatic() && rf.isAnnotationPresent(Inject.class)) { try { //skip when bean value already set. if (null != rf.getValue(null)) { continue; } Object injectedBean = resolveInjectValue(factory, bd, rf.getName(), rf.getType(), rf.getGenericType(), rf.getAnnotations()); if (null != injectedBean) { rf.setValue(null, injectedBean); } } catch (Exception e) { log.error("Error injecting static field '{}' in class '{}' : {}", rf.getName(), cls.getName(), e.getMessage()); throw e; } } } }
public void setValue(Object instance, Object value, boolean useSetter) { try { if(field.isSynthetic() || isFinal()){ field.set(instance, safeValue(value)); }else{ if(useSetter && null != setter){ if(setterAccessorIndex != -1){ accessor.invokeMethod(instance, setterAccessorIndex, safeValue(value)); }else{ setter.invoke(instance, safeValue(value)); } }else{ if(fieldAccessorIndex != -1){ accessor.setFieldValue(instance, fieldAccessorIndex, safeValue(value)); }else{ field.set(instance, safeValue(value)); } } } } catch (Exception e) { throw new ReflectException(Strings.format("Error setting value '{0}' to field '{1}'",value,getName()),e); } }
rf.setValue(bean, injectedValue); } catch (Exception e) { log.error("Error injecting field '{}' in bean '{}' : {}", rf.getName(), bd, e.getMessage()); throw e;