Útmutató a tavaszi konverziókhoz

1. Bemutatkozás

Ebben a cikkben a Spring típusú konverziókat vesszük szemügyre.

A Spring dobozon kívül különféle átalakítókat biztosít beépített típusokhoz; ez azt jelenti, hogy áttérünk alaptípusokra, mint például Karakterlánc, egész szám, logikai érték és számos más típus.

Ettől eltekintve a Spring egy szilárd típusú konverziós SPI-t is kínál egyedi átalakítóink fejlesztéséhez.

2. Beépített Átalakítós

Kezdjük az átalakítókkal, amelyek tavasszal kaphatók a dobozból; vessünk egy pillantást a Húr nak nek Egész szám átalakítás:

@Autowired ConversionService conversionService; @Test public void whenConvertStringToIntegerUsingDefaultConverter_thenSuccess () {assertThat (conversionService.convert ("25", Integer.class)). IsEqualTo (25); }

Az egyetlen dolog, amit itt kell tennünk, az a ConversionService nyújtotta Spring és hívja a alakítani() módszer. Az első argumentum az az érték, amelyet konvertálni akarunk, a második argumentum pedig a céltípus, amelyre konvertálni akarunk.

Ettől függetlenül Húr nak nek Egész szám Például sok más kombináció áll rendelkezésünkre.

3. Egyéni létrehozása Átalakító

Nézzünk meg egy példát az a konvertálására Húr egy Munkavállaló egy Munkavállaló példa.

Itt van a Munkavállaló osztály:

