spring（五）类型转换

最新推荐文章于 2025-06-08 16:16:51 发布
最新推荐文章于 2025-06-08 16:16:51 发布
阅读量514 收藏 1
点赞数
CC 4.0 BY-SA版权
分类专栏： spring 文章标签： java spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/lxlneversettle/article/details/118853926
本文深入探讨了Spring中的类型转换过程，从`TypeConverter.convertIfNecessary`到`GenericConversionService.convert`，涉及`BeanWrapperImpl`、`TypeConverterDelegate`和`ConversionService`等关键组件。还介绍了`Converter`的注册方法，包括`addConverter`系列方法，并提到了如何通过`ConversionServiceFactoryBean`注册自定义转换器。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

类型转换

之前在介绍bean的创建过程中，其中有一步是调用populateBean，来将BeanDefinition中的PropertyValue来设置到bean中
因为在xml中标签中指定的值都为字符串类型，所以需要进行类型转换，将字符串类型的值转换为bean对应属性的类型
在populateBean中最后会调用applyPropertyValues来将PropertyValue中的属性值设置到创建的bean实例中

// AbstractAutowireCapableBeanFactory
protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) {
	if (pvs != null) {
		applyPropertyValues(beanName, mbd, bw, pvs);
	}
}

在调用applyPropertyValues的过程中，会遍历PropertyValues中的所有属性，然后调用convertForProperty进行类型转换

// AbstractAutowireCapableBeanFactory
protected void applyPropertyValues(String beanName, BeanDefinition mbd, BeanWrapper bw, PropertyValues pvs) {
	// 省略
	// 判断是否使用了自定义的类型转换器
	// 如果没有指定，那么会使用BeanWrapper作为类型转换器
	TypeConverter converter = getCustomTypeConverter();
	if (converter == null) {
		converter = bw;
	}
	List<PropertyValue> deepCopy = new ArrayList<>(original.size());
	boolean resolveNecessary = false;
	for (PropertyValue pv : original) {
		// 如果已经转换过，直接添加到deepCopy中
		if (pv.isConverted()) {
			deepCopy.add(pv);
		}
		else {
			String propertyName = pv.getName();
			Object originalValue = pv.getValue();
			if (originalValue == AutowiredPropertyMarker.INSTANCE) {
				Method writeMethod = bw.getPropertyDescriptor(propertyName).getWriteMethod();
				if (writeMethod == null) {
					throw new IllegalArgumentException("Autowire marker for property without write method: " + pv);
				}
				originalValue = new DependencyDescriptor(new MethodParameter(writeMethod, 0), true);
			}
			Object resolvedValue = valueResolver.resolveValueIfNecessary(pv, originalValue);
			Object convertedValue = resolvedValue;
			boolean convertible = bw.isWritableProperty(propertyName) &&
					!PropertyAccessorUtils.isNestedOrIndexedProperty(propertyName);
			if (convertible) {
				// 进行转换
				convertedValue = convertForProperty(resolvedValue, propertyName, bw, converter);
			}
			// Possibly store converted value in merged bean definition,
			// in order to avoid re-conversion for every created bean instance.
			if (resolvedValue == originalValue) {
				if (convertible) {
					pv.setConvertedValue(convertedValue);
				}
				deepCopy.add(pv);
			}
			else if (convertible && originalValue instanceof TypedStringValue &&
					!((TypedStringValue) originalValue).isDynamic() &&
					!(convertedValue instanceof Collection || ObjectUtils.isArray(convertedValue))) {
				pv.setConvertedValue(convertedValue);
				deepCopy.add(pv);
			}
			else {
				resolveNecessary = true;
				deepCopy.add(new PropertyValue(pv, convertedValue));
			}
		}
	}
}

下面主要看下convertForProperty做了什么

private Object convertForProperty(
			@Nullable Object value, String propertyName, BeanWrapper bw, TypeConverter converter) {
	// 如果传入的Converter是BeanWrapperImpl，那么会调用BeanWrapperImpl的convertForProperty来进行类型的转换
	if (converter instanceof BeanWrapperImpl) {
		return ((BeanWrapperImpl) converter).convertForProperty(value, propertyName);
	}
	else {
		// 否则会调用TypeConvertor的convertIfNecessary来进行类型的转换
		PropertyDescriptor pd = bw.getPropertyDescriptor(propertyName);
		MethodParameter methodParam = BeanUtils.getWriteMethodParameter(pd);
		return converter.convertIfNecessary(value, pd.getPropertyType(), methodParam);
	}
}

