Java NoTypeConversionAvailableException类代码示例

import org.apache.camel.NoTypeConversionAvailableException; //导入依赖的package包/类
private static Object convert(TypeConverter typeConverter, Class<?> type, Object value)
    throws URISyntaxException, NoTypeConversionAvailableException {
    if (typeConverter != null) {
        return typeConverter.mandatoryConvertTo(type, value);
    }
    if (type == URI.class) {
        return new URI(value.toString());
    }
    PropertyEditor editor = PropertyEditorManager.findEditor(type);
    if (editor != null) {
        // property editor is not thread safe, so we need to lock
        Object answer;
        synchronized (LOCK) {
            editor.setAsText(value.toString());
            answer = editor.getValue();
        }
        return answer;
    }
    return null;
}
 

import org.apache.camel.NoTypeConversionAvailableException; //导入依赖的package包/类
@Converter
public static InputStream genericFileToInputStream(GenericFile<?> file, Exchange exchange) throws IOException, NoTypeConversionAvailableException {
    if (file.getFile() instanceof File) {
        // prefer to use a file input stream if its a java.io.File
        File f = (File) file.getFile();
        // the file must exists
        if (f.exists()) {
            // read the file using the specified charset
            String charset = file.getCharset();
            if (charset != null) {
                LOG.debug("Read file {} with charset {}", f, file.getCharset());
            } else {
                LOG.debug("Read file {} (no charset)", f);
            }
            return IOConverter.toInputStream(f, charset);
        }
    }
    if (exchange != null) {
        // otherwise ensure the body is loaded as we want the input stream of the body
        file.getBinding().loadContent(exchange, file);
        return exchange.getContext().getTypeConverter().convertTo(InputStream.class, exchange, file.getBody());
    } else {
        // should revert to fallback converter if we don't have an exchange
        return null;
    }
}
 

import org.apache.camel.NoTypeConversionAvailableException; //导入依赖的package包/类
@Converter
public static String genericFileToString(GenericFile<?> file, Exchange exchange) throws IOException, NoTypeConversionAvailableException {
    // use reader first as it supports the file charset
    BufferedReader reader = genericFileToReader(file, exchange);
    if (reader != null) {
        return IOConverter.toString(reader);
    }
    if (exchange != null) {
        // otherwise ensure the body is loaded as we want the content of the body
        file.getBinding().loadContent(exchange, file);
        return exchange.getContext().getTypeConverter().convertTo(String.class, exchange, file.getBody());
    } else {
        // should revert to fallback converter if we don't have an exchange
        return null;
    }
}
 

import org.apache.camel.NoTypeConversionAvailableException; //导入依赖的package包/类
@Converter
public static Serializable genericFileToSerializable(GenericFile<?> file, Exchange exchange) throws IOException, NoTypeConversionAvailableException {
    if (exchange != null) {
        // load the file using input stream
        InputStream is = genericFileToInputStream(file, exchange);
        if (is != null) {
            // need to double convert to convert correctly
            byte[] data = exchange.getContext().getTypeConverter().convertTo(byte[].class, exchange, is);
            if (data != null) {
                return exchange.getContext().getTypeConverter().convertTo(Serializable.class, exchange, data);
            }
        }
    }
    // should revert to fallback converter if we don't have an exchange
    return null;
}
 

import org.apache.camel.NoTypeConversionAvailableException; //导入依赖的package包/类
private static BufferedReader genericFileToReader(GenericFile<?> file, Exchange exchange) throws IOException, NoTypeConversionAvailableException {
    if (file.getFile() instanceof File) {
        // prefer to use a file input stream if its a java.io.File
        File f = (File) file.getFile();
        // the file must exists
        if (!f.exists()) {
            return null;
        }
        // and use the charset if the file was explicit configured with a charset
        String charset = file.getCharset();
        if (charset != null) {
            LOG.debug("Read file {} with charset {}", f, file.getCharset());
            return IOConverter.toReader(f, charset);
        } else {
            LOG.debug("Read file {} (no charset)", f);
            return IOConverter.toReader(f, exchange);
        }
    }
    return null;
}
 

import org.apache.camel.NoTypeConversionAvailableException; //导入依赖的package包/类
/**
 * Regression test to ensure that a NodeList of length > 1 is not processed by the new converters.
 * @throws Exception
 */
