Java Formatter类代码示例

import org.springframework.format.Formatter; //导入依赖的package包/类
private Formatter<Number> configureFormatterFrom(NumberFormat annotation) {
	if (StringUtils.hasLength(annotation.pattern())) {
		return new NumberFormatter(resolveEmbeddedValue(annotation.pattern()));
	}
	else {
		Style style = annotation.style();
		if (style == Style.PERCENT) {
			return new PercentFormatter();
		}
		else if (style == Style.CURRENCY) {
			return new CurrencyFormatter();
		}
		else {
			return new NumberFormatter();
		}
	}
}
 

import org.springframework.format.Formatter; //导入依赖的package包/类
private void registerFormatters() {
	if (this.formatters != null) {
		for (Object formatter : this.formatters) {
			if (formatter instanceof Formatter<?>) {
				this.conversionService.addFormatter((Formatter<?>) formatter);
			}
			else if (formatter instanceof AnnotationFormatterFactory<?>) {
				this.conversionService.addFormatterForFieldAnnotation((AnnotationFormatterFactory<?>) formatter);
			}
			else {
				throw new IllegalArgumentException(
						"Custom formatters must be implementations of Formatter or AnnotationFormatterFactory");
			}
		}
	}
	if (this.formatterRegistrars != null) {
		for (FormatterRegistrar registrar : this.formatterRegistrars) {
			registrar.registerFormatters(this.conversionService);
		}
	}
	installFormatters(this.conversionService);
}
 

import org.springframework.format.Formatter; //导入依赖的package包/类
private Formatter<Number> configureFormatterFrom(NumberFormat annotation) {
	if (StringUtils.hasLength(annotation.pattern())) {
		return new NumberStyleFormatter(resolveEmbeddedValue(annotation.pattern()));
	}
	else {
		Style style = annotation.style();
		if (style == Style.CURRENCY) {
			return new CurrencyStyleFormatter();
		}
		else if (style == Style.PERCENT) {
			return new PercentStyleFormatter();
		}
		else {
			return new NumberStyleFormatter();
		}
	}
}
 

import org.springframework.format.Formatter; //导入依赖的package包/类
private Formatter<MonetaryAmount> configureFormatterFrom(NumberFormat annotation) {
	if (StringUtils.hasLength(annotation.pattern())) {
		return new PatternDecoratingFormatter(resolveEmbeddedValue(annotation.pattern()));
	}
	else {
		Style style = annotation.style();
		if (style == Style.NUMBER) {
			return new NumberDecoratingFormatter(new NumberStyleFormatter());
		}
		else if (style == Style.PERCENT) {
			return new NumberDecoratingFormatter(new PercentStyleFormatter());
		}
		else {
			return new NumberDecoratingFormatter(new CurrencyStyleFormatter());
		}
	}
}
 

import org.springframework.format.Formatter; //导入依赖的package包/类
private void registerFormatters() {
	if (this.formatters != null) {
		for (Object formatter : this.formatters) {
			if (formatter instanceof Formatter<?>) {
				this.conversionService.addFormatter((Formatter<?>) formatter);
			}
			else if (formatter instanceof AnnotationFormatterFactory<?>) {
				this.conversionService.addFormatterForFieldAnnotation((AnnotationFormatterFactory<?>) formatter);
			}
			else {
				throw new IllegalArgumentException(
						"Custom formatters must be implementations of Formatter or AnnotationFormatterFactory");
			}
		}
	}
	if (this.formatterRegistrars != null) {
		for (FormatterRegistrar registrar : this.formatterRegistrars) {
			registrar.registerFormatters(this.conversionService);
		}
	}
}
 

import org.springframework.format.Formatter; //导入依赖的package包/类
/**
 * Extract handled types from all possible sources (annotation and interface).
 * @param formatter
 * @return
 */
@SuppressWarnings("unchecked")
public static Set<Key<?>> getHandledMetatypes(Formatter<?> formatter) {
    Assert.notNull(formatter, "formatter is null");
    Set<Key<?>> set = new HashSet<>();
    if(formatter instanceof SelfDescribedFormatter) {
        set.addAll(((SelfDescribedFormatter) formatter).getHandledMetatypes());
    }
    FormatterInfo formatterInfo = AnnotationUtils.findAnnotation(formatter.getClass(), FormatterInfo.class);
    if(formatterInfo != null) {
        for(MetatypeInfo metatypeInfo: formatterInfo.metatypes()) {
            set.add(MetatypeUtils.toKey(metatypeInfo));
        }
    }
    return set;
}
 

import org.springframework.format.Formatter; //导入依赖的package包/类
private void registerFormatters() {
	if (this.formatters != null) {
		for (Object formatter : this.formatters) {
			if (formatter instanceof Formatter<?>) {
				this.conversionService
						.addFormatter((Formatter<?>) formatter);
			} else if (formatter instanceof AnnotationFormatterFactory<?>) {
				this.conversionService
						.addFormatterForFieldAnnotation((AnnotationFormatterFactory<?>) formatter);
			} else {
				throw new IllegalArgumentException(
						"Custom formatters must be implementations of Formatter or AnnotationFormatterFactory");
			}
		}
	}
	if (this.formatterRegistrars != null) {
		for (FormatterRegistrar registrar : this.formatterRegistrars) {
			registrar.registerFormatters(this.conversionService);
		}
	}
	installFormatters(this.conversionService);
}
 