TypeConverter.convertIfNecessary

下面首先看下走TypeConverter.convertIfNecessary这个分支
convertIfNecessary方法主要由DateBinder和TypeConverterSupport两个类来实现，这里主要看下TypeConverterSupport

// TypeConverterSupport
public <T> T convertIfNecessary(@Nullable Object value, @Nullable Class<T> requiredType,
			@Nullable TypeDescriptor typeDescriptor) throws TypeMismatchException {

	Assert.state(this.typeConverterDelegate != null, "No TypeConverterDelegate");
	try {
		return this.typeConverterDelegate.convertIfNecessary(null, null, value, requiredType, typeDescriptor);
	}
	catch (ConverterNotFoundException | IllegalStateException ex) {
		throw new ConversionNotSupportedException(value, requiredType, ex);
	}
	catch (ConversionException | IllegalArgumentException ex) {
		throw new TypeMismatchException(value, requiredType, ex);
	}
}

可以看到主要是调用TypeConverterDelegate的convertIfNecessary来完成的

BeanWrapperImpl.convertForProperty

// BeanWrapperImpl
public Object convertForProperty(@Nullable Object value, String propertyName) throws TypeMismatchException {
	// 在进行属性转换之前，增加了对PropertyDescriptor和TypeDescriptor的缓存
	CachedIntrospectionResults cachedIntrospectionResults = getCachedIntrospectionResults();
	PropertyDescriptor pd = cachedIntrospectionResults.getPropertyDescriptor(propertyName);
	if (pd == null) {
		throw new InvalidPropertyException(getRootClass(), getNestedPath() + propertyName,
				"No property '" + propertyName + "' found");
	}
	TypeDescriptor td = cachedIntrospectionResults.getTypeDescriptor(pd);
	if (td == null) {
		td = cachedIntrospectionResults.addTypeDescriptor(pd, new TypeDescriptor(property(pd)));
	}
	// 执行类型转换
	return convertForProperty(propertyName, null, value, td);
}

// AbstractNestablePropertyAccessor
protected Object convertForProperty(
			String propertyName, @Nullable Object oldValue, @Nullable Object newValue, TypeDescriptor td)
			throws TypeMismatchException {

	return convertIfNecessary(propertyName, oldValue, newValue, td.getType(), td);
}

// AbstractNestablePropertyAccessoor
private Object convertIfNecessary(@Nullable String propertyName, @Nullable Object oldValue,
			@Nullable Object newValue, @Nullable Class<?> requiredType, @Nullable TypeDescriptor td)
			throws TypeMismatchException {

	Assert.state(this.typeConverterDelegate != null, "No TypeConverterDelegate");
	try {
		// 最终也会交给TypeConverterDelegate进行类型转换
		return this.typeConverterDelegate.convertIfNecessary(propertyName, oldValue, newValue, requiredType, td);
	}
	catch (ConverterNotFoundException | IllegalStateException ex) {
		PropertyChangeEvent pce =
				new PropertyChangeEvent(getRootInstance(), this.nestedPath + propertyName, oldValue, newValue);
		throw new ConversionNotSupportedException(pce, requiredType, ex);
	}
	catch (ConversionException | IllegalArgumentException ex) {
		PropertyChangeEvent pce =
				new PropertyChangeEvent(getRootInstance(), this.nestedPath + propertyName, oldValue, newValue);
		throw new TypeMismatchException(pce, requiredType, ex);
	}
}

可以看到，不管走哪个分支，最终都会交给TypeConverterDelegate进行类型转换

TypeConverterDelegate.convertIfNecessary

