总结WebService的一些封装技巧

开发 后端
讨论一下WebService的一些封装技巧,也就是会碰到的常见问题的解决,希望能给大家以后在用WebService时一点帮助和启发吧。

今天早上起来,想谈谈.NET中的WebService,当然我不想讲什么是WebService,或者怎么用WebService,因为那个大家随便Google一下前100页都能找到答案。今天我想来分享一下我在用WebService中的一些技巧(至少我认为是技巧,还有点成就感),希望能给大家以后在用WebService时一点帮助和启发吧。

一、问题诞生 -- 大部分解决方案的背后总是一些头痛的问题

很早以前就用过传说中的WebService,但一直是用常规的思路在用:创建WebService项目-->写Web服务方法--> 在项目中添加Web引用-->调用Web方法。这样貌似很好,非常符合规范,在一段时间内效果也还可以,但渐渐的随着项目的扩大和同时参与项目的人员增多,就越来越觉得这种常规的方法很是不爽,为什么呢?我每次修改WebService端(添加、删除Web方法,以及修改方法名称),在引用端我都要更新WebService引用,其实是就是更新WSDL文件,很是烦人。

二、化分为合 -- 传说分久必合,合久必分

好吧,既然增加、删除、修改web方法名都会引起WSDL的更新,那么我们索性用一个统一的方法来作为webservice的访问入口吧,然后内部用switch case来区分调用哪个方法,先贴代码吧,再来简单讲讲:

统一访问接口IRemoteCall:

  1. public interface IRemoteCall{      
  2. byte[] GeneralCall(string methodName, params byte[] param);} 

