WebService封装技巧

今天我想来分享一下我在用WebService中的一些技巧(至少我认为是技巧,还有点成就感),希望能给大家以后在用WebService时一点帮助和启发吧。WebService封装技巧 WebService封装技巧有哪些 ?

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

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

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

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

统一访问接口IRemoteCall:

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

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

 
 
[WebService(Namespace = "http://tempuri.org/")]
[WebServiceBinding(ConformsTo = WsiProfiles.BasicProfile1_1)]
[ToolboxItem(false)]
public class BlogService : System.Web.Services.WebService, IRemoteCall
{
    [WebMethod(EnableSession = true)]
    public byte[] GeneralCall(string methodName, params byte[] param)
    {
        switch (methodName)
        {
            case "LoadBlog":
               {
                   long blogId = Serializer.DeserializeToObject<long>(param);
                   BLLBlogArtical ba = new AppBlog().LoadBlog(blogId);
                   return Serializer.SerializeToBinary(ba);
               }
            case "DeleteBlog":
               {
                   //To Do Your Code
                   return null;
               }
         }
     }
}

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

这里我们定义了一个统一的访问入口byte[] GeneralCall(string methodName,params byte[] param)

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

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

三、自定义webservice访问器,爽死客户端

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

 
  
using System;
using System.Collections.Generic;
using System.Text;
using System.Collections;
using System.Web.Services.Protocols;
using SharedLib_403;
 
namespace ITIvy.Shared.RemoteCaller
{
     
    /// <summary>
    /// 远程接口访问器
    /// </summary>
    public class RemoteCaller
    {
        private string _MethodName;
        private byte[] _ParamByte;
        private IRemoteCall _Caller;
        private ArrayList _Params;
 
        /// <summary>
        /// 参数列表
        /// </summary>
        public ArrayList Params
        {
            get { return _Params; }
            set { _Params = value; }
        }
 
        /// <summary>
        /// 序列化后的参数
        /// </summary>
        public byte[] ParamByte
        {
            get { return _ParamByte; }
            set { _ParamByte = value; }
        }
 
        /// <summary>
        /// 远程服务方法名称
        /// </summary>
        public string MethodName
        {
            get { return _MethodName; }
            set { _MethodName = value; }
        }
 
        /// <summary>
        /// 远程服务调用接口
        /// </summary>
        public IRemoteCall Caller
        {
            get { return _Caller; }
            set { _Caller = value; }
        }
 
        /// <summary>
        /// 构造
        /// </summary>
        /// <param name="caller">Webservice远程接口</param>
        public RemoteCaller(IRemoteCall caller)
        {
            _Caller = caller;
            _Params = new ArrayList();
        }
 
        /// <summary>
        /// 调用远程接口
        /// </summary>
        /// <param name="methodName">方法名称</param>
        /// <param name="param">参数对象</param>
        /// <returns></returns>
        public byte[] Call(string methodName, object param)
        {
            try
            {
                _MethodName = methodName;
                _ParamByte = Serializer.SerializeToBinary(param);
                return _Caller.GeneralCall(_MethodName, _ParamByte);
            }
            catch (Exception ex)
            {
                if (ex is SoapException)
                    throw new Exception(((SoapException)ex).Detail["Message"].InnerText);
                else
                    throw ex;
            }
        }
 
        /// <summary>
        /// 调用远程接口
        /// </summary>
        /// <param name="methodName">方法名称</param>
        /// <param name="param">参数列表</param>
        /// <returns></returns>
        public byte[] Call(string methodName, ArrayList param)
        {
            try
            {
                _MethodName = methodName;
                _Params = param;
                _ParamByte = Serializer.SerializeToBinary(_Params);
                return _Caller.GeneralCall(_MethodName, _ParamByte);
            }
            catch (Exception ex)
            {
                if (ex is SoapException)
                    throw new Exception(((SoapException)ex).Detail["Message"].InnerText);
                else
                    throw ex;
            }
        }
 
        /// <summary>
        /// 调用远程接口
        /// </summary>
        /// <param name="methodName">方法名称</param>
        /// <param name="param">参数对象数组</param>
        /// <returns></returns>
        public byte[] Call(string methodName, params object[] param)
        {
            try
            {
                foreach (object obj in param)
                    _Params.Add(obj);
                _MethodName = methodName;
                _ParamByte = Serializer.SerializeToBinary(_Params);
                return _Caller.GeneralCall(_MethodName, _ParamByte);
            }
            catch (Exception ex)
            {
                if (ex is SoapException)
                    throw new Exception(((SoapException)ex).Detail["Message"].InnerText);
                else
                    throw ex;
            }
        }
 
        /// <summary>
        /// 调用远程接口
        /// </summary>
        /// <returns></returns>
        public byte[] Call()
        {
            try
            {
                if (string.IsNullOrEmpty(_MethodName))
                    throw new Exception("远程方法不能为空!");
                return _Caller.GeneralCall(_MethodName, _ParamByte);
            }
            catch (Exception ex)
            {
                if (ex is SoapException)
                    throw new Exception(((SoapException)ex).Detail["Message"].InnerText);
                else
                    throw ex;
            }
        }
 
        /// <summary>
        /// 调用远程接口
        /// </summary>
        /// <typeparam name="T">返回值类型</typeparam>
        /// <returns></returns>
        public T Call<T>()
        {
            byte[] resultByte = Call();
            return Serializer.DeserializeToObject<T>(resultByte);
        }
 
        /// <summary>
        /// 调用远程接口
        /// </summary>
        /// <typeparam name="T">返回值类型</typeparam>
        /// <param name="methodName">方法名称</param>
        /// <param name="param">参数列表</param>
        /// <returns></returns>
        public T Call<T>(string methodName, ArrayList param)
        {
            byte[] resultByte = Call(methodName, param);
            return Serializer.DeserializeToObject<T>(resultByte);
        }
 
        public T Call<T>(string methodName, object param)
        {
            try
            {
                _MethodName = methodName;
                _ParamByte = Serializer.SerializeToBinary(param);
                byte[] resultByte = _Caller.GeneralCall(_MethodName, _ParamByte);
                return Serializer.DeserializeToObject<T>(resultByte);
            }
            catch (Exception ex)
            {
                if (ex is SoapException)
                    throw new Exception(((SoapException)ex).Detail["Message"].InnerText);
                else
                    throw ex;
            }
        }
 
        /// <summary>
        /// 调用远程接口
        /// </summary>
        /// <typeparam name="T">返回值类型</typeparam>
        /// <param name="methodName">方法名称</param>
        /// <param name="param">参数对象数组</param>
        /// <returns></returns>
        public T Call<T>(string methodName, params object[] param)
        {
            byte[] resultByte = Call(methodName, param);
            return Serializer.DeserializeToObject<T>(resultByte);
        }
    }
}

这个访问器主要是定义了一系列访问接口的重载,利用了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访问。

评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值