axis2客户端编码，RPC，OMElement，上传下载实现，服务端验证

1. 简单做一下使用axis2作为客户端的情况下一些编码的实现内容。
2. 首先应该部署一套服务以应对客户端调用。我要做的例子不是很麻烦，所以只需要三个接口就可以了，一个接收字符串参数，返回字符串参数。另外两个做上传和下载。一共三个接口，我已经在附件上传了一个类，这个类编译后的class文件放到下载的axis2事例工程的WEB-INF下的pojo文件夹中，pojo文件夹是自己创建的。这样就会发布一个有三个方法的接口。具体关于axis2的发布网络上内容很多，我也会在以后博客中做详细解释。为了方便我也在这里放出代码。
   Java代码   

   1. import java.io.FileOutputStream;  
   2. import java.text.SimpleDateFormat;  
   3. import java.util.Date;  
   4. /** 
   5.  * 这个是作为服务端的方法类，不能带有命名空间，方法必须为public 
   6.  * 崔素强 
   7.  * cuisuqiang@163.COM 
   8.  */  
   9. public class MyAxis2Service {     
   10.     /* 
   11.      * 请求的方法，输出接收到的参数，返回时间戳字符串 
   12.      */  
   13.     public String getServiceInit(String name){  
   14.         System.out.println("you name is :" + name);  
   15.         SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");  
   16.         return format.format(new Date());  
   17.     }  
   18.       
   19.     // 下载图像  
   20.     public byte[] dowImageWithByte() {  
   21.         byte[] imageByte = null;  
   22.         try {  
   23.             // 下面的代码调用uploadImageWithByte方法上传图像文件  
   24.             // 打开图像文件，确定图像文件的大小  
   25.             java.io.File file = new java.io.File("c:\\test.jpg");  
   26.             java.io.FileInputStream fis = new java.io.FileInputStream("c:\\test.jpg");  
   27.             // 创建保存要上传的图像文件内容的字节数组  
   28.             imageByte = new byte[(int) file.length()];  
   29.              fis.read(imageByte);  
   30.         } catch (Exception e) {  
   31.             return null;  
   32.         } finally {  
   33.               
   34.         }  
   35.         return imageByte;  
   36.     }  
   37.       
   38.     // 上传图像，imageByte参数表示上传图像文件的字节  
   39.     public boolean uploadImageWithByte(byte[] imageByte, int length) {  
   40.         FileOutputStream fos = null;  
   41.         try {  
   42.             // 将上传的图像保存在D盘的test1.jpg文件中  
   43.             fos = new FileOutputStream("d:\\test1.jpg");  
   44.             // 开始写入图像文件的字节  
   45.             fos.write(imageByte, 0, length);  
   46.             fos.close();  
   47.         } catch (Exception e) {  
   48.             return false;  
   49.         } finally {  
   50.             if (fos != null) {  
   51.                 try {  
   52.                     fos.close();  
   53.                 } catch (Exception e) {  
   54.   
   55.                 }  
   56.             }  
   57.         }  
   58.         return true;  
   59.     }  
   60. }  
    其中要上传和下载的文件是图片，请自己事先准备好。
