Java ReflectionUtils.doWithFields方法代码示例

import org.springframework.util.ReflectionUtils; //导入方法依赖的package包/类
private void injectServicesViaAnnotatedFields(final Object bean, final String beanName) {
	ReflectionUtils.doWithFields(bean.getClass(), new ReflectionUtils.FieldCallback() {
		public void doWith(Field field) {
			ServiceReference s = AnnotationUtils.getAnnotation(field, ServiceReference.class);
			if (s != null && !Modifier.isStatic(field.getModifiers()) && !Modifier.isFinal(field.getModifiers())) {
				try {
					if (logger.isDebugEnabled())
						logger.debug("Processing annotation [" + s + "] for [" + field + "] on bean [" + beanName + "]");
					if (!field.isAccessible()) {
						field.setAccessible(true);
					}
					ReflectionUtils.setField(field, bean, getServiceImporter(s, field.getType(), beanName).getObject());
				}
				catch (Exception e) {
					throw new IllegalArgumentException("Error processing service annotation", e);
				}
			}
		}
	});
}
 

import org.springframework.util.ReflectionUtils; //导入方法依赖的package包/类
/**
 * Create a new DirectFieldAccessor for the given target object.
 * @param target the target object to access
 */
public DirectFieldAccessor(final Object target) {
	Assert.notNull(target, "Target object must not be null");
	this.target = target;
	ReflectionUtils.doWithFields(this.target.getClass(), new ReflectionUtils.FieldCallback() {
		@Override
		public void doWith(Field field) {
			if (fieldMap.containsKey(field.getName())) {
				// ignore superclass declarations of fields already found in a subclass
			}
			else {
				fieldMap.put(field.getName(), field);
			}
		}
	});
	this.typeConverterDelegate = new TypeConverterDelegate(this, target);
	registerDefaultEditors();
	setExtractOldValueForEditor(true);
}
 

import org.springframework.util.ReflectionUtils; //导入方法依赖的package包/类
/**
 * Return JPA managed properties.
 * 
 * @param <T>
 *            Bean type.
 * @param beanType
 *            the bean type.
 * @return the headers built from given type.
 */
public <T> String[] getJpaHeaders(final Class<T> beanType) {
	// Build descriptor list respecting the declaration order
	final OrderedFieldCallback fieldCallBack = new OrderedFieldCallback();
	ReflectionUtils.doWithFields(beanType, fieldCallBack);
	final List<String> orderedDescriptors = fieldCallBack.descriptorsOrdered;

	// Now filter the properties
	final List<String> descriptorsFiltered = new ArrayList<>();
	final ManagedType<T> managedType = transactionManager.getEntityManagerFactory().getMetamodel().managedType(beanType);
	for (final String propertyDescriptor : orderedDescriptors) {
		for (final Attribute<?, ?> attribute : managedType.getAttributes()) {
			// Match only basic attributes
			if (attribute instanceof SingularAttribute<?, ?> && propertyDescriptor.equals(attribute.getName())) {
				descriptorsFiltered.add(attribute.getName());
				break;
			}
		}
	}

	// Initialize the CSV reader
	return descriptorsFiltered.toArray(new String[descriptorsFiltered.size()]);
}
 

import org.springframework.util.ReflectionUtils; //导入方法依赖的package包/类
@SuppressWarnings("unchecked")
public JdbcEntityInformation(Class<T> domainClass) {

    super(domainClass);
    className = domainClass.getName();

    ReflectionUtils.doWithFields(domainClass, new FieldCallback() {
        public void doWith(Field field) {
            if (field.isAnnotationPresent(ID_ANNOTATION)) {
                JdbcEntityInformation.this.idFields.add(field);
                return;
            }
        }
    });

    if (domainClass.isAnnotationPresent(ID_CLASS_ANNOTATION)) {
        idType = (Class<ID>) domainClass.getAnnotation(ID_CLASS_ANNOTATION).value();
        Assert.notNull(idType, "@IdClass must have a valid class");
        getIdStrategy = new GetIdCompound();
    } else {
        assertUniqueId(
                "There must be one and only one field annotated with @Id unless you annotate the class with @IdClass");
        idType = (Class<ID>) idFields.get(0).getType();
        idFields.get(0).setAccessible(true);
        getIdStrategy = new GetIdSingleKey();
    }
    entityType = calculateEntityType(domainClass, idFields);

}
 

import org.springframework.util.ReflectionUtils; //导入方法依赖的package包/类
@Override
public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
  // 扫描所有field，处理扩展的field标注
  ReflectionUtils.doWithFields(bean.getClass(), new ReflectionUtils.FieldCallback() {
    public void doWith(Field field) throws IllegalArgumentException, IllegalAccessException {
      processConsumerField(bean, field);
    }
  });

  return bean;
}
 

import org.springframework.util.ReflectionUtils; //导入方法依赖的package包/类
private <T> void mapVarsToFields(Object command, ExternalTask<?> externalTask, Class<T> taskClass, T task) {
    ReflectionUtils.doWithFields(taskClass, field -> {
        if (!externalTask.getFields().containsKey(field.getName())) {
            return;
        }

        Field commandField = externalTask.getFields().get(field.getName());
        JavaUtils.setFieldWithoutCheckedException(
                field
                , task
                , () -> JavaUtils.getFieldWithoutCheckedException(commandField, command)
        );
    });
}
 

