关于Spring MVC中自定义类型转换器的方式

本文介绍如何在SpringMVC中实现自定义数据转换器,包括Converter接口、PropertyEditor编辑器及WebBindingInitializer的使用,确保不同类型数据的正确转换。

关于Spring mvc ,我觉得他是一个特别人性化的框架,它的内部实现,帮我们省去了很多麻烦

例如,在我们在前端页面输入数据的时候,后台接受数据的时候,如果事先写好一个类,且后台接收到响应参数为该类型时,那么他就会自动匹配类的属性,并将值注入,那么后台接受到的参数就是一个已经注入好参数的实例;

这是一个User类,包含以下属性

import java.io.Serializable;

public class User implements Serializable {
	private String id;
	private String userName;
	private String password;

	public User() {
	}
     //省略get和set方法
}

前段jsp页面如下:

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>注册页面</title>
</head>
<body>
  <h3>注册页面</h3>
  ${message}
  <form action="register " method="post">
    <table>
      <tr>
      		<td><label>用户名:</label></td>
      		<td><input type ="text" id ="id" name="id"></td>
      </tr>
      <tr>
      		<td><label>密码:</label></td>
      		<td><input type ="password" id ="password" name="password"></td>
      </tr>
       <tr>
      		<td><label>真实姓名:</label></td>
      		<td><input type ="text" id ="userName" name="userName"></td>
      </tr>
       <tr>
      		<td><input type ="submit" id ="submit" value ="注册"></td>
      </tr>
    </table>
  </form>
</body>
</html>

后台接受到前端的请求时;

@RequestMapping("/login")
	public String userLogin(User user){
		System.out.println(user);   //输出即时前段输入的完整信息
		//.....
		return "success";
	}

Spring mvc将数据依照匹配注入,非常的人性化但是,在默认情况下,他只能将请求参数(字符串类型)转换为一部分类型。对于某些特殊类型则无法转换成功。

如果现在User类中新添加一个属性

private Date birthday;属性,那么在前段提交数据的时候,Springmvc 没办法将字符串类型的(1997-4-2)转换为Date类型的数据,那么我们就需要自己自定义数据转换器;

Spring 支持的数据转换器

Spring提供了3种类型的数据转换器接口,我们可以实现任意一种转换器接口,并将它作为自定义转换器注册到ConversionServiceFactoryBean当中。

一,Converser<S,T>接口是Spring中最简单的一个转换器,该接口只有一个方法

T convert(S source)   该方法负责将S类型的对象转换为T类型的对象。

二,ConverterFactory<S,R> 如果希望将一种类型的对象转换为另一种类型及其子类的对象,比如将String转换为Number以及Number的子类Integer,Doublele类型的对象,就需要一系列的connverter了,如StringToInteger,StringToDouble等,ConverterFactory<S,R>接口的作用就是将相同系列的converter封装在一起,该接口也只有一个方法:

<T extends R> Converter<S,T> GetConverter(Class<T> targetType)

S为源类型,R为目标类型的基类,T为R的子类

三,GenericConverter .Converter<S,T>接口只是负责讲一个类型对象转换为另一个类型对象,他并没有考虑对象上下文信息,因此不能完成复杂类型转换的工作。GenericConverter接口会根据源类对象及目标类对象的上下文信息进行类型转换

1.实现Converter接口进行类型转换。

在上述问题中,当前端输入一个字符串表示用户的生日信息的时候,spring不能帮我们转换数据格式,那么我们需要自定义一个转换器,自定义一个类 实现Converter<S,T>接口

public class StringToDateConverter implements Converter<String, Date>{
	/*
	 * 这是配置转换器可以转换的格式,例如 yyyy年MM月dd日,  yyyy-MM-dd
	 */
    private String datePattern;
    
    public StringToDateConverter() {
	}
	
	public void setDatePattern(String datePattern) {
		this.datePattern = datePattern;
	}
  
	@Override
	public Date convert(String date) {
		
		try {
			SimpleDateFormat dateFormat = new SimpleDateFormat(this.datePattern);
			return dateFormat.parse(date);//根据格式转换
		} catch (ParseException e) {
			e.printStackTrace();
			System.out.println("转换失败");
			return null;
		}
	}

}