public <T> T convertIfNecessary(@Nullable String propertyName, @Nullable Object oldValue, @Nullable Object newValue,
			@Nullable Class<T> requiredType, @Nullable TypeDescriptor typeDescriptor) throws IllegalArgumentException {

	// Custom editor for this type?
	// 判断是否有合适的自定义editor
	PropertyEditor editor = this.propertyEditorRegistry.findCustomEditor(requiredType, propertyName);

	ConversionFailedException conversionAttemptEx = null;

	// No custom editor but custom ConversionService specified?
	ConversionService conversionService = this.propertyEditorRegistry.getConversionService();
	// 如果没有合适的自定义editor，并且conversionService不为空，那么使用conversionService进行类型转换
	if (editor == null && conversionService != null && newValue != null && typeDescriptor != null) {
		TypeDescriptor sourceTypeDesc = TypeDescriptor.forObject(newValue);
		if (conversionService.canConvert(sourceTypeDesc, typeDescriptor)) {
			try {
				return (T) conversionService.convert(newValue, sourceTypeDesc, typeDescriptor);
			}
			catch (ConversionFailedException ex) {
				// fallback to default conversion logic below
				conversionAttemptEx = ex;
			}
		}
	}
	// 省略
}

从上面的代码可以看出TypeConverterDelegate最终调用ConversionService的convert方法来进行类型的转换
而ConversionService的convert方法又是由GenericConversionService来实现的

GenericConversionService.convert
// GenericConversionService
public Object convert(@Nullable Object source, @Nullable TypeDescriptor sourceType, TypeDescriptor targetType) {
	Assert.notNull(targetType, "Target type to convert to cannot be null");
	// <1> 如果源类型为null，则待转换的值也必须为null
	// 这里会判断目标类型是否是Optional，如果是，则会返回Optional.empty()，否则直接返回null
	if (sourceType == null) {
		Assert.isTrue(source == null, "Source must be [null] if source type == [null]");
		return handleResult(null, targetType, convertNullSource(null, targetType));
	}
	// <2> 属性值和源类型不一致，直接抛出异常
	if (source != null && !sourceType.getObjectType().isInstance(source)) {
		throw new IllegalArgumentException("Source to convert from must be an instance of [" +
				sourceType + "]; instead it was a [" + source.getClass().getName() + "]");
	}
	// <3> 根据源类型和目标类型获取对应的GenericConverter
	GenericConverter converter = getConverter(sourceType, targetType);
	if (converter != null) {	
		// 使用GenericConverter来进行类型转换
		Object result = ConversionUtils.invokeConverter(converter, source, sourceType, targetType);
		return handleResult(sourceType, targetType, result);
	}
	return handleConverterNotFound(source, sourceType, targetType);
}
handlerResult

handlerResult的作用就是对最终转换之后的结果进行校验

// GenericConversionService
private Object handleResult(@Nullable TypeDescriptor sourceType, TypeDescriptor targetType, @Nullable Object result) {
	// 如果结果是null，会判断目标类型是否是基础类型，如果是基础类型直接抛出异常，因为基础类型无法接收null
	if (result == null) {
		assertNotPrimitiveTargetType(sourceType, targetType);
	}
	return result;
}
convertNullSource

convertNullSource对源类型为null情况的处理，这里会根据目标类型是否是Optional，来决定返回Optional.empty还是null

protected Object convertNullSource(@Nullable TypeDescriptor sourceType, TypeDescriptor targetType) {
	if (targetType.getObjectType() == Optional.class) {
		return Optional.empty();
	}
	return null;
}
handleConverterNotFound

hnadlerConverterNotFound用来处理没有合适Converter的情况

// GenericConversionService
private Object handleConverterNotFound(
			@Nullable Object source, @Nullable TypeDescriptor sourceType, TypeDescriptor targetType) {
	// 属性值为null
	if (source == null) {
		assertNotPrimitiveTargetType(sourceType, targetType);
		return null;
	}
	//  源类型可以转换成目标类型
	if ((sourceType == null || sourceType.isAssignableTo(targetType)) &&
			targetType.getObjectType().isInstance(source)) {
		return source;
	}
	throw new ConverterNotFoundException(sourceType, targetType);
}
getConverter

getConverter的主要作用是根据源类型和目标类型来获取合适的GenericConverter

