Java MappingException类代码示例

import org.springframework.data.mapping.model.MappingException; //导入依赖的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.MappingException; //导入依赖的package包/类
@Override
public void doWithPersistentProperty(SolrPersistentProperty property) {

	if (property.isDynamicProperty()) {

		if (!property.isMap()) {
			throw new MappingException(String.format(DYNAMIC_PROPERTY_NOT_A_MAP, property.getName(),
					property.getFieldName()));
		}

		if (!property.containsWildcard()) {
			throw new MappingException(String.format(DYNAMIC_PROPERTY_NOT_CONTAINING_WILDCARD, property.getName(),
					property.getFieldName()));
		}
	}
}
 

import org.springframework.data.mapping.model.MappingException; //导入依赖的package包/类
public SimpleCratePersistentProperty(Field field, PropertyDescriptor propertyDescriptor, 
									 PersistentEntity<?, CratePersistentProperty> owner, SimpleTypeHolder simpleTypeHolder) {
	super(field, propertyDescriptor, owner, simpleTypeHolder);
	
	this.fieldNamingStrategy = INSTANCE;

	String fieldName = getFieldName();
	
	if(RESERVED_ID_FIELD_NAME.equals(fieldName)) {				
		throw new MappingException(format(RESERVED_ID, fieldName, owner.getType()));
	}
	
	if(RESERVED_VESRION_FIELD_NAME.equals(fieldName)) {				
		throw new MappingException(format(RESERVED_VERSION, fieldName, owner.getType()));
	}
	
	if(startsWithIgnoreCase(fieldName, "_")) {
		throw new MappingException(format(STARTS_WITH_UNDERSCORE, fieldName, owner.getType()));
	}
}
 

import org.springframework.data.mapping.model.MappingException; //导入依赖的package包/类
@Override
public <T> T findById(Object id, Class<T> entityClass, String tableName) {
	
	notNull(id);
	
	if(!isIdPropertyDefined(entityClass)) {
		throw new MappingException(format("Entity '%s' has no id property defined", entityClass.getName()));
	}
	
	List<T> dbEntity = execute(new SelectAction(entityClass, tableName, id),
   						 	   new ReadDbHandler<T>(entityClass));
	if(dbEntity.isEmpty()) {
		logger.info("No row found with id '{}'", id);
		return null;
	}else {
		return dbEntity.iterator().next();
	}
}
 

import org.springframework.data.mapping.model.MappingException; //导入依赖的package包/类
@Test(expected=MappingException.class)
public void shouldNotWriteForMapWithComplexKeys() {
	
	String[][] nested = new String[1][1];
	nested[0] = new String[]{"STRING"};
	
	NestedArrays compleKey = new NestedArrays();
	compleKey.nested = nested;
	
	Map<NestedArrays, String> map = new HashMap<MappingCrateConverterTest.NestedArrays, String>();
	map.put(compleKey, "ComplexKey");
	
	MapWithComplexKey entity = new MapWithComplexKey();
	entity.map = map;
	
	converter.write(entity, new CrateDocument());
}
 

import org.springframework.data.mapping.model.MappingException; //导入依赖的package包/类
/**
 * Returns the given property if it is a better candidate for the id
 * property than the current id property.
 * 
 * @param property
 *            the new id property candidate, will never be {@literal null}.
 * @return the given id property or {@literal null} if the given property is
 *         not an id property.
 */
protected DynamoDBPersistentProperty returnPropertyIfBetterIdPropertyCandidateOrNull(DynamoDBPersistentProperty property) {

	if (!property.isIdProperty()) {
		return null;
	}

	if (getIdProperty() != null) {

		if (getIdProperty().isCompositeIdProperty() && property.isHashKeyProperty()) {
			// Do nothing - favour id annotated properties over hashkey
			return null;
		} else if (getIdProperty().isHashKeyProperty() && property.isCompositeIdProperty()) {
			return property;
		} else {
			throw new MappingException(String.format("Attempt to add id property %s but already have property %s registered "
					+ "as id. Check your mapping configuration!", property.getField(), getIdProperty().getField()));
		}
	}

	return property;
}
 

import org.springframework.data.mapping.model.MappingException; //导入依赖的package包/类
public static Field getIdField(Class<?> clazz) {
	Field idField = null;

	for(Field f : ReflectionUtils.getDeclaredFieldsInHierarchy(clazz)) {
		// named id or annotated with Id
		if(f.getName().equals(FIELD_NAME_DEFAULT_ID) || f.getAnnotation(Id.class) != null) {
			if(idField != null) {
				throw new MappingException("Multiple id fields detected for class " + clazz.getName());
			}
			idField = f;
		}

	}

	return idField;
}
 

