调用webService的几种方式

转自：http://blog.csdn.net/u011165335/article/details/51345224

一、概览

方式1：

HttpClient：可以用来调用webservie服务，也可以抓取网页数据

版本1：HttpClient3.0.x

版本2：HttpClient4.x.x(目前最新4.5.2)

这2个版本的使用方式不一样；变动较大

方式2：纯Java(自带API)      jws

方式3：cxf框架

方式4：axis2框架

准备工作:

1.了解wsimport        java自带的一个命令（建议使用jdk7，稳定支持）

作用：将wsdl文件生成本地代理（java代码），方便调用

语法  wsimport [opations] <wsdl_uri>
    - wsdl_uri:wsdl 的统一资源标识符
    - d  ：指定要输出的文件的位置
    - s  ：表示要解析java的源码 ，默认解析出的是class字节码 
    - p  ： 指定输出的包名
 
1. 获取服务路径:比如
  http://ws.webxml.com.cn/WebServices/MobileCodeWS.asmx?WSDL

2. 获取wsdl文件.建议使用JDK1.6以上的版本的wsimport命令

进入dos的桌面：
方式1：wsimport http://ws.webxml.com.cn/WebServices/MobileCodeWS.asmx?WSDL
这种默认只会生成class，且会生成默认的包
方式2：生成源码，指定包和路径
wsimport -s ./ -p cn.aa http://ws.webxml.com.cn/WebServices/MobileCodeWS.asmx?WSDL

3.可以把class文件打成jar包 jar cvf  test.jar  打包目录

4.放在你的项目中进行调用：

1. public static void main(String[] args) {
2. MobileCodeWS mobileCodeWs=new MobileCodeWS();
3. MobileCodeWSSoap mobileCodeWSSoap=mobileCodeWs.getMobileCodeWSSoap();
4. String tel=mobileCodeWSSoap.getMobileCodeInfo("183735xxxx",null);
5. System.out.println(tel);
6. }

2.规范了解

JAVA *有三种WebService 规范，分别是JAX-WS（JAX-RPC）、JAXM&SAAJ、JAX-RS。

1. Jaxws(掌握)

JAX-WS  的全称为 JavaAPI for XML-Based Webservices ，早期的基于SOAP 的JAVA 的Web 服务规范JAX-RPC（javaAPI For XML-RemoteProcedure Call）目前已经被JAX-WS 规范取代。从java5开始支持JAX-WS2.0版本，Jdk1.6.0_13以后的版本支持2.1版本，jdk1.7支持2.2版本。

Jaxws开发的webservice传输soap协议。

2JAXM&SAAJ(了解)

JAXM（JAVA API For XML Message）主要定义了包含了发送和接收消息所需的API，SAAJ（SOAP With Attachment APIFor Java，JSR 67）是与JAXM 搭配使用的API，为构建SOAP 包和解析SOAP 包提供了重要的支持，支持附件传输等，JAXM&SAAJ 与JAX-WS 都是基于SOAP 的Web 服务，相比之下JAXM&SAAJ 暴漏了SOAP更多的底层细节，编码比较麻烦，而JAX-WS 更加抽象，隐藏了更多的细节，更加面向对象，实现起来你基本上不需要关心SOAP 的任何细节

3.  JAX-RS(掌握)

JAX-RS 是JAVA 针对REST(Representation State Transfer)风格制定的一套Web 服务规范，由于推出的较晚，该规范（JSR 311，目前JAX-RS 的版本为1.0）并未随JDK1.6 一起发行。

Rest定义可以自行搜索

jax-RS可以发布 rest风格webservice，因为rest的webservice不采用soap传输，直接采用http传输，可以返回xml或json，比较轻量。

以后可能会流行Rest风格的

二、简单例子

1.httpClient3.x.x

此方式不需要wsimport命令

