Java SimpleTypeHolder类代码示例

import org.springframework.data.mapping.model.SimpleTypeHolder; //导入依赖的package包/类
public TarantoolPersistentPropertyImpl(Field field, PropertyDescriptor propertyDescriptor, TarantoolPersistentEntity<?> owner, SimpleTypeHolder simpleTypeHolder) {
    super(field, propertyDescriptor, owner, simpleTypeHolder);

    this.tupleIndex = Optional.ofNullable(findPropertyOrOwnerAnnotation(Tuple.class))
            .map(Tuple::index)
            .orElse(null);

    if(tupleIndex != null) {
        Assert.isTrue(tupleIndex >= 0, "Tuple index cannot be negative");
    }

    this.spaceName =
            Optional.ofNullable(findPropertyOrOwnerAnnotation(Index.class))
            .map(Index::value)
            .orElse(null);

    if(spaceName != null) {
        Assert.hasText(spaceName, "Space index cannot be negative");
    }

    if(isIdProperty()) {
        Assert.isTrue(tupleIndex != null, "Id property must have tuple index");
    }
}
 

import org.springframework.data.mapping.model.SimpleTypeHolder; //导入依赖的package包/类
/**
 * Create new instance registering given converters
 *
 * @param converters
 */
@SuppressWarnings({ "unchecked", "rawtypes" })
public CustomConversions(List converters) {
	this.converters = (converters != null ? new ArrayList<Object>(converters) : new ArrayList<Object>());
	this.readingPairs = new HashSet<ConvertiblePair>();
	this.writingPairs = new HashSet<ConvertiblePair>();
	this.customSimpleTypes = new HashSet<Class<?>>();

	this.simpleTypeHolder = new SimpleTypeHolder(customSimpleTypes, SolrSimpleTypes.HOLDER);

	this.converters.add(GeoConverters.StringToPointConverter.INSTANCE);
	this.converters.add(GeoConverters.Point3DToStringConverter.INSTANCE);
	this.converters.add(new SolrjConverters.UpdateToSolrInputDocumentConverter());

	// Register Joda-Time converters only if Joda-Time was found in the classpath.
	if (VersionUtil.isJodaTimeAvailable()) {
		this.converters.add(DateTimeConverters.DateToJodaDateTimeConverter.INSTANCE);
		this.converters.add(DateTimeConverters.JodaDateTimeToDateConverter.INSTANCE);
		this.converters.add(DateTimeConverters.DateToLocalDateTimeConverter.INSTANCE);
		this.converters.add(DateTimeConverters.JodaLocalDateTimeToDateConverter.INSTANCE);
	}

	for (Object converter : this.converters) {
		registerConversion(converter);
	}
}
 

import org.springframework.data.mapping.model.SimpleTypeHolder; //导入依赖的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.SimpleTypeHolder; //导入依赖的package包/类
/**
 * Create a new instance with a given list of converters.
 * @param converters the list of custom converters.
 */
public CustomConversions(final List<?> converters) {
  notNull(converters);

  readingPairs = new LinkedHashSet<>();
  writingPairs = new LinkedHashSet<>();
  customSimpleTypes = new HashSet<>();
  customReadTargetTypes = new ConcurrentHashMap<>();

  this.converters = new ArrayList<>();
  this.converters.addAll(converters);
  this.converters.add(LocaleToStringConverter.INSTANCE);
  this.converters.add(DateToLongConverter.INSTANCE);
  this.converters.add(LongToDateConverter.INSTANCE);
  
  for (Object converter : this.converters) {
    registerConversion(converter);
  }

  simpleTypeHolder = new SimpleTypeHolder(customSimpleTypes, HOLDER);
}
 

import org.springframework.data.mapping.model.SimpleTypeHolder; //导入依赖的package包/类
@Override
public DocumentDbPersistentProperty createPersistentProperty(Field field, PropertyDescriptor propertyDescriptor,
                                                             BasicDocumentDbPersistentEntity<?> owner,
                                                             SimpleTypeHolder simpleTypeHolder) {
    return new BasicDocumentDbPersistentProperty(field, propertyDescriptor, owner,
            simpleTypeHolder);
}
 

import org.springframework.data.mapping.model.SimpleTypeHolder; //导入依赖的package包/类
@Override
protected TarantoolPersistentPropertyImpl createPersistentProperty(Field field,
                                                                   PropertyDescriptor descriptor,
                                                                   TarantoolPersistentEntity<?> owner,
                                                                   SimpleTypeHolder simpleTypeHolder) {
    return new TarantoolPersistentPropertyImpl(field, descriptor, owner, simpleTypeHolder);
}
 