import org.springframework.format.Formatter; //导入依赖的package包/类
/**
 * Get a formatter for class and property name
 * @param clazz the class
 * @param propertyName the property name
 * @return the formatter or null if none
 */
public static Formatter<?> getFormatter(Class<?> clazz, String propertyName) {
	PropertyDescriptor pd = BeanUtils.getPropertyDescriptor(clazz, propertyName);
	if (pd != null) {
		NumberFormat format = getAnnotation(pd, NumberFormat.class);
		if (format != null) {
			return (Formatter<?>) numberFormatFactory.getPrinter(format, pd.getPropertyType());
		}
		
		PeriodFormat periodFormat = getAnnotation(pd, PeriodFormat.class);
		if (periodFormat != null)
			return new PeriodFormatter();
	}
	
	return null;
}
 

import org.springframework.format.Formatter; //导入依赖的package包/类
@Override
public void addFormatter(Formatter<?> formatter) {
	Class<?> fieldType = GenericTypeResolver.resolveTypeArgument(formatter.getClass(), Formatter.class);
	if (fieldType == null) {
		throw new IllegalArgumentException("Unable to extract parameterized field type argument from Formatter [" +
				formatter.getClass().getName() + "]; does the formatter parameterize the <T> generic type?");
	}
	addFormatterForFieldType(fieldType, formatter);
}
 

import org.springframework.format.Formatter; //导入依赖的package包/类
protected Formatter<Date> getFormatter(DateTimeFormat annotation, Class<?> fieldType) {
	DateFormatter formatter = new DateFormatter();
	formatter.setStylePattern(resolveEmbeddedValue(annotation.style()));
	formatter.setIso(annotation.iso());
	formatter.setPattern(resolveEmbeddedValue(annotation.pattern()));
	return formatter;
}
 

import org.springframework.format.Formatter; //导入依赖的package包/类
@Bean
@Autowired // L'ho spostato qui per risolvere il problema "Requested bean is currently in creation"
// Questo registra un Date Formatter
public FormattingConversionService mvcConversionService(YadaDateFormatter yadaDateFormatter) {
	FormattingConversionServiceFactoryBean result = new FormattingConversionServiceFactoryBean();
	Set<Formatter<Date>> formatters = new HashSet<Formatter<Date>>();
	formatters.add(yadaDateFormatter);
	result.setFormatters(formatters);
	result.afterPropertiesSet();
	return result.getObject();
}
 

import org.springframework.format.Formatter; //导入依赖的package包/类
/**
 * Add a custom formatter for the field type specified in {@link Formatter} class,
 * applying it to the specified fields only, if any, or otherwise to all fields.
 * <p>Registers a corresponding {@link PropertyEditor} adapter underneath the covers.
 * @param formatter the formatter to add, generically declared for a specific type
 * @param fields the fields to apply the formatter to, or none if to be applied to all
 * @since 4.2
 * @see #registerCustomEditor(Class, String, PropertyEditor)
 */
public void addCustomFormatter(Formatter<?> formatter, String... fields) {
	FormatterPropertyEditorAdapter adapter = new FormatterPropertyEditorAdapter(formatter);
	Class<?> fieldType = adapter.getFieldType();
	if (ObjectUtils.isEmpty(fields)) {
		getPropertyEditorRegistry().registerCustomEditor(fieldType, adapter);
	}
	else {
		for (String field : fields) {
			getPropertyEditorRegistry().registerCustomEditor(fieldType, field, adapter);
		}
	}
}
 

import org.springframework.format.Formatter; //导入依赖的package包/类
static Class<?> getFieldType(Formatter<?> formatter) {
	Class<?> fieldType = GenericTypeResolver.resolveTypeArgument(formatter.getClass(), Formatter.class);
	if (fieldType == null) {
		throw new IllegalArgumentException("Unable to extract parameterized field type argument from Formatter [" +
				formatter.getClass().getName() + "]; does the formatter parameterize the <T> generic type?");
	}
	return fieldType;
}
 

import org.springframework.format.Formatter; //导入依赖的package包/类
@Override
@SuppressWarnings("unchecked")
public <T> Formatter<T> getFormatter(Key<T> key) {
    Assert.notNull(key, "key is null");
    Formatter<?> formatter = map.get(key);
    if(formatter == null) {
        throw new RuntimeException("No registered formatters for: " + key);
    }
    return (Formatter<T>) formatter;
}
 

import org.springframework.format.Formatter; //导入依赖的package包/类
/**
 * Do invocation of specified formatter on text with default locale.
 * @param formatter
 * @param text allow null
 * @param <T>
 * @return parsed object or null if text is null
 */
public static <T> T parse(Formatter<T> formatter, String text) {
    if(text == null) {
        return null;
    }
    try {
        return formatter.parse(text, Locale.getDefault());
    } catch (ParseException e) {
        throw new IllegalArgumentException("Can not parse:'" + text + "'", e);
    }
}