1. // 通过Http-Client 框架来模拟实现 Http请求--get
2. public static String getMobileCodeInfo1(String mobileCode, String userID)
3. throws HttpException, IOException {
4. HttpClient client = new HttpClient();
5. GetMethod getMethod=new GetMethod("http://ws.webxml.com.cn/WebServices/MobileCodeWS.asmx/getMobileCodeInfo?mobileCode="
6. + mobileCode + "&userID=" + userID);
7. //执行，得到消息码
8. int code = client.executeMethod(getMethod);
9. System.out.println("消息码："+code);
10. String result="";
11. if (code==HttpURLConnection.HTTP_OK) {
12. //得到执行结果
13. result = getMethod.getResponseBodyAsString();
14. System.out.println(result);
15. }
16. return result;
17. }
18. // 通过Http-Client 框架来模拟实现 Http请求--post
19. // 需要导入3个jar包,本demo的jar包版本是3.1.0
20. // 目前最新的是4.5.2，使用方式也发生了变化
21. public static String getMobileCodeInfo2(String mobileCode, String userID)
22. throws HttpException, IOException {
23. // 输入服务网址
24. HttpClient client = new HttpClient();
25. // GetMethod
26. PostMethod post = new PostMethod(
27. "http://ws.webxml.com.cn/WebServices/MobileCodeWS.asmx/getMobileCodeInfo");
28. // 设置参数
29. post.setParameter("mobileCode", mobileCode);
30. post.setParameter("userID", userID);
31. // client.setTimeout(newTimeoutInMilliseconds);
32. // 执行,返回一个结果码
33. int code = client.executeMethod(post);
34. System.out.println("结果码：" + code);
35. // 获取xml结果
36. String result = post.getResponseBodyAsString();
37. System.out.println("结果：" + result);
38. //释放连接
39. post.releaseConnection();
40. return result;
41. }
42. // Post请求 ：通过Http-Client 框架来模拟实现 Http请求
43. //从xml中获取请求参数
44. //SOAP1.1方式
45. //问题：soap怎么定义,这里已经返回接结果，但是没有手机号信息，也就返回的结果匹配，不知道为什么
46. //估计是配置文件有问题
47. //soap1.1
48. @Test
49. public void soap() throws Exception{
50. HttpClient client=new HttpClient();
51. PostMethod postMethod=new PostMethod("http://ws.webxml.com.cn/WebServices/MobileCodeWS.asmx");
52. //3.设置请求参数
53. postMethod.setRequestBody(new FileInputStream("D:/soap.xml")); //文件名自定义
54. //修改请求的头部
55. postMethod.setRequestHeader("Content-Type", "text/xml; charset=utf-8");
56. //4.执行请求 ,结果码
57. int code=client.executeMethod(postMethod);
58. System.out.println("结果码:"+code);
59. //5. 获取结果
60. String result=postMethod.getResponseBodyAsString();
61. System.out.println("Post请求的结果："+result);
62. }
63. public static void main(String[] args) throws IOException {
64. // getMobileInfo("13476699xxx", "");
65. getMobileCodeInfo1("13476699xxx", "");//
66. //      getMobileCodeInfo2("13476699xxx", "");//
67. //soap,利用xml传输参数
68. }

其中：请求参数封装在soap.xml中

请求规范服务方会提供给你的

soap.xml请求内容如下：

1. <?xml version="1.0" encoding="utf-8"?>
2. <soap:Envelope xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
3. <soap:Body>
4. <getMobileCodeInfo xmlns="http://WebXml.com.cn/">
5. <mobileCode>1347669xxxx</mobileCode>
6. <userID></userID>
7. </getMobileCodeInfo>
8. </soap:Body>
9. </soap:Envelope>

httpClient4.x.x不做演示，感兴趣的可以去查查，资料很多

2.java自带API实现

2.1 类发布

2.1.1 使用默认设置

1. @WebService
2. //默认服务名会加上Service
3. public class PhoneInfoWS {
4. //默认方法名getPhoneInfo
5. //默认参数名arg0
6. //默认返回值名字：return
7. //targetNamespace默认情况下为倒置的包名
8. public Phone getPhoneInfo(String OSName) {
9. Phone p=new Phone();
10. if ("Android".equalsIgnoreCase(OSName)) {
11. p.setOS(OSName);
12. p.setOwn("Google");
13. p.setScale(80);
14. }else if("IOS".equalsIgnoreCase(OSName)){
15. p.setOS(OSName);
16. p.setOwn("Apple");
17. p.setScale(14);
18. }else if("windows Phone".equalsIgnoreCase(OSName)){
19. p.setOS(OSName);
20. p.setOwn("Microsoft");
21. p.setScale(4);
22. }else{
23. p.setOS("others");
24. p.setOwn("others");
25. p.setScale(2);
26. }
27. return p;
28. }
29. //静态，非public方法不会被自动发布
30. public static String say(String city){
31. return "hello"+city;
32. }
33. //访问时自动生成一个描述文件xml+xsd约束文件
34. public static void main(String[] args) {
35. //implementor要发布的对象，一般是接口的实现类
36. String address1="http://127.0.0.1/PhoneInfoWS1?WSDL";
37. // String address2="http://127.0.0.1/PhoneInfoWS2?WSDL";
38. Endpoint point = Endpoint.publish(address1, new PhoneInfoWS());
39. Endpoint.publish(address1, new PhoneInfoWS());
40. //   Endpoint.publish(address2, new PhoneInfoWS());
41. //关闭发布
42. //       point.stop();
43. }
44. }