public class Alkalmazott {private long id; magán kettős fizetés; // szabványos kivitelezők, szerelők, beállítók}

A Húr vesszővel elválasztott pár lesz id és fizetés. Például: „1.50000.00”.

A szokásunk megalkotása érdekében Átalakító, végre kell hajtanunk a Átalakító interfész és implementálja a alakítani() módszer:

public class StringToEmployeeConverter implementálja a Converter {@Override public Employee convert (String from) {String [] data = from.split (","); return new Employee (Long.parseLong (adatok [0]), Double.parseDouble (adatok [1])); }}

Még nem fejeztük be. Azt is el kell mondanunk Springnek erről az új átalakítóról a StringToEmployeeConverter hoz FormatterRegistry. Ez a WebMvcConfigurer és felülbíráló addFormatters () módszer:

@Configuration public class A WebConfig végrehajtja a WebMvcConfigurer {@Override public void addFormatters (FormatterRegistry registry) {register.addConverter (új StringToEmployeeConverter ()); }}

És ez az. A mi új Átalakító már elérhető a ConversionService és ugyanúgy használhatjuk, mint bármely más beépítettet Átalakító:

@Test public void whenConvertStringToEmployee_thenSuccess () {Employee worker = conversionService .convert ("1,50000,00", Employee.class); Employee actualEmployee = új alkalmazott (1, 50000.00); assertThat (conversionService.convert ("1,50000.00", Employee.class)) .isEqualToComparingFieldByField (ténylegesEmployee); }

3.1. Implicit konverzió

Ezen kifejezett átalakításon túl a ConversionService, A tavasz az értékek implicit konvertálására is képes Vezérlő mód minden regisztrált átalakító számára:

@RestController public class StringToEmployeeConverterController {@GetMapping ("/ string-to-worker") public ResponseEntity getStringToEmployee (@RequestParam ("worker") Employee alkalmazott) {return ResponseEntity.ok (alkalmazott); }}

Ez természetesebb módja a Átalakítós. Tegyünk hozzá egy tesztet, hogy lássuk működés közben:

A @Test public void getStringToEmployeeTest () kiveti a {mockMvc.perform (get ("/ string-to-worker? Worker = 1.2000")) .andDo (print ()) .andExpect (jsonPath ("$. Id", is (1))) .andExpect (jsonPath ("$. fizetés", az (2000.0)))}

Mint látható, a teszt kinyomtatja a kérés minden részletét, valamint a választ. Itt van Munkavállaló objektum JSON formátumban, amelyet a válasz részeként adnak vissza:

{"id": 1, "fizetés": 2000.0}

4. A. Létrehozása ConverterFactory

Lehetőség van a ConverterFactory hogy létrehoz Átalakítós igény szerint. Ez különösen hasznos az alkotásban Átalakítós for Enums.

Vessünk egy pillantást egy igazán egyszerű Enumra:

nyilvános enum módok {ALPHA, BETA; }

Ezután hozzunk létre egy StringToEnumConverterFactory hogy generálhat Átalakítós a konvertálásához Húr bármelyikre Enum:

@Component public class StringToEnumConverterFactory implementálja a ConverterFactory {privát statikus osztályt a StringToEnumConverter a Converter {private Class enumType; public StringToEnumConverter (Class enumType) {this.enumType = enumType; } public T convert (String source) {return (T) Enum.valueOf (this.enumType, source.trim ()); }} @Orride public Converter getConverter (Class targetType) {return new StringToEnumConverter (targetType); }}

Mint láthatjuk, a gyári osztály belsőleg használja a Átalakító felület.

Itt egy dolgot meg kell jegyezni, hogy bár a mi használatunkat használjuk Módok Enum a használat bemutatásához nem említettük Enum bárhol a StringToEnumConverterFactory. Gyári osztályunk elég általános a Átalakítós bármelyik igényére Enum típus.

A következő lépés ennek a gyári osztálynak a regisztrálása, amikor regisztráltuk Átalakító az előző példában:

@Orride public void addFormatters (FormatterRegistry registry) {register.addConverter (új StringToEmployeeConverter ()); register.addConverterFactory (új StringToEnumConverterFactory ()); }

Most a ConversionService készen áll az átalakításra Húrs to Enums:

@Test public void whenConvertStringToEnum_thenSuccess () {assertThat (conversionService.convert ("ALPHA", Modes.class)) .isEqualTo (Modes.ALPHA); }

5. A. Létrehozása GenericConverter

A GenericConverter nagyobb rugalmasságot biztosít számunkra a Átalakító általánosabb felhasználáshoz, valamilyen típusú biztonság elvesztése árán.

Vegyünk egy példát egy Egész szám, Kettős, vagy a Húr a BigDecimal érték. Nem kell hármat írni Átalakítós erre. Egy egyszerű GenericConverter szolgálhatta a célt.

Első lépésként meg kell mondani Springnek, hogy milyen típusú átalakítások támogatottak. Ezt a Készlet nak,-nek ConvertiblePair:

public class GenericBigDecimalConverter hajtja végre a GenericConverter {@Override public Set getConvertibleTypes () {ConvertiblePair [] párokat = new ConvertiblePair [] {új ConvertiblePair (Number.class, BigDecimal.class), new ConvertiblePair (String.class, String.class, return ImmutableSet.copyOf (párok); }}

A következő lépés a alakítani() módszer ugyanabban az osztályban:

@Orride public Object convert (Object source, TypeDescriptor sourceType, TypeDescriptor targetType) {if (sourceType.getType () == BigDecimal.class) {return source; } if (sourceType.getType () == String.class) {String number = (String) forrás; return new BigDecimal (szám); } else {Szám száma = (Szám) forrás; BigDecimal convert = new BigDecimal (number.doubleValue ()); return convert.setScale (2, BigDecimal.ROUND_HALF_EVEN); }}

A alakítani() A módszer a lehető legegyszerűbb. Azonban a TypeDescriptor nagy rugalmasságot biztosít számunkra a forrás és a céltípus részleteinek megismerése szempontjából.

Mint már sejtette, a következő lépés ennek regisztrálása Átalakító:

@Orride public void addFormatters (FormatterRegistry registry) {register.addConverter (új StringToEmployeeConverter ()); register.addConverterFactory (új StringToEnumConverterFactory ()); register.addConverter (új GenericBigDecimalConverter ()); }

Ennek felhasználásával Átalakító hasonló a már látott többi példához:

@Test public void whenConvertingToBigDecimalUsingGenericConverter_thenSuccess () {assertThat (conversionService .convert (Integer.valueOf (11), BigDecimal.class)) .isEqualTo (BigDecimal.valueOf (11.00), SetScaleF (2). assertThat (conversionService .convert (Double.valueOf (25.23), BigDecimal.class)) .isEqualByComparingTo (BigDecimal.valueOf (Double.valueOf (25.23))); assertThat (conversionService.convert ("2.32", BigDecimal.class)) .isEqualTo (BigDecimal.valueOf (2.32)); }

6. Következtetés

Ebben az oktatóanyagban láthattuk, hogyan lehet a Spring típusú konverziós rendszert különféle példákkal használni és kibővíteni.

Mint mindig, a cikk teljes forráskódja megtalálható a GitHubon.