SpringMVC 之類型轉換Converter詳解轉載

時間  2019-11-12
標籤 springmvc 類型 轉換 converter 詳解 轉載 欄目 Spring 简体版
原文   原文鏈接

SpringMVC之類型轉換Converter詳解java

本文轉載web

http://www.tuicool.com/articles/uUjaumspring

 

 

1.1     目錄

 

1.1      目錄數據庫

 

1.2      前言數組

 

1.3      Converter接口mvc

 

1.4      ConversionService接口ide

 

1.5      ConverterFactory接口ui

 

1.6      GenericConverter接口this

 

1.6.1     概述spa

 

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了。

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程