2.1.2自定义设置

1. @WebService(serviceName="PhoneInfoService",targetNamespace="http://PhoneService.web.com/")
2. //默认服务名会加上Service
3. public class PhoneInfoWS1 {
4. @WebMethod(operationName="getPhoneInfo")
5. public @WebResult(name="phone") Phone getPhoneInfo(@WebParam(name="OSName") String OSName) {
6. Phone p=new Phone();
7. if ("Android".equalsIgnoreCase(OSName)) {
8. p.setOS(OSName);
9. p.setOwn("Google");
10. p.setScale(80);
11. }else if("IOS".equalsIgnoreCase(OSName)){
12. p.setOS(OSName);
13. p.setOwn("Apple");
14. p.setScale(14);
15. }else if("windows Phone".equalsIgnoreCase(OSName)){
16. p.setOS(OSName);
17. p.setOwn("Microsoft");
18. p.setScale(4);
19. }else{
20. p.setOS("others");
21. p.setOwn("others");
22. p.setScale(2);
23. }
24. return p;
25. }
26. //静态，非public方法不会被自动发布
27. public static String say(String city){
28. return "hello"+city;
29. }
30. //屏蔽要发布的方法
31. @WebMethod(exclude=true)
32. public  String say1(String city){
33. return "hello"+city;
34. }
35. public  String say2(String city){
36. return "hello"+city;
37. }
38. //访问时自动生成一个描述文件xml+xsd约束文件
39. public static void main(String[] args) {
40. //implementor要发布的对象，一般是接口的实现类
41. String address1="http://127.0.0.1/PhoneInfoWS1?WSDL";
42. //       String address2="http://127.0.0.1/PhoneInfoWS2?WSDL";
43. Endpoint point = Endpoint.publish(address1, new PhoneInfoWS1());
44. point.toString();
45. Endpoint.publish(address1, new PhoneInfoWS1());
46. //       Endpoint.publish(address2, new PhoneInfoWS1());
47. //关闭发布
48. //       point.stop();
49. }
50. }

注意：

1.  在类上添加@WebService注解,代表发布一个WebService服务
2. 通过EndPoint(端点服务)发布一个webService。Endpoint也是jdk提供的一个专门用于发布服务的类，它的publish方法接收两个参数，
                 一个是本地的服务地址，二是提供服务的类。它位于javax.xml.ws.*包中。
3. Endpoint.publish(String address, Object implementor) 静态方法在给定地址处针对指定的实现者对象创建并发布端点
4. 默认public修饰的方法自动发布，静态方法不会公布
5. 如果希望某个方法不对外公开，可以在方法上添加@WebMethod(exclude=true)，阻止对外公开。
6. 如果一个类上，被添加了@WebService注解，则必须此类至少有一个可以公开的方法，否则将会启动失败。

7.异常处理：
报错：
 com.sun.xml.internal.ws.model.RuntimeModelerException: runtime modeler error: Wrapper class com.web.PhoneService.jaxws.GetPhoneInfo is not found. 
 Have you run APT to generate them?
解决办法：jdk7就可以了

8.测试方法：

a.利用上面说的wsimport生成本地代理，然后调用里面的代码进行测试就可以了，这里就省略了

b.更方便的测试是使用Eclipse的Web Services Explorer 或者Myeclipse的SOAP Web Services Explorer进行测试

把链接：比如 http://127.0.0.1/PhoneInfoWS1?WSDL 放入到浏览器的WSDL地址栏就可以了

2.2接口发布