// GenericConversionService
protected GenericConverter getConverter(TypeDescriptor sourceType, TypeDescriptor targetType) {
	// <1> 使用源类型和目标类型来生成缓存key，如果缓存中有，直接返回缓存中对应的GenericConverter
	ConverterCacheKey key = new ConverterCacheKey(sourceType, targetType);
	GenericConverter converter = this.converterCache.get(key);
	if (converter != null) {
		return (converter != NO_MATCH ? converter : null);
	}

	// <2> 如果缓存中不存在，那么会从Converters中寻找合适的GenericConverter
	converter = this.converters.find(sourceType, targetType);
	if (converter == null) {
		converter = getDefaultConverter(sourceType, targetType);
	}

	// <3> 将找到的GenericConverter放入缓存
	if (converter != null) {
		this.converterCache.put(key, converter);
		return converter;
	}

	this.converterCache.put(key, NO_MATCH);
	return null;
}
Converters

Converters用来维护所有注册进来的GenericConverter
其中有两个属性用来维护注册进来的converter

// 用来维护全局converter
private final Set<GenericConverter> globalConverters = new CopyOnWriteArraySet<>();

private final Map<ConvertiblePair, ConvertersForPair> converters = new ConcurrentHashMap<>(256);

// Converters
public GenericConverter find(TypeDescriptor sourceType, TypeDescriptor targetType) {
	// Search the full type hierarchy
	// 分别获得源类型和目标类型的类继承层次中的类
	List<Class<?>> sourceCandidates = getClassHierarchy(sourceType.getType());
	List<Class<?>> targetCandidates = getClassHierarchy(targetType.getType());
	// 分别使用源类型和目标类型类继承层次中的类来生成ConvertiblePair，在注册进来的converter中进行查找
	for (Class<?> sourceCandidate : sourceCandidates) {
		for (Class<?> targetCandidate : targetCandidates) {
			ConvertiblePair convertiblePair = new ConvertiblePair(sourceCandidate, targetCandidate);
			GenericConverter converter = getRegisteredConverter(sourceType, targetType, convertiblePair);
			if (converter != null) {
				return converter;
			}
		}
	}
	return null;
}

// Converters
private GenericConverter getRegisteredConverter(TypeDescriptor sourceType,
				TypeDescriptor targetType, ConvertiblePair convertiblePair) {

	// Check specifically registered converters
	// 分别从converters和globalConverters中进行查找
	// <1> 从converters中进行查找，首先根据源类型和目标类型，构建convertiblePair
	// 根据convertiblePair找到对应的ConvertersForPair，再从ConvertersForPair中找到合适的converter
	ConvertersForPair convertersForPair = this.converters.get(convertiblePair);
	if (convertersForPair != null) {
		GenericConverter converter = convertersForPair.getConverter(sourceType, targetType);
		if (converter != null) {
			return converter;
		}
	}
	// Check ConditionalConverters for a dynamic match
	// <2> 从全局converters中查找，则是遍历每个converter，然后调用match，判断是否可以支持当前源类型和目标类型的转换
	for (GenericConverter globalConverter : this.globalConverters) {
		if (((ConditionalConverter) globalConverter).matches(sourceType, targetType)) {
			return globalConverter;
		}
	}
	return null;
}
ConversionUtils.invokeConverter

使用找到的GenericConverter对属性进行转换

// ConversionUtils
public static Object invokeConverter(GenericConverter converter, @Nullable Object source,
			TypeDescriptor sourceType, TypeDescriptor targetType) {

	try {
		return converter.convert(source, sourceType, targetType);
	}
	catch (ConversionFailedException ex) {
		throw ex;
	}
	catch (Throwable ex) {
		throw new ConversionFailedException(sourceType, targetType, source, ex);
	}
}

Converter注册

GenericConversionService有多个重载的addConverter以及一个addConverterFactory

addConverter(Class, Class,Converter<S super S,T extends T>)

// GenericConversionService
public <S, T> void addConverter(Class<S> sourceType, Class<T> targetType, Converter<? super S, ? extends T> converter) {
	addConverter(new ConverterAdapter(
			converter, ResolvableType.forClass(sourceType), ResolvableType.forClass(targetType)));
}

public void addConverter(GenericConverter converter) {
	this.converters.add(converter);
	invalidateCache();
}

addConverter(Converter<?,?>)

