刚好 我这两天也在学webservice，给你一个我才学的例子
我们提供的服务有：成都网站制作、网站建设、微信公众号开发、网站优化、网站认证、南谯ssl等。为上千企事业单位解决了网站和推广的问题。提供周到的售前咨询和贴心的售后服务，是有科学管理、有技术的南谯网站制作公司
1.解压axis压缩包，然后解压，取出里面的webapps里面的axis项目放到tomcat中的webapps中，然后启动tomcat
项目的发布有两种形式
1.即时发布
直接在axis中放置java源文件，注意后缀名字改为.jws.注意源文件中不要有任何的导包语句
详细步骤如下
1.直接在axis目录下编写java源文件，写好后把后缀名改为jws。如Demo.jws
2.重启动服务器，在浏览器中输入，点开后得到一个网址
3.在myeclipse中导入网址，可以执行里面的方法就可以了。
2.定制发布
编写要发布为服务器javaBean
编写生成class文件放在tomcat中的axis中的webinf中的classes中
编写deploy.wsdd文件描述服务器的名称入口等信息。
详细步骤
以一个add为例子
1.编写javaBean代码
public class add {
public Integer getAdd(Integer a, Integer b){
return a+b;
}
}
2.将class文件放入axis中的webinf下的classes中
注意，如果该类有包的话，就要建立相应的文件名，如
package com.ssh.webservice
那么classes文件下就要有相应的com文件夹，ssh文件夹，webservice文件夹
3.写上他的描述文件wsdd文件
描述文件直接放到classes中即可，名字为deploy.wsdd，文件为
deployment xmlns="" xmlns:java=""
service name="Add" provider="java:RPC"
list中显示的名字
parameter name="className" value="add"/
调用的类
parameter name="allowedMethods" value="*"/
指定调用的方法
/service
/deployment
4.编写批处理文件.bat文件，如下
set classpath=%classpath%;E:\ur2001Tomcat\apache-tomcat-6.0.32\webapps\axis\WEB-INF\lib\axis.jar;
set classpath=%classpath%;E:\ur2001Tomcat\apache-tomcat-6.0.32\webapps\axis\WEB-INF\lib\axis-ant.jar;
set classpath=%classpath%;E:\ur2001Tomcat\apache-tomcat-6.0.32\webapps\axis\WEB-INF\lib\commons-discovery-0.2.jar;
set classpath=%classpath%;E:\ur2001Tomcat\apache-tomcat-6.0.32\webapps\axis\WEB-INF\lib\commons-logging-1.0.4.jar;
set classpath=%classpath%;E:\ur2001Tomcat\apache-tomcat-6.0.32\webapps\axis\WEB-INF\lib\jaxrpc.jar;
set classpath=%classpath%;E:\ur2001Tomcat\apache-tomcat-6.0.32\webapps\axis\WEB-INF\lib\log4j-1.2.8.jar;
set classpath=%classpath%;E:\ur2001Tomcat\apache-tomcat-6.0.32\webapps\axis\WEB-INF\lib\saaj.jar;
set classpath=%classpath%;E:\ur2001Tomcat\apache-tomcat-6.0.32\webapps\axis\WEB-INF\libwsdl4j-1.5.1.jar
java org.apache.axis.client.AdminClient E:\ur2001Tomcat\apache-tomcat-6.0.32\webapps\axis\WEB-INF\classes\deploy.wsdd
然后运行该批处理文件
5.启动服务器，在浏览器中输入项目的发布地址，如就会有已个list，然后点进方法
6.编写客户端代码，如下
package com.ssh.client;
import org.apache.axis.client.Call;
import org.apache.axis.client.Service;
import javax.xml.namespace.QName;
public class TestClient
{
public static void main(String [] args) {
try {
String endpoint =
"";
这个地址是值xml文件中的最后一行的local地址
Service service = new Service();
Call call = (Call) service.createCall();
call.setTargetEndpointAddress( new java点虐 .URL(endpoint) );
call.setOperationName(new QName("getMessage") );
指定调用的方法
String ret = (String) call.invoke( new Object[] { } );
如果有参数需要传入的话直接在括号里面写上1，2，2等
System.out.println(ret);
} catch (Exception e) {
System.err.println(e.toString());
}
}
}
我这里还有webservice的教学视屏，要的话说一声
1.，选择其中的win版本下载，我选择的是protoc-2.4.1-win32.zip
2.下载一个protobuf-java-2.4.1.jar文件(注意，要与你刚才下的proto.exe版本相同)
然后就开始开发了。
步骤：
1.用记事本编写一个.proto文件：
}如：编写的是test.proto
package protobuf;
option java_package = "com.sq.protobuf";
option java_outer_classname = "FirstProtobuf";
message testBuf {
required int32 ID = 1;
required string Url = 2;
}
将其放在与刚解压的protoc.exe同级目录中。
2.在cmd中，到protoc-2.4.1-win32文件夹下，
执行
E:\protoc-2.4.1-win32 protoc.exe --java_out=./ test.proto
则可以找到的一个生成的FirstProtobuf.java文件。
3.在MyEclipse中新建一个java project，建立包com.sq.protobuf，然后将刚才生成的FirstProtobuf.java文件放在其下面。
此时会报错，因为没有引入jar包，在package视图下，将protobuf-java-2.4.1.jar引入，即可解决问题。
JSON-RPC-Java 由两个对用户可视化的组件构成，它们是JSONRPCBridge和JSONRPCServlet，二者的协调实现了JSON服务器端对请求对象的处理，并响应给用户。
JSONRPCBridge是一个拥有服务器端导出给特定客户端的对象的引用的session对象，它接收服务器（也就是JSONRPCServlet）传来的JSON-RPC请求，然后其把JSON对象解码（unmarshalling）为Java对象，再扮演方法调用的角色，还要把方法调用返回的Java对象结果组码（marshall）为JSON对象传给客户端处理。而具体的从Java对象到Javascript对象的类型转换由负责串行化的串行化类Serializer处理。
JSONRPCBridge必须放置在HttpSession对象中，并且注册属性名为“JSONRPCBridge”，以使JSONRPCServlet能够定位负责调用导出到客户端的Java对象的桥。为此，为了导出一个对象的所有实例和静态方法到客户端，应该有如下的代码： JSONRPCBridge.registerObject("myObject", myObject)；
为了导出一个类的所有的静态方法，应该：JSONRPCBridge.registerClass(("myObject", myObject)；
如果registerObject和registerClass被多次调用为有相同键值的对象使用，那么其将被最新赋值的对象所更新。
在JSON中，还可以使用单例模式的globalBridge来为所有的HTTP客户端导出所有的实例方法。其可以用来注册工厂类，但使用时要注意认证与安全问题。使用时如下标识：JSONRPCBridge.getGlobalBridge().registerObject("myObject",myObject); 同上其还可以导出所有的静态方法。
该协议中最重要的一部分还有就是Servlet了，现在就来简单的介绍一下：
在该协议中，JSONRPCServlet充当传送器，处理通过HTTP传输过来的JSON
0，服务接口定义---Echo.java
/*
* 定义了服务器提供的服务类型 */public interface Echo { public String echo(String string);
}
一，客户端代码分析--实现类：MainClient.java
客户端实现包括：获得一个代理对象，并使用该代理对象调用服务器的服务。获取代理对象时，需要指定被代理的类(相当于服务器端提供的服务名)，Server IP，Port，这样客户端就能找到服务端的服务了。
延伸：分布式环境下，Client如何打到Server的服务？---因为，在服务器中运行的某些服务不像标准服务有着固定的端口，如HTTP的80端口。
一种解决方法是：在运行服务的每台机器上都运行一个特殊的守护进程，该守护进程负责跟踪位于该机器中每一项服务所使用的端口；此外，守护进程还监听一个特定的已经端口，Client通过这个端口与守护进程联系，请求得到指定服务的端口。
复杂的RPC实现框架中，比如可以把服务注册到ZooKeeper中，Client也从ZooKeeper中查询服务。参考：一个更复杂的RPC框架实现
Echo echo = RPC.getProxy(Echo.class, "127.0.0.1", 20382);
System.out.println(echo.echo("hello,hello"));//使用代理对象调用服务器的服务.并将结果输出
二，服务器端分析--实现类：MainServer.java
服务器实现包括：创建一个服务器对象，将它能提供的服务注册，并启动进程监听客户端的连接
Server server = new RPC.RPCServer(); /*
* server 启动后,需要注册server端能够提供的服务,这样client使用 服务的名字、
* 服务器的IP、以及服务所运行的端口 来调用 server 的服务 */
server.register(Echo.class, RemoteEcho.class);//注册服务的名字
server.register(AnOtherEchoService.class, AnOtherEchoServiceImpl.class);
server.start();//启动server
三，服务器监听Client连接分析----实现类：Listener.java
当server.start()后，它要创建一个Listener对象，这是一个线程类，该线程用来监听Client连接。
public void start() {
System.out.println("启动服务器");
/*
* server 启动时,需要Listener监听是否有client的请求连接
* listener 是一个线程,由它来监听连接 */
listener = new Listener(this); this.isRuning = true;
listener.start();//listener 是一个线程类,start()后会执行线程的run方法
}
其实，监听连接就是JAVA ServerSocket类和Socket类提供的相关功能而已。
/*
* accept()是一个阻塞方法,server_socket 一直等待client 是否有连接到来 */
Socket client = server_socket.accept();//建立一条TCP连接
四，动态代理对象 生成---RPC.java
客户端只需要编写生成代理对象，用代理对象去调用远程服务的代码即可。但是，底层的功能如：建立连接，序列化(本例中也没有考虑)，跨语言调用(未考虑)...是由RPC框架完成的。
当MainClient 语句：RPC.getProxy(Echo.class, "127.0.0.1", 20382);执行时,会由
/*
* @param Class[]{} 该参数声明了动态生成的代理对象实现了的接口,即 clazz 所代表的接口类型 .
* 这表明了生成的代理对象它是一个它所实现了的接口类型的对象
* 从而就可以用它来调用它所实现的接口中定义的方法
*
* @param handler 生成代理实例对象时需要传递一个handler参数
* 这样当该 代理实例对象调用接口中定义的方法时,将会委托给InvocationHandler 接口中声明的invoke方法
* 此时,InvocationHandler 的invoke 方法将会被自动调用 */
T t = (T) Proxy.newProxyInstance(RPC.class.getClassLoader(), new Class[] {clazz}, handler); return t;
返回该代理对象,然后就会委托第三个参数 handler 自动执行 invoke(),invoke将客户端调用的所有相关信息封装到Invocation 对象中(后面分析)。然后执行第16行代码发起连接。
1 public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { 2 Invocation invo = new Invocation(); 3 invo.setInterfaces(clazz); 4 5 //利用反射机制将java.lang.reflect.Method 所代表的方法名,参数 封装到 Invocation invo对象中 6 invo.setMethod(new org.jy.rpc.protocal.Method(method.getName(),method.getParameterTypes())); 7 invo.setParams(args); 8 9 /*10 * 当把需要调用的远程server端的方法名和参数封装到invo之后，Client 对象 就可以把 invo 作为参数 传递给服务器了.11 * 为什么需要这样做呢？InvocationHandler 的invoke方法是自动执行的，在该方法里面，它根据生成的代理对象 proxy (第一个参数)12 * 所实现的接口(由 Proxy.newProxyInstance()的第二个参数指定) 就可以知道这个接口中定义了哪些方法13 * InvocationHandler 的 invoke 方法的第二个参数Method method 就可以解析出接口中的方法名和参数了14 * 把它们封装进Invocation invo对象中,再将 invo 作为 client.invoke(invo)的参数 发送到服务器方15 */16 client.invoke(invo);//invoke 先调用init发起一个Socket连接,再将invo 发送至输出流中17 return invo.getResult();18 }
五，“客户端存根”--Client.java
最重要的是它的 invoke方法(注意与InvocationHandler的invoke()区分)。它负责建立连接，打开输入、输出流，向服务器发送字节数据。
1 public void invoke(Invocation invo) throws UnknownHostException, IOException, ClassNotFoundException {2 init();3 System.out.println("写入数据");4 oos.writeObject(invo);//将Client 需要调用的Server的 接口、方法、参数 封装起来 发给服务器5 oos.flush();6 ois = new ObjectInputStream(socket.getInputStream());//用来接收从 server 返回 回来的执行结果 的输入流7 Invocation result = (Invocation) ois.readObject();8 invo.setResult(result.getResult());//将结果 保存到 Invocation result对象中9 }
六，“服务器存根“---实现类：RPCServer.java
上面提到，服务器通过Listener监听客户端连接，当建立客户端连接后，Socket client = server_socket.accept(); 不再阻塞，服务器调用它的call()方法完成客户端请求的功能。也即，客户端请求的结果实际上是在服务器执行生成的。返回的结果是在Client.java 的 invoke() 方法里被读取出来 。call()再一次用到了JAVA反射(第11行） 参考：JAVA动态代理
1 public void call(Invocation invo) { 2 System.out.println(invo.getClass().getName()); 3 Object obj = serviceEngine.get(invo.getInterfaces().getName()); 4 if(obj!=null) { 5 try { 6 Method m = obj.getClass().getMethod(invo.getMethod().getMethodName(), invo.getMethod().getParams()); 7 /* 8 * 利用JAVA反射机制来执行java.lang.reflect.Method 所代表的方法 9 * @param result : 执行实际方法后 得到的 服务的执行结果10 */11 Object result = m.invoke(obj, invo.getParams());12 invo.setResult(result);//将服务的执行结果封装到invo对象中。在后面的代码中，将该对象写入到输出流中13 } catch (Throwable th) {14 th.printStackTrace();15 }16 } else {17 throw new IllegalArgumentException("has no these class");18 }19 }
七，”RPC 编码、解码，协议的定义“---Invocation.java Method.java
其实，这里并不是那种实用的开源RPC框架如Thrift中所指的编码、IDL……上面两个类只是RPC实现过程中辅助完成Java动态代理的实现，说白了就是封装客户端需要调用的方法，然后指定生成的代理对象需要实现的接口(服务).
八，总结：
先运行MainServer.java启动服务器，然后，再运行MainClient.java 启动一个客户端连接服务器就可以看到执行结果。
当需要添加新的服务时：按以下步骤即可：①定义服务接口及其实现类，如：AnOtherEchoService.java ②：在MainServer.java中注册新添加的服务。
③：在MainClient.java中编写获得新服务的代理对象的代码，并用该代理对象调用新服务接口中声明的方法。
这样，在客户端就能够远程地调用服务器上的一个新服务了。