1. @WebService
2. public interface JobService {
3. public String getJobInfo();
4. }
5. /*
6. * 默认只会发布接口的方法，实现类自定义的方法不会被发布了
7. * 接口和实现类都需要加注解修饰
8. *
9. * 联想Spring的注入只需在实现类加入注解即可
10. */
11. @WebService(serviceName="JobServiceImplService",
12. endpointInterface="com.web.InterfaceService.JobService")
13. public class JobServiceImpl implements JobService{
14. @Override
15. public String getJobInfo() {
16. // TODO Auto-generated method stub
17. return "java开发|前端开发|数据库开发";
18. }
19. //  实现类自定义的方法不会被发布
20. public String say(String name){
21. return "hello "+name;
22. }
23. public static void main(String[] args) {
24. String address="http://127.0.0.1/JobServiceImpl?WSDL";
25. Endpoint.publish(address, new JobServiceImpl());
26. System.out.println(address);
27. }
28. }

3.CXF框架

Apache CXF 是一个开源的 Services 框架，是XFire和Celtix项目的结合产品,CXF 帮助您来构建和开发 Services 这些 Services 可以支持多种协议，比如：SOAP、POST/HTTP、RESTful HTTP CXF 大大简化了 Service可以天然地和 spring 进行无缝集成。

3.1最简单的接口发布

这里先不与Spring集成，需要的jar包

asm-3.3.jar
commons-logging-1.1.1.jar
cxf-2.4.2.jar
jetty-continuation-7.4.5.v20110725.jar
jetty-http-7.4.5.v20110725.jar
jetty-io-7.4.5.v20110725.jar
jetty-security-7.4.5.v20110725.jar
jetty-server-7.4.5.v20110725.jar
jetty-util-7.4.5.v20110725.jar
neethi-3.0.1.jar
wsdl4j-1.6.2.jar
xmlschema-core-2.0.jar

这里用的是2.4.2的，老版本，不要介意，最新版本3.1.6，可以自行下载

1. @WebService
2. //声明soap1.2
3. //@BindingType(value=SOAPBinding.SOAP12HTTP_BINDING)
4. public interface LanguageService {
5. public  String getLanguage(int num);
6. }
7. //开发语言排行榜
8. @WebService
9. public class LanguageServiceImpl implements LanguageService {
10. @Override
11. public String getLanguage(int num) {
12. String language="";
13. switch (num) {
14. case 1:
15. language="java语言";
16. break;
17. case 2:
18. language="C语言";
19. break;
20. case 3:
21. language="Objective-C语言";
22. break;
23. case 4:
24. language="C#语言";
25. break;
26. default:
27. language="没有找到你要排名的语言";
28. break;
29. }
30. return language;
31. }
32. /*
33. * 方式1：ServerFactoryBean
34. * 不支持注解，就算你添加了注解也不起作用
35. * 所以你不能修改服务名，方法名，参数名，工作空间等
36. * 另外不支持拦截器
37. * 方式2：JaxWsServerFactoryBean为ServerFactoryBean的子类（功能扩展）
38. * 特点：
39. * 1、支持注解，如果你没有使用@webService，运行后，是不会发布方法的。。，所以注解必须加
40. * 如果有接口实现，只需要在接口加上注解即可，命名注解也要在接口里面做
41. * 这跟之前的纯java开发webservice有些不一样，纯java开发接口和实现类要改名必须都加上注解才行
42. * 2、支持拦截器
43. * 3、生成的wsdl更加规范
44. * 两者的wsdl区别：
45. *     a.方式1 默认不加servcie  方式2：默认加Service，比如<wsdl:definitions name="LanguageServiceService"
46. *     b.方式1 元素前缀 xsd    方式2 元素前缀xs
47. *     c.方式1
48. <wsdl:portType name="LanguageServicePortType">
49. 方式2
50. <wsdl:portType name="LanguageService">没有加PortType
51. webService访问流程：
52. 1.首先进行握手，检查本地代理与服务端的wsdl是否一致，采用的是get请求验证
53. 2.采用post请求，封装请求参数到xml中，采用soap通信，将这个请求xml传输到服务端
54. 3.封装结果为xml，采用soap通信返回xml，再到客户端解析得到方法的返回值
55. */
56. //方式1：不通过注解发布
57. //这种方式没有添加webService注解,也就是说没有注解也可以发布webService服务,
58. //    但是这种方式不是很规范,比如我们不可以通过注解的方式来修改WSDL的标签信息
59. private static void publishServie1(){
60. LanguageService languageService=new LanguageServiceImpl();
61. ServerFactoryBean bean=new ServerFactoryBean();
62. //Endpoint :地址  ， 实现对象
63. //      bean.setAddress("http://192.168.8.178:9999/ws/cxf/languangeService");
64. bean.setAddress("http://127.0.0.1:9999/ws/cxf/languangeService?WSDL");
65. //注册服务器地址和端口
66. bean.setServiceClass(LanguageService.class);//对外提供webservcie的业务类或者接口
67. //注册哪个实现类提供服务
68. bean.setServiceBean(languageService);//服务的实现bean
69. Server server = bean.create();//创建，发布webservice
70. //10秒有效
71. //      Thread.sleep(1*10*1000);
72. //      server.stop();
73. //      System.exit(0);
74. }
75. //JaxWsServerFactoryBean是ServerFactoryBean的子类
76. //可以提供拦截器
77. private static void publishServie2(){
78. JaxWsServerFactoryBean bean=new JaxWsServerFactoryBean();
79. //地址WSDL加不加都可以，访问时加上就可以了,不加端口也可以发布
80. bean.setAddress("http://127.0.0.1:8888/ws/cxf/languangeService?WSDL");
81. //      bean.setAddress("http://127.0.0.1/ws/cxf/languangeService?WSDL");
82. //设置服务接口
83. bean.setServiceClass(LanguageService.class);
84. //设置服务的类
85. bean.setServiceBean(new LanguageServiceImpl());
86. //输入信息拦截器
87. bean.getInInterceptors().add(new LoggingInInterceptor());
88. //输出信息拦截器
89. bean.getOutInterceptors().add(new LoggingOutInterceptor());
90. Server server = bean.create();
91. }
92. public static void main(String[] args) throws Exception{
93. //      publishServie1();
94. publishServie2();
95. }
96. }

