<?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"
    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/osgi/cxf-extension-osgi.xml" />

    <jaxws:endpoint id="MtomEndpoint"
        implementor="org.apache.servicemix.examples.cxf.mtom.TestMtomImpl"
        address="/mtom"
        wsdlLocation="wsdl/mtom.wsdl"
        endpointName="e:TestMtomPort"
        serviceName="s:TestMtomService"
        xmlns:e="http://cxf.apache.org/mime"
            xmlns:s="http://cxf.apache.org/mime">
             <jaxws:features>
                 <bean class="org.apache.cxf.feature.LoggingFeature"/>
             </jaxws:features>
             <jaxws:properties>
                 <entry key="mtom-enabled" value="true"/>
             </jaxws:properties>
        </jaxws:endpoint>

       
       <jaxws:client id="client" 
             serviceClass="org.apache.cxf.mime.TestMtom"    
             endpointName="e:TestMtomPort"
            serviceName="s:TestMtomService"
            xmlns:e="http://cxf.apache.org/mime"
            xmlns:s="http://cxf.apache.org/mime"
            wsdlLocation="wsdl/mtom.wsdl"
             address="http://localhost:8080/cxf/mtom">
             <jaxws:features>
                 <bean class="org.apache.cxf.feature.LoggingFeature"/>
             </jaxws:features>
             <jaxws:properties>
                 <entry key="mtom-enabled" value="true"/>
             </jaxws:properties>
        </jaxws:client>   
 
       <osgi:service id="testMtom" ref="client"
            interface="org.apache.cxf.mime.TestMtom"/>

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