import org.springframework.util.ReflectionUtils; //导入方法依赖的package包/类
@Test
public void testToCommand() {
    manager.init();

    LockedExternalTaskDto task = EnhancedRandom.random(LockedExternalTaskDto.class);
    JavaUtils.setFieldWithoutCheckedException(
            ReflectionUtils.findField(LockedExternalTaskDto.class, "topicName")
            , task
            , Command.TASK_NAME
    );
    String stringVar = "value";
    String otherVar = "other value";

    task.getVariables().put("stringVar", VariableValueDto.fromTypedValue(new PrimitiveTypeValueImpl.StringValueImpl(stringVar)));
    task.getVariables().put("otherVar", VariableValueDto.fromTypedValue(new PrimitiveTypeValueImpl.StringValueImpl(otherVar)));

    Object object = manager.toCommand(task);
    Assert.assertNotNull(object);
    Assert.assertTrue(object instanceof Command);

    Command command = (Command) object;
    Assert.assertEquals(stringVar, command.getStringVar());
    Assert.assertEquals(otherVar, command.getAnotherStringVar());

    ReflectionUtils.doWithFields(LockedExternalTaskDto.class, field -> {
        if (field.getName().equals("variables")) {
            return;
        }

        Field commandField = ReflectionUtils.findField(Command.class, field.getName());
        Assert.assertNotNull("No field with name: " + field.getName(), commandField);
        Assert.assertEquals(
                JavaUtils.getFieldWithoutCheckedException(field, task)
                , JavaUtils.getFieldWithoutCheckedException(commandField, command)
        );
    });
}
 

import org.springframework.util.ReflectionUtils; //导入方法依赖的package包/类
@Test
public void testToCompleteTask() {
    manager.init();

    Pair<String, CompleteExternalTaskDto> pair = manager.toCompleteTask(null, new Object());
    Assert.assertNull(pair);

    pair = manager.toCompleteTask(Command.TASK_NAME, null);
    Assert.assertNull(pair);

    Command command = EnhancedRandom.random(Command.class);
    pair = manager.toCompleteTask(Command.TASK_NAME, command);

    Assert.assertNotNull(pair);
    Assert.assertNotNull(pair.getKey());
    Assert.assertEquals(command.getId(), pair.getKey());

    Assert.assertNotNull(pair.getValue());
    Assert.assertEquals(command.getWorkerId(), pair.getValue().getWorkerId());

    Assert.assertNotNull(pair.getValue().getVariables());
    Assert.assertFalse(pair.getValue().getVariables().isEmpty());

    final Pair<String, CompleteExternalTaskDto> finalPair = pair;
    ReflectionUtils.doWithFields(Command.class, field -> {
        CamundaVar camundaVar = field.getAnnotation(CamundaVar.class);
        if (camundaVar == null) {
            return;
        }

        Assert.assertTrue(finalPair.getValue().getVariables().containsKey(ExternalTaskManager.getVarName(field, camundaVar)));
    });
}
 

import org.springframework.util.ReflectionUtils; //导入方法依赖的package包/类
@Override
public void fail(final Object task) {
    List<String> errors = new LinkedList<>();
    ReflectionUtils.doWithFields(task.getClass(), field -> {
        ErrorMessage errorMessage = field.getAnnotation(ErrorMessage.class);
        if (errorMessage != null) {
            errors.add((String) JavaUtils.getFieldWithoutCheckedException(field, task));
        }
    });

    fail(task, Strings.emptyToNull(errors.stream().collect(Collectors.joining("; "))));
}
 

import org.springframework.util.ReflectionUtils; //导入方法依赖的package包/类
public <T> List<FieldDescriptor> parseFields(Class<T> clazz) {
    int[] index = new int[]{1};
    List<FieldDescriptor> descriptors = new ArrayList<>();
    ReflectionUtils.doWithFields(clazz, field -> {
        ReflectionUtils.makeAccessible(field);
        Class<?> type = field.getType();
        ValueTransformer transformer = identifyTransformer(type);
        descriptors.add(new FieldDescriptor(index[0]++, field.getName(), transformer));
    }, field -> {
        int modifiers = field.getModifiers();
        return !Modifier.isTransient(modifiers) && !Modifier.isStatic(modifiers);
    });
    return addDefaultDescriptors(descriptors);
}
 

import org.springframework.util.ReflectionUtils; //导入方法依赖的package包/类
private boolean isHelpRequested(Object command) {
    AtomicBoolean result = new AtomicBoolean(false);
    ReflectionUtils.doWithFields(AopUtils.getTargetClass(command),
            f -> {
                f.setAccessible(true);
                if (f.getBoolean(command)) {
                    result.set(true);
                }
            },
            f -> f.isAnnotationPresent(Option.class) && f.getAnnotation(Option.class).help());
    return result.get();
}
 

import org.springframework.util.ReflectionUtils; //导入方法依赖的package包/类
private void checkFields(Object bean) {
  ReflectionUtils.doWithFields(bean.getClass(), new ExecutorFieldCallback(bean, omegaContext));
}