3.2 结合Spring发布服务

这里重点是如何配置发布服务，业务逻辑仅仅是演示（辅助），不必参考

要发布的服务：保存和根据姓名查询员工

saveEmployee          findEmployeeByName

步骤：

3.2.1.导包cxf2.7.18里面的所有jar包 ，其中jetty包不需要，因为应用是部署在tomcat里面

3.2. 2.建实体类，DB类（模拟）

1. public class Employee {
2. private String name;
3. private Integer age;
4. @DateTimeFormat(pattern="yyyy-MM-dd")
5. private Date birthday;
6. public Employee() {
7. super();
8. }
9. public Employee(String name, Integer age, Date birthday) {
10. super();
11. this.name = name;
12. this.age = age;
13. this.birthday = birthday;
14. }
15. public String getName() {
16. return name;
17. }
18. public void setName(String name) {
19. this.name = name;
20. }
21. public Integer getAge() {
22. return age;
23. }
24. public void setAge(Integer age) {
25. this.age = age;
26. }
27. public Date getBirthday() {
28. return birthday;
29. }
30. public void setBirthday(Date birthday) {
31. this.birthday = birthday;
32. }
33. @Override
34. public String toString() {
35. return "Employee [name=" + name + ", age=" + age + ", birthday="
36. + birthday + "]";
37. }
38. }

1. //运行时如果报错Unsupported major.minor version 51.0
2. //这说明jdk版本不对，即tomcat的jdk版本跟项目版本不一致
3. @Repository
4. public class EmployeeDB {
5. public EmployeeDB(){}
6. private static List<Employee> list=new ArrayList<Employee>();
7. static{
8. list.add(new  Employee("小米", 12, new Date()));
9. }
10. public void save(Employee employee){
11. list.add(employee);
12. }
13. public Employee findByName(String name){
14. if (list.size()>0) {
15. for(Employee e:list){
16. if (e.getName().equals(name)) {
17. return e;
18. }
19. }
20. }
21. return null;
22. }
23. public List<Employee> findAll(){
24. return list;
25. }
26. public void deleteByName(String name) throws Exception{
27. if (name.length()==0||name==null) {
28. throw new Exception("删除用户异常");
29. }
30. for (int i = 0; i < list.size(); i++) {
31. if (name.equals(list.get(i).getName())) {
32. list.remove(list.get(i));
33. break;
34. }
35. }
36. }
37. }

3.2.3.建立服务类