import org.springframework.data.mapping.model.SimpleTypeHolder; //导入依赖的package包/类
/**
 * Creates a new {@link CustomConversions} instance registering the given converters.
 *
 * @param converters
 */
public CustomConversions(List<?> converters) {

    Assert.notNull(converters);

    this.readingPairs = new LinkedHashSet<ConvertiblePair>();
    this.writingPairs = new LinkedHashSet<ConvertiblePair>();
    this.customSimpleTypes = new HashSet<Class<?>>();
    this.customReadTargetTypes = new ConcurrentHashMap<ConvertiblePair, CacheValue<Class<?>>>();
    this.customWriteTargetTypes = new ConcurrentHashMap<ConvertiblePair, CacheValue<Class<?>>>();
    this.rawWriteTargetTypes = new ConcurrentHashMap<Class<?>, CacheValue<Class<?>>>();

    List<Object> toRegister = new ArrayList<Object>();

    // Add user provided converters to make sure they can override the defaults
    toRegister.addAll(converters);

    toRegister.add(new BinaryConverters.EnumToStringConverter());
    toRegister.add(new BinaryConverters.StringToEnumConverterFactory());
    toRegister.add(new BinaryConverters.DateToNumberConverter());
    toRegister.add(new BinaryConverters.NumberToDateConverter());

    for (Object c : toRegister) {
        registerConversion(c);
    }

    Collections.reverse(toRegister);

    this.converters = Collections.unmodifiableList(toRegister);
    this.simpleTypeHolder = new SimpleTypeHolder(customSimpleTypes, true);
}
 

import org.springframework.data.mapping.model.SimpleTypeHolder; //导入依赖的package包/类
@Test public void
should_return_the_attribute_name(){
	
	MongoPersistentEntity<FieldWithoutAnnotation> entity = new BasicMongoPersistentEntity<FieldWithoutAnnotation>(ClassTypeInformation.from(FieldWithoutAnnotation.class));
	java.lang.reflect.Field field = ReflectionUtils.findField(FieldWithoutAnnotation.class, "name");
	
	BasicMongoPersistentProperty persistentProperty = new BasicMongoPersistentProperty(field, null, entity, new SimpleTypeHolder());		
	String fieldName = persistentProperty.getFieldName();
	
	assertEquals("Class attribute reading failed", field.getName(), fieldName);
}
 

import org.springframework.data.mapping.model.SimpleTypeHolder; //导入依赖的package包/类
@Test public void
should_return_the_name_using_the_annotation(){
	
	MongoPersistentEntity<AnnotatedField> entity = new BasicMongoPersistentEntity<AnnotatedField>(ClassTypeInformation.from(AnnotatedField.class));
	java.lang.reflect.Field field = ReflectionUtils.findField(AnnotatedField.class, "name");
	
	BasicMongoPersistentProperty persistentProperty = new BasicMongoPersistentProperty(field, null, entity, new SimpleTypeHolder());		
	String fieldName = persistentProperty.getFieldName();
	
	assertEquals("Class attribute reading failed","name_user", fieldName);
}
 

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

    if (isIdProperty() && getFieldName() != ID_FIELD_NAME) {
        LOG.warn("Custom field name for id property is not supported!");
    }
}
 

import org.springframework.data.mapping.model.SimpleTypeHolder; //导入依赖的package包/类
/**
 * Create new instance registering given converters
 * 
 * @param converters
 */
@SuppressWarnings({ "unchecked", "rawtypes" })
public CustomConversions(List converters) {
	this.converters = (converters != null ? new ArrayList<Object>(converters) : new ArrayList<Object>());
	this.readingPairs = new HashSet<ConvertiblePair>();
	this.writingPairs = new HashSet<ConvertiblePair>();
	this.customSimpleTypes = new HashSet<Class<?>>();

	this.simpleTypeHolder = new SimpleTypeHolder(customSimpleTypes, SolrSimpleTypes.HOLDER);

	this.converters.add(StringToGeoLocationConverter.INSTANCE);
	this.converters.add(GeoLocationToStringConverter.INSTANCE);
	this.converters.add(StringToPointConverter.INSTANCE);
	this.converters.add(new SolrjConverters.UpdateToSolrInputDocumentConverter());

	// Register Joda-Time converters only if Joda-Time was found in the classpath.
	if (VersionUtil.isJodaTimeAvailable()) {
		this.converters.add(DateTimeConverters.DateToJodaDateTimeConverter.INSTANCE);
		this.converters.add(DateTimeConverters.JodaDateTimeToDateConverter.INSTANCE);
		this.converters.add(DateTimeConverters.DateToLocalDateTimeConverter.INSTANCE);
		this.converters.add(DateTimeConverters.JodaLocalDateTimeToDateConverter.INSTANCE);
	}

	for (Object converter : this.converters) {
		registerConversion(converter);
	}
}
 