然后定义一个WebService并实现以上接口(以前还没真在webservice上实现过接口,哈哈):

  1. [WebService(Namespace = http://tempuri.org/)]
  2. [WebServiceBinding(ConformsTo =   WsiProfiles.BasicProfile1_1)]
  3. [ToolboxItem(false)]public class BlogService : 
  4. System.Web.Services.WebService, IRemoteCall{      
  5. [WebMethod(EnableSession = true)]     
  6.  public byte[] GeneralCall(string methodName, params byte[] param) 
  7.    {          
  8. switch (methodName)         
  9.  {            
  10.   case "LoadBlog":            
  11.      {                 
  12.     long blogId = Serializer.DeserializeToObject<long>(param);                   
  13.   BLLBlogArtical ba = new AppBlog().LoadBlog(blogId);                 
  14.     return Serializer.SerializeToBinary(ba);            
  15.      }           
  16.    case "DeleteBlog":          
  17.        {                
  18.      //To Do Your Code        
  19.              return null;          
  20.        }    
  21.        }     }} 

这里为什么要定义接口IRemoteCall呢,主要是为接下来统一调用webservice服务的,所有实现这个接口的webservice类都可以通过GeneralCall来完成调用,待会将webservice访问器的时候会具体讲到,这里主要讲讲这个switch case。

这里我们定义了一个统一的访问入口
 

  1. byte[] GeneralCall(string methodName,params byte[] param) 

意思是:传入要调用的方法名称以及序列化后的参数,返回序列化后的结果。这里为了统一数据,我们均对参数和返回值都序列化成byte数组,即用Serializer.SerializeToBinary(object)来实现,这样所有调用就都统一了格式。

有人可能会提出质疑,这样方法名称都已字符串形式是不是会显得难看,而且字符串容易出错,还没有智能提示?那也好解决,我们可以把方法名称定义成const常量就可以了。这里我对webservice的一个态度是:webservice层就是完成转接和调度工作的,它仅仅起到承接的作用,用了他可以将服务任意分布,所以里面是没有任何逻辑的(逻辑都是被封装在其他dll中的),最多是一些数据转换,所以我采用了这种模糊接口的方式。

三、自定义webservice访问器

上面我们完成了webservice端的工作,接下来就来实现客户端对webservice的灵活调用,这里上面定义的那个IRemoteCall就起到作用了,首先我们定义一个webservice访问器类RemoteCaller,代码如下:

  1. using System;using   
  2. System.Collections.Generic;using   
  3. System.Text;using   
  4. System.Collections;using System.Web.Services.Protocols;  
  5. using SharedLib_403;   
  6. namespace ITIvy.Shared.RemoteCaller{      
  7.      /// <summary>     
  8.  /// 远程接口访问器     
  9.  /// </summary>     
  10.  public class RemoteCaller    
  11.   {      
  12.     private string _MethodName;     
  13.      private byte[] _ParamByte;      
  14.     private IRemoteCall _Caller;       
  15.    private ArrayList _Params;       
  16.     /// <summary>         
  17.  /// 参数列表     
  18.      /// </summary>        
  19.   public ArrayList Params      
  20.     {           
  21.    get { return _Params; }            
  22.   set { _Params = value; }      
  23.     }  
  24.          /// <summary>       
  25.    /// 序列化后的参数        
  26.   /// </summary>       
  27.    public byte[] ParamByte       
  28.    {        
  29.       get { return _ParamByte; }      
  30.         set { _ParamByte = value; }       
  31.    }         /// <summary>      
  32.     /// 远程服务方法名称        
  33.   /// </summary>        
  34.   public string MethodName    
  35.       {        
  36.       get { return _MethodName; }        
  37.       set { _MethodName = value; }       
  38.    }         /// <summary>      
  39.     /// 远程服务调用接口       
  40.    /// </summary>       
  41.    public IRemoteCall Caller    
  42.       {          
  43.     get { return _Caller; }      
  44.         set { _Caller = value; }    
  45.       }          
  46.  /// <summary>       
  47.    /// 构造       
  48.    /// </summary>      
  49.     /// <param name="caller">Webservice远程接口</param>        
  50.   public RemoteCaller(IRemoteCall caller)        {             
  51.  _Caller = caller;            
  52.   _Params = new ArrayList();      
  53.     }       
  54.     /// <summary>      
  55.     /// 调用远程接口        /// </summary>      
  56.     /// <param name="methodName">方法名称</param>        
  57.   /// <param name="param">参数对象</param>     
  58.      /// <returns></returns>      
  59.     public byte[] Call(string methodName, object param)   
  60.      {           
  61.    try            {         
  62.          _MethodName = methodName;            
  63.     _ParamByte = Serializer.SerializeToBinary(param);         
  64.          return _Caller.GeneralCall(_MethodName, _ParamByte);          
  65.     }     
  66.          catch (Exception ex)       
  67.      {                
  68.   if (ex is SoapException)                
  69. throw new Exception(((SoapException)ex).Detail["Message"].InnerText); 
  70.                else                   
  71.    throw ex;          
  72.     }        }        
  73.    /// <summary>      
  74.     /// 调用远程接口       
  75.    /// </summary>        
  76.   /// <param name="methodName">方法名称</param>        
  77.   /// <param name="param">参数列表</param>       
  78.    /// <returns></returns>         
  79.  public byte[] Call(string methodName, ArrayList param)       
  80.    {            
  81.   try            
  82.   {        
  83.           _MethodName = methodName;                
  84. _Params = param;       
  85.            _ParamByte = Serializer.SerializeToBinary(_Params);           
  86.        return _Caller.GeneralCall(_MethodName, _ParamByte);         
  87.      }          
  88.     catch (Exception ex)        
  89.       {                
  90.   if (ex is SoapException)                 
  91.  throw new Exception(((SoapException)ex).Detail["Message"].InnerText);           
  92.        else               
  93.        throw ex;            }   
  94.        }         
  95.   /// <summary>      
  96.     /// 调用远程接口      
  97.     /// </summary>        
  98.   /// <param name="methodName">方法名称</param>       
  99.    /// <param name="param">参数对象数组</param>        
  100.   /// <returns></returns>      
  101.     public byte[] Call(string methodName, params object[] param)   
  102.        {         
  103.      try          
  104.     {        
  105.           foreach (object obj in param)         
  106.              _Params.Add(obj);              
  107.   _MethodName = methodName;       
  108.            _ParamByte = Serializer.SerializeToBinary(_Params);               
  109.    return _Caller.GeneralCall(_MethodName, _ParamByte);           
  110.    }       
  111.        catch (Exception ex)           
  112.    {                
  113.   if (ex is SoapException)                 
  114.      throw new Exception(((SoapException)ex).Detail["Message"].InnerText);    
  115.             else                   
  116.    throw ex;            }    
  117.       }           
  118. /// <summary>      
  119.     /// 调用远程接口     
  120.      /// </summary>     
  121.      /// <returns></returns>     
  122.      public byte[] Call()       
  123.    {            try          
  124.     {             
  125.      if (string.IsNullOrEmpty(_MethodName))                 
  126.      throw new Exception("远程方法不能为空!");                
  127.   return _Caller.GeneralCall(_MethodName, _ParamByte);            }    
  128.           catch (Exception ex)      
  129.         {                
  130.   if (ex is SoapException)          
  131.             throw new Exception(((SoapException)ex).Detail["Message"].InnerText);  
  132.               else                 
  133.      throw ex;         
  134.      }        }         
  135.   /// <summary>         
  136.  /// 调用远程接口        /// </summary>   
  137.        /// <typeparam name="T">返回值类型</typeparam>       
  138.  /// <returns></returns>        
  139. public T Call<T>()     
  140.      {            byte[] resultByte = Call();          
  141.   return Serializer.DeserializeToObject<T>(resultByte);        }     
  142.       /// <summary>       
  143.    /// 调用远程接口        
  144.   /// </summary>       
  145.    /// <typeparam name="T">返回值类型</typeparam>      
  146.     /// <param name="methodName">方法名称</param>       
  147.    /// <param name="param">参数列表</param>      
  148.     /// <returns></returns>      
  149.     public T Call<T>(string methodName, ArrayList param)   
  150.        {            
  151.   byte[] resultByte = Call(methodName, param);            
  152.   return Serializer.DeserializeToObject<T>(resultByte);        
  153.   }     
  154.       public T Call<T>(string methodName, object param)        {          
  155.     try            {            
  156.       _MethodName = methodName;              
  157.     _ParamByte = Serializer.SerializeToBinary(param);                
  158.   byte[] resultByte = _Caller.GeneralCall(_MethodName, _ParamByte);          
  159.    
  160.        return Serializer.DeserializeToObject<T>(resultByte);          
  161.     }            catch (Exception ex)           
  162.    {        
  163.           if (ex is SoapException)             
  164.        throw new Exception(((SoapException)ex).Detail["Message"].InnerText);    
  165.             else                  
  166.     throw ex;          
  167.     }        }         
  168.   /// <summary>     
  169.      /// 调用远程接口      
  170.     /// </summary>   
  171.        /// <typeparam name="T">返回值类型</typeparam>     
  172.      /// <param name="methodName">方法名称</param>        
  173.   /// <param name="param">参数对象数组</param>     
  174.      /// <returns></returns>        
  175.   public T Call<T>(string methodName, params object[] param)        
  176.   {          
  177.     byte[] resultByte = Call(methodName, param);           
  178.    return Serializer.DeserializeToObject<T>(resultByte);       
  179.    }    }}  
  180.  

这个访问器主要是定义了一系列访问接口的重载,利用了c#的泛型更加使接口简单了。哈哈,这个类就能让我们实现一句话调用webservice,相当简洁。注意里面的IRemoteCall属性,就是只要传入实现了该接口的类,就都可以通过该访问器来访问webservice。如何使用该类呢,下面给一个例子吧:


IRemoteCall Caller = new BlogService.BlogService();BLLBlogArtical bllArtical = new RemoteCaller(Caller).Call<BLLBlogArtical>("LoadBlog", id);

抱歉,说错了,要两句话来调用,但是这里少去了很多数据转换的工作,因为有了泛型,呵呵,而且我可以在RemoteCaller这个访问器类中做很多工作,比如异常处理,权限验证等等。

四、总结 -- 写了这么多不总结可不行

这个实现方法的核心在于用IRemoteCall接口来规范webservice类的实现方式均为统一GenerateCall,然后 webservice类中通过switch case来将所有方法整合在一起,避免频繁更新WSDL的麻烦,***客户端利用IRemoteCall定义一个webservice访问器类 RemoteCaller来提供统一的webservice访问。

原文链接:http://www.cnblogs.com/sxwgf/archive/2011/07/10/something-about-webservice.html

【编辑推荐】

  1. Java与.NET的WebServices相互调用
  2. 如何使用Netbeans生成的Webservice
  3. 浅谈关于Webservices对接的一些问题
  4. MyEclipse配置WebService六步曲
  5. Flex跨域调用Webservice问题揭秘
责任编辑:彭凡 来源: 博客园
相关推荐

2009-11-26 10:32:57

PHP代码优化

2020-10-19 19:25:32

Python爬虫代码

2024-01-30 10:11:00

SpringBoot项目开发

2018-01-09 18:06:41

Python爬虫技巧

2011-06-01 16:50:21

JAVA

2012-05-21 10:13:05

XCode调试技巧

2013-03-29 13:17:53

XCode调试技巧iOS开发

2011-10-26 20:55:43

ssh 安全

2011-05-23 18:06:24

站内优化SEO

2021-10-12 23:10:58

UnsafeJavaJDK

2009-06-22 15:36:00

如何学好java

2011-11-28 15:57:26

MySQL数据库主从配置

2022-12-02 14:58:27

JavaScript技巧编程

2009-09-27 11:09:42

API设计

2015-12-08 09:05:41

Java内部类

2009-07-15 16:16:22

JDBC下载

2020-04-14 09:22:47

bash脚本技巧

2020-04-08 10:21:58

bash脚本语言

2017-09-20 15:07:32

数据库SQL注入技巧分享

2017-05-10 15:30:30

skynet崩溃程序
点赞
收藏

51CTO技术栈公众号