public void addConverter(Converter<?, ?> converter) {
	// 获取当前converter的泛型
	ResolvableType[] typeInfo = getRequiredTypeInfo(converter.getClass(), Converter.class);
	if (typeInfo == null && converter instanceof DecoratingProxy) {
		typeInfo = getRequiredTypeInfo(((DecoratingProxy) converter).getDecoratedClass(), Converter.class);
	}
	if (typeInfo == null) {
		throw new IllegalArgumentException("Unable to determine source type <S> and target type <T> for your " +
				"Converter [" + converter.getClass().getName() + "]; does the class parameterize those types?");
	}
	addConverter(new ConverterAdapter(converter, typeInfo[0], typeInfo[1]));
}

public void addConverter(GenericConverter converter) {
	this.converters.add(converter);
	invalidateCache();
}

addConverterFactory(ConverterFactory<?,?>)

public void addConverterFactory(ConverterFactory<?, ?> factory) {
	// 获取factory的泛型
	ResolvableType[] typeInfo = getRequiredTypeInfo(factory.getClass(), ConverterFactory.class);
	if (typeInfo == null && factory instanceof DecoratingProxy) {
		typeInfo = getRequiredTypeInfo(((DecoratingProxy) factory).getDecoratedClass(), ConverterFactory.class);
	}
	if (typeInfo == null) {
		throw new IllegalArgumentException("Unable to determine source type <S> and target type <T> for your " +
				"ConverterFactory [" + factory.getClass().getName() + "]; does the class parameterize those types?");
	}
	addConverter(new ConverterFactoryAdapter(factory,
			new ConvertiblePair(typeInfo[0].toClass(), typeInfo[1].toClass())));
}

public void addConverter(GenericConverter converter) {
	this.converters.add(converter);
	invalidateCache();
}

addConverter(GenericConverter)

// GenericConversionService
public void addConverter(GenericConverter converter) {
	this.converters.add(converter);
	invalidateCache();
}

可以看到上面不同形式添加converter的方法，最终都是创建GenericConverter的实现类的实例，然后调用当前这个addConverter进行converter注册操作的，不同的是，如果入参是Converter，那么会创建ConverterAdapter；如果入参是ConverterFactory，那么会创建ConverterFactoryAdapter
接着看下Converters的add方法

// Converters
public void add(GenericConverter converter) {
	// <1> 获取当前converter的ConvertiblePair
	Set<ConvertiblePair> convertibleTypes = converter.getConvertibleTypes();
	// <2> 如果为空，加入到全局converter中
	if (convertibleTypes == null) {
		Assert.state(converter instanceof ConditionalConverter,
				"Only conditional converters may return null convertible types");
		this.globalConverters.add(converter);
	}
	else {
		// <3> 根据当前ConvertiblePair找到已有的ConvertersPair，然后将当前converter添加进去
		// 一个ConvertersForPair中包含多个GenericConverter
		for (ConvertiblePair convertiblePair : convertibleTypes) {
			getMatchableConverters(convertiblePair).add(converter);
		}
	}
}

DefaultConversionService

DefaultConversionService是GenericConversionService的默认实现类，主要的作用就是注册一些默认的converter

public static void addDefaultConverters(ConverterRegistry converterRegistry) {
	addScalarConverters(converterRegistry);
	addCollectionConverters(converterRegistry);

	converterRegistry.addConverter(new ByteBufferConverter((ConversionService) converterRegistry));
	converterRegistry.addConverter(new StringToTimeZoneConverter());
	converterRegistry.addConverter(new ZoneIdToTimeZoneConverter());
	converterRegistry.addConverter(new ZonedDateTimeToCalendarConverter());

	converterRegistry.addConverter(new ObjectToObjectConverter());
	converterRegistry.addConverter(new IdToEntityConverter((ConversionService) converterRegistry));
	converterRegistry.addConverter(new FallbackObjectToStringConverter());
	converterRegistry.addConverter(new ObjectToOptionalConverter((ConversionService) converterRegistry));
}

注册自定义Converter

spring提供了ConversionServiceFactoryBean来支持自定义Converter

// ConversionServiceFactoryBean
public class ConversionServiceFactoryBean implements FactoryBean<ConversionService>, InitializingBean {