1. @WebService(serviceName="EmployeeService")
2. public interface EmployeeService {
3. public void saveEmployee(@WebParam(name="employee")Employee employee );
4. public @WebResult(name="Employee")Employee  findEmployeeByName(@WebParam(name="name")String name);
5. }
6. public class EmployeeServiceImpl implements EmployeeService{
7. @Autowired
8. private EmployeeDB db;
9. @Override
10. public void saveEmployee(Employee employee) {
11. System.out.println("EmployeeDB:"+db);
12. db.save(employee);
13. }
14. @Override
15. public Employee findEmployeeByName(String name) {
16. if (name.length()==0||name==null) {
17. return null;
18. }
19. return  db.findByName(name);
20. }
21. }

3.2. 4.写页面，写Servlet（如果单纯为了测试发布的服务，这些可以不需要）

1. <%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
2. <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
3. <html>
4. <head>
5. <title>添加员工</title>
6. <meta http-equiv="pragma" content="no-cache">
7. <meta http-equiv="cache-control" content="no-cache">
8. <meta http-equiv="expires" content="0">
9. <meta http-equiv="keywords" content="keyword1,keyword2,keyword3">
10. <meta http-equiv="description" content="This is my page">
11. <!--
12. <link rel="stylesheet" type="text/css" href="styles.css">
13. -->
14. </head>
15. <body>
16. <form action="${pageContext.request.contextPath}/AddServlet" method="post">
17. 用户名:<input type="text" name="name" /><br/>
18. 年龄:<input type="text" name="age" /><br/>
19. 生日:<input type="text" name="birthday" /><br/>
20. <input type="submit" value="提交" />
21. </form>
22. </body>
23. </html>

1. public class AddServlet extends HttpServlet {
2. private EmployeeService employeeService;
3. @Override
4. public void init() throws ServletException {
5. WebApplicationContext context=WebApplicationContextUtils.getWebApplicationContext(this.getServletContext());
6. //得到的是实现类对象
7. employeeService=(EmployeeService) context.getBean("employeeService");
8. System.out.println("employeeService:"+employeeService);
9. }
10. public void doGet(HttpServletRequest request, HttpServletResponse response)
11. throws ServletException, IOException {
12. response.setContentType("text/html;charset=utf-8");
13. String name=request.getParameter("name");
14. String age=request.getParameter("age");
15. String birthday=request.getParameter("birthday");
16. Employee employee=new Employee();
17. employee.setName(name);
18. employee.setAge(Integer.parseInt(age));
19. employee.setBirthday(DateUtil.stringToDate(birthday, "yyyy-MM-dd"));
20. employeeService.saveEmployee(employee);
21. //检查是否存进去进去了
22. EmployeeDB db=new EmployeeDB();
23. System.out.println("db.size():"+db.findAll().size());
24. }
25. public void doPost(HttpServletRequest request, HttpServletResponse response)
26. throws ServletException, IOException {
27. doGet(request, response);
28. }
29. }

3.2.5.配置applicationContext.xml和web.xml

1. <?xml version="1.0" encoding="UTF-8"?>
2. <beans
3. xmlns="http://www.springframework.org/schema/beans"
4. xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
5. xmlns:p="http://www.springframework.org/schema/p"
6. xmlns:context="http://www.springframework.org/schema/context"
7. xmlns:jaxws="http://cxf.apache.org/jaxws"
8. xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.1.xsd
9. http://www.springframework.org/schema/context
10. http://www.springframework.org/schema/context/spring-context.xsd
11. http://cxf.apache.org/jaxws
12. http://cxf.apache.org/schemas/jaxws.xsd">
13. <context:component-scan base-package="com.demo.*"></context:component-scan>
14. <bean id="employeeService"  class="com.demo.webService.EmployeeServiceImpl"></bean>
15. <!-- 配置cxf
16. 地址：    比如：  http://192.168.114.10:8080/CXF_Server/ws/employeeManager
17. 组成 ：           http://192.168.114.10:8080 +CXF_Server（ 项目名）+ws（过滤的路径）+/employeeManager(自定义部分)
18. 服务类 ：
19. 服务的实现类：
20. 拦截器
21. -->
22. <jaxws:server serviceClass="com.demo.webService.EmployeeService" address="/employeeService">
23. <jaxws:serviceBean>
24. <ref bean="employeeService"/>
25. </jaxws:serviceBean>
26. <jaxws:inInterceptors>
27. <bean class="org.apache.cxf.interceptor.LoggingInInterceptor"></bean>
28. </jaxws:inInterceptors>
29. <jaxws:outInterceptors>
30. <bean class="org.apache.cxf.interceptor.LoggingOutInterceptor"/>
31. </jaxws:outInterceptors>
32. </jaxws:server>
33. </beans>

