<?xml version="1.0" encoding="UTF-8"?>
<!--
    Licensed to the Apache Software Foundation (ASF) under one
    or more contributor license agreements. See the NOTICE file
    distributed with this work for additional information
    regarding copyright ownership. The ASF licenses this file
    to you under the Apache License, Version 2.0 (the
    "License"); you may not use this file except in compliance
    with the License. You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

    Unless required by applicable law or agreed to in writing,
    software distributed under the License is distributed on an
    "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
    KIND, either express or implied. See the License for the
    specific language governing permissions and limitations
    under the License.
-->
<!-- START SNIPPET: beans -->
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:osgi="http://www.springframework.org/schema/osgi"
       xmlns:camel="http://camel.apache.org/schema/spring"
       xmlns:jaxws="http://cxf.apache.org/jaxws"
       xsi:schemaLocation="
       http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd
       http://www.springframework.org/schema/osgi  http://www.springframework.org/schema/osgi/spring-osgi.xsd
       http://camel.apache.org/schema/spring http://camel.apache.org/schema/spring/camel-spring.xsd
       http://cxf.apache.org/jaxws http://cxf.apache.org/schemas/jaxws.xsd">

    <import resource="classpath:META-INF/cxf/cxf.xml" />
    <import resource="classpath:META-INF/cxf/transport/nmr/cxf-transport-nmr.xml" />
    <import resource="classpath:org/apache/servicemix/camel/nmr/camel-nmr.xml" />

    <camel:camelContext xmlns="http://camel.apache.org/schema/spring">
        <!-- Route periodically sent events into the NMR -->
        <route>
            <from uri="timer://myTimer?fixedRate=true&amp;period=5000&amp;exchangePattern=InOut" />
            <bean ref="myTransform" method="transform"/>
            <to uri="nmr:HelloWorld"/>
            <bean ref="myTransform" method="display" />
        </route>
    </camel:camelContext>

    <bean id="myTransform" class="org.apache.servicemix.examples.cxfcamel.MyTransform">
        <property name="value"><value><![CDATA[<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/"><soap:Body><ns1:sayHi xmlns:ns1="http://cxfcamel.examples.servicemix.apache.org/"><arg0>Guillaume</arg0></ns1:sayHi></soap:Body></soap:Envelope>]]></value></property>
    </bean>

    <jaxws:endpoint id="helloWorld"
                    implementor="org.apache.servicemix.examples.cxfcamel.HelloWorldImpl"
                    address="nmr:HelloWorld" />

</beans>
<!-- END SNIPPET: beans -->