3. 下面创建一个项目，将所需的JAR包加到工程中，发现有的人说如果不知道是那个包就全加进去，可是axis2的包有几十个，我也尝尽了JAR冲突的痛苦，所以我在这里告诉大家，只需要加我附件里面的几个JAR就可以了。
4. 首先编码调用简单接口的代码，传递的参数和返回的参数都是字符串。发现网络上的例子都是RPC的，为了方便学习，我会给出两种调用方式。首先的网络上通用的方式：
   Java代码   

   1. import javax.xml.namespace.QName;  
   2. import org.apache.axis2.addressing.EndpointReference;  
   3. import org.apache.axis2.client.Options;  
   4. import org.apache.axis2.rpc.client.RPCServiceClient;  
   5. /** 
   6.  * RPC axis2调用方式 
   7.  * @author cuisuqiang 
   8.  */  
   9. public class RpcCommonClient {  
   10.     @SuppressWarnings("unchecked")  
   11.     public static void main(String[] args) {  
   12.         try {  
   13.             // 获得客户端  
   14.             RPCServiceClient serviceClient = new RPCServiceClient();  
   15.             // 可以在该对象中设置服务端的验证信息  
   16.             Options options = serviceClient.getOptions();  
   17.             EndpointReference targetEPR = new EndpointReference("http://127.0.0.1:8080/axis2/services/MyAxis2Service");  
   18.             options.setTo(targetEPR);  
   19.             // 在创建QName对象时，QName类的构造方法的第一个参数表示WSDL文件的命名空间名，也就是<wsdl:definitions>元素的targetNamespace属性值  
   20.             QName opAddEntry = new QName("http://ws.apache.org/axis2","getServiceInit");  
   21.             // 参数，如果有多个，继续往后面增加即可，不用指定参数的名称  
   22.             Object[] opAddEntryArgs = new Object[] {"cuisuqiang" };  
   23.             // 返回参数类型，这个和axis1有点区别  
   24.             // invokeBlocking方法有三个参数，其中第一个参数的类型是QName对象，表示要调用的方法名；  
   25.             // 第二个参数表示要调用的WebService方法的参数值，参数类型为Object[]；  
   26.             // 第三个参数表示WebService方法的返回值类型的Class对象，参数类型为Class[]。  
   27.             // 当方法没有参数时，invokeBlocking方法的第二个参数值不能是null，而要使用new Object[]{}  
   28.             // 如果被调用的WebService方法没有返回值，应使用RPCServiceClient类的invokeRobust方法，  
   29.             // 该方法只有两个参数，它们的含义与invokeBlocking方法的前两个参数的含义相同  
   30.             Class[] classes = new Class[] { String.class };  
   31.             System.out.println(serviceClient.invokeBlocking(opAddEntry,opAddEntryArgs, classes)[0]);   
   32.         } catch (Exception e) {  
   33.             e.printStackTrace();  
   34.         }  
   35.     }  
   36. }  
    RPC的调用方式还是非常简洁明了的，但是axis2的调用方式是有很多种实现的。下面的实现方式，使用到了一些底层的东西，不过更加让我们开发人员明了：
   Java代码   

   1. import java.util.Iterator;  
   2. import org.apache.axiom.om.OMAbstractFactory;  
   3. import org.apache.axiom.om.OMElement;  
   4. import org.apache.axiom.om.OMFactory;  
   5. import org.apache.axiom.om.OMNamespace;  
   6. import org.apache.axis2.addressing.EndpointReference;  
   7. import org.apache.axis2.client.Options;  
   8. import org.apache.axis2.client.ServiceClient;  
   9.   
   10. /** 
   11.  * Axis2客户端 
   12.  * 崔素强 cuisuqiang@163.com 
   13.  */  
   14. public final class AxisWebServiceClient {  
   15.       
   16.     public static void main(String[] args) {  
   17.         // 直接运行也可以看到效果  
   18.         callWebservice2();  
   19.     }  
   20.       
   21.     /** 
   22.      * 客户端调用service 
   23.      */  
   24.     @SuppressWarnings("unchecked")  
   25.     public static void callWebservice2() {  
   26.         try {  
   27.             // 服务地址，服务地址，命名空间，方法名称，组装参数，返回数据解析，可以自己根据实际情况编码  
   28.             EndpointReference targetEPR = new EndpointReference("http://127.0.0.1:8080/axis2/services/MyAxis2Service");   
   29.             ServiceClient serviceClient = new ServiceClient();  
   30.             Options options = new Options();  
   31.             options.setTo(targetEPR);  
   32.             serviceClient.setOptions(options);  
   33.             OMFactory fac = OMAbstractFactory.getOMFactory();                 
   34.             // 命名空间，有时命名空间不增加没事，不过最好加上，因为有时有事，你懂的  
   35.             OMNamespace omNs = fac.createOMNamespace("http://ws.apache.org/axis2", "");           
   36.             //为SOAP Header构造验证信息，如果你的服务端是没有验证的，那么你不用在Header中增加验证信息  
   37. //          OMElement header = fac.createOMElement("AuthenticationToken", omNs);              
   38. //          OMElement ome_user = fac.createOMElement("Username", omNs);  
   39. //          ome_user.setText("");  
   40. //          header.addChild(ome_user);  
   41. //          OMElement ome_pass = fac.createOMElement("Password", omNs);  
   42. //          ome_pass.setText("");  
   43. //          header.addChild(ome_pass);  
   44. //          serviceClient.addHeader(header);  
   45.             //调用据方法  
   46.             OMElement data = fac.createOMElement("getServiceInit", omNs);             
   47.             // 设置参数，如果参数名称没有设置正确，后果自负  
   48.             OMElement metaData = fac.createOMElement("name", omNs);  
   49.             metaData.setText("cuisuqiang");  
   50.             data.addChild(metaData);              
   51.             //发送请求  
    以上方法调用后返回的是OMElement对象，而传递参数也用到了该对象，具体关于该对象的一些内容，可以查看源码了解。
5. 下面我们来看一下，如何上传一个文件，大家也看到了服务端的地方我文件用的是字节数组，为的是不同业务调用方便和统一。同样，先来看一下RPC调用的方式，这里给出一个方法，大家看代码即可：
   Java代码   

   1. /** 
   2.  * 上传 
   3.  */  
   4. @SuppressWarnings("unchecked")  
   5. public static void test2() {  
   6.     try {  
   7.         RPCServiceClient serviceClient = new RPCServiceClient();  
   8.         Options options = serviceClient.getOptions();  
   9.         EndpointReference targetEPR = new EndpointReference("http://localhost:8080/axis2/services/MyAxis2Service");  
   10.         options.setTo(targetEPR);  
   11.         QName opAddEntry;  
   12.         byte[] buffer;  
   13.         // 下面的代码调用uploadImageWithByte方法上传图像文件  
   14.         // 打开图像文件，确定图像文件的大小  
   15.         java.io.File file = new java.io.File("c:\\test.jpg");  
   16.         java.io.FileInputStream fis = new java.io.FileInputStream("c:\\test.jpg");  
   17.         // 创建保存要上传的图像文件内容的字节数组  
   18.         buffer = new byte[(int) file.length()];  
   19.         // 将图像文件的内容读取buffer数组中  
   20.         int n = fis.read(buffer);  
   21.         Object[] opAddEntryArgs = new Object[] { buffer, n };  
   22.         Class[] classes = new Class[] { Boolean.class };  
   23.         opAddEntry = new QName("http://ws.apache.org/axis2","uploadImageWithByte");  
   24.         fis.close();  
   25.         // 开始上传图像文件，并输出uploadImageWithByte方法的返回传  
   26.         System.out.println(serviceClient.invokeBlocking(opAddEntry,opAddEntryArgs, classes)[0]);  
   27.     } catch (Exception e) {  
   28.         e.printStackTrace();  
   29.     }  
   30. }  
    从这里我更感觉到了这种调用方式的简洁性，因为参数的传递非常容易，放到参数的数组中就行了。对比一下，再看一下另一种实现方式：
   Java代码   

   1. /** 
   2.  * 上传附件 
   3.  */  
   4. @SuppressWarnings("unchecked")  
   5. public static void test1() {  
   6.     try {  
   7.         // 服务地址，服务地址，命名空间，方法名称，组装参数，返回数据解析，可以自己根据实际情况编码  
   8.         EndpointReference targetEPR = new EndpointReference("http://127.0.0.1:8080/axis2/services/MyAxis2Service");  
   9.         ServiceClient serviceClient = new ServiceClient();  
   10.         Options options = new Options();  
   11.         options.setTo(targetEPR);  
   12.         serviceClient.setOptions(options);  
   13.         OMFactory fac = OMAbstractFactory.getOMFactory();  
   14.         OMNamespace omNs = fac.createOMNamespace("http://ws.apache.org/axis2", "");  
   15.         // 调用据方法  
   16.         OMElement data = fac.createOMElement("uploadImageWithByte", omNs);  
   17.         // 增加附件  
   18.         OMElement fileData = fac.createOMElement("imageByte", omNs);  
   19.         java.io.File file = new java.io.File("c:\\test.jpg");  
   20.         FileDataSource fs = new FileDataSource(file);  
   21.         DataHandler fileHandle = new DataHandler(fs);  
   22.         OMText textData = fac.createOMText(fileHandle, true);  
   23.         fileData.addChild(textData);  
   24.         data.addChild(fileData);  
   25.         // 增加元数据  
   26.         OMElement metaData = fac.createOMElement("length", omNs);  
   27.         metaData.setText(file.length() + "");  
   28.         data.addChild(metaData);  
   29.         // 发送请求  
   30.         OMElement results = serviceClient.sendReceive(data);  
   31.         Iterator it = results.getChildElements();  
   32.         while (it.hasNext()) {  
   33.             OMElement el = (OMElement) it.next();  
   34.             System.out.println("element.getLocalName(): "+ el.getLocalName());  
   35.             System.out.println("element.getText(): " + el.getText());  
   36.         }  
   37.     } catch (Exception e) {  
   38.         e.printStackTrace();  
   39.     }  
   40. }  
    虽然看着是没有第一种好看，不过我也很喜欢，为什么？多写点代码有时候才能显出来我们编码人员的重要性啊，呵呵呵，开玩笑了。
6. 一下再看看下载的方法，首先还是使用第一种方式：
   Java代码   

   1. /** 
   2.  * 下载 
   3.  */  
   4. public static void test1() {  
   5.     try {  
   6.         RPCServiceClient serviceClient = new RPCServiceClient();  
   7.         Options options = serviceClient.getOptions();  
   8.         EndpointReference targetEPR = new EndpointReference("http://localhost:8080/axis2/services/MyAxis2Service");  
   9.         options.setTo(targetEPR);  
   10.         QName opAddEntry;  
   11.         byte[] buffer;  
   12.         opAddEntry = new QName("http://ws.apache.org/axis2","dowImageWithByte");  
   13.         buffer = (byte[]) serviceClient.invokeBlocking(opAddEntry,new Object[] {}, new Class[] { byte[].class })[0];  
   14.         FileOutputStream fos = null;  
   15.         try {  
   16.             fos = new FileOutputStream("d:\\test1.jpg");  
   17.             // 开始写入图像文件的字节  
   18.             fos.write(buffer, 0, buffer.length);  
   19.             fos.close();  
   20.         } catch (Exception e) {  
   21.             e.printStackTrace();  
   22.         } finally {  
   23.             if (fos != null) {  
   24.                 try {  
   25.                     fos.close();  
   26.                 } catch (Exception e) {  
   27.                     e.printStackTrace();  
   28.                 }  
   29.             }  
   30.         }  
   31.     } catch (Exception e) {  
   32.         e.printStackTrace();  
   33.     }  
   34. }  
    同样很简单呀，只要强制转换就可以了。下面继续看一下第二种方式的代码：
   Java代码   

   1. /** 
   2.  * 下载 
   3.  */  
   4. @SuppressWarnings("unchecked")  
   5. public static void test2() {  
   6.     try {  
   7.         // 服务地址，服务地址，命名空间，方法名称，组装参数，返回数据解析，可以自己根据实际情况编码  
   8.         EndpointReference targetEPR = new EndpointReference("http://127.0.0.1:8080/axis2/services/MyAxis2Service");  
   9.         ServiceClient serviceClient = new ServiceClient();  
   10.         Options options = new Options();  
   11.         options.setTo(targetEPR);  
   12.         serviceClient.setOptions(options);  
   13.         OMFactory fac = OMAbstractFactory.getOMFactory();  
   14.         OMNamespace omNs = fac.createOMNamespace("http://ws.apache.org/axis2", "");  
   15.         // 调用据方法  
   16.         OMElement data = fac.createOMElement("dowImageWithByte", omNs);  
   17.         // 发送请求  
   18.         OMElement results = serviceClient.sendReceive(data);  
   19.         Iterator it = results.getChildElements();  
   20.         while (it.hasNext()) {  
   21.             OMElement el = (OMElement) it.next();  
   22.             OMText binaryNode = (OMText) el.getFirstOMChild();  
   23.             binaryNode.setOptimize(true); //必须加此句，否则会出现ContentID is null的异常!  
   24.             DataHandler dh = (DataHandler) binaryNode.getDataHandler();  
   25.             FileOutputStream fileOutStream = new FileOutputStream("d:\\test.jpg");  
   26.             InputStream is = dh.getInputStream();  
   27.             fileOutStream.write(IOUtils.getStreamAsByteArray(is));  
   28.         }  
   29.     } catch (Exception e) {  
   30.         e.printStackTrace();  
   31.     }  
   32. }  
    在接收到参数后的解析工作确实有点麻烦。不过，你知道就行了，底层的东西依赖少，出问题也好解决。
7. 不过是不是看着有点晕呀，没关系，每次都会上传工程给大家的。在附件中大家解压后可以直接导入到MyEclipse中查看代码。可以直接main方法运行，也可以跑起来点击首页的按钮来触发后台调用。其中MyAxis2Service.java是要部署的服务端代码，不用关心。