web.xml

1. <?xml version="1.0" encoding="UTF-8"?>
2. <web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://java.sun.com/xml/ns/javaee" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd" id="WebApp_ID" version="3.0">
3. <display-name>CXFDemo1</display-name>
4. <welcome-file-list>
5. <welcome-file>index.jsp</welcome-file>
6. </welcome-file-list>
7. <!--   配置CXF的Servlet，用来处理webService的请求 -->
8. <servlet>
9. <servlet-name>cxf</servlet-name>
10. <servlet-class>org.apache.cxf.transport.servlet.CXFServlet</servlet-class>
11. <load-on-startup>1</load-on-startup>
12. </servlet>
13. <servlet>
14. <servlet-name>AddServlet</servlet-name>
15. <servlet-class>com.demo.web.AddServlet</servlet-class>
16. </servlet>
17. <servlet-mapping>
18. <servlet-name>cxf</servlet-name>
19. <url-pattern>/ws/*</url-pattern>
20. </servlet-mapping>
21. <servlet-mapping>
22. <servlet-name>AddServlet</servlet-name>
23. <url-pattern>/AddServlet</url-pattern>
24. </servlet-mapping>
25. <listener>
26. <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
27. </listener>
28. <context-param>
29. <param-name>contextConfigLocation</param-name>
30. <param-value>classpath:applicationContext.xml</param-value>
31. </context-param>
32. </web-app>

3.2.6.工具类

1. public class DateUtil {
2. private DateUtil() {
3. }
4. public static String dateToString(Date d, String format) {
5. return new SimpleDateFormat(format).format(d);
6. }
7. public static Date stringToDate(String s, String format) {
8. try {
9. return new SimpleDateFormat(format).parse(s);
10. } catch (ParseException e) {
11. e.printStackTrace();
12. }
13. return null;
14. }
15. }

3.2.7.访问：http://localhost:8080/CXFDemo2/ws

4.Axis2发布服务

4.1比较

Axis2是从Axis1.x系列发展而来。CXF则是XFire和Celtix项目的结合产品。Axis2是从底层全部重新实现，使用了新的扩展性更好模块架构。 CXF也重新的深化了XFire和Celtix这两个开发工具。
1.CXF支持 WS-Addressing，WS-Policy， WS-RM， WS-Security和WS-I Basic Profile。Axis2不支持WS-Policy，现在应该支持了。
2. CXF可以很好支持Spring。Axis2不能（没测试过，现在应该可以吧，待测。。）
3. AXIS2支持更广泛的数据并对，如XMLBeans，JiBX，JaxMe和JaxBRI和它自定义的数据绑定ADB。注意JaxME和JaxBRI都还是试验性的。CXF只支持JAXB和Aegis。
4. Axis2支持多语言-除了Java,他还支持C/C++版本
如何抉择： 
1、如果应用程序需要多语言的支持，Axis2 应当是首选了； 
2、如果应用程序是遵循 Spring 哲学路线的话，Apache CXF 是一种更好的选择，特别对嵌入式的 Web Services 来说；

目前asix2最新版本1.7.1

4.2安装插件

4.2.1Eclipse

axis2-eclipse-codegen-plugin-1.7.1.zip
     axis2-eclipse-service-plugin-1.7.1.zip

解压的jar包放入Eclipse的dropins目录

4.2.2Myeclipse

axis2-eclipse-codegen-wizard.zip
     axis2-eclipse-service-archiver-wizard.zip
     解压放入到Myeclipse的dropins目录

4.3  实现方式有很多

这里简单说明下最快速的2种方式，Eclipse实现

方式1：不使用插件实现

1.配置环境变量（不是必须的）

2.配置webService环境

2.建立一个动态web项目

方式2：使用插件实现

建一个普通的动态项目，不选择webService环境

这个实现网上有很多，实现参考：http://blog.csdn.NET/wangchangpen62/article/details/45171001

好了，先写到这吧

以上做了个简单的小结，深入应用还待学习。。。。