接口类和实现类：
package com.demo;
import java.util.List;
import javax.jws.WebParam;
import javax.jws.WebService;
@WebService
public interface HelloWorld {
String sayHi(@WebParam(name = "text") String text);// http://localhost:8080/simple_cxf_ws/webservice/helloWorld/sayHi/text/a
String sayHiToUser(@WebParam(name = "user") Users user);
String[] SayHiToUserList(@WebParam(name = "userList") List<Users> userList);
}
package com.demo;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import javax.jws.WebService;
@WebService(endpointInterface = "com.demo.HelloWorld", serviceName = "HelloWorld")
public class HelloWorldImpl implements HelloWorld {
Map<Integer, Users> users = new LinkedHashMap<Integer, Users>();
public String sayHi(String text) {
return "Hello " + text;
}
public String sayHiToUser(Users user) {
users.put(users.size() + 1, user);
return "Hello " + user.getName();
}
public String[] SayHiToUserList(List<Users> userList) {
String[] result = new String[userList.size()];
int i = 0;
for (Users u : userList) {
result[i] = "Hello " + u.getName();
i++;
}
return result;
}
}接下来就是JAVABEAN，Users类：
package com.demo;
public class Users {
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}我们要用做WEB项目吗？不急，先不用，CXF自带了一个轻量的容器服务，相当于spring自己提供了IOC容器一样。我们可以先用它来测试一下我们部署成功没。
直接来一个测试类来暴露 web服务（直接run，在浏览器访问http://localhost:8080/helloWorld?wsdl）：
package com.demo;
import javax.xml.ws.Endpoint;
public class webServiceApp {
public static void main(String[] args) {
System.out.println("web service start");
HelloWorldImpl implementor = new HelloWorldImpl();
String address = "http://localhost:8080/helloWorld";
Endpoint.publish(address, implementor);
System.out.println("web service started");
}
}它生成了我们所需要的wsdl文件，说明我们部署成功了。
部署成功后，我们就是要调用啦，它的调用也相当简单，跟xfire类似，取得接口，然后就可以跟本地类一样调用方法了。
package com.demo;
import java.util.ArrayList;
import java.util.List;
import org.apache.cxf.jaxws.JaxWsProxyFactoryBean;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class HelloWorldClient {
public static void main(String[] args) {
// 创建WebService客户端代理工厂
JaxWsProxyFactoryBean svr = new JaxWsProxyFactoryBean();
// 注册WebService接口
svr.setServiceClass(HelloWorld.class);
// 设置WebService地址
svr.setAddress("http://localhost:8080/helloWorld");
HelloWorld hw = (HelloWorld) svr.create();
Users user = new Users();
user.setName("Tony");
System.out.println(hw.sayHiToUser(user));
ApplicationContext context = new ClassPathXmlApplicationContext(
"applicationContext.xml");
HelloWorld client = (HelloWorld) context.getBean("client");
Users user1 = new Users();
user1.setName("Tony");
Users user2 = new Users();
user2.setName("freeman");
List<Users> userList = new ArrayList<Users>();
userList.add(user1);
userList.add(user2);
String[] res = client.SayHiToUserList(userList);
System.out.println(res[0]);
System.out.println(res[1]);
}
}这里很简单，也是取得一个工厂类，然后直接设接口和地址再create就可以得取相应的接口了，这里跟xfire一样，也是需要调用端先定义好接口原型，否则这些调用将无从说起。
但很多情况下，我们并不希望我们的webservice和我们的应用分开两个服务器，而希望他们在同一个容器，tomcat或JBOSS或其他的，这样我们就必须通过WEB来部署我们前面完成的webservice。
注意，我们这里需要用到spring定义文件。
首先看看web.xml:
<?xml version="1.0" encoding="UTF-8"?>
<web-app>
<welcome-file-list>
<welcome-file>index.jsp</welcome-file>
</welcome-file-list>
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>WEB-INF/classes/applicationContext.xml</param-value>
</context-param>
<listener>
<listener-class>
org.springframework.web.context.ContextLoaderListener
</listener-class>
</listener>
<servlet>
<servlet-name>CXFServlet</servlet-name>
<display-name>CXFServlet</display-name>
<servlet-class>
org.apache.cxf.transport.servlet.CXFServlet
</servlet-class>
<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>CXFServlet</servlet-name>
<url-pattern>/*</url-pattern>
</servlet-mapping>
</web-app>这里很简单，只是指定了spring的监听器和相应的配置文件路径，并且指定了CXF的拦截方式。
接下来看看applicationContext.xml:
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:jaxws="http://cxf.apache.org/jaxws"
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">
<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-servlet.xml" />
<jaxws:endpoint id="helloWorld" implementor="com.demo.HelloWorldImpl"
address="/helloWorld" />
<bean id="client" class="com.demo.HelloWorld" factory-bean="clientFactory"
factory-method="create" />
<bean id="clientFactory" class="org.apache.cxf.jaxws.JaxWsProxyFactoryBean">
<property name="serviceClass" value="com.demo.HelloWorld" />
<property name="address"
value="http://localhost:8080/simple_cxf_ws/helloWorld" />
</bean>
</beans>这里很简单，只是通过jaxws:endpoint定义了一个webservice，implementor是webservice的处理类，而address是它的访问路径，跟我们前面写的readerService类似。
这时我们可以把它部署到tomcat中，通过http://localhost:8080/simple_cxf_ws/helloWorld?wsdl 可以直接访问。
有些朋友会问，为什么这次访问的URL跟前面的不一样呢。其实前面的访问地址是我们自己定义的，而这里的webservice地址是我们在配置文件中配置 好的，并且是通过web项目来部署的，这里就需要用项目名称，而且我们在CXFServlet那里配置了url-pattern是/*， 所以最后的URL就跟上面一致了。
可以再次用前面的测试类测试一下，注意，需要把address修改成我们发布后的URL。
CXF相比xfire又更简洁了一些，虽然它增加了一些注解，但这些无伤大雅，它只是把以前的services.xml中的信息集中到类中，反而更 方便维护，但这还是见仁见智的，有些人就喜欢配置文件，而有些人就不喜欢。另外CXF的调用方式更加简洁，比起xfire它的代码量更小了，是一个较大的 进步。
