@Test public void testToStringConversion() { BeanFactoryTypeConverter typeConverter = new BeanFactoryTypeConverter(); typeConverter.setBeanFactory(new DefaultListableBeanFactory()); String converted = (String) typeConverter.convertValue(1234, TypeDescriptor.valueOf(Integer.class), TypeDescriptor.valueOf(String.class)); assertEquals("1234", converted); }
@Override public boolean canConvert(TypeDescriptor sourceTypeDescriptor, TypeDescriptor targetTypeDescriptor) { if (this.conversionService.canConvert(sourceTypeDescriptor, targetTypeDescriptor)) { return true; } // TODO: what does this mean? This method is not used in SpEL so probably ignorable? Class<?> sourceType = sourceTypeDescriptor.getObjectType(); Class<?> targetType = targetTypeDescriptor.getObjectType(); return canConvert(sourceType, targetType); }
public void setConversionService(ConversionService conversionService) { if (conversionService != null) { this.typeConverter.setConversionService(conversionService); } }
@SuppressWarnings("unchecked") @Test public void testEmptyCollectionConversion() { BeanFactoryTypeConverter typeConverter = new BeanFactoryTypeConverter(); List<String> sourceObject = new ArrayList<>(); ArrayList<BeanFactoryTypeConverterTests> convertedCollection = (ArrayList<BeanFactoryTypeConverterTests>) typeConverter.convertValue(sourceObject, TypeDescriptor.forObject(sourceObject), TypeDescriptor.forObject(new ArrayList<BeanFactoryTypeConverterTests>())); assertEquals(sourceObject, convertedCollection); }
public void initialConcurrency() throws Exception { ConversionService conversionService = mock(ConversionService.class); // can convert nothing so we drop down to P.E.s final BeanFactoryTypeConverter beanFactoryTypeConverter = new BeanFactoryTypeConverter(conversionService); ConfigurableBeanFactory beanFactory = mock(ConfigurableBeanFactory.class); SimpleTypeConverter typeConverter = spy(new SimpleTypeConverter()); return invocation.callRealMethod(); }).when(typeConverter).getDefaultEditor(UUID.class); beanFactoryTypeConverter.setBeanFactory(beanFactory); final TypeDescriptor sourceType = TypeDescriptor.valueOf(UUID.class); final TypeDescriptor targetType = TypeDescriptor.valueOf(String.class); ExecutorService exec = Executors.newFixedThreadPool(2); Runnable test = () -> { beanFactoryTypeConverter.canConvert(sourceType, targetType); beanFactoryTypeConverter.convertValue(UUID.randomUUID(), sourceType, targetType); }; exec.execute(test);
PropertyEditor editor = this.delegate.findCustomEditor(sourceType.getType(), null); if (editor == null) { editor = this.getDefaultEditor(sourceType.getType()); return text; return convertValue(text, TypeDescriptor.valueOf(String.class), targetType);
@Override public Object processMessage(Message<?> message) { Node node = this.converter.convertToNode(message.getPayload()); Object result = this.evaluationType.evaluateXPath(this.expression, node); if (result instanceof String && ((String) result).length() == 0) { result = null; } if (result != null && this.headerTypeDescriptor != null) { return this.typeConverter.convertValue(result, TypeDescriptor.forObject(result), this.headerTypeDescriptor); } else { return result; } }
@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()); }
/** * Specify a BeanFactory in order to enable resolution via <code>@beanName</code> in the expression. */ @Override public void setBeanFactory(final @Nullable BeanFactory beanFactory) { if (beanFactory != null) { this.beanFactory = beanFactory; this.typeConverter.setBeanFactory(beanFactory); if (this.evaluationContext != null && this.evaluationContext.getBeanResolver() == null) { this.evaluationContext.setBeanResolver(new BeanFactoryResolver(beanFactory)); } } }
public boolean canConvert(Class<?> sourceType, Class<?> targetType) { if (this.conversionService.canConvert(sourceType, targetType)) { return true; } if (!String.class.isAssignableFrom(sourceType) && !String.class.isAssignableFrom(targetType)) { // PropertyEditor cannot convert non-Strings return false; } if (!String.class.isAssignableFrom(sourceType)) { return this.delegate.findCustomEditor(sourceType, null) != null || this.getDefaultEditor(sourceType) != null; } return this.delegate.findCustomEditor(targetType, null) != null || this.getDefaultEditor(targetType) != null; }
@Test public void testNullArg() { DefaultConversionService conversionService = new DefaultConversionService(); BeanFactoryTypeConverter typeConverter = new BeanFactoryTypeConverter(conversionService); Object foo = typeConverter.convertValue(null, null, TypeDescriptor.valueOf(Bar.class)); assertNull(foo); }
PropertyEditor editor = this.delegate.findCustomEditor(sourceType.getType(), null); if (editor == null) { editor = this.getDefaultEditor(sourceType.getType()); return text; return convertValue(text, TypeDescriptor.valueOf(String.class), targetType);
/** * Specify a BeanFactory in order to enable resolution via <code>@beanName</code> in the expression. */ @Override public void setBeanFactory(final @Nullable BeanFactory beanFactory) { if (beanFactory != null) { this.beanFactory = beanFactory; this.typeConverter.setBeanFactory(beanFactory); if (this.evaluationContext != null && this.evaluationContext.getBeanResolver() == null) { this.evaluationContext.setBeanResolver(new BeanFactoryResolver(beanFactory)); } } }
public boolean canConvert(Class<?> sourceType, Class<?> targetType) { if (this.conversionService.canConvert(sourceType, targetType)) { return true; } if (!String.class.isAssignableFrom(sourceType) && !String.class.isAssignableFrom(targetType)) { // PropertyEditor cannot convert non-Strings return false; } if (!String.class.isAssignableFrom(sourceType)) { return this.delegate.findCustomEditor(sourceType, null) != null || this.getDefaultEditor(sourceType) != null; } return this.delegate.findCustomEditor(targetType, null) != null || this.getDefaultEditor(targetType) != null; }
@Test public void testToNonStringConversionNotSupportedByGenericConversionService() { BeanFactoryTypeConverter typeConverter = new BeanFactoryTypeConverter(); typeConverter.setBeanFactory(new DefaultListableBeanFactory()); @SuppressWarnings("unchecked") Collection<Integer> converted = (Collection<Integer>) typeConverter.convertValue(1234, TypeDescriptor.valueOf(Integer.class), TypeDescriptor.forObject(new ArrayList<>(Arrays.asList(1)))); assertEquals(Collections.singletonList(1234), converted); }
@Test public void testVoidArg() { DefaultConversionService conversionService = new DefaultConversionService(); BeanFactoryTypeConverter typeConverter = new BeanFactoryTypeConverter(conversionService); Object foo = typeConverter.convertValue(null, null, TypeDescriptor.valueOf(Void.class)); assertNull(foo); foo = typeConverter.convertValue(null, null, TypeDescriptor.valueOf(Void.TYPE)); assertNull(foo); }
@Override public void setBeanFactory(BeanFactory beanFactory) throws BeansException { ConversionService conversionService = IntegrationUtils.getConversionService(beanFactory); if (conversionService != null) { this.typeConverter.setConversionService(conversionService); } }
@Override public boolean canConvert(TypeDescriptor sourceTypeDescriptor, TypeDescriptor targetTypeDescriptor) { if (this.conversionService.canConvert(sourceTypeDescriptor, targetTypeDescriptor)) { return true; } // TODO: what does this mean? This method is not used in SpEL so probably ignorable? Class<?> sourceType = sourceTypeDescriptor.getObjectType(); Class<?> targetType = targetTypeDescriptor.getObjectType(); return canConvert(sourceType, targetType); }
@Test public void testObjectToStringIsConverted() { ConversionService conversionService = mock(ConversionService.class); when(conversionService.canConvert(any(TypeDescriptor.class), any(TypeDescriptor.class))) .thenReturn(true); when(conversionService.convert(any(), any(TypeDescriptor.class), any(TypeDescriptor.class))) .thenReturn("foo"); BeanFactoryTypeConverter typeConverter = new BeanFactoryTypeConverter(conversionService); typeConverter.setBeanFactory(new DefaultListableBeanFactory()); Object object = new Object(); assertEquals("foo", typeConverter.convertValue(object, TypeDescriptor.valueOf(Object.class), TypeDescriptor.valueOf(String.class))); }
@Test public void testEditorWithTargetString() { DefaultConversionService conversionService = new DefaultConversionService(); BeanFactoryTypeConverter typeConverter = new BeanFactoryTypeConverter(conversionService); UUID uuid = UUID.randomUUID(); Object foo = typeConverter.convertValue(uuid, TypeDescriptor.valueOf(UUID.class), TypeDescriptor.valueOf(String.class)); assertEquals(uuid.toString(), foo); }