@Test
public void testMultipleNodeList() throws Exception {
    getMockEndpoint("mock:found").expectedMessageCount(0);
    getMockEndpoint("mock:found").setResultWaitTime(500);
    getMockEndpoint("mock:notfound").expectedMessageCount(0);
    getMockEndpoint("mock:notfound").setResultWaitTime(500);

    try {
        template.requestBody("direct:doTest", XML_INPUT_MULTIPLE, String.class);
        fail("NoTypeConversionAvailableException expected");
    } catch (CamelExecutionException ex) {
        assertEquals(RuntimeCamelException.class, ex.getCause().getClass());
        assertEquals(NoTypeConversionAvailableException.class, ex.getCause().getCause().getClass());
    }
    
    assertMockEndpointsSatisfied();
}
 

import org.apache.camel.NoTypeConversionAvailableException; //导入依赖的package包/类
public void testBeanNoTypeConvertionPossibleFail() throws Exception {
    MockEndpoint mock = getMockEndpoint("mock:result");
    mock.expectedMessageCount(0);

    // we send in a Date object which cannot be converted to XML so it should fail
    try {
        template.requestBody("direct:start", new Date());
        fail("Should have thrown an exception");
    } catch (CamelExecutionException e) {
        NoTypeConversionAvailableException ntae = assertIsInstanceOf(NoTypeConversionAvailableException.class, e.getCause().getCause());
        assertEquals(Date.class, ntae.getFromType());
        assertEquals(Document.class, ntae.getToType());
        assertNotNull(ntae.getValue());
        assertNotNull(ntae.getMessage());
    }

    assertMockEndpointsSatisfied();
}
 

import org.apache.camel.NoTypeConversionAvailableException; //导入依赖的package包/类
public void testBeanHeaderNoTypeConvertionPossibleFail() throws Exception {
    MockEndpoint mock = getMockEndpoint("mock:result");
    mock.expectedMessageCount(0);

    // we send in a bar string as header which cannot be converted to a number so it should fail
    try {
        template.requestBodyAndHeader("direct:start", "Hello World", "foo", 555);
        fail("Should have thrown an exception");
    } catch (CamelExecutionException e) {
        ParameterBindingException pbe = assertIsInstanceOf(ParameterBindingException.class, e.getCause());
        assertEquals(1, pbe.getIndex());
        assertTrue(pbe.getMethod().getName().contains("hello"));
        assertEquals(555, pbe.getParameterValue());

        NoTypeConversionAvailableException ntae = assertIsInstanceOf(NoTypeConversionAvailableException.class, e.getCause().getCause());
        assertEquals(Integer.class, ntae.getFromType());
        assertEquals(Document.class, ntae.getToType());
        assertEquals(555, ntae.getValue());
        assertNotNull(ntae.getMessage());
    }

    assertMockEndpointsSatisfied();
}
 

import org.apache.camel.NoTypeConversionAvailableException; //导入依赖的package包/类
public void testCannotBindToParameter() throws Exception {
    // Create hashmap for testing purpose
    users.put("charles", new User("Charles", "43"));
    users.put("claus", new User("Claus", "33"));

    Exchange out = template.send("direct:in", new Processor() {
        public void process(Exchange exchange) throws Exception {
            exchange.setProperty("p1", "abc");
            exchange.setProperty("p2", 123);

            Message in = exchange.getIn();
            in.setHeader("users", users); // add users hashmap
            in.setBody("TheBody");
        }
    });

    assertTrue("Should fail", out.isFailed());
    assertIsInstanceOf(RuntimeCamelException.class, out.getException());
    assertIsInstanceOf(NoTypeConversionAvailableException.class, out.getException().getCause());
}
 

import org.apache.camel.NoTypeConversionAvailableException; //导入依赖的package包/类
public void testOrderNoFQNUnknown() throws Exception {
    context.addRoutes(new RouteBuilder() {
        @Override
        public void configure() throws Exception {
            from("direct:start")
                .bean(MyBean.class, "order(Unknown)")
                .to("mock:result");

        }
    });
    context.start();

    try {
        template.sendBody("direct:start", new MyOrder());
        fail("Should have thrown an exception");
    } catch (CamelExecutionException e) {
        NoTypeConversionAvailableException cause = assertIsInstanceOf(NoTypeConversionAvailableException.class, e.getCause().getCause());
        assertEquals("Unknown", cause.getValue());
    }
}
 

