@Test public void convertStringToCustomCharArray() throws Exception { conversionService.addConverter(new Converter<String, char[]>() { @Override public char[] convert(String source) { return source.toCharArray(); } }); char[] converted = conversionService.convert("abc", char[].class); assertThat(converted, equalTo(new char[] {'a', 'b', 'c'})); }
@Bean @Qualifier("spring-shell") public ConversionService shellConversionService(ApplicationContext applicationContext) { Collection<Converter> converters = applicationContext.getBeansOfType(Converter.class).values(); Collection<GenericConverter> genericConverters = applicationContext.getBeansOfType(GenericConverter.class).values(); Collection<ConverterFactory> converterFactories = applicationContext.getBeansOfType(ConverterFactory.class).values(); DefaultConversionService defaultConversionService = new DefaultConversionService(); for (Converter converter : converters) { defaultConversionService.addConverter(converter); } for (GenericConverter genericConverter : genericConverters) { defaultConversionService.addConverter(genericConverter); } for (ConverterFactory converterFactory : converterFactories) { defaultConversionService.addConverterFactory(converterFactory); } return defaultConversionService; }
@Test @SuppressWarnings("rawtypes") public void convertCollectionToObjectWithCustomConverter() throws Exception { List<String> source = new ArrayList<>(); source.add("A"); source.add("B"); conversionService.addConverter(new Converter<List, ListWrapper>() { @Override public ListWrapper convert(List source) { return new ListWrapper(source); } }); ListWrapper result = conversionService.convert(source, ListWrapper.class); assertSame(source, result.getList()); }
@Test public void convertCannotOptimizeArray() { conversionService.addConverter(new Converter<Byte, Byte>() { @Override public Byte convert(Byte source) { return (byte) (source + 1); } }); byte[] byteArray = new byte[] {1, 2, 3}; byte[] converted = conversionService.convert(byteArray, byte[].class); assertNotSame(byteArray, converted); assertTrue(Arrays.equals(new byte[] {2, 3, 4}, converted)); }
@Test // SPR-16483 public void useCustomConversionService() throws SQLException { Timestamp timestamp = new Timestamp(0); DefaultConversionService myConversionService = new DefaultConversionService(); myConversionService.addConverter(Timestamp.class, MyLocalDateTime.class, source -> new MyLocalDateTime(source.toLocalDateTime())); SingleColumnRowMapper<MyLocalDateTime> rowMapper = SingleColumnRowMapper.newInstance(MyLocalDateTime.class, myConversionService); ResultSet resultSet = mock(ResultSet.class); ResultSetMetaData metaData = mock(ResultSetMetaData.class); given(metaData.getColumnCount()).willReturn(1); given(resultSet.getMetaData()).willReturn(metaData); given(resultSet.getObject(1, MyLocalDateTime.class)) .willThrow(new SQLFeatureNotSupportedException()); given(resultSet.getObject(1)).willReturn(timestamp); MyLocalDateTime actualMyLocalDateTime = rowMapper.mapRow(resultSet, 1); assertNotNull(actualMyLocalDateTime); assertEquals(timestamp.toLocalDateTime(), actualMyLocalDateTime.value); }
public KafkaStreamsConfiguration(Map<String, Object> configs) { Assert.notNull(configs, "Configuration map cannot be null"); this.configs = new HashMap<>(configs); // Not lambdas so we retain type information this.conversionService.addConverter(new Converter<Class<?>, String>() { @Override public String convert(Class<?> c) { return c.getName(); } }); this.conversionService.addConverter(new Converter<List<?>, String>() { @Override public String convert(List<?> l) { String value = l.toString(); // trim [...] - revert to comma-delimited list return value.substring(1, value.length() - 1); } }); }
@Test public void genericConverters() { QueueChannel channel = createChannel(Foo.class); DefaultConversionService conversionService = new DefaultConversionService(); conversionService.addConverter(new StringToBarConverter()); conversionService.addConverter(new IntegerToBazConverter()); DefaultDatatypeChannelMessageConverter converter = new DefaultDatatypeChannelMessageConverter(); converter.setConversionService(conversionService); channel.setMessageConverter(converter); assertTrue(channel.send(new GenericMessage<String>("foo"))); Message<?> out = channel.receive(0); assertThat(out.getPayload(), instanceOf(Bar.class)); assertTrue(channel.send(new GenericMessage<Integer>(42))); out = channel.receive(0); assertThat(out.getPayload(), instanceOf(Baz.class)); }
public class CustomerConversionServiceFactoryBean extends ConversionServiceFactoryBean { List<Converter<Object, Object>> converters = new ArrayList<>(); public CustomerConversionServiceFactoryBean() { super(); DefaultConversionService conversionservice = (DefaultConversionService) super.getObject(); for(int i=0;i<converters.size();i++){ conversionservice.addConverter(converters.get(i)); } } }
@Test public void testEditorWithTargetFoo() { DefaultConversionService conversionService = new DefaultConversionService(); final Foo foo = new Foo(); conversionService.addConverter(new Converter<String, Foo>() { // Must be explicit type with generics @Override public Foo convert(String source) { return foo; } }); BeanFactoryTypeConverter typeConverter = new BeanFactoryTypeConverter(conversionService); UUID uuid = UUID.randomUUID(); Object convertedFoo = typeConverter.convertValue(uuid, TypeDescriptor.valueOf(UUID.class), TypeDescriptor.valueOf(Foo.class)); assertSame(foo, convertedFoo); }
DefaultListableBeanFactory beanFactory = new DefaultListableBeanFactory(); DefaultConversionService conversionService = new DefaultConversionService(); conversionService.addConverter(new Converter<Foo, Bar>() { // Must be explicit type with generics @Override public Bar convert(Foo source) {
@ConditionalOnMissingBean @Bean ConversionService defaultCamelConversionService(ApplicationContext applicationContext) { DefaultConversionService service = new DefaultConversionService(); for (Converter converter : applicationContext.getBeansOfType(Converter.class).values()) { service.addConverter(converter); } return service; }
@Bean public DefaultConversionService mongoStoreConverter() { DefaultConversionService conversion = new DefaultConversionService(); if (customConverters != null) { for (Converter<?, String> converter : customConverters) { conversion.addConverter(converter); } } return conversion; } }
@Bean ConversionService conversionService() { DefaultConversionService registry = new DefaultConversionService(); registry.addConverter(new DateToStringConverter()); registry.addConverter(new StringToDateConverter()); return registry; }
@Test public void testCollectionIsConverted() { DefaultListableBeanFactory beanFactory = new DefaultListableBeanFactory(); DefaultConversionService conversionService = new DefaultConversionService(); conversionService.addConverter(new Converter<Foo, Bar>() { // Must be explicit type with generics @Override public Bar convert(Foo source) { return new Bar(); } }); BeanFactoryTypeConverter typeConverter = new BeanFactoryTypeConverter(conversionService); beanFactory.setConversionService(conversionService); typeConverter.setBeanFactory(beanFactory); Service service = new Service(); MethodInvokingMessageProcessor<Service> processor = new MethodInvokingMessageProcessor<>(service, "handle"); processor.setConversionService(conversionService); processor.setUseSpelInvoker(true); processor.setBeanFactory(beanFactory); ServiceActivatingHandler handler = new ServiceActivatingHandler(processor); QueueChannel replyChannel = new QueueChannel(); handler.setOutputChannel(replyChannel); handler.handleMessage(new GenericMessage<Collection<Foo>>(Collections.singletonList(new Foo()))); Message<?> message = replyChannel.receive(10000); assertNotNull(message); assertEquals("baz", message.getPayload()); }
@Bean public ConversionService myConversionService() { DefaultConversionService conv = new DefaultConversionService(); conv.addConverter(foo1To2Converter()); return conv; }
@Bean public ConversionService myConversionService() { DefaultConversionService conv = new DefaultConversionService(); conv.addConverter(foo1To2Converter()); return conv; }
/** * Discover and register plugin resolvers, accessors, and converters. */ @Override public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException { if (bean instanceof ConstructorResolver) { addConstructorResolver((ConstructorResolver) bean); } else if (bean instanceof MethodResolver) { addMethodResolver((MethodResolver) bean); } else if (bean instanceof PropertyAccessor) { addPropertyAccessor((PropertyAccessor) bean); } else if (bean instanceof Converter) { conversionService.addConverter((Converter<?, ?>) bean); } else if (bean instanceof BeanResolver) { setBeanResolver((BeanResolver) bean); } return bean; }
/** * Discover and register plugin resolvers, accessors, and converters. */ @Override public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException { if (bean instanceof ConstructorResolver) { addConstructorResolver((ConstructorResolver) bean); } if (bean instanceof MethodResolver) { addMethodResolver((MethodResolver) bean); } if (bean instanceof PropertyAccessor) { addPropertyAccessor((PropertyAccessor) bean); } if (bean instanceof Converter) { conversionService.addConverter((Converter<?, ?>) bean); } if (bean instanceof BeanResolver) { setBeanResolver((BeanResolver) bean); } return bean; }
private ELEvaluator() { addPropertyAccessor(new EnvironmentAccessor()); addPropertyAccessor(new MessageAccessor()); addPropertyAccessor(new ContextAccessor()); addMethodResolver(new ELMethodResolver()); conversionService.addConverter(new MessageAccessor.MessageContextConverter()); setTypeConverter(new StandardTypeConverter(conversionService)); }
private ELEvaluator() { addPropertyAccessor(new EnvironmentAccessor()); addPropertyAccessor(new MessageAccessor()); addPropertyAccessor(new ContextAccessor()); addMethodResolver(new ELMethodResolver()); conversionService.addConverter(new MessageAccessor.MessageContextConverter()); setTypeConverter(new StandardTypeConverter(conversionService)); }