<?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:jaxws="http://cxf.apache.org/jaxws"
    xmlns:osgi="http://www.springframework.org/schema/osgi"
    xmlns:p="http://www.springframework.org/schema/p"
        xsi:schemaLocation="
        http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
        http://cxf.apache.org/jaxws http://cxf.apache.org/schemas/jaxws.xsd
        http://www.springframework.org/schema/osgi http://www.springframework.org/schema/osgi/spring-osgi.xsd">

    <import resource="classpath:META-INF/cxf/cxf.xml" />
    <import resource="classpath:META-INF/cxf/cxf-extension-soap.xml" />
    <import resource="classpath:META-INF/cxf/cxf-extension-jms.xml" />

    <jaxws:endpoint id="JMSEndpoint"
        implementor="org.apache.servicemix.examples.cxf_jms_osgi.HelloWorldImpl"
        wsdlLocation="wsdl/hello_world.wsdl"
        endpointName="e:HelloWorldImplPort"
        serviceName="s:HelloWorldImplService"
        xmlns:e="http://cxf.examples.servicemix.apache.org/"
            xmlns:s="http://cxf.examples.servicemix.apache.org/">
            <jaxws:features>
                <bean xmlns="http://www.springframework.org/schema/beans"
                        class="org.apache.cxf.transport.jms.JMSConfigFeature"
                        p:jmsConfig-ref="jmsConfig"/>
            </jaxws:features>
        </jaxws:endpoint>


    <jaxws:client id="client" 
         serviceClass="org.apache.servicemix.examples.cxf.HelloWorld"    
        endpointName="e:HelloWorldImplPort"
        serviceName="s:HelloWorldImplService"
        xmlns:e="http://cxf.examples.servicemix.apache.org/"
        xmlns:s="http://cxf.examples.servicemix.apache.org/"
         wsdlLocation="wsdl/hello_world.wsdl"
         >
        <jaxws:features>
                <bean xmlns="http://www.springframework.org/schema/beans"
                        class="org.apache.cxf.transport.jms.JMSConfigFeature"
                        p:jmsConfig-ref="jmsConfig"/>
        </jaxws:features>
    </jaxws:client>   
 
    <bean id="jmsConfig" class="org.apache.cxf.transport.jms.JMSConfiguration"
        p:connectionFactory-ref="jmsConnectionFactory"
        p:targetDestination="test.cxf.jmstransport.queue"
     />

     <bean id="jmsConnectionFactory" class="org.springframework.jms.connection.SingleConnectionFactory">
        <property name="targetConnectionFactory">
                <bean class="org.apache.activemq.ActiveMQConnectionFactory">
                        <property name="brokerURL" value="tcp://localhost:61616" />
                </bean>
        </property>
    </bean>

    <osgi:service id="testHelloWorld" ref="client"
        interface="org.apache.servicemix.examples.cxf.HelloWorld">
        <osgi:service-properties>
            <entry key="TEST-BUNDLE-NAME" value="cxf-jms-osgi" />
        </osgi:service-properties>
    </osgi:service>


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