import org.springframework.data.mapping.model.MappingException; //导入依赖的package包/类
@SuppressWarnings("unchecked")
private <T, ID extends Serializable> SpannerEntityInformation<T, ID> getEntityInformation(Class<T> domainClass,
                                                                                          RepositoryInformation information) {
  SpannerPersistentEntity<?> entity = mappingContext.getPersistentEntity(domainClass);

  if (entity == null) {
    throw new MappingException(
        String.format("Could not lookup mapping metadata for domain class %s!", domainClass.getName()));
  }

  BasicSpannerPersistentEntity<T> persistentEntity = (BasicSpannerPersistentEntity<T>) mappingContext.getPersistentEntity(domainClass);
  return new MappingSpannerEntityInformation<T, ID>(persistentEntity);
}
 

import org.springframework.data.mapping.model.MappingException; //导入依赖的package包/类
public MappingTarantoolEntityInformation(TarantoolPersistentEntity<T> entity) {
    super(entity);

    if(!entity.hasIdProperty()) {

        throw new MappingException(
                String.format("Entity %s requires to have an explicit id field. Did you forget to provide one using @Id?",
                        entity.getName())
        );
    }
}
 

import org.springframework.data.mapping.model.MappingException; //导入依赖的package包/类
/**
 * @see DATAREDIS-425
 */
@Test(expected = MappingException.class)
@SuppressWarnings("unchecked")
public void throwsMappingExceptionWhenNoIdPropertyPresent() {

    when(entity.hasIdProperty()).thenReturn(false);
    when(entity.getType()).thenReturn((Class<T>) ConversionTestEntities.Person.class);
    new MappingTarantoolEntityInformation<>(entity);
}
 

import org.springframework.data.mapping.model.MappingException; //导入依赖的package包/类
public String get(int typeCode) throws MappingException {
    final String result = defaults.get(typeCode);
    if (result == null) {
        throw new MappingException("No Dialect mapping for JDBC type: " + typeCode);
    }
    return result;
}
 

import org.springframework.data.mapping.model.MappingException; //导入依赖的package包/类
@Override
public void onBeforeConvert(final Object source) {
	ReflectionUtils.doWithFields(source.getClass(),
			new ReflectionUtils.FieldCallback() {

				public void doWith(Field field)
						throws IllegalArgumentException,
						IllegalAccessException {
					ReflectionUtils.makeAccessible(field);

					if (field.isAnnotationPresent(DBRef.class)
							&& field.isAnnotationPresent(CascadeSave.class)) {
						final Object fieldValue = field.get(source);

						DbRefFieldCallback callback = new DbRefFieldCallback();

						ReflectionUtils.doWithFields(fieldValue.getClass(),
								callback);

						if (!callback.isIdFound()) {
							throw new MappingException(
									"Cannot perform cascade save on child object without id set");
						}

						if (Collection.class.isAssignableFrom(field
								.getType())) {
							Collection<?> models = (Collection<?>) fieldValue;
							for (Object model : models) {
								mongoOperations.save(model);
							}
						} else {
							mongoOperations.save(fieldValue);
						}
					}
				}
			});
}
 

import org.springframework.data.mapping.model.MappingException; //导入依赖的package包/类
@Override
public <T, ID extends Serializable> MyBatisEntityInformation<T, ID> getEntityInformation(final Class<T> domainClass) {
    final Object mapper = mapperProvider.getMapper(domainClass);
    if (mapper == null) {
        throw new MappingException(
                String.format("Could not lookup mapping metadata for domain class %s!", domainClass.getName()));
    }
    return new MappingMyBatisEntityInformation<>(domainClass);
}
 

import org.springframework.data.mapping.model.MappingException; //导入依赖的package包/类
@Test(expectedExceptions = DawgIllegalArgumentException.class)
public void testDeleteSingleWithException() {
    HouseRestController controller = new HouseRestController();
    ReflectionTestUtils.setField(controller, "serverUtils", utils);

    HouseService mockService = EasyMock.createMock(HouseService.class);
    mockService.deleteStbById((String) EasyMock.anyObject());
    EasyMock.expectLastCall().andThrow(new MappingException(""));
    EasyMock.replay(mockService);
    ReflectionTestUtils.setField(controller, "service", mockService);

    String id = "id";
    controller.deleteSingle(id);
}
 

import org.springframework.data.mapping.model.MappingException; //导入依赖的package包/类
private void assertUniqueness(SolrPersistentProperty property) {

			if (property.isScoreProperty()) {

				if (scoreProperty != null) {
					throw new MappingException(String.format(AMBIGUOUS_FIELD_MAPPING, property.getFieldName(),
							scoreProperty.getFieldName()));
				}

				scoreProperty = property;
			}
		}