	@Nullable
	private Set<?> converters;

	@Nullable
	private GenericConversionService conversionService;


	/**
	 * Configure the set of custom converter objects that should be added:
	 * implementing {@link org.springframework.core.convert.converter.Converter},
	 * {@link org.springframework.core.convert.converter.ConverterFactory},
	 * or {@link org.springframework.core.convert.converter.GenericConverter}.
	 */
	public void setConverters(Set<?> converters) {
		this.converters = converters;
	}

	@Override
	public void afterPropertiesSet() {
		// 创建DefaultConversionService
		this.conversionService = createConversionService();
		// 遍历convertes，将其中的每个converter注册到conversionService中
		ConversionServiceFactory.registerConverters(this.converters, this.conversionService);
	}

	/**
	 * Create the ConversionService instance returned by this factory bean.
	 * <p>Creates a simple {@link GenericConversionService} instance by default.
	 * Subclasses may override to customize the ConversionService instance that
	 * gets created.
	 */
	protected GenericConversionService createConversionService() {
		return new DefaultConversionService();
	}


	// implementing FactoryBean

	@Override
	@Nullable
	public ConversionService getObject() {
		return this.conversionService;
	}

	@Override
	public Class<? extends ConversionService> getObjectType() {
		return GenericConversionService.class;
	}

	@Override
	public boolean isSingleton() {
		return true;
	}

}

为了注册我们自己的converter，只需要在创建ConversionServiceFactoryBean的时候，通过setConverters方法将我们自己定义的converter注册进去即可

