SpringMVC之類型轉換Converter

(轉載：http://blog.csdn.net/renhui999/article/details/9837897）

1.1     目錄

1.1      目錄

1.2      前言

1.3      Converter接口

1.4      ConversionService接口

1.5      ConverterFactory接口

1.6      GenericConverter接口

1.6.1     概述

1.6.2     ConditionalGenericConverter 接口

 

1.2     前言

       在以往我們需要SpringMVC為我們自動進行類型轉換的時候都是用的PropertyEditor。通過PropertyEditor的setAsText()方法我們可以實現字符串向特定類型的轉換。但是這里有一個限制是它只支持從String類型轉為其他類型。在Spring3中引入了一個Converter接口，它支持從一個Object轉為另一個Object。除了Converter接口之外，實現ConverterFactory接口和GenericConverter接口也可以實現我們自己的類型轉換邏輯。

1.3     Converter接口

       我們先來看一下Converter接口的定義：

Java代碼  

1. public interface Converter<S, T> {  
2.      
3.     T convert(S source);  
4.    
5. }  

 

       我們可以看到這個接口是使用了泛型的，第一個類型表示原類型，第二個類型表示目標類型，然后里面定義了一個convert方法，將原類型對象作為參數傳入進行轉換之后返回目標類型對象。當我們需要建立自己的converter的時候就可以實現該接口。下面假設有這樣一個需求，有一個文章實體，在文章中是可以有附件的，而附件我們需要記錄它的請求地址、大小和文件名，所以這個時候文章應該是包含一個附件列表的。在實現的時候我們的附件是實時上傳的，上傳后由服務端返回對應的附件請求地址、大小和文件名，附件信息不直接存放在數據庫中，而是作為文章的屬性一起存放在MongoDB中。客戶端獲取到這些信息以后做一個簡單的展示，然后把它們封裝成特定格式的字符串作為隱藏域跟隨文章一起提交到服務端。在服務端我們就需要把這些字符串附件信息轉換為對應的List<Attachment>。所以這個時候我們就建立一個String[]到List<Attachment>的Converter。代碼如下：

Java代碼  

1. import java.util.ArrayList;  
2. import java.util.List;  
3.    
4. import org.springframework.core.convert.converter.Converter;  
5.    
6. import com.tiantian.blog.model.Attachment;  
7.    
8. public class StringArrayToAttachmentList implements Converter<String[], List<Attachment>> {  
9.    
10.     @Override  
11.     public List<Attachment> convert(String[] source) {  
12.        if (source == null)  
13.            return null;  
14.        List<Attachment> attachs = new ArrayList<Attachment>(source.length);  
15.        Attachment attach = null;  
16.        for (String attachStr : source) {  
17.            //這里假設我們的Attachment是以“name,requestUrl,size”的形式拼接的。  
18.            String[] attachInfos = attachStr.split(",");  
19.            if (attachInfos.length != 3)//當按逗號分隔的數組長度不為3時就拋一個異常，說明非法操作了。  
20.               throw new RuntimeException();  
21.            String name = attachInfos[0];  
22.            String requestUrl = attachInfos[1];  
23.            int size;  
24.            try {  
25.               size = Integer.parseInt(attachInfos[2]);  
26.            } catch (NumberFormatException e) {  
27.               throw new RuntimeException();//這里也要拋一個異常。  
28.            }  
29.            attach = new Attachment(name, requestUrl, size);  
30.            attachs.add(attach);  
31.        }  
32.        return attachs;  
33.     }  
34.    
35. }  

 

 

1.4     ConversionService接口

       在定義好Converter之后，就是使用Converter了。為了統一調用Converter進行類型轉換，spring為我們提供了一個ConversionService接口。通過實現這個接口我們可以實現自己的Converter調用邏輯。我們先來看一下ConversionService接口的定義：

Java代碼  

1. public interface ConversionService {  
2.    
3.     boolean canConvert(Class<?> sourceType, Class<?> targetType);  
4.    
5.     <T> T convert(Object source, Class<T> targetType);  
6.      
7.     boolean canConvert(TypeDescriptor sourceType, TypeDescriptor targetType);  
8.    
9.     Object convert(Object source, TypeDescriptor sourceType, TypeDescriptor targetType);  
10.    
11. }  

 

       我們可以看到ConversionService接口里面定義了兩個canConvert方法和兩個convert方法，canConvert方法用於判斷當前的ConversionService是否能夠對原類型和目標類型進行轉換，convert方法則是用於進行類型轉換的。上面出現的參數類型TypeDescriptor是對於一種類型的封裝，里面包含該種類型的值、實際類型等等信息。

在定義了ConversionService之后我們就可以把它定義為一個bean對象，然后指定<mvn:annotation-driven/>的conversion-service屬性為我們自己定義的ConversionService bean對象。如：

Xml代碼  

1. <mvc:annotation-driven conversion-service="myConversionService"/>  
2.   
3. <bean id="myConversionService" class="com.tiantian.blog.web.converter.support.MyConversionService"/>  

 

       這樣當SpringMVC需要進行類型轉換的時候就會調用ConversionService的canConvert和convert方法進行類型轉換。

       一般而言我們在實現ConversionService接口的時候也會實現ConverterRegistry接口。使用ConverterRegistry可以使我們對類型轉換器做一個統一的注冊。ConverterRegistry接口的定義如下：

Java代碼  

1. public interface ConverterRegistry {  
2.      
3.     void addConverter(Converter<?, ?> converter);  
4.    
5.     void addConverter(GenericConverter converter);  
6.    
7.     void addConverterFactory(ConverterFactory<?, ?> converterFactory);  
8.    
9.     void removeConvertible(Class<?> sourceType, Class<?> targetType);  
10.    
11. }  

 

       正如前言所說的，要實現自己的類型轉換邏輯我們可以實現Converter接口、ConverterFactory接口和GenericConverter接口，ConverterRegistry接口就分別為這三種類型提供了對應的注冊方法，至於里面的邏輯就可以發揮自己的設計能力進行設計實現了。

       對於ConversionService，Spring已經為我們提供了一個實現，它就是GenericConversionService，位於org.springframework.core.convert.support包下面，它實現了ConversionService接口和ConverterRegistry接口。但是不能直接把它作為SpringMVC的ConversionService，因為直接使用時不能往里面注冊類型轉換器。也就是說不能像下面這樣使用：

Xml代碼  

1. <mvc:annotation-driven conversion-service="conversionService"/>  
2.   
3. <bean id="conversionService" class="org.springframework.core.convert.support.GenericConversionService"/>  

 

       為此我們必須對GenericConversionService做一些封裝，比如說我們可以在自己的ConversionService里面注入一個GenericConversionService，然后通過自己的ConversionService的屬性接收Converter並把它們注入到GenericConversionService中，之后所有關於ConversionService的方法邏輯都可以調用GenericConversionService對應的邏輯。按照這種思想我們的ConversionService大概是這樣的：

Java代碼  

1. package com.tiantian.blog.web.converter.support;  
2.    
3. import java.util.Set;  
4.    
5. import javax.annotation.PostConstruct;  
6.    
7. import org.springframework.beans.factory.annotation.Autowired;  
8. import org.springframework.core.convert.ConversionService;  
9. import org.springframework.core.convert.TypeDescriptor;  
10. import org.springframework.core.convert.converter.Converter;  
11. import org.springframework.core.convert.converter.ConverterFactory;  
12. import org.springframework.core.convert.converter.GenericConverter;  
13. import org.springframework.core.convert.support.GenericConversionService;  
14.    
15. public class MyConversionService implements ConversionService {  
16.    
17.     @Autowired  
18.     private GenericConversionService conversionService;  
19.     private Set<?> converters;  
20.      
21.     @PostConstruct  
22.     public void afterPropertiesSet() {  
23.        if (converters != null) {  
24.            for (Object converter : converters) {  
25.               if (converter instanceof Converter<?, ?>) {  
26.                   conversionService.addConverter((Converter<?, ?>)converter);  
27.               } else if (converter instanceof ConverterFactory<?, ?>) {  
28.                   conversionService.addConverterFactory((ConverterFactory<?, ?>)converter);  
29.               } else if (converter instanceof GenericConverter) {  
30.                   conversionService.addConverter((GenericConverter)converter);  
31.               }  
32.            }  
33.        }  
34.     }  
35.      
36.     @Override  
37.     public boolean canConvert(Class<?> sourceType, Class<?> targetType) {  
38.        return conversionService.canConvert(sourceType, targetType);  
39.     }  
40.    
41.     @Override  
42.     public boolean canConvert(TypeDescriptor sourceType,  
43.            TypeDescriptor targetType) {  
44.        return conversionService.canConvert(sourceType, targetType);  
45.     }  
46.    
47.     @Override  
48.     public <T> T convert(Object source, Class<T> targetType) {  
49.        return conversionService.convert(source, targetType);  
50.     }  
51.    
52.     @Override  
53.     public Object convert(Object source, TypeDescriptor sourceType,  
54.            TypeDescriptor targetType) {  
55.        return conversionService.convert(source, sourceType, targetType);  
56.     }  
57.    
58.     public Set<?> getConverters() {  
59.        return converters;  
60.     }  
61.    
62.     public void setConverters(Set<?> converters) {  
63.        this.converters = converters;  
64.     }  
65.    
66. }  

 

       在上面代碼中，通過converters屬性我們可以接收需要注冊的Converter、ConverterFactory和GenericConverter，在converters屬性設置完成之后afterPropertiesSet方法會被調用，在這個方法里面我們把接收到的converters都注冊到注入的GenericConversionService中了，之后關於ConversionService的其他操作都是通過這個GenericConversionService來完成的。這個時候我們的SpringMVC文件可以這樣配置：

Xml代碼  

1. <mvc:annotation-driven conversion-service="conversionService"/>  
2.   
3. <bean id="genericConversionService" class="org.springframework.core.convert.support.GenericConversionService"/>  
4.   
5. <bean id="conversionService" class="com.tiantian.blog.web.converter.support.MyConversionService">  
6.    <property name="converters">  
7.        <set>  
8.           <bean class="com.tiantian.blog.web.converter.StringArrayToAttachmentList"/>  
9.        </set>  
10.    </property>  
11. </bean>  

 

       除了以上這種使用GenericConversionService的思想之外，Spring已經為我們提供了一個既可以使用GenericConversionService，又可以注入Converter的類，那就是ConversionServiceFactoryBean。該類為我們提供了一個可以接收Converter的converters屬性，在它的內部有一個GenericConversionService對象的引用，在對象初始化完成之后它會new一個GenericConversionService對象，並往GenericConversionService中注冊converters屬性指定的Converter和Spring自身已經實現了的默認Converter，之后每次返回的都是這個GenericConversionService對象。當使用ConversionServiceFactoryBean的時候我們的SpringMVC文件可以這樣配置：

Xml代碼  

1.    <mvc:annotation-driven conversion-service="conversionService"/>  
2. <bean id="conversionService"  
3.   class="org.springframework.context.support.ConversionServiceFactoryBean">  
4.     <property name="converters">  
5.         <list>  
6.             <bean class="com.tiantian.blog.web.converter.StringArrayToAttachmentList"/>  
7.         </list>  
8.     </property>  
9. </bean>  

 

 

       除了ConversionServiceFactoryBean之外，Spring還為我們提供了一個FormattingConversionServiceFactoryBean。當使用FormattingConversionServiceFactoryBean的時候我們的SpringMVC配置文件的定義應該是這樣：

Xml代碼  

1.     <mvc:annotation-driven conversion-service="conversionService"/>  
2.    
3.     <bean id="conversionService"  
4.           class="org.springframework.format.support.FormattingConversionServiceFactoryBean">  
5.           <property name="converters">  
6.              <set>  
7.                  <bean class="com.tiantian.blog.web.converter.StringArrayToAttachmentList"/>  
8.              </set>  
9.           </property>  
10. </bean>  

 

       以上介紹的是SpringMVC自動進行類型轉換時需要我們做的操作。如果我們需要在程序里面手動的來進行類型轉換的話，我們也可以往我們的程序里面注入一個ConversionService，然后通過ConversionService來進行相應的類型轉換操作，也可以把Converter直接注入到我們的程序中。

1.5     ConverterFactory接口

       ConverterFactory的出現可以讓我們統一管理一些相關聯的Converter。顧名思義，ConverterFactory就是產生Converter的一個工廠，確實ConverterFactory就是用來產生Converter的。我們先來看一下ConverterFactory接口的定義：

Java代碼  

1. public interface ConverterFactory<S, R> {  
2.      
3.     <T extends R> Converter<S, T> getConverter(Class<T> targetType);  
4.    
5. }  

 

       我們可以看到ConverterFactory接口里面就定義了一個產生Converter的getConverter方法，參數是目標類型的class。我們可以看到ConverterFactory中一共用到了三個泛型，S、R、T，其中S表示原類型，R表示目標類型，T是類型R的一個子類。

考慮這樣一種情況，我們有一個表示用戶狀態的枚舉類型UserStatus，如果要定義一個從String轉為UserStatus的Converter，根據之前Converter接口的說明，我們的StringToUserStatus大概是這個樣子：

Java代碼  

1. public class StringToUserStatus implements Converter<String, UserStatus> {  
2.   
3.    @Override  
4.    public UserStatus convert(String source) {  
5.        if (source == null) {  
6.           return null;  
7.        }  
8.        return UserStatus.valueOf(source);  
9.    }  
10.     
11. }  

 

       如果這個時候有另外一個枚舉類型UserType，那么我們就需要定義另外一個從String轉為UserType的Converter——StringToUserType，那么我們的StringToUserType大概是這個樣子：

Java代碼  

1. public class StringToUserType implements Converter<String, UserType> {  
2.   
3.    @Override  
4.    public UserType convert(String source) {  
5.        if (source == null) {  
6.           return null;  
7.        }  
8.        return UserType.valueOf(source);  
9.    }  
10.     
11. }  

 

       如果還有其他枚舉類型需要定義原類型為String的Converter的時候，我們還得像上面那樣定義對應的Converter。有了ConverterFactory之后，這一切都變得非常簡單，因為UserStatus、UserType等其他枚舉類型同屬於枚舉，所以這個時候我們就可以統一定義一個從String到Enum的ConverterFactory，然后從中獲取對應的Converter進行convert操作。Spring官方已經為我們實現了這么一個StringToEnumConverterFactory：

Java代碼  

1. @SuppressWarnings("unchecked")  
2. final class StringToEnumConverterFactory implements ConverterFactory<String, Enum> {  
3.    
4.     public <T extends Enum> Converter<String, T> getConverter(Class<T> targetType) {  
5.        return new StringToEnum(targetType);  
6.     }  
7.    
8.     private class StringToEnum<T extends Enum> implements Converter<String, T> {  
9.    
10.        private final Class<T> enumType;  
11.    
12.        public StringToEnum(Class<T> enumType) {  
13.            this.enumType = enumType;  
14.        }  
15.    
16.        public T convert(String source) {  
17.            if (source.length() == 0) {  
18.               // It's an empty enum identifier: reset the enum value to null.  
19.               return null;  
20.            }  
21.            return (T) Enum.valueOf(this.enumType, source.trim());  
22.        }  
23.     }  
24.    
25. }  

 

       這樣，如果是要進行String到UserStatus的轉換，我們就可以通過StringToEnumConverterFactory實例的getConverter(UserStatus.class).convert(string)獲取到對應的UserStatus，如果是要轉換為UserType的話就是getConverter(UserType.class).convert(string)。這樣就非常方便，可以很好的支持擴展。

       對於ConverterFactory我們也可以把它當做ConvertionServiceFactoryBean的converters屬性進行注冊，在ConvertionServiceFactoryBean內部進行Converter注入的時候會根據converters屬性具體元素的具體類型進行不同的注冊，對於FormattingConversionServiceFactoryBean也是同樣的方式進行注冊。所以如果我們自己定義了一個StringToEnumConverterFactory，我們可以這樣來進行注冊：

Xml代碼  

1. <bean id="conversionService"  
2.   class="org.springframework.context.support.ConversionServiceFactoryBean">  
3.     <property name="converters">  
4.         <list>  
5.             <bean class="com.tiantian.blog.web.converter.StringArrayToAttachmentList"/>  
6.             <bean class="com.tiantian.blog.web.converter.StringToEnumConverterFactory"/>  
7.         </list>  
8.     </property>  
9. </bean>  

 

1.6     GenericConverter接口

1.6.1概述

GenericConverter接口是所有的Converter接口中最靈活也是最復雜的一個類型轉換接口。像我們之前介紹的Converter接口只支持從一個原類型轉換為一個目標類型；ConverterFactory接口只支持從一個原類型轉換為一個目標類型對應的子類型；而GenericConverter接口支持在多個不同的原類型和目標類型之間進行轉換，這也就是GenericConverter接口靈活和復雜的地方。

       我們先來看一下GenericConverter接口的定義：

Java代碼  

1. public interface GenericConverter {  
2.      
3.     Set<ConvertiblePair> getConvertibleTypes();  
4.    
5.     Object convert(Object source, TypeDescriptor sourceType, TypeDescriptor targetType);  
6.    
7.     public static final class ConvertiblePair {  
8.    
9.        private final Class<?> sourceType;  
10.    
11.        private final Class<?> targetType;  
12.    
13.        public ConvertiblePair(Class<?> sourceType, Class<?> targetType) {  
14.            Assert.notNull(sourceType, "Source type must not be null");  
15.            Assert.notNull(targetType, "Target type must not be null");  
16.            this.sourceType = sourceType;  
17.            this.targetType = targetType;  
18.        }  
19.    
20.        public Class<?> getSourceType() {  
21.            return this.sourceType;  
22.        }  
23.    
24.        public Class<?> getTargetType() {  
25.            return this.targetType;  
26.        }  
27.     }  
28.    
29. }  

 

      我們可以看到GenericConverter接口中一共定義了兩個方法，getConvertibleTypes()和convert(Object source, TypeDescriptor sourceType, TypeDescriptor targetType)。getConvertibleTypes方法用於返回這個GenericConverter能夠轉換的原類型和目標類型的這么一個組合；convert方法則是用於進行類型轉換的，我們可以在這個方法里面實現我們自己的轉換邏輯。之所以說GenericConverter是最復雜的是因為它的轉換方法convert的參數類型TypeDescriptor是比較復雜的。TypeDescriptor對類型Type進行了一些封裝，包括value、Field及其對應的真實類型等等，具體的可以查看API。

       關於GenericConverter的使用，這里也舉一個例子。假設我們有一項需求是希望能通過user的id或者username直接轉換為對應的user對象，那么我們就可以針對於id和username來建立一個GenericConverter。這里假設id是int型，而username是String型的，所以我們的GenericConverter可以這樣來寫：

Java代碼  

1. public class UserGenericConverter implements GenericConverter {  
2.    
3.     @Autowired  
4.     private UserService userService;  
5.      
6.     @Override  
7.     public Object convert(Object source, TypeDescriptor sourceType,  
8.            TypeDescriptor targetType) {  
9.        if (source == null || sourceType == TypeDescriptor.NULL || targetType == TypeDescriptor.NULL) {  
10.            return null;  
11.        }  
12.        User user = null;  
13.        if (sourceType.getType() == Integer.class) {  
14.            user = userService.findById((Integer) source);//根據id來查找user  
15.        } else if (sourceType.getType() == String.class) {  
16.            user = userService.find((String)source);//根據用戶名來查找user  
17.        }  
18.        return user;  
19.     }  
20.    
21.     @Override  
22.     public Set<ConvertiblePair> getConvertibleTypes() {  
23.        Set<ConvertiblePair> pairs = new HashSet<ConvertiblePair>();  
24.        pairs.add(new ConvertiblePair(Integer.class, User.class));  
25.        pairs.add(new ConvertiblePair(String.class, User.class));  
26.        return pairs;  
27.     }  
28.    
29. }  

 

       我們可以看到在上面定義的UserGenericConverter中，我們在getConvertibleTypes方法中添加了兩組轉換的組合，Integer到User和String到User。然后我們給UserGenericConverter注入了一個UserService，在convert方法

中我們簡單的根據原類型是Integer還是String來判斷傳遞的原數據是id還是username，並利用UserService對應的方法返回相應的User對象。

       GenericConverter接口實現類的注冊方法跟Converter接口和ConverterFactory接口實現類的注冊方法是一樣的，這里就不再贅述了。

       雖然Converter接口、ConverterFactory接口和GenericConverter接口之間沒有任何的關系，但是Spring內部在注冊Converter實現類和ConverterFactory實現類時是先把它們轉換為GenericConverter，之后再統一對GenericConverter進行注冊的。也就是說Spring內部會把Converter和ConverterFactory全部轉換為GenericConverter進行注冊，在Spring注冊的容器中只存在GenericConverter這一種類型轉換器。我想之所以給用戶開放Converter接口和ConverterFactory接口是為了讓我們能夠更方便的實現自己的類型轉換器。基於此，Spring官方也提倡我們在進行一些簡單類型轉換器定義時更多的使用Converter接口和ConverterFactory接口，在非必要的情況下少使用GenericConverter接口。

1.6.2ConditionalGenericConverter 接口

       對於GenericConverter接口Spring還為我們提供了一個它的子接口，叫做ConditionalGenericConverter，在這個接口中只定義了一個方法：matches方法。我們一起來看一下ConditionalGenericConverter接口的定義：

Java代碼  

1. public interface ConditionalGenericConverter extends GenericConverter {  
2.    
3.     boolean matches(TypeDescriptor sourceType, TypeDescriptor targetType);  
4.      
5. }  

 

       顧名思義，從Conditional我們就可以看出來這個接口是用於定義有條件的類型轉換器的，也就是說不是簡單的滿足類型匹配就可以使用該類型轉換器進行類型轉換了，必須要滿足某種條件才能使用該類型轉換器。而該類型轉換器的條件控制就是通過ConditionalGenericConverter接口的matches方法來實現的。關於ConditionalGenericConverter的使用Spring內部已經實現了很多，這里我們來看一個Spring已經實現了的將String以逗號分割轉換為目標類型數組的實現：

Java代碼  

1. final class StringToArrayConverter implements ConditionalGenericConverter {  
2.    
3.     private final ConversionService conversionService;  
4.    
5.     public StringToArrayConverter(ConversionService conversionService) {  
6.        this.conversionService = conversionService;  
7.     }  
8.    
9.     public Set<ConvertiblePair> getConvertibleTypes() {  
10.        return Collections.singleton(new ConvertiblePair(String.class, Object[].class));  
11.     }  
12.    
13.     public boolean matches(TypeDescriptor sourceType, TypeDescriptor targetType) {  
14.        return this.conversionService.canConvert(sourceType, targetType.getElementTypeDescriptor());  
15.     }  
16.    
17.     public Object convert(Object source, TypeDescriptor sourceType, TypeDescriptor targetType) {  
18.        if (source == null) {  
19.            return null;  
20.        }       
21.        String string = (String) source;  
22.        String[] fields = StringUtils.commaDelimitedListToStringArray(string);  
23.        Object target = Array.newInstance(targetType.getElementType(), fields.length);  
24.        for (int i = 0; i < fields.length; i++) {  
25.            Object sourceElement = fields[i];  
26.            Object targetElement = this.conversionService.convert(sourceElement, sourceType, targetType.getElementTypeDescriptor());  
27.            Array.set(target, i, targetElement);  
28.        }  
29.        return target;  
30.     }  
31.    
32. }  

 

       我們可以看到這個StringToArrayConverter就是實現了ConditionalGenericConverter接口的。根據里面的matches方法的邏輯我們知道當我們要把一個字符串轉換為一個數組的時候，只有我們已經定義了一個字符串到這個目標數組元素對應類型的類型轉換器時才可以使用StringToArrayConverter進行類型轉換。也就是說假如我們已經定義了一個String到User的類型轉換器，那么當我們需要將String轉換為對應的User數組的時候，我們就可以直接使用Spring為我們提供的StringToArrayConverter了。