定义好了这和转换器之后,将他注册到CinversionServiceFactoryBean的converters属性,那么当前端输入数据之后,spring在进行参数的时候使用我们自定义的数据转换器进行数据的转换,参数的注入


在applicationContext.xml文件中(也就是配置Spring上下文的文件中注册

<bean id = "conversionService"
     class = "org.springframework.context.support.ConversionServiceFactoryBean">
     		<property name="converters">  
     			<list>
     			  <bean class = "com.lzy.model.StringToDateConverter">
     			  		<property name="datePattern" value="yyyy年MM月dd日"></property>    <!-- 配置bean 以及bean的参数入参格式-->  
     			  </bean>
                        <!-- 这里可以配置多个格式的转换器 -->
                         </list>
     		</property>
     </bean>

  <mvc:annotation-driven  conversion-service = "conversionService"/> 

注册成功之后,再次尝试前端输入(生日类型的值时),后才接收的时候,可以正常解析参数转换成功。

2.使用@InitBinder添加自定义编辑器转换数据

Springmvc在支持新的转换器框架的时候,也支持JavaBeans的PropertyEditor(但是他只支持字符串到Java对象的转换)。可以在控制器使用@InitBinder添加自定义的编辑器,在控制器中注册编辑器,在该控制器中就可以使用该类型转换。不用在applicationContext.xml中注册。

自定义编辑器需要继承自PropertyEditorSupport,重写其setAsText方法,代码如下

public class DateEditor extends PropertyEditorSupport{
    
	@Override
	public void setAsText(String text) throws IllegalArgumentException {
		SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy年MM月dd日");
		try {
			Date date = dateFormat.parse(text);
			setValue(date);
		} catch (ParseException e) {
			e.printStackTrace();
		}
	}
}
自定义好编辑器后,在控制器中注册之后,就可以实现类型的转换了。
	@InitBinder
	public void initBinder(WebDataBinder binder){  //WebDateBinder用于处理请求消息和处理方法的绑定工作
		binder.registerCustomEditor(Date.class, new DateEditor());//将传入的Date类型使用DateEditor类进行转换
	}

注册好了之后,测试,成功

三,使用WebBindingInitilizer注册全局自定义编辑器转换数据

希望在全局范围内使用自定义的编辑器,则可以通过实现WebBindingInitilizer接口并在该实现类中注册自定义编辑器来完成

public class DateBindingInitializer implements WebBindingInitializer{

	@Override
	public void initBinder(WebDataBinder binder, WebRequest request) {
		binder.registerCustomEditor(Date.class, new DateEditor());   //注册自定义的编辑器,将传入的Date类型的参数用DateEditor类型进行转换
	}

}
注册完毕之后,在控制器中,不使用@InitBinder注解的方法,而是在applicationCintext.xml文件中去配置全局的自定义编辑器。
    <bean class ="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter">
       <property name="webBindingInitializer">
         <bean class="com.lzy.model.DateBindingInitializer"></bean>
       </property>
    </bean>

<mvc:annotation-driven  /> 

这里需要注意一点,<mvc:annotation-driven  /> 的配置应该放在全局变量的编辑器配置之后,否则会出错误。

配置完成后测试,正确。

多种转换器的优先顺序

    对于同一个类型的对象来说,如果即在ConversionService中配置了自定义的类型转换器,又通过WebInitilizer接口配置了全局的自定义编辑器,同时还在控制器中使用@InitBinder注解装配了自定义的编辑器,此时spingmvc将按照优先顺序查找对应的转换器:

        1,查询通过@InitBinder装配的自定义编辑器

        2,查询通过ConversionService装配的自定义转换器

        3,查询通过WebBindingInitilizer接口配置的全局自定义编辑器





<think>我们正在讨论如何在Spring框架中创建并注册自定义类型转换器到ConversionService。根据用户的问题和之前的引用,我们可以总结如下: 用户之前遇到了自定义转换器实例化失败的问题,现在希望了解如何正确创建和注册自定义类型转换器。引用[1]提供了关于ConversionService的基本信息:它是一个无状态对象,在应用程序启动时实例化,并在整个容器中共享。如果没有注册自定义的ConversionService,Spring会使用基于PropertyEditor的旧系统。 引用[2]虽然讲的是自定义消息转换器(用于HTTP消息转换),但注册方式类似,都是通过声明一个Bean来加入Spring容器。引用[3]提到@Required注解已被弃用,推荐使用构造函数注入,这提示我们在自定义转换器时,如果需要依赖其他Bean,应使用构造函数注入。 现在,我们将详细说明创建和注册自定义类型转换器的步骤: ### 步骤1:创建自定义转换器自定义转换器需要实现Spring的`Converter`接口(通常使用`Converter<S, T>`),其中S是源类型,T是目标类型。 例如,假设我们需要将字符串转换自定义的`Money`对象: ```java package com.example.converter; import org.springframework.core.convert.converter.Converter; public class StringToMoneyConverter implements Converter<String, Money> { @Override public Money convert(String source) { // 解析字符串,例如"100.00 USD" -> Money对象 String[] parts = source.split(" "); double amount = Double.parseDouble(parts[0]); String currency = parts[1]; return new Money(amount, currency); } } ``` 注意:转换器类应该是线程安全的,避免使用可变状态。 ### 步骤2:注册自定义转换器到ConversionService #### 方式1:使用Java配置(推荐) 在配置类中,定义一个`ConversionServiceFactoryBean`的Bean,并将自定义转换器添加到其转换器集合中。 ```java import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; import org.springframework.core.convert.ConversionService; import org.springframework.format.support.FormattingConversionServiceFactoryBean; import java.util.Set; @Configuration public class AppConfig { @Bean public ConversionService conversionService() { FormattingConversionServiceFactoryBean factory = new FormattingConversionServiceFactoryBean(); // 添加自定义转换器 factory.setConverters(getConverters()); // 初始化 factory.afterPropertiesSet(); return factory.getObject(); } private Set<?> getConverters() { return Set.of(new StringToMoneyConverter()); } } ``` #### 方式2:使用XML配置 在Spring XML配置文件中,声明`ConversionServiceFactoryBean`并添加自定义转换器: ```xml <bean id="conversionService" class="org.springframework.format.support.FormattingConversionServiceFactoryBean"> <property name="converters"> <set> <bean class="com.example.converter.StringToMoneyConverter"/> </set> </property> </bean> ``` ### 步骤3:使用自定义转换器 一旦注册,Spring框架在执行类型转换时会自动使用这个转换器。例如,在控制器中,当接收一个字符串参数并需要转换为`Money`对象时: ```java @RestController public class PaymentController { @GetMapping("/pay") public String processPayment(@RequestParam("amount") Money money) { // 由于注册了StringToMoneyConverter,Spring自动字符串参数转换为Money对象 return "Payment processed: " + money; } } ``` ### 注意事项 1. **转换器依赖注入**:如果转换器需要依赖其他Bean(如服务类),可以通过构造函数注入: ```java public class StringToMoneyConverter implements Converter<String, Money> { private final CurrencyService currencyService; // 使用构造函数注入 public StringToMoneyConverter(CurrencyService currencyService) { this.currencyService = currencyService; } @Override public Money convert(String source) { // 使用currencyService进行转换 } } ``` 然后在配置中,将转换器声明为一个Bean,并注入依赖: ```java @Bean public StringToMoneyConverter stringToMoneyConverter(CurrencyService currencyService) { return new StringToMoneyConverter(currencyService); } // 然后在conversionService中引用这个Bean @Bean public ConversionService conversionService(StringToMoneyConverter stringToMoneyConverter) { FormattingConversionServiceFactoryBean factory = new FormattingConversionServiceFactoryBean(); factory.setConverters(Set.of(stringToMoneyConverter)); factory.afterPropertiesSet(); return factory.getObject(); } ``` 2. **多个转换器**:可以同时注册多个转换器Spring会按需使用最匹配的转换器。 3. **Spring Boot自动配置**:在Spring Boot中,默认已经创建了一个`ConversionService`,你只需要通过`@Bean`提供自定义转换器Spring Boot会自动将它们添加默认的`ConversionService`中。但是,如果使用`FormattingConversionService`,则需要像上面一样显式配置。 ### 总结 创建自定义类型转换器需要: 1. 实现`Converter<S, T>`接口。 2. 通过配置类或XML将转换器注册到`ConversionService`。 3. 确保`ConversionService`的Bean被Spring容器管理。 这样,Spring在需要类型转换时就会自动使用你的转换器。 §§相关问题§§ 1. Spring Boot中如何自动注册自定义类型转换器? 2. 如何为自定义转换器编写单元测试? 3. Spring MVC中类型转换和格式化有什么区别? [^1]: ConversionService是一个无状态对象,旨在在应用程序启动时实例化,然后在多个线程之间共享。 [^2]: 自定义消息转化器,只需要在@Configuration的类中添加消息转化器的@bean加入到Spring容器,就会被Spring Boot自动加入到容器中。 [^3]: 从Spring Framework 5.1开始,@Required注释被正式弃用,支持为所需的设置使用构造函数注入。</think>### 如何在 Spring 中创建并注册自定义类型转换器到 ConversionService 以下是创建和注册自定义类型转换器的完整步骤,基于 Spring 框架的最佳实践: #### 1. 创建自定义转换器类 实现 `Converter<S, T>` 接口,定义类型转换逻辑: ```java import org.springframework.core.convert.converter.Converter; public class TranslationConvert implements Converter<String, CustomObject> { // 可选:注入依赖服务 private final DictionaryService dictionaryService; // 推荐使用构造函数注入 public TranslationConvert(DictionaryService dictionaryService) { this.dictionaryService = dictionaryService; } @Override public CustomObject convert(String source) { // 实现转换逻辑,例如: String translated = dictionaryService.translate(source); return new CustomObject(translated); } } ``` **关键点**: - 必须实现 `Converter<S, T>` 接口 - 建议提供无参构造函数或显式依赖注入 - 确保线程安全性(无共享可变状态) #### 2. 注册转换器到 ConversionService ##### 方式 1:Java 配置(推荐) ```java import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; import org.springframework.format.support.FormattingConversionServiceFactoryBean; @Configuration public class AppConfig { @Bean public FormattingConversionServiceFactoryBean conversionService( TranslationConvert translationConvert) { FormattingConversionServiceFactoryBean factory = new FormattingConversionServiceFactoryBean(); factory.setConverters(Set.of(translationConvert)); return factory; } @Bean public TranslationConvert translationConvert(DictionaryService dictionaryService) { return new TranslationConvert(dictionaryService); } } ``` ##### 方式 2:XML 配置 ```xml <bean id="conversionService" class="org.springframework.format.support.FormattingConversionServiceFactoryBean"> <property name="converters"> <set> <bean class="com.example.TranslationConvert"> <constructor-arg ref="dictionaryService"/> </bean> </set> </property> </bean> ``` #### 3. 在应用中使用转换器 Spring自动在需要类型转换的场景使用注册的转换器: ```java // 在控制器中自动转换请求参数 @GetMapping("/translate") public ResponseEntity<?> handleRequest(@RequestParam("input") CustomObject obj) { // obj 已通过 TranslationConvert 自动转换 return ResponseEntity.ok(obj); } // 手动使用 ConversionService @Service public class TranslationService { private final ConversionService conversionService; public TranslationService(ConversionService conversionService) { this.conversionService = conversionService; } public CustomObject manualConvert(String input) { return conversionService.convert(input, CustomObject.class); } } ``` #### 关键注意事项 1. **依赖注入**:如果转换器需要其他 Bean,使用构造函数注入(推荐)或 setter 注入 2. **Bean 命名**:ConversionService 的 Bean ID 必须是 `conversionService` 3. **初始化顺序**:确保依赖 Bean 在转换器之前初始化 4. **作用范围**:转换器应设计为无状态线程安全对象 5. **Spring Boot 简化**:在 Boot 应用中只需声明 `@Bean`,Boot 会自动注册到默认 ConversionService #### 调试技巧 如果遇到实例化问题: ```properties # application.properties logging.level.org.springframework.beans=DEBUG logging.level.org.springframework.core.convert=TRACE ``` 这会显示转换器注册和使用的详细日志,帮助定位问题[^1]。
评论 2
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值