import org.springframework.data.mapping.model.ConvertingPropertyAccessor; //导入依赖的package包/类
public void writeInternal(final Object entity,
                          final Document targetDocument,
                          final DocumentDbPersistentEntity<?> entityInformation) {
    if (entity == null) {
        return;
    }

    if (entityInformation == null) {
        throw new MappingException("no mapping metadata for entity type: " + entity.getClass().getName());
    }

    final ConvertingPropertyAccessor accessor = getPropertyAccessor(entity);
    final DocumentDbPersistentProperty idProperty = entityInformation.getIdProperty();

    if (idProperty != null) {
        targetDocument.setId((String) accessor.getProperty(idProperty));
    }

    for (final Field field : entity.getClass().getDeclaredFields()) {
        if (null != idProperty && field.getName().equals(idProperty.getName())) {
            continue;
        }
        targetDocument.set(field.getName(),
                accessor.getProperty(entityInformation.getPersistentProperty(field.getName())));
    }
}
 

import org.springframework.data.mapping.model.ConvertingPropertyAccessor; //导入依赖的package包/类
private <S extends Object> S read(final SolrPersistentEntity<S> entity, final Map<String, ?> source, Object parent) {
	ParameterValueProvider<SolrPersistentProperty> parameterValueProvider = getParameterValueProvider(entity, source,
			parent);

	EntityInstantiator instantiator = instantiators.getInstantiatorFor(entity);
	final S instance = instantiator.createInstance(entity, parameterValueProvider);
	final PersistentPropertyAccessor accessor = new ConvertingPropertyAccessor(entity.getPropertyAccessor(instance),
			getConversionService());

	entity.doWithProperties(new PropertyHandler<SolrPersistentProperty>() {

		@Override
		public void doWithPersistentProperty(SolrPersistentProperty persistentProperty) {
			if (entity.isConstructorArgument(persistentProperty)) {
				return;
			}

			Object o = getValue(persistentProperty, source, instance);
			if (o != null) {
				accessor.setProperty(persistentProperty, o);
			}
		}
	});

	return instance;
}
 

import org.springframework.data.mapping.model.ConvertingPropertyAccessor; //导入依赖的package包/类
private <S> S read(VaultPersistentEntity<S> entity, SecretDocument source) {

		ParameterValueProvider<VaultPersistentProperty> provider = getParameterProvider(
				entity, source);
		EntityInstantiator instantiator = instantiators.getInstantiatorFor(entity);
		S instance = instantiator.createInstance(entity, provider);

		PersistentPropertyAccessor accessor = new ConvertingPropertyAccessor(
				entity.getPropertyAccessor(instance), conversionService);

		VaultPersistentProperty idProperty = entity.getIdProperty();
		SecretDocumentAccessor documentAccessor = new SecretDocumentAccessor(source);

		// make sure id property is set before all other properties
		Object idValue;

		if (idProperty != null && documentAccessor.hasValue(idProperty)) {

			idValue = readIdValue(idProperty, documentAccessor);
			accessor.setProperty(idProperty, idValue);
		}

		VaultPropertyValueProvider valueProvider = new VaultPropertyValueProvider(
				documentAccessor);

		readProperties(entity, accessor, idProperty, documentAccessor, valueProvider);

		return instance;
	}
 

import org.springframework.data.mapping.model.ConvertingPropertyAccessor; //导入依赖的package包/类
private ConvertingPropertyAccessor getPropertyAccessor(Object entity) {
    final DocumentDbPersistentEntity<?> entityInformation = mappingContext.getPersistentEntity(entity.getClass());
    final PersistentPropertyAccessor accessor = entityInformation.getPropertyAccessor(entity);
    return new ConvertingPropertyAccessor(accessor, conversionService);
}
 

import org.springframework.data.mapping.model.ConvertingPropertyAccessor; //导入依赖的package包/类
@SuppressWarnings("rawtypes")
protected void write(Object source, final Map target, SolrPersistentEntity<?> entity) {

	final PersistentPropertyAccessor accessor = new ConvertingPropertyAccessor(entity.getPropertyAccessor(source),
			getConversionService());

	entity.doWithProperties(new PropertyHandler<SolrPersistentProperty>() {

		@SuppressWarnings("unchecked")
		@Override
		public void doWithPersistentProperty(SolrPersistentProperty persistentProperty) {

			Object value = accessor.getProperty(persistentProperty);
			if (value == null || persistentProperty.isReadonly()) {
				return;
			}

			if (persistentProperty.containsWildcard() && !persistentProperty.isMap()) {
				throw new IllegalArgumentException("Field '" + persistentProperty.getFieldName()
						+ "' must not contain wildcards. Consider excluding Field from beeing indexed.");
			}

			Collection<SolrInputField> fields;
			if (persistentProperty.isMap() && persistentProperty.containsWildcard()) {
				fields = writeWildcardMapPropertyToTarget(target, persistentProperty, (Map<?, ?>) value);
			} else {
				fields = writeRegularPropertyToTarget(target, persistentProperty, value);
			}

			if (persistentProperty.isBoosted()) {
				for (SolrInputField field : fields) {
					field.setBoost(persistentProperty.getBoost());
				}
			}
		}
	});

	if (entity.isBoosted() && target instanceof SolrInputDocument) {
		((SolrInputDocument) target).setDocumentBoost(entity.getBoost());
	}

}