❶ java Webservice都有哪幾種方式啊，哪種方式比較好啊
webservice的應用已經越來越廣泛了，下面介紹幾種在Java體系中開發webservice的方式，相當於做個記錄。
1.Axis2
Axis是apache下一個開源的webservice開發組件，出現的算是比較早了，也比較成熟。這里主要介紹Axis+eclipse開發webservice，當然不用eclipse也可以開發和發布webservice，只是用eclipse會比較方便。
（1）下載eclipse的Java EE版本
（2）下載axis2
（3）下載eclipse的axis2插件
Axis2_Codegen_Wizard
Axis2_Service_Archiver
推薦使用1.3的版本
（4）eclipse安裝axis2插件
1）在任意目錄下新建一個Axis2文件夾，在該文件夾下新建eclipse目錄，在eclipse目錄中新建plugins目錄和features目錄，例如：D:\programSoftware\eclipse-SVN\Axis2\eclipse；
2）把下載的axis2插件解壓，並把解壓的文件放到新建的eclipse的plugins目錄下；
3）在%eclipse_home%的目錄下新建links目錄，並在links目錄下新建axis2.link文件，內容為：path=D:\programSoftware\eclipse-SVN\Axis2;
4）重啟eclipse，點擊·file-new-other,如果看到Axis2 Wizards，則表明插件安裝成功。
（5）安裝axis2
（6）使用eclipse新建web工程，創建一個普通java類，至少包含一個方法。
（7）發布webservice
1）點擊eclipse的File-New-other，打開Axis2 Wizards，選擇Axis2 Service Archiver，然後Next;
2）選擇Class File Location，也就是類文件存放路徑，注意：只選到classes目錄，不要包括包文件夾，然後Next;
3）選擇Skip WSDL，然後Next
4）一路Next到Select the Service XML file to be included in the Service archive，勾選Generate theservice xml automatically；
5）Service Name-填寫你的service名稱，Class Name-填寫類名稱，要包括包名，然後點擊load，然後點擊Finish，這時webservice就發布成功了；
6）然後到%TOMCAT_HOME%/webapps/axis2/WEB-INF/services 看看是否多了一個.aar的文件；
注意：以上的方式是發布到axis2.war包中，你也可以把生成.aar文件到你的實際應用中，同時，你也可以使用eclipse的create webservice功能發布你的webservice，選擇axis2生成你的webservice，這樣webservice就會部署到你的應用中了。
2.Apche CXF
CXF開發webservice也是比較方便和簡單的，它和spring的集成可以說是非常地好。舉一個CXF開發webservice的例子吧。
1）在eclipse中新建一個web工程，導入依賴包，如圖：
2）編寫一個介面，如:
注意：CXF開發的webservice，介面中的方法的參數一定要以這種方式，否則客戶端調用的時候CXF服務端會接收不到參數的值，name：參數名稱，可不寫（建議寫上），targetNamespace：命名空間，一定要填寫上，默認是包名反過來的順序，mode：參數類型，IN表示輸入。
3）編寫一個實現類，實現介面的方法；
4）和spring的集成，編寫一個bean文件，如：cxf-beans.xml，內容如下：
Cxf-beans.xml代碼
<?xml version="1.0" encoding="UTF-8" ?>
<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="vote" implementor="com.zcl.cxf.service.VoteImpl" address="/Vote" />
</beans>
這個文件比較容易理解，就不解釋了。
5）配置CXFServlet
在web.xml文件中配置CXFServlet，載入cxf-beans.xml文件，內容如下：
Web.xml代碼
id="WebApp_ID" version="2.5">
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>WEB-INF/cxf-beans.xml</param-value>
</context-param>
<listener>
<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>
<servlet>
<servlet-name>cxf</servlet-name>
<servlet-class>org.apache.cxf.transport.servlet.CXFServlet</servlet-class>
<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>cxf</servlet-name>
<url-pattern>/services/*</url-pattern>
</servlet-mapping>
</web-app>
把工程部署到中間件，如tomcat，就可以訪問該webservice了。
3.JDK開發webservice
1）編寫一個Java類，如下：
Jdkwebservice.java代碼
package demo;
import javax.jws.WebParam;
import javax.jws.WebService;
import javax.xml.ws.Endpoint;
@WebService
public class JdkWebService {
return "Just do it," + value + "!";
}
public static void main(String[] args) {
}
}
2）運行該java類，在瀏覽器上就可以訪問該webservice了。
注意：開發web工程的時候，這種方法不太友好。我們可以編寫一個servlet類，在servlet類的初始化方法中發布webservice，這樣我們的中間件伺服器啟動的時候就會幫我們自動webservice了。
4) xfire
開發WebService的框架不少，每個框架都有各自的有點，最近我用xfire練習開發WebService,下面是開發WebService的小例子，希望對入門的人有些小幫助
1.新建一個java web project命名為TestWebService，將xfire相關的jar包添加到lib目錄中,寫介面類和實現類
Java代碼
package com.lamp.service;
public interface MessageService {
public String getName(String name);
}
[java] view plainprint?
package com.lamp.service;
public interface MessageService {
public String getName(String name);
}
實現類
Java代碼
package com.lamp.service.impl;
import com.lamp.service.MessageService;
public class MessageServiceImpl implements MessageService {
public String getName(String name) {
return "hellow " + name + ", welcome to WebService world";
}
}
[java] view plainprint?
package com.lamp.service.impl;
import com.lamp.service.MessageService;
public class MessageServiceImpl implements MessageService {
public String getName(String name) {
return "hellow " + name + ", welcome to WebService world";
}
}
在src目錄下新建文件夾META-INF，然後再在其下新建文件夾xfire,在xfire目錄下新建配置文件services.xml
Xml代碼
<?xml version="1.0" encoding="UTF-8"?>
<service>
<name>MessageService</name>
<serviceClass>com.lamp.service.MessageService</serviceClass>
<implementationClass>com.lamp.service.impl.MessageServiceImpl</implementationClass>
</service>
</beans>
[xml] view plainprint?
<?xml version="1.0" encoding="UTF-8"?>
<service>
<name>MessageService</name>
<serviceClass>com.lamp.service.MessageService</serviceClass>
<implementationClass>com.lamp.service.impl.MessageServiceImpl</implementationClass>
</service>
</beans>
最後在web.xml中配置xfire的servlet
Xml代碼
<servlet>
<servlet-name>XFireServlet</servlet-name>
<servlet-class>
</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>XFireServlet</servlet-name>
<url-pattern>/servlet/XFireServlet/*</url-pattern>
</servlet-mapping>
<servlet-mapping>
<servlet-name>XFireServlet</servlet-name>
<url-pattern>/services/*</url-pattern>
</servlet-mapping>
[xml] view plainprint?
<servlet>
<servlet-name>XFireServlet</servlet-name>
<servlet-class>
</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>XFireServlet</servlet-name>
<url-pattern>/servlet/XFireServlet/*</url-pattern>
</servlet-mapping>
<servlet-mapping>
<servlet-name>XFireServlet</servlet-name>
<url-pattern>/services/*</url-pattern>
</servlet-mapping>
這樣伺服器端開發完畢，現在開始客戶端的開發
新建一個java project也將xfire相關的jar引入，我用ant在客戶端生成代理對象，在項目路徑下新建build.xml,代碼為
Xml代碼
<?xml version="1.0" encoding="UTF-8"?>
<project name="WebService" basedir="." default="gen-webservice">
<property file="build.properties">
</property>
<path id="project-classpath">
<fileset dir="${lib.dir}">
<include name="**/*.jar" />
</fileset>
</path>
<target name="gen-webservice">
<taskdef name="wsgen" classname="org.codehaus.xfire.gen.WsGenTask" classpathref="project-classpath" />
<wsgen outputDirectory="${src.dir}"
wsdl="${wsdl.dir}" package="com.lamp.ws.client" overwrite="true"/>
</target>
</project>
[xml] view plainprint?
<?xml version="1.0" encoding="UTF-8"?>
<project name="WebService" basedir="." default="gen-webservice">
<property file="build.properties">
</property>
<path id="project-classpath">
<fileset dir="${lib.dir}">
<include name="**/*.jar" />
</fileset>
</path>
<target name="gen-webservice">
<taskdef name="wsgen" classname="org.codehaus.xfire.gen.WsGenTask" classpathref="project-classpath" />
<wsgen outputDirectory="${src.dir}"
wsdl="${wsdl.dir}" package="com.lamp.ws.client" overwrite="true"/>
</target>
</project>
❷ java如何寫webservice服務端
Java 中的 Web Service 分為基於 SOAP 的和基於 REST 的兩種，下面簡單說一個基於 SOAP 的例子。要使用 JDK6u4 之後的版本才能編譯通過。
先編寫一個 Web Service 的介面：
@WebService
@SOAPBinding(style=Style.RPC)
publicinterfaceTimeServer{
@();
@WebMethodlonggetTimeAsElapsed();
}
再編寫 Web Service 實現：
importjava.util.Date;
importjavax.jws.WebService;
@WebService(endpointInterface="test.TimeServer")
{
publicStringgetTimeAsString(){returnnewDate().toString();}
publiclonggetTimeAsElapsed(){returnnewDate().getTime();}
}
最後啟動 Web Service：
{
publicstaticvoidmain(String[]args){
Endpoint.publish("http://127.0.0.1:9876/ts",newTimeServerImpl());
}
}如果正常啟動，可以用瀏覽器訪問 http://127.0.0.1:9876/ts?wsdl 看到這個 Web Service 的 wsdl 文檔。
❸ 怎麼規范的開發webservice介面
以下是操作步驟：
1、編寫服務代碼
服務代碼提供了兩個函數，分別為sayHello和sayHelloToPerson，在HelloService.java類中
2、發布WebService
要將上邊寫的HelloService類發布為WebService，需要先搭建Web應用。下面是在Tomcat下使用Axis創建WebService服務的例子。
3、在Tomcat下創建Web應用
在該例子中，在Tomcat下創建了一個context path為test_webservice的WEB應用。
（1） 在Tomcat的webapps下創建如下文件系統
test_webservice
WEB-INF
lib
Classes
（2）在WEB-INF文件夾下創建web.xml文件，在web.xml中主要是配置axis。
4、復制axis相關的jar文件
將axis的相關jar文件復制到WEB-INF\lib文件夾下。這些文件包括：
activation.jar
axis.jar
axis-ant.jar
axis-schema.jar
commons-discovery-0.2.jar
commons-logging-1.0.4.jar
jaxrpc.jar
log4j-1.2.8.jar
mailapi.jar
saaj.jar
wsdl4j-1.5.1.jar
xmlsec-1.3.0.jar
5、測試發布的WEB應用
啟動Tomcat服務，打開IE瀏覽器，訪問http:host:port/test_webservice/services，
如果看到如下界面就說明AXIS部署成功了。
6、發布WebService
發布WebService需要使用現有的AdminService來實現，這里我寫了一個批處理文件來發布WebService，以後如果需要發布其他文件，只需要修改相應的參數就可以了。
（1）創建deploy.wsdd文件。
（2）創建發布WebService服務的批處理文件deploywebservice.bat。
其中E:\workspace\Libwebservice是存放axis對應的jar文件的文件夾，現在將所有的jar文件都加入到此文件夾中。
-l後的參數是本地要發布WebService的AdminService對應的訪問地址。
最後deploy.wsdd是對應的配置文件名稱。
（3） 將deploy.wsdd文件和deploywebservice.bat文件復制到同一個文件夾下，執行deploywebservice.bat批處理文件，就可以將deploy.wsdd中描述的Java類發布為WebService。發布完成之後再訪問http://host:port/test_webservice/services
❹ 怎樣新建一個Java的Web Service
伺服器端的操作:
1. 創建一個WebService項目。（不需要是Java EE 5.0）
2. 創建包與介面以及實現類。
3. 加上WebService的包
4. 編輯配置文件
5. 部署後在瀏覽器中測試:http localhost:8080/testWebService/services， 格式是固定的，中間換成項目名即可！
至此，伺服器端已完成！以下做的是客戶端的調用。
1. 創建客戶端項目
2．將伺服器端的包復制到客戶端(注意，實現類要去掉)
3. 加入WebService包
4. 在Next時， 注意將紅框中的勾打上。
6. 在包中創建一個類測試調用外部的WebService是否成功！(注意取地址時應加上webservice的名稱)
package com.yenange.service;
import java.net.MalformedURLException;
import org.codehaus.xfire.XFireFactory;
import org.codehaus.xfire.client.XFireProxyFactory;
import org.codehaus.xfire.service.Service;
import org.codehaus.xfire.service.binding.ObjectServiceFactory;
public class TestWS {
public static void main(String[] args) {
//1.取得WebService的路徑
String url="http /localhost:8080/testWebService/services/testWebService";
//2.創建服務
Service service=new ObjectServiceFactory().create(IMyWebService.class);
//3.創建服務代理
XFireProxyFactory factory=new XFireProxyFactory(XFireFactory.newInstance().getXFire());
//4.調用外部的WebService, 建立對象. 再測試其方法
try {
IMyWebService obj=(IMyWebService)factory.create(service,url);
System.out.println(obj.HelloWorld("leaf"));
} catch (MalformedURLException e) {
e.printStackTrace();
}
}
}
至此，java的WebService調用完成！
❺ 求助.webservice用JAVA怎麼連接資料庫 進行開發
1、webservice部署後連接中心資料庫
2、需要本地後台客戶端，讀取本地數據，然後通過報文的形式發送給webservice，webservice接收後插入資料庫中
3、本地客戶端程序是java後台程序,直接讀取本地資料庫，生成報文.
❻ Java訪問WebService介面方法 , 返回xml數據，能根據 下面的能給我寫個實例嗎略急
樓主，你好。不知道你自己有沒有許可權修改這個介面的隱戚參數類型和返回值類型。
如果可以，建議修改成
Document getHolidayMsg (String key, String flag, Document xmlMessage)
然後建議你下灶告陵載一個dom4j的包，這個包是專門處理xml讀寫的。
你可以把xmlMessage里的信息直接創建一個XML文檔傳給伺服器。伺服器返回XML文檔即可。
如果實現過程有不懂可以追問或私友前信聊~
希望對你有幫助
❼ 如何在Java中快速發布WebService服務
在Java中快速發布WebService服務方法：
一、通過Axis2提供的模板自動發布
這種方法非常簡單，只要下載Axis包後從裡面的「axis-1_4\webapps」中找到axis站點，將它拷出來放到你要部署的tomcat/webapps下，再將要發布的java類放到axis文件夾里，再將文件名的後綴改為「jws」，這樣一個webservice就發布成功了。訪問時按照路徑「http://IP:Port/axis/類名.jws?wsdl」就可以了。
怎麼樣？這種方法非常是不是非常簡單？對，它特別適合初學java或者是手頭沒有很好的SDE開發和調試工具的時候。
但很明顯，這種方法不太好調試，又不能凸顯您的專業水準，更不能集成到您的開發環境里。所以如果您不是很急，就可以用下面一種辦法來發布：
二、通過JWS來手動發布
步驟如下：
1、在Eclipse里新建一個Dynamic Web Project，如下圖所示(相信這一步您比我還熟，所以會的可以略過)：
2、在「Project Name」中輸入工程名稱，如「JavaWebService」：
3、一直單擊「Next」按鈕直到出現如下對話框：
在上面的對話框中一定要注意需要選中「Generate web.xml deployment descriptor」，否則後面再添加就比較麻煩。選中後單擊「Finish」按鈕即可完成工程創建。
4、引入必須的jar包：
axis.jar、commons-discovery-0.2.jar、commons-logging.jar、jaxrpc.jar、saaj.jar、wsdl4j.jar
最好將jar包拷貝到工程的WEB-INF/lib下後直接引用本工程內的jar包，這樣不會導致工程文件夾或jar包所在文件夾移動後讀取不到jar包的問題：
分別單擊頂層對話框和「Properties」對話框的「OK」按鈕完成jar包引用。
5、新建package和java文件，如下圖所示：
首先說說com.test.javabean.Student.java這個類。看得出來這個類是個JavaBean，目的是為了封裝一個Java的實體類，這樣做的好處是萬一要把很多變數返回給客戶端的話，客戶端不至於在方法中聲明很多形參來接收，而是通過一個對象來接收。Student.java的實現如下：
[java] view plain
package com.test.javabean;
import java.io.Serializable;
public class Student implements Serializable{
private String ID;
private String Name;
private String Sex;
private int age;
public String getID() {
return ID;
}
public void setID(String iD) {
ID = iD;
}
public String getName() {
return Name;
}
public void setName(String name) {
Name = name;
}
public String getSex() {
return Sex;
}
public void setSex(String sex) {
Sex = sex;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
再來看看com.test.webservice.CStudent.java這個類，定義如下：
[java] view plain
package com.test.webservice;
import javax.jws.WebService;
import com.test.javabean.Student;
@WebService
public class CStudent {
public Student getStudent(String name) throws java.rmi.RemoteException{
Student student = new Student();
student.setName(name);
student.setAge(14);
student.setID("25");
student.setSex("Male");
return student;
}
}
為了簡單起見，就不涉及到更多的後台查詢了，先寫死返回結果吧。不知您注意到了沒有，這個類跟普通類的區別是在類的頂部加了個「@WebService」聲明。對，這樣就是個WebService方法了，是不是也很簡單？但是這樣就得記著在上面引入javax.jws.WebService包。偶對了，這種方式是JDK1.7里增加的方式，所以要想使用這種特性，就得麻煩您把JDK升級到1.7，方法很簡單，用綠色版的就可以啦，不用勞煩您把JDK卸了又重裝。只需要把JDK放到哪個盤的根目錄(這樣是為了防止路徑中有空格或是括弧什麼的，否則一旦出問題您就苦逼了)，然後把JDK的路徑定義為JAVA_HOME，再在path中增加%JAVA_HOME%/bin;就可以了。這樣做的好處是可以隨時很方便地更換JDK的版本，而不需要卸載後再重新安裝。
扯遠了。有了WebService的方法體，您還需要再發布一下WebService，所以還得新建一個com.test.servlet.CStudentServlet.java類：
[java] view plain
package com.test.servlet;
import java.io.IOException;
import java.net.InetAddress;
import java.net.UnknownHostException;
import java.util.Properties;
import javax.jws.WebService;
import javax.servlet.*;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.xml.ws.Endpoint;
import com.test.webservice.CStudent;
public class CStudentServlet extends HttpServlet{
/**
* @see Servlet#init(ServletConfig)
*/
public void init(ServletConfig config) throws ServletException {
// TODO Auto-generated method stub
super.init(config);
System.out.println("正在啟動WebService服務：http://192.168.56.1:8082/JavaWebService/Student");
Endpoint.publish("http://<span style="font-family: Arial, Helvetica, sans-serif;">192.168.56.1</span><span style="font-family: Arial, Helvetica, sans-serif;">:8082/</span><span style="font-family: Arial, Helvetica, sans-serif;">JavaWebService</span><span style="font-family: Arial, Helvetica, sans-serif;">/Student", new CStudent());</span>
}
/**
* @see Servlet#getServletConfig()
*/
public ServletConfig getServletConfig() {
// TODO Auto-generated method stub
return null;
}
/**
* @see HttpServlet#doGet(HttpServletRequest request, HttpServletResponse response)
*/
protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
// TODO Auto-generated method stub
}
public void service(ServletRequest servletRequest, ServletResponse servletResponse) throws ServletException, IOException {
System.out.println("進入WSServlet的service()方法");
}
/**
* @see HttpServlet#doPost(HttpServletRequest request, HttpServletResponse response)
*/
protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
// TODO Auto-generated method stub
}
}
上面的代碼中有處細節不知您注意了沒有：把IP地址、埠號、站點名等信息寫死到了代碼里。對，不僅如此，你這里寫的什麼IP，就必須用什麼IP訪問，即便是在本機寫成localhost都不可以。jws就是這么奇怪。所以在實際中可以參考一些資料動態獲取IP地址和埠號。
對了，您那邊代碼是不是報錯了？對，這是因為您還得做一步操作——添加server和對server組件包的引用，以tomcat為例，方法如下：
找到servers窗口，單擊「new server wizard...」鏈接：
打開如下對話框：
看到了吧？選擇Apache下的」Tomcat v7.0 Server「，然後單擊」Next「：
在上圖中單擊右側」Browse「按鈕，找到Tomcat所在的目錄，再在JRE中選擇1.7的JDK。如果您還沒有配置JDK，就請自行查找資料進行配置吧，某在這里就不講了，不然又扯遠啦。
然後進入這個窗口：
這個對話框得特別留意一下，不要著急單擊」Add「按鈕添加站點那，否則啟動後您就找不到站點部署的位置了。所以這一步直接單擊」Finish「。完畢後雙擊新添加的server，打開如下對話框：
在上面的窗口中，一定要先選擇第二項」Use Tomcat installation (takes control of Tomcat installation)「，然後在」Deploy path「中將內容改為」webapps「，然後再按下」Ctrl+S「鍵保存配置，這樣就可以把站點部署到您指定的tomcat的webapps下了。
然後記著給站點添加servlet-api.jar包的引用，在工程上單擊右鍵，選擇」Properties「，打開如下對話框：
看到了吧？切換到」Libraries「選項卡後先點擊右側的」Add Library「按鈕，再在彈出的窗口中選擇」Server Runtime「，單擊」Next「-->「Finish」和父窗口的」OK「按鈕就可以成功引入servlet所需的jar包了。怎麼樣？CStudentServlet.java中再沒有錯誤提示了吧？
下一步需要將servlet配置為自啟動，您只要在web.xml中增加如下內容就可以了：
[html] view plain
<servlet>
<servlet-name>CStudentServlet</servlet-name>
<servlet-class>com.test.servlet.CStudentServlet</servlet-class>
<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>CStudentServlet</servlet-name>
<url-pattern>/servlet/CStudentServlet</url-pattern>
</servlet-mapping>
記著把站點發布一下，在tomcat上單擊郵件，選擇「Add and Remove」，將JavaWebService發布到tomcat中。
下一步只要發布和啟動一下站點就可以了。如果您還不會，那就在server上單擊右鍵，選擇「Publish」，然後再選擇「Start」就可以了。
啟動成功
❽ 用 java 編寫一個 基於Web Service的軟體
1.首先說一下兩個開發webservices的工具包：axis 和XFire 本人首先接觸的是axis。
兩者比較如下：
相對於Axis來說，目前XFire相對受歡迎，加上其提供了和Spring集成的支持，在目前的Web Service開源社區擁有眾多的追隨者。並且因為XFire為Spring提供的支持，使得我們可以很容易在Spring中使用XFire構建Web Service應用。
知道了這兩個框架你研究起來也就不難了。
下面我就基於xfire說一下開發說明：
xfire對WebServices的開發非常方便，在Eclipse里開發就更方便了。總結起來有這么幾點：
1.編寫類，跟普通JAVABEAN沒什麼區別。
2.配置文件
如果是要深層次的去理解WebServices還需努力，下面是我給你找的一個網上的例子作為參考：
使用XFire+Spring構建Web Service
XFire是與Axis 2並列的新一代Web Service框架，通過提供簡單的API支持Web Service各項標准協議，幫助你方便快速地開發Web Service應用。
相 對於Axis來說，目前XFire相對受歡迎，加上其提供了和Spring集成的支持，在目前的Web Service開源社區擁有眾多的追隨者。並且因為XFire為Spring提供的支持，使得我們可以很容易在Spring中使用XFire構建Web Service應用。
XFire與Axis2相比具有如下特徵：
l 支持一系列Web Service的新標准--jsR181、WSDL2.0 、JAXB2、WS-Security等；
l 使用Stax解釋XML,性能有了質的提高。XFire採用Woodstox 作Stax實現；
l 容易上手，可以方便快速地從pojo發布服務；
l 支持Spring、Pico、Plexus、Loom等容器；
l 靈活的Binding機制，包括默認的Aegis,xmlbeans,jaxb2,castor；
l 高性能的SOAP 棧設計；
l 支持Spring、Pico、Plexus、Loom等容器。
XFire與Axis1性能的比較如下：
l XFire比Axis1.3快2-6倍；
l XFire的響應時間是Axis1.3的1/2到1/5。
XFire在WebService框逗譽架山蘆段中開始較晚，它從現有的框架中借鑒了許多優秀的理念，力爭將Web Service的應用開發難度降到最低。此外，還提供了各種綁定技術、支持多種傳輸協議，對WebService體系中許多新的規范提供了支持。
下面讓我們來看一個XFire於Spring集成的helloWorld的簡單例子。
一．實現的功能和特點
本例具有如下功能和特點：
1） 基於J2EE平台的Web Service服務；
2） 開發方便，配置簡單；
3） 與spring無縫集成。
XFire是完全基於流數據處理進行工作的系統，這意味著XFire不是將整個SOAP文檔緩存在內存中，而是以管道的方式接收SOAP流數據。這種工作方式的嘩悔轉變帶來了可觀的性能回報，同時節省了內存的佔用。
XFire從 管道中接收一個SOAP請求到返回一個SOAP響應，會經歷一系列的階段。在管道調用的任何一個階段，XFire都可以添加一些額外的Handler，在 對消息進行加工處理後再傳入到下一個階段中。在SOAP請求消息對Web Service發起真正調用之前，分別會經過傳輸、預轉發、轉發、策略實施、用戶信息處理、預調用、服務調用等階段。
二．開發環境
筆者的開發環境描述如下：
1） jdk: 1.5版本；
2） Tomcat：5.5.20；
3） MyEclipse:5.1.1 GA。
三．開發步驟
1. 工程與環境的建立
在MyEclipse 中新建Web工程，名為webservice_helloworld。選擇該工程後，點擊右鍵選擇MyEclipse->Add Web Service Capabilities，彈出Add Web Service Capabilities對話框，點擊「Next」，彈出Project Library Configuration對話框，默認選擇Core Libraries，點擊「Finish」按鈕，完成XFire核心包的添加。為了後續的客戶端的測試，還需讀者加入commons- httpclient.jar包到WEB-INF/lib下。
部署後可看到此時WEB-INF/lib的jar包列表如下：
activation-1.1.jar、commons -beanutils-1.7.0.jar、commons-codec-1.3.jar、commons-httpclient.jar、 commons-logging-1.0.4.jar、jaxen-1.1-beta-9.jar、jaxws-api-2.0.jar、jdom- 1.0.jar、jsr173_api-1.0.jar、mail-1.4.jar、saaj-api-1.3.jar、saaj-impl- 1.3.jar、spring-1.2.6.jar、stax-api-1.0.1.jar、wsdl4j-1.5.2.jar、wstx-asl- 3.0.1.jar、xbean-2.1.0.jar、xbean-spring-2.5.jar、xfire-aegis-1.2.2.jar、 xfire-annotations-1.2.2.jar、xfire-core-1.2.2.jar、xfire-java5-1.2.2.jar、 xfire-jaxws-1.2.2.jar、xfire-jsr181-api-1.0-M1.jar、xfire-spring- 1.2.2.jar、XmlSchema-1.1.jar
為了後續的開發和測試，在src目錄下分別建立test和webservice目錄，分別用於存放測試文件和webservice的相關類。
2．Web Service實現的編寫
在本例中，我們只是做一個helloWorld的簡單例子。Web Service服務端提供一個根據輸入的名字信息回復相應的helloWorld信息的。例如，當名字為「阿蜜果」時，恢復信息為「hello，阿蜜果」。下面讓我們一步一步來開始進行編碼。
1）web.xml的配置
一 般情況下，我們通過HTTP作為Web Service的傳輸協議，這樣我們只需啟動一個Web伺服器(如Tomcat，在本例中使用的是Tomcat5.5.20)，這樣客戶端就可以通過 HTTP訪問到Web Service服務。為了集成Spring容器，XFire專門提供一個XFireSpringServlet，我們可以在web.xml中配置該 Servlet，將Spring容器中定義的Web Service在某個URI下發布。
為了能正確使用XFire，需在web.xml中進行相應配置，在該文件中配置XFire的servlet和servlet-mapping。同時因為本實例需要將XFire集成到Spring中，因而需要在web.xml文件中載入Spring的相應配置文件。在本實例中，我們首先在WEB-INF下建立兩個配置Spring配置文件，一個為applicationContext.xml，該文件用來定義本工程的bean，一個為xfire-servlet.xml，用來配置XFire的相關bean。修改後的web.xml的內容如下所示：
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://java.sun.com/xml/ns/j2ee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="2.4" xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd">
<display-name>XFireService</display-name>
<!-- begin Spring配置 -->
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>/WEB-INF/applicationContext.xml,/WEB-INF/xfire-servlet.xml</param-value>
</context-param>
<listener>
<listener-class> org.springframework.web.context.ContextLoaderListener
</listener-class>
</listener>
<listener>
<listener-class> org.springframework.web.util.IntrospectorCleanupListener
</listener-class>
</listener>
<!-- end Spring配置 -->
<!-- begin XFire 配置 -->
<servlet>
<servlet-name>xfire</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>xfire</servlet-name>
<url-pattern>*.ws</url-pattern>
</servlet-mapping>
<servlet>
<!-- 配合Spring容器中XFire一起工作的Servlet-->
<servlet-name>xfireServlet</servlet-name>
<servlet-class>org.codehaus.xfire.spring.XFireSpringServlet</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>xfireServlet</servlet-name>
<!-- 在這個URI下開放Web Service服務 -->
<url-pattern>/service/*</url-pattern>
</servlet-mapping>
<!-- end XFire 配置 -->
</web-app>
2）Web Service的介面類HelloWorld.java和對應實現類HelloWorldImpl.java
為了用Web Service完成HelloWorld功能，我們首先在src/webservice目錄下建立介面類HelloWold.java。它僅包含一個sayHelloWorld(String name)的方法，其詳細內容如下：
package webservice;
/** *//**
*HelloWorld的介面類.
*/
publicinterface HelloWorld {
/** *//**
*對名字為name的人打招呼.
*@paramname名字
*@return返回打招呼的字元串
*/
String sayHelloWorld(String name);
}
我們還需要建立一個對應的實現類，來實現sayHelloWorld的功能，該實現類即為HelloWorldImpl.java。該類的詳細內容如下：
package webservice;
/** *//**
*HelloWorld的實現類.
*/
publicclass HelloWorldImpl implements HelloWorld {
public String sayHelloWorld(String name) {
String helloWorld = "hello," + name;
return helloWorld;
}
}
3）Spring配置文件applicationContext.xml和xfire-servlet.xml的配置
首先我們在applicationContext.xml文件中配置對應的bean——HelloWorldBean，該xml文件的內容如下：
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN"
"http://www.springframework.org/dtd/spring-beans.dtd">
<beans>
<bean id="HelloWorldBean" class="webservice.HelloWorldImpl"/>
</beans>
這個配置文件很簡單，在此不詳述。
XFire為Spring 提供了方便易用的導出器XFireExporter，藉助該導出器的支持，我們可以在Spring容器中將一個POJO導出為Web Service。HelloWorld是業務服務類，在此擁有一個sayHelloWorld的方法，我們希望將此方法開放為Web Service。在實際應用中，如果某個類具有眾多的方法，而其中的某些方法不需要開放為Web Service的情況下，我們可以定義一個窄介面，該介面中只需定義那些開放為Web Service的業務方法。
將一個業務類所有需要開放為Web Service的方法通過一個窄介面來描述是值得推薦的作法，這讓Web Service的介面顯得很「干凈」。其次，XFire的導出器也需要服務介面的支持，因為它採用基於介面的動態代理技術。
窄介面中的方法在真實的系統中可能需要引用其它的業務類或DAO獲取資料庫中的真實數據，為了簡化實例，我們在此簡化了實例。
下面讓我們看看在xfire-servlet.xml文件中導出器的設置，該文件內容如下：
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN"
"http://www.springframework.org/dtd/spring-beans.dtd">
<beans>
<!-- 引入XFire預配置信息 -->
<import resource="classpath:org/codehaus/xfire/spring/xfire.xml" />
<!—定義訪問的url-->
<bean class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping">
<property name="urlMap">
<map>
<entry key="/HelloWorldService.ws">
<ref bean="HelloWorldService" />
</entry>
</map>
</property>
</bean>
<!-- 使用XFire導出器 -->
<bean id="baseWebService" class="org.codehaus.xfire.spring.remoting.XFireExporter" lazy-init="false" abstract="true">
<!-- 引用xfire.xml中定義的工廠 -->
<property name="serviceFactory" ref="xfire.serviceFactory" />
<!-- 引用xfire.xml中的xfire實例 -->
<property name="xfire" ref="xfire" />
</bean>
<bean id="HelloWorldService" parent="baseWebService">
<!-- 業務服務bean -->
<property name="serviceBean" ref="HelloWorldBean" />
<!-- 業務服務bean的窄介面類 -->
<property name="serviceClass" value="webservice.HelloWorld" />
</bean>
</beans>
在 上面的配置中，我們可以看到，在該配置文件中引入了xfire.xml這個Spring配置文件。它是在XFire核心JAR包中擁有一個預定義的 Spring配置文件，它定義了XFire在Spring中必須用到的一些Bean和資源，需要引入這個預定義的配置文件。從該配置文件中可以看出，我們 通過XFireExporter將業務類導出為Web Service，對於任何導出器，我們都需要引入XFire環境，即serviceFactory和xfire，這是標準的配置。ServiceFactory是XFire的核心類，它可以將一個POJO生成為一個Web Service。
在本實例中，我們通過定義一個baseWebService，其餘的webService配置都將該bean作為父bean，這樣可以簡化Spring的配置，不需要多次引入serviceFactory和xfire。
3. Web Service的測試
在上一步操作完成之後，我們的這個簡單的Web Service已經編寫完畢，下面讓我們來看看自己的勞動成果吧。
在瀏覽器中輸入地址：http://localhost:8080/webservice_helloworld/HelloWorldService.ws?wsdl，我們可以看到HelloWorldService對應的WSDL信息，閱讀這個WSDL文檔，我們可以知道HelloWorld的sayHelloWorld方法已經被成功地發布為Web Service了。只要拿到這個WSDL就可以開發相應的客戶端調用程序了。
XFire為訪問服務端Web Service提供了各種方便的方式：我們一般根據服務地址和窄介面類創建客戶調用程序。
在不能獲得服務窄介面類的情況下，XFire允許我們通過WSDL文件生成客戶端調用程序，通過指定服務介面的方式調用服務。
1）通過WSDL文件生成客戶端調用程序
首先我們通過http://localhost:8080/webservice_helloworld/HelloWorldService.ws?wsdl我們可以獲得WSDL文件HelloWorldService.wsdl，並將其放在src目錄下面，接著我們通過程序訪問該WSDL文件，並調用需測試的方法。此時測試類WebServiceClientTest.java的內容如下所示：
package test;
import org.codehaus.xfire.client.Client;
import org.springframework.core.io.ClassPathResource;
import org.springframework.core.io.Resource;
import webservice.HelloWorld;
/** *//**
*Copyright2007GuangZhouAmigo.
*Allrightreserved.
*HelloWorld的webservice的測試類.
*@author<a href="mailto:[email protected]">AmigoXie</a>
*@version1.0
*Creationdate:2007-9-16-下午05:36:05
*/
publicclass WebServiceClientTest {
HelloWorld helloWorld = null;
publicstaticvoid main(String[] args) throws Exception {
WebServiceClientTest test = new WebServiceClientTest();
test.testClient();
}
publicvoid testClient() throws Exception {
String wsdl = "HelloWorldService.wsdl"; //對應的WSDL文件
Resource resource = new ClassPathResource(wsdl);
Client client = new Client(resource.getInputStream(), null); //根據WSDL創建客戶實例
Object[] objArray = new Object[1];
objArray[0] = "阿蜜果";
//調用特定的Web Service方法
Object[] results = client.invoke("sayHelloWorld", objArray);
System.out.println("result: " + results[0]);
}
}
運行該類，可得到如下輸出結果：
result: hello,阿蜜果
可看出運行結果正確。
2）根據服務地址創建客戶端調用程序
接著讓我們來看一個根據服務地址創建客戶端調用程序的例子。我們可以通過測試類來測試Web Service的正確性，下面讓我們來看一個簡單的測試類，首先我們在src/test目錄建立WebServiceClientTest.java文件，並在src目錄下建立客戶端調用的Spring配置文件client.xml。在client.xml配置文件中我們定義了一個testWebService的bean，該bean訪問wsdlDocumentUrl為http://localhost:8080/webservice_helloworld/HelloWorldService.ws?wsdl的WSDL。該xml文件的詳細內容如下：
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN"
"http://www.springframework.org/dtd/spring-beans.dtd">
<beans>
<bean id="testWebService" class="org.codehaus.xfire.spring.remoting.XFireClientFactoryBean">
<property name="serviceClass">
<value>webservice.HelloWorld</value>
</property>
<property name="wsdlDocumentUrl">
<value>http://localhost:8080/webservice_helloworld/HelloWorldService.ws?wsdl</value>
</property>
</bean>
</beans>
在WebServiceClientTest.java文件中獲得HelloWorld，並調用它的sayHelloWorld方法來完成測試，該類的詳細內容如下所示：
package test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.;
import webservice.HelloWorld;
/** *//**
*HelloWorld的webservice的測試類.
*/
publicclass WebServiceClientTest {
HelloWorld helloWorld = null;
publicstaticvoid main(String[] args) {
WebServiceClientTest test = new WebServiceClientTest();
test.testClient();
}
publicvoid testClient() {
ApplicationContext ctx = new (
"client.xml");
helloWorld = (HelloWorld) ctx.getBean("testWebService");
System.out.println(helloWorld.sayHelloWorld("阿蜜果"));
}
}
在啟動webservice_helloworld工程的情況下，運行WebServiceClientTest類，可看到控制台包含如下信息：
hello,阿蜜果
由此可看出調用Web Service成功。
四．總結
與Axis 相比，在實施Web Service時XFire更加簡潔高效，並且XFire對Spring提供了強大的支持，可以非常方便地在Spring中使用XFire實施Web Service，因此XFire在短短的時間里成為了受Web Service開發者喜愛的框架。
XFire為客戶端提供了多種訪問Web Service的方式，如果可以獲取客戶端的窄介面類，則可以採用窄介面類調用Web Service。如果僅能獲取WSDL，XFire也可以採用動態反射的機制調用Web Service。XFire為Eclipse提供了一個可以根據WSDL生成客戶端存根代碼的插件，相信XFire也將為其它非Java語言提供類似的插 件。
在Axis2中也開始使用Stax來處理XML，還有Xfire不支持WSDL2.0, 而Axis2支持WSDL2.0。
還可使用Xfire的後續版本，Apache CXF (相當於 Xfire2.0).
❾ java webservice例子，例子完整，最好有注釋，demo也行！但是一定要完整！謝謝！
Web Services以XML作為數據交換的標准格式，它是跨平台的應用，允許以任何方式創建Web Services，在.NET、Java平台上訪問。
在Java平台創建和訪問Web Service多通過Axis完成。Axis本質上就是一個SOAP引擎，提供創建伺服器端、客戶端和網關SOAP操作的基本框架。Axis目前版本是為Java編寫的。在使用Axis訪問Web Service時，需要引入以下包（10個）：axis-ant.jar、axis.jar、commons-discovery-0.2.jar、commons-logging-1.0.4.jar、jaxrpc.jar、log4j-1.2.8.jar、saaj.jar、wsdl4j-1.5.1.jar、activation-1.1.jar和mail-1.4.jar。
（1）訪問Java創建的Web Service
在當前Java客戶端應用中添加相應的10個Axis包，編寫客戶端程序：
import org.apache.axis.client.Call;
import org.apache.axis.client.Service;
public class Test {
public static void main(String[] args) throws Exception {
try{
String endpoint = "http://localhost:8080/MyService/services/Hello";
Service service = new Service();
Call call = (Call)service.createCall();
call.setTargetEndpointAddress(new java.net.URL(endpoint));
call.setOperationName("getHello");
String res = (String) call.invoke(new Object[]{});
System.out.println(res);
}
catch (Exception ex){
ex.printStackTrace();
}
}
}
其中兩處代碼加粗，第一處表示引用Java Web Service的URL，第二處表示公共的方法名稱。
具體的創建和訪問Web Service的代碼已發到你郵箱，使用AXIS所用的包也一並發送。
❿ 如何用java來獲取webservice數據
Java調用WebService可以直接使用Apache提供的axis.jar自己編寫代碼，或者利用Eclipse自動生成WebService Client代碼，利殲敬辯用其中的Proxy類進行調用。理論上是一樣的，只不過用Eclipse自動生成代碼省事些。
1、編寫代碼方式氏缺：
package com.yun.test;
import java.rmi.RemoteException;
import org.apache.axis.client.Call;
import org.apache.axis.client.Service;
import org.apache.axis.message.PrefixedQName;
import org.apache.axis.message.SOAPHeaderElement;
import com.cezanne.golden.user.Exception;
import com.cezanne.golden.user.UserManagerServiceProxy;
import javax.xml.namespace.QName;
import java.net.MalformedURLException;
import javax.xml.rpc.ServiceException;
import javax.xml.soap.Name;
import javax.xml.soap.SOAPException;
public class testWebService {
public static String getResult() throws ServiceException, MalformedURLException, RemoteException, SOAPException
{
//標識Web Service的具體路徑
String endpoint = "WebService服務地址";
// 創建 Service實例
Service service = new Service();
// 通過Service實例創建Call的實例
Call call = (Call) service.createCall();
//將Web Service的服務路徑加入到call實例之中.
call.setTargetEndpointAddress( new java.net.URL(endpoint) );//為Call設置服務的位置
// 由於需要認證，故需要設置調用的SOAP頭信息。
Name headerName = new PrefixedQName( new QName("發布的稿則wsdl里的targetNamespace里的url", "string_itemName") );
org.apache.axis.message.SOAPHeaderElement header = new SOAPHeaderElement(headerName);
header.addTextNode( "blablabla" );
call.addHeader(header);
// SOAPHeaderElement soapHeaderElement = new SOAPHeaderElement("發布的wsdl里的targetNamespace里的url", "SoapHeader");