import org.springframework.data.mapping.model.SimpleTypeHolder; //导入依赖的package包/类
@Test
public void testIdType() throws NoSuchFieldException, SecurityException {
	Mockito.when(persistentEntity.getTypeInformation()).thenReturn(ClassTypeInformation.from(ProductBean.class));
	SimpleSolrPersistentProperty property = new SimpleSolrPersistentProperty(ProductBean.class.getDeclaredField("id"),
			null, persistentEntity, new SimpleTypeHolder());
	Mockito.when(persistentEntity.getIdProperty()).thenReturn(property);

	SolrEntityInformation<ProductBean, String> entityInformation = new MappingSolrEntityInformation<ProductBean, String>(
			persistentEntity);
	Assert.assertEquals(String.class, entityInformation.getIdType());
}
 

import org.springframework.data.mapping.model.SimpleTypeHolder; //导入依赖的package包/类
@Test
public void testIdTypeWithLongIdFieldType() throws NoSuchFieldException, SecurityException {
	Mockito.when(persistentEntityWithLongIdFieldType.getTypeInformation()).thenReturn(
			ClassTypeInformation.from(ProductBeanWithLongIdFieldType.class));

	SimpleSolrPersistentProperty property = new SimpleSolrPersistentProperty(
			ProductBeanWithLongIdFieldType.class.getDeclaredField("id"), null, persistentEntityWithLongIdFieldType,
			new SimpleTypeHolder());
	Mockito.when(persistentEntityWithLongIdFieldType.getIdProperty()).thenReturn(property);

	SolrEntityInformation<ProductBeanWithLongIdFieldType, Long> entityInformation = new MappingSolrEntityInformation<ProductBeanWithLongIdFieldType, Long>(
			persistentEntityWithLongIdFieldType);
	Assert.assertEquals(Long.class, entityInformation.getIdType());
}
 

import org.springframework.data.mapping.model.SimpleTypeHolder; //导入依赖的package包/类
@Test
public void testGetIdAttribute() throws NoSuchFieldException, SecurityException {
	Mockito.when(persistentEntity.getTypeInformation()).thenReturn(ClassTypeInformation.from(ProductBean.class));
	SimpleSolrPersistentProperty property = new SimpleSolrPersistentProperty(ProductBean.class.getDeclaredField("id"),
			null, persistentEntity, new SimpleTypeHolder());
	Mockito.when(persistentEntity.getIdProperty()).thenReturn(property);

	SolrEntityInformation<ProductBean, String> entityInformation = new MappingSolrEntityInformation<ProductBean, String>(
			persistentEntity);
	Assert.assertEquals("id", entityInformation.getIdAttribute());
}
 

import org.springframework.data.mapping.model.SimpleTypeHolder; //导入依赖的package包/类
@Test
public void testGetIdAttributeForAlternateFieldName() throws NoSuchFieldException, SecurityException {
	Mockito.when(persistentEntityWithAlternateFieldNameForId.getTypeInformation()).thenReturn(
			ClassTypeInformation.from(ProductBeanWithAlternateFieldNameForId.class));

	SimpleSolrPersistentProperty property = new SimpleSolrPersistentProperty(
			ProductBeanWithAlternateFieldNameForId.class.getDeclaredField("productId"), null,
			persistentEntityWithAlternateFieldNameForId, new SimpleTypeHolder());
	Mockito.when(persistentEntityWithAlternateFieldNameForId.getIdProperty()).thenReturn(property);

	SolrEntityInformation<ProductBeanWithAlternateFieldNameForId, String> entityInformation = new MappingSolrEntityInformation<ProductBeanWithAlternateFieldNameForId, String>(
			persistentEntityWithAlternateFieldNameForId);
	Assert.assertEquals("product_id", entityInformation.getIdAttribute());
}