Spring的类型转换器Converter
daimeijin的博客
09-16 5706
前言 一直想开发一个功能比较强大的项目，但是一直没有动手，最近终于有点时间来折腾它了。由于时隔两年没有接触前端了，所以需要一个小项目先练练手感。等这个项目完工之后在着手搞一个大工程。都说好记星不如烂笔头，现在就将这一个过程记录下来，万一有什么踩坑的地方，也可以提示后来人。 背景 由于项目中需要使用到日期和字符串的一个转换，使用到了Converter，所以记录下来。 /** * 日期转换 */ @Component public class DateConverter implements Convert
Spring 类型转换详解，SpringBean创建时属性类型转换源码详解
秃了也弱了
01-29 1587
本文主要内容是Spring Bean通过xml等配置进行属性映射时，发生的类型转换的基本原理与源码分析。扩展模式： 扩展 java.beans.PropertyEditorSupport 类实现 org.springframework.beans.PropertyEditorRegistrar• 实现 registerCustomEditors(org.springframework.beans.PropertyEditorRegistry) 方法。
SpringMVC数据类型转换超详细介绍
09-17
SpringMVC数据类型转换超详细介绍，注解式控制器的数据验证、类型转换及格式化
Spring的类型转换
ABestRookie的博客
04-13 406
Spring的类型转换1 类型转换说明2 WebMvcConfigurer配置类3 Converter4 自定义转换案例1自定义实现Converter接口2 自定义实现WebMvcConfigurer接口3 实体类4 测试类 1 类型转换说明 前台传参到后台,后台会对参数进行转换,封装成实体类中类型的参数.(常见: 时间字符串2021年4月12日21:56:50转换为Date类型时间) 时间类型转换:https://blog.youkuaiyun.com/ABestRookie/article/details/1076
Spring类型转换器相关接口和实现原理
最新发布
几许的博客
06-08 918
Spring类型转换框架提供了统一机制处理类型转换问题，核心包括三种转换接口：1) Converter处理简单类型转换；2) ConverterFactory通过工厂模式支持同一源类型到多种目标类型的转换；3) GenericConverter处理复杂场景如集合转换。这些组件通过ConversionService统一管理，支持字符串转数字/日期/枚举等常见转换场景，解决了表单提交、配置加载、属性注入等开发中的类型匹配问题。框架采用分层设计，从简单到复杂满足不同转换需求。
1. 揭秘Spring类型转换 - 框架设计的基石
架构师：通透，才能写出好代码！
12-01 1873
你的字符串，有很多话要说
Spring类型转换
wenqi1的博客
10-26 254
假如String类型要转换成Date类型 首先： 新建StringToDataConvert类，泛型第一个参数表示你要转换的类型，第二个参数表示你转换后想得到的类型，由此可以设置成任何的类型转换 public class StringToDataConvert implements Converter<String, Date> { @Override public Date convert(String s) { SimpleDateFormat s
Spring 类型转换
CoderChronicle的博客
12-16 1011
扩展模式扩展类实现实现方法将实现注册为 Spring Bean向注册自定义 PropertyEditor 实现通用类型实现。
第十五章 Spring 类型转换（Type Conversion）1
08-03
Spring 3.0 引入了通用类型转换接口，包括 `Converter` 和 `GenericConverter`，它们提供了更为强大的类型转换功能，不仅限于简单的 String 到其他类型的转换。`Converter` 接口适用于一对一的类型转换，而 `...
Spring类型转换 ConversionSerivce Convertor解析
09-01
本文将深入解析Spring类型转换`ConversionService`和`Convertor`的概念及其用法。 `ConversionService`是Spring提供的核心接口，用于执行各种类型之间的转换操作。它的主要职责是接收一个对象并尝试将其转换为另一...
Spring MVC自定义日期类型转换器实例详解
10-20
Spring MVC框架本身已经提供了基本的类型转换支持，但在实际开发中，我们可能需要根据特定的格式需求来扩展或自定义类型转换器。 在本文中，我们将详细讲解如何在Spring MVC中自定义一个日期类型转换器，以满足特定...
利用 Spring 自动类型转换与回调模式写出优雅的代码
12-22
当我们使用 dubbo 或者 feign 进行 RPC 调用用时，通常的调用模板方式如下： public BizResponse method(BizRequest request){ RpcRequest rpcRequest = buildRpcRequest(); RpcReponse reuslt = xxxFacade.invoke...
Spring数据类型转化
zcx的博客
09-01 1279
Spring内置Converter讲解、自定义Converter
Spring mvc参数类型转换
weixin_30847939的博客
05-18 217
1,需求 有时候我们接收到的参数为String类型的，但是我们需要将它们转化为其他类型的如：date类型，枚举类型等等，spring mvc为我们提供了这样的功能。 2,配置文件 在springmvc.xml配置文件中添加如下代码： <mvc:annotation-driven conversion-service="conversionService...
Spring-类型转换
qq_43259860的博客
08-22 89
这里进行注册时候后名称必须为conversionService。我们会发现，我们写的值会被转换为Properties对象。3 Spring拓展PropertyEditor。5 自定义PropertyEditor拓展。6 PropertyEditor 设计缺陷。4 Spring内建实现。
6.5 Spring3 类型转换
懒人的博客
12-28 1577
Spring3官方文档翻译：6.5 Spring3 类型转换
spring中的类型转换
King
06-13 159
类型转换 spring提供了供在用户自定义的扩展机制 具体步骤: 第一步:编写自己的类 继承自spring的PropertyEditorSupport类[code="java"] public class UtilDatePropertyEditor extends PropertyEditorSupport { private String format = "yyyy-...
spring的类型转换器
xc博客
06-26 378
第十二章 自定义类型转换器 1： 类型转换器 作⽤：Spring通过类型转换器把配置⽂件中字 符串类型的数据，转换成了对象中成员变量对应 类型的数据，进⽽完成了注⼊ 2：自定义类型转换器 原因：当Spring内部没有提供特定类型转换器时，⽽程序员在应⽤的过程中还需要使⽤，那么就需要程序员⾃⼰定义类型转换器 编写自定义类型转换器 实现Converter接口 applicationContext.xml配置文件 ...
Spring(十二)--Spring类型转换
Xjzzon的博客
10-11 1038
Spring类型转换的实现 基于JavaBeans接口的类型转换实现:基于java.beans.PropertyEditor接口扩展 Spring 3.0+通用类型转换实现 使用场景 基于JavaBeans接口的类型转换 核心职责: 将String类型的内容转换为目标类型的对象 扩展原理 1.Spring框架将文本内容传递到PropertyEditor实现的setAsText(String)方法。 2.PropertyEditor#setAsText(String)方法实现将String类型转化为
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值