import org.apache.camel.NoTypeConversionAvailableException; //导入依赖的package包/类
public void testOrderFQNUnknown() throws Exception {
    context.addRoutes(new RouteBuilder() {
        @Override
        public void configure() throws Exception {
            from("direct:start")
                .bean(MyBean.class, "order(org.apache.camel.component.bean.BeanOverloadedMethodFQNTest$Unknown)")
                .to("mock:result");

        }
    });
    context.start();

    try {
        template.sendBody("direct:start", new MyOrder());
        fail("Should have thrown an exception");
    } catch (CamelExecutionException e) {
        NoTypeConversionAvailableException cause = assertIsInstanceOf(NoTypeConversionAvailableException.class, e.getCause().getCause());
        assertEquals("org.apache.camel.component.bean.BeanOverloadedMethodFQNTest$Unknown", cause.getValue());
    }
}
 

import org.apache.camel.NoTypeConversionAvailableException; //导入依赖的package包/类
/**
 * Writes the given row.
 *
 * @param exchange exchange to use (for type conversion)
 * @param row      row to write
 * @param writer   uniVocity writer to use
 * @throws NoTypeConversionAvailableException when it's not possible to convert the row as map.
 */
private void writeRow(Exchange exchange, Object row, W writer) throws NoTypeConversionAvailableException {
    Map<?, ?> map = convertToMandatoryType(exchange, Map.class, row);
    if (adaptHeaders) {
        for (Object key : map.keySet()) {
            headers.add(convertToMandatoryType(exchange, String.class, key));
        }
    }

    Object[] values = new Object[headers.size()];
    int index = 0;
    for (String header : headers) {
        values[index++] = map.get(header);
    }
    writer.writeRow(values);
}
 

import org.apache.camel.NoTypeConversionAvailableException; //导入依赖的package包/类
/**
 * Gets the string body to be used when sending with the textline codec.
 *
 * @param body                 the current body
 * @param exchange             the exchange
 * @param delimiter            the textline delimiter
 * @param autoAppendDelimiter  whether absent delimiter should be auto appended
 * @return the string body to send
 * @throws NoTypeConversionAvailableException is thrown if the current body could not be converted to a String type
 */
public static String getTextlineBody(Object body, Exchange exchange, TextLineDelimiter delimiter, boolean autoAppendDelimiter) throws NoTypeConversionAvailableException {
    String s = exchange.getContext().getTypeConverter().mandatoryConvertTo(String.class, exchange, body);

    // auto append delimiter if missing?
    if (autoAppendDelimiter) {
        if (TextLineDelimiter.LINE.equals(delimiter)) {
            // line delimiter so ensure it ends with newline
            if (!s.endsWith("\n")) {
                LOG.trace("Auto appending missing newline delimiter to body");
                s = s + "\n";
            }
        } else {
            // null delimiter so ensure it ends with null
            if (!s.endsWith("\u0000")) {
                LOG.trace("Auto appending missing null delimiter to body");
                s = s + "\u0000";
            }
        }
    }

    return s;
}
 

import org.apache.camel.NoTypeConversionAvailableException; //导入依赖的package包/类
private static long extractOffset(String now, TypeConverter typeConverter) throws NoTypeConversionAvailableException {
    Matcher matcher = NOW_PATTERN.matcher(now);
    if (matcher.matches()) {
        String op = matcher.group(1);
        String remainder = matcher.group(2);

        // convert remainder to a time millis (eg we have a String -> long converter that supports
        // syntax with hours, days, minutes: eg 5h30m for 5 hours and 30 minutes).
        long offset = typeConverter.mandatoryConvertTo(long.class, remainder);

        if ("+".equals(op)) {
            return offset;
        } else {
            return -1 * offset;
        }
    }

    return 0;
}
 

import org.apache.camel.NoTypeConversionAvailableException; //导入依赖的package包/类
public void publish() throws IOException {
    AMQP.BasicProperties properties;
    byte[] body;
    try {
        // To maintain backwards compatibility try the TypeConverter (The DefaultTypeConverter seems to only work on Strings)
        body = camelExchange.getContext().getTypeConverter().mandatoryConvertTo(byte[].class, camelExchange, message.getBody());

        properties = endpoint.getMessageConverter().buildProperties(camelExchange).build();
    } catch (NoTypeConversionAvailableException | TypeConversionException e) {
        if (message.getBody() instanceof Serializable) {
            // Add the header so the reply processor knows to de-serialize it
            message.getHeaders().put(RabbitMQEndpoint.SERIALIZE_HEADER, true);
            properties = endpoint.getMessageConverter().buildProperties(camelExchange).build();
            body = serializeBodyFrom(message);
        } else if (message.getBody() == null) {
            properties = endpoint.getMessageConverter().buildProperties(camelExchange).build();
            body = null;
        } else {
            LOG.warn("Could not convert {} to byte[]", message.getBody());
            throw new RuntimeCamelException(e);
        }
    }
    
    publishToRabbitMQ(properties, body);
}