WCF4.0 –- RESTful WCF Services -SOA-火龙果软件工程

WCF4.0 –- RESTful WCF Services

作者：therockthe 来源：博客发布于 2016-10-31

次浏览

WCF 很好的支持了 REST 的开发，而 RESTful 的服务通常是架构层面上的考虑。因为它天生就具有很好的跨平台跨语言的集成能力，几乎所有的语言和网络平台都支持 HTTP 请求，无需去实现复杂的客户端代理，无需使用复杂的数据通讯方式既可以将我们的服务暴露给任何需要的人，无论他使用 VB、Ruby、JavaScript，甚至是 HTML FORM，或者直接在浏览器地址栏输入。

WCF 中通过 WebGetAttribute、WebInvokeAttribute (GET/PUT/POST/DELETE)、UriTemplate 定义 REST 的服务的调用方式，通过 WebMessageFormat (Xml/Json) 定义消息传递的格式。

1. 契约

using System;  
using System.Collections.Generic;  
using System.Runtime.Serialization;  
using System.ServiceModel;  
using System.ServiceModel.Web;  
  
namespace WcfRESTfulSvc1  
{  
    [ServiceContract]  
    public interface ITaskService  
    {  
        [OperationContract]  
        [WebGet(UriTemplate=
"Tasks/Xml", ResponseFormat=WebMessageFormat.Xml)]  
        List<Task> GetTasksXml();  
  
        [OperationContract]  
        [WebGet(UriTemplate =
 "Tasks/Json", ResponseFormat = WebMessageFormat.Json)]  
        List<Task> GetTasksJson();  
  
        [OperationContract]  
        [WebInvoke(UriTemplate=
"Task/{title}", Method="GET", ResponseFormat=WebMessageFormat.Json)]  
        Task GetTasksByTitle(string title);  
    }  
  
  
    [DataContract]  
    public class Task  
    {  
        [DataMember]  
        public string Title { get; set; }  
        [DataMember]  
        public string Detail { get; set; }  
        [DataMember]  
        public DateTime CreatedDate { get; set; }  
    }  
}

2. 实现

using System;  
using System.Collections.Generic;  
using System.Linq;  
  
namespace WcfRESTfulSvc1  
{  
    public class TaskService : ITaskService  
    {  
        public List<Task> GetTasksXml()  
        {  
            return GetData();  
        }  
  
        public List<Task> GetTasksJson()  
        {  
            return GetData();  
        }  
  
        public Task GetTasksByTitle(string title)  
        {  
            return GetData().Where(t => t.Title == title).FirstOrDefault();  
        }  
  
        private static List<Task> GetData()  
        {  
            return new List<Task>  
            {  
                new Task 
{ Title="Task1", Detail="Do Something 1", CreatedDate=DateTime.Now },  
                new Task 
{ Title="Task2", Detail="Do Something 2", CreatedDate=DateTime.Now },  
                new Task 
{ Title="Task3", Detail="Do Something 3", CreatedDate=DateTime.Now },  
                new Task 
{ Title="Task4", Detail="Do Something 4", CreatedDate=DateTime.Now },  
                new Task 
{ Title="Task5", Detail="Do Something 5", CreatedDate=DateTime.Now },  
            };  
        }  
    }  
}

通过 WCF 4.0 里创建的 WCF Service Application 发布REST服务很简单，只需要在 svc 的 Markup 里加上 Factory：

<%@ ServiceHost Language="C#" Debug="true" Service="WcfRESTfulSvc1.TaskService" CodeBehind="TaskService.svc.cs" Factory="System.ServiceModel.Activation.WebServiceHostFactory"%>

BTW: 不过这样，WCF的Metadata就不能访问到了，也就说不能访问到svc的wsdl了。

OK，在浏览器中键入 http://localhost:2571/TaskService.svc/Tasks/Xml 就能得到结果：

<ArrayOfTask xmlns= 
  "http://schemas.datacontract.org/2004/07/WcfRESTfulSvc1" 
   xmlns:i="http://www.w3.org/2001/XMLSchema-instance">  
  <Task>  
    <CreatedDate>2011-03-09T21:51:13.3376004+08:00</CreatedDate>  
    <Detail>Do Something 1</Detail>  
    <Title>Task1</Title>  
  </Task>  
  <Task>  
    <CreatedDate>2011-03-09T21:51:13.3376004+08:00</CreatedDate>  
    <Detail>Do Something 2</Detail>  
    <Title>Task2</Title>  
  </Task>  
  <Task>  
    <CreatedDate>2011-03-09T21:51:13.3376004+08:00</CreatedDate>  
    <Detail>Do Something 3</Detail>  
    <Title>Task3</Title>  
  </Task>  
  <Task>  
    <CreatedDate>2011-03-09T21:51:13.3376004+08:00</CreatedDate>  
    <Detail>Do Something 4</Detail>  
    <Title>Task4</Title>  
  </Task>  
  <Task>  
    <CreatedDate>2011-03-09T21:51:13.3376004+08:00</CreatedDate>  
    <Detail>Do Something 5</Detail>  
    <Title>Task5</Title>  
  </Task>  
</ArrayOfTask>

客户端的调用利用System.Net.WebClient也很容易：

var client = new WebClient();  
this.txtResponse.Text = client.DownloadString(url);

Json的返回结果：

[{"CreatedDate":"//Date(1299687080328+0800)//","Detail":"Do Something 1","Title":"Task1"},{"CreatedDate":"//Date(1299687080328+0800)//","Detail":"Do Something 2","Title":"Task2"},{"CreatedDate":"//Date(1299687080328+0800)//","Detail":"Do Something 3","Title":"Task3"},{"CreatedDate":"//Date(1299687080328+0800)//","Detail":"Do Something 4","Title":"Task4"},{"CreatedDate":"//Date(1299687080328+0800)//","Detail":"Do Something 5","Title":"Task5"}]

再来看看利用jQuery如何调用这个服务：

<mce:script type="text/javascript" language="JavaScript"><!--  
    $(document).ready(function () {  
        $("#btnGet").click(function () {  
            var url = $("#txtUrl").val();  
            $.get(url, function (data) {  
                for (var i = 0; i < data.length; i++)  
                    $("#divResponse").append("<li>" +  
                    data[i].Title + "&nbsp;-&nbsp;" +  
                    data[i].Detail + "</li>");  
            });  
        });  
    });  
// --></mce:script>

RESTful服务就是为了实现一个易于整合的系统，可以跨平台跨语言的调用(如下图)，【上篇】介绍了如何用WCF构建一个RESTful的服务。

本篇进一步通过一个实例记录如何实施一个具体的RESTful WCF服务以及客户端调用服务进行增，删，改，查。

WCF 4.0 其新功能之一就是 WCF 更容易以 REST API 来呈现，在 WCF 3.5 中的 WebGetAttribute 与 WebInvokeAttribute 中的 UriTemplate 参数原本不支持 REST URL 格式，为了 REST 功能，微软还特意发布了 WCF REST Starter Kit 组件，让开发人员可以利用 WCF 3.5 开发真正 REST-based 的应用程序，由 URL 对应到指定的 Service Contract 中的 Operation Contract，在 WCF 4.0 中，WCF 的核心已经融入了 REST Starter Kit 中的 URL 引擎，在 WebGetAttribute 与 WebInvokeAttribute 已经可以支持 REST 的功能，Windows Azure 许多服务的 REST API 就是利用 WCF 来开发的。

主要涉及以下内容：

1. 如何通过 JSON 数据进行交互；

2. 如何进行服务端的错误处理，并在客户端区分不同的异常；

3. 如何利用 Microsoft.HttpClient (微软提供的第3方组件)；

本次示例的工程：

PS：上面虽然在一个solution里有两个工程，但是工程之前没有任何引用。完全靠Http消息传递。

1. 创建服务端工程：

通过VS2010的Extension Manager，可以下载一个“WCF REST Service Template”。通过这个我们可以快速创建一个WCF REST服务。它是一个创建在Web Application工程里的服务。和前一篇介绍的WCF服务不同的是在Globel.asax中的Application_Start事件中注册服务。并且注册的"TaskService"自动成为服务的基地址，即 http://<machine_name>:<port>/TaskService/

public class Global : HttpApplication  
{  
    void Application_Start(object sender, EventArgs e)  
    {  
        RegisterRoutes();  
    }  
  
    private void RegisterRoutes()  
    {  
        RouteTable.Routes.Add(new ServiceRoute("TaskService",   
            new WebServiceHostFactory(), typeof(TaskService)));  
    }  
}

2. 服务的实现：

服务端直接通过Linq2Entities操作DB，为了返回JSON的数据，参数和返回值都设计为POCO类。在Linq2Entities生成代码后，又拷贝了一份进行删减修改为POCO类。(现在有一个ADO.NET POCO Generator 的t4模板，不知道能否简化我现在的做法...)

namespace WcfRestService2.Model  
{  
    [DataContract]  
    public class PocoTask  
    {  
        [DataMember]  
        public virtual int ID { get; set; }  
        [DataMember]  
        public virtual string Title { get; set; }  
        [DataMember]  
        public virtual string Detail { get; set; }  
        [DataMember]  
        public virtual int State { get; set; }  
        [DataMember]  
        public virtual DateTime UpdatedDate { get; set; }  
    }  
}

REST中很好的利用了HTTP的GET/POST/PUT/DELETE方式，绑定到服务的不同方法上。比如GET方法不用客户端提供太多数据，正适合查询只提供主键或者查询字段的场景。POST则适合数据的插入，PUT则应用在数据更新，DELETE则直接用在数据删除上。当然通过URI的区别，也可以全部用POST或者PUT，只是语义符合调用场景的话，是的服务使用更易于理解和习惯。

服务端实现片段：

(1) 查询(Http/GET)，这里定义了访问的UriTemplate，完整访问地址就是"基地址+UriTemplate"，比如：

http://localhost:port/TaskService/Tasks/State/{state} 另外ResponseFormat设定为Json格式。

也可以在配置文件中，修改 <standardEndpoint> 节点的 defaultOutgoingResponseFormat 属性控制Response的格式。

[WebGet(UriTemplate = "Tasks/State/{state}",   
    ResponseFormat = WebMessageFormat.Json)]  
public List<PocoTask> GetTasksByState(string state)  
{  
    using (var db = new TasksEntities())  
    {  
        int s = Int32.Parse(state);  
        var query = db.Task.Where(t => t.State == s || -1 == s);  
        return GetPocoData(query);  
    }  
}

(2) 新建(Http/POST)，POST里的数据格式通过RequestFormat定义为Json，WCF框架接受到Json数据的请求，会自动反序列化成PocoTask实例。然后我又创建真正EF里的Entity实例，将PocoTask数据复制到Entity里，插入DB。

[WebInvoke(UriTemplate = "Tasks/Add", Method = "POST",   
    RequestFormat=WebMessageFormat.Json)]  
public void Create(PocoTask pocoTask)  
{  
    var ctx = WebOperationContext.Current;  
    ctx.OutgoingResponse.StatusCode = 
System.Net.HttpStatusCode.OK;  
    try  
    {  
        using (var db = new TasksEntities())  
        {  
            var task = new Task();  
            CopyValue(pocoTask, task);  
            task.UpdatedDate = DateTime.Now;  
            db.AddToTask(task);  
            db.SaveChanges();  
        }  
        ctx.OutgoingResponse.StatusCode = 
System.Net.HttpStatusCode.Created;  
    }  
    catch (Exception ex)  
    {  
        ctx.OutgoingResponse.StatusCode = 
System.Net.HttpStatusCode.ExpectationFailed;  
        ctx.OutgoingResponse.StatusDescription = ex.Message;  
    }  
}

(3) 更新(Http/PUT)，先通过id查出Entity，再将客户端的数据更新到Entity上。

[WebInvoke(UriTemplate = "Tasks/{id}", Method = "PUT",   
    RequestFormat=WebMessageFormat.Json)]  
public void Update(string id, PocoTask pocoTask)  
{  
    var ctx = WebOperationContext.Current;  
    ctx.OutgoingResponse.StatusCode = 
System.Net.HttpStatusCode.OK;  
    try  
    {  
        using (var db = new TasksEntities())  
        {  
            var nId = Convert.ToInt32(id);  
            var target = 
db.Task.SingleOrDefault(t => t.ID == nId);  
            target.Title = pocoTask.Title;  
            target.Detail = pocoTask.Title;  
            target.State = pocoTask.State;  
            target.UpdatedDate = DateTime.Now;  
            db.SaveChanges();  
        }  
        ctx.OutgoingResponse.StatusCode = 
System.Net.HttpStatusCode.Accepted;  
    }  
    catch (Exception ex)  
    {  
        ctx.OutgoingResponse.StatusCode = 
System.Net.HttpStatusCode.ExpectationFailed;  
        ctx.OutgoingResponse.StatusDescription = ex.Message;  
    }  
}

(4) 删除(Http/DELETE)

[WebInvoke(UriTemplate =  
"Tasks/{id}", Method = "DELETE")]  
public void Delete(string id)  
{  
    var ctx = WebOperationContext.Current;  
    ctx.OutgoingResponse.StatusCode = 
 System.Net.HttpStatusCode.OK;  
    try  
    {  
        using (var db = new TasksEntities())  
        {  
            var nId = Convert.ToInt32(id);  
            var task = db.Task.SingleOrDefault(t => t.ID == nId);  
            db.Task.DeleteObject(task);  
            db.SaveChanges();  
        }  
        ctx.OutgoingResponse.StatusCode =  
System.Net.HttpStatusCode.Accepted;  
    }  
    catch (Exception ex)  
    {  
        ctx.OutgoingResponse.StatusCode = 
 System.Net.HttpStatusCode.ExpectationFailed;  
        ctx.OutgoingResponse.StatusDescription = ex.Message;  
    }  
}

服务端的异常处理中通过 OutgoingResponse.StatusCode 返回不同的Code，这样客户端通过这些Code就知道服务端出现了什么错误。但是目前我还不知道OutgoingResponse.StatusDescription如何在客户端获得。如果可以的话，我们就可以知道错误的详细内容。

本示例中：

a) 查询成功 —— System.Net.HttpStatusCode.OK (默认)

b) 创建成功 —— System.Net.HttpStatusCode.Created

c) 更新成功 —— System.Net.HttpStatusCode.Accepted

d) 删除成功 —— System.Net.HttpStatusCode.Accepted

System.Net.HttpStatusCode的枚举可以参看 MSDN： http://msdn.microsoft.com/en-us/library/system.net.httpstatuscode.aspx。

3. 客户端实现：

因为REST 是基于HTTP的，所以对于 REST 的客户端的开发者，无法像传统的 WebService或者其他的WCF服务通过引用wsdl，享受“奢侈”的代码生成，而使用强类型的本地代理调用服务。开发者只能通过 Http Request 的组装，但正因为这种直接的HttpRequest组装，而使得客户端真正是语言无关的。这里不得不提一下 Microsoft.Http.dll 和 Microsoft.Http.Extensions.dll，它们是微软提供的REST客户端包。可以更加方便地操作 HttpRequest/Response，你可以在这里下到： http://aspnet.codeplex.com/releases/view/24644

客户端片段：

(1) 查询(HTTP/GET), 使用 HttpClient.Get 方法，返回的是HttpResponseMessage，HttpResponseMessage.Content 返回的是Json数据。再通过 Json.NET 第3方组件进行反序列化。另外，为了是在客户端里能通过实例化的类来操作数据，所以在客户端单独再定义了 Task 类。(因为客户端无法通过wsdl生成代理)

// Get Data by state    
var client = new HttpClient();  
var strUrl = "http://localhost:1180/TaskService/Tasks/State/{0}";  
strUrl = string.Format(strUrl, comboBox1.SelectedValue);  
var response = client.Get(strUrl);  
response.EnsureStatusIsSuccessful();  
var json = response.Content.ReadAsString();  
var data = JsonConvert.DeserializeObject<List<Task>>(json);

(2) 新建(HTTP/POST)，将数据序列化成Json格式放进 HttpContent 再使用 HttpClient.Post 提交 HttpContent 数据。

HttpContent 需要指定 ContentType 是Json格式的。

// Add Task   
var task = GetTask();  
var client = new HttpClient();  
var strUrl = "http://localhost:1180/TaskService/Tasks/Add";  
var response = client.Post(strUrl, GetContent(task));  
response.EnsureStatusIsSuccessful();

(3) 更新(HTTP/PUT)

// Update Task   
var task = GetTask();  
var client = new HttpClient();  
var strUrl = "http://localhost:1180/TaskService/Tasks/{0}";  
strUrl = string.Format(strUrl, task.ID);  
var response = client.Put(strUrl, GetContent(task));  
response.EnsureStatusIsSuccessful();

(4) 删除(HTTP/DELETE)

// Delete Task   
var task = GetTask();  
var client = new HttpClient();  
var strUrl = "http://localhost:1180/TaskService/Tasks/{0}";  
strUrl = string.Format(strUrl, task.ID);  
var response = client.Delete(strUrl);  
response.EnsureStatusIsSuccessful();

哦，还漏了个 GetContent(Task task) 方法：

private HttpContent GetContent(Task task)  
{  
    var strContent = JsonConvert.SerializeObject(task);  
    var data = System.Text.Encoding.UTF8.GetBytes(strContent);  
    return HttpContent.Create(data, "application/json");  
}

response.EnsureStatusIsSuccessful 用来检查 Response.StatusCode。

前面2篇blog，主要在介绍REST WCF如何通过json/xml 和客户端完成交互。这篇文章将对REST WCF的原生(RAW)流传输进行一次实例分析。

OK，还是利用 WCF REST Service Application 的工程模板，创建我们的REST WCF工程。

因为WCF REST服务不需要公开metadata, 所以 OperationContract 的定义也省略了。直接定义[ServiceContract]

如果修改模板中Service名，Global.asax中的RegisterRoutes方法也必须相应的修改。

下面是服务的实现：

[ServiceContract]  
[AspNetCompatibilityRequirements
(RequirementsMode = 
AspNetCompatibilityRequirementsMode.Allowed)]  
[ServiceBehavior(InstanceContextMode =
 InstanceContextMode.PerCall, Namespace="")]  
public class ImageService  
{  
    [WebGet(UriTemplate = "{image}")]  
    public Stream GetImage(string image)  
    {  
        var imageType = 
Path.GetExtension(image).TrimStart('.');  
        WebOperationContext.Current.OutgoingResponse.ContentType 
= "image/" + imageType;  
        var dir =
 System.Web.HttpContext.Current.Server.MapPath("~/Images");  
        var file =
 Path.Combine(dir, image);  
        return File.OpenRead(file);  
    }  
  
    [WebInvoke(UriTemplate = "Add/{image}", Method="POST")]  
    public void AddImage(Stream stream, string image)  
    {  
        var dir = 
System.Web.HttpContext.Current.Server.MapPath("~/Images");  
        var file = Path.Combine(dir, image);  
        var bitmap = Bitmap.FromStream(stream);  
        bitmap.Save(file);  
    }  
  
    [WebGet(UriTemplate = 
"ListAll", ResponseFormat=WebMessageFormat.Xml)]  
    public string[] GetAllImageNames()  
    {  
        var dir = System.Web.HttpContext.Current.Server.MapPath("~/Images");  
        var files = Directory.GetFiles(dir);  
        var images = new List<string>();  
        foreach (var file in files)  
        {  
            var ext = Path.GetExtension(file);  
            if (ext == ".jpg" || ext == ".gif")  
                images.Add(file);  
        }  
        for (int i = 0; i < images.Count; i++)  
            images[i] = Path.GetFileName(images[i]);  
        return images.ToArray();  
    }  
}

- GetImage 用于返回图片 Stream，

- AddImage 用于接受图片 Stream 并保存，

- GetAllImageNames 返回所有图片名。

在Http协议中，通过content-type控制客户端的解析行为。当content-type是"image/jpg"或者是"image/gif"的时候，

浏览器就能够直接显示图片了。因此，在代码里有这样的设定：

WebOperationContext.Current.OutgoingResponse.ContentType = "image/" + imageType;

还可以通过 OutgoingResponse.Header 控制缓存。另外，这个REST WCF是建立在一个Web Application中，

我们还可以利用 System.Web.HttpContext.Current.Server.MapPath 方法，获得物理路径。

我们知道一般的WCF服务中，可以实现Streamed传输。在那种场合下，服务契约必须的参数或者返回值必须是Stream，且不能有别的类型的参数（要传递别的参数可以通过MessageHeader)。但是在上面的示例代码中，我定义的 AddImage 就有两个参数：

一个是Stream,还有一个是string。这个string参数其实是通过url传递的： UriTemplate = "Add/{image}"，且这两个参数没有顺序要求。

如果没有写"{image}"会抛出下面的异常（因为Request的Body已经被定义为Stream，图片名只能通过Url传过来。）

Operation 'AddImage' of contract 'ImageService' specifies multiple request body parameters to be serialized without any wrapper elements. At most one body parameter can be serialized without wrapper elements. Either remove the extra body parameters or set the BodyStyle property on the WebGetAttribute/WebInvokeAttribute to Wrapped.

运行服务，直接在浏览器里输入服务URL：http://localhost:3577/ImageService/GIF002.gif 我们就可以看到结果了。

另外，利用REST WCF返回原生流的特性，我们完全可以取代以前在 ASP.NET 中专门生成验证码或者图片读取步骤的页面类，

是不是很方便？

为了体现 REST WCF 的便利性，我设计了一个 WPF 的客户端：

客户端代码：

public partial class MainWindow : Window  
{  
    public MainWindow()  
    {  
        InitializeComponent();  
    }  
  
    private void Window_Loaded 
(object sender, RoutedEventArgs e)  
    {  
        op.RestoreDirectory = true;  
        op.Filter = "Jpeg Files(*.jpg)|*.jpg|Gif Files(*.gif)|*.gif";  
  
        BindData();  
    }  
  
    private void BindData()  
    {  
        var url = "http://localhost:3577/ImageService/ListAll";  
        var client = new HttpClient();  
        var stream = client.Get(url).Content.ReadAsStream();  
        var dataSer = new DataContractSerializer(typeof(string[]));  
        var obj = (string[])dataSer.ReadObject(stream);  
        this.listBox1.DataContext = obj;  
    }  
  
    private Microsoft.Win32.OpenFileDialog op  
= new Microsoft.Win32.OpenFileDialog();  
  
    private void button1_Click(object sender, RoutedEventArgs e)  
    {  
        var ret = op.ShowDialog();  
        if (!ret.HasValue || !ret.Value || !op.CheckFileExists) return;  
        var file = op.FileName;  
        var name = System.IO.Path.GetFileName(file);  
        var url = "http://localhost:3577/ImageService/Add/" + name;  
        var client = new HttpClient();  
        var content = HttpContent.Create(File.OpenRead(file));  
        var resp = client.Post(url, content);  
        resp.EnsureStatusIsSuccessful();  
  
        BindData();  
    }  
  
    private void button2_Click 
(object sender, RoutedEventArgs e)  
    {  
        this.Close();  
    }  
}  
  
[ValueConversion(typeof(string), typeof(string))]  
public class UriConverter : IValueConverter  
{  
    public object Convert(object value, Type targetType,   
        object parameter, System.Globalization.CultureInfo culture)  
    {  
        if (value == null) return null;  
        string sourceValue = value.ToString();  
        return "http://localhost:3577/ImageService/" + sourceValue;  
    }  
  
    public object ConvertBack(object value, Type targetType,  
        object parameter, System.Globalization.CultureInfo culture)  
    {  
        return value;  
    }  
}

实现的注意点：

1) 获得所有图片名，服务端返回的是string[]的序列化的xml，用DataContractSerializer反序列化。

var dataSer = new DataContractSerializer(typeof(string[]));

2) WPF中的OpenFileDialog在Microsoft.Win32命名空间下。（必须引用WindowsBase.dll）

3) 利用 Microsoft.Http.HttpClient 上传图片, 实例化 HttpContent, 通过client.Post上传

var url = "http://localhost:3577/ImageService/Add/" + name;

var client = new HttpClient();

var content = HttpContent.Create(File.OpenRead(file));

var resp = client.Post(url, content);

resp.EnsureStatusIsSuccessful();

4) 定义了一个Converter, 将 ListBox 绑定到 Image 控件的 Source

Source="{Binding ElementName=listBox1, Path=SelectedItem, Converter={StaticResource uriConv}}"

源代码下载：REST WCF Raw Stream 示例代码

在REST架构的WCF服务中，它不像一般的WCF服务绑定，有配套的安全模式，实现起来那么简单。REST WCF服务只能在传输层加密，而一般的WCF 服务可以在消息层加密。因此 REST WCF服务启用ASP.NET兼容模式后，它的安全是由ASP.NET来保证的。本篇文章主要介绍在 REST WCF 中如何实现最简单的 Username 验证。

在SOAP协议的WCF中，可以通过SOAPHeader（MessageHeader)来实现用户名密码的传输，早在WebService时代我们就这么用过了。在REST WCF中，我们可以利用 HttpHeader 来完成这一目标。（你可不会想在每个服务契约里加上用户和密码的参数吧...)

首先在服务中加入如下方法用于校验，Header的信息：如果 Header 中 Authorization 的字符串不是"fangxing/123" 那么就将返回 405 MethodNotAllowed 的错误。这个字符串的内容可以自定义，反正服务端根据某种规则检查这个字符串。

private bool CheckAuthorization()  
{  
    var ctx = WebOperationContext.Current;  
    var auth = ctx.IncomingRequest.Headers 
[HttpRequestHeader.Authorization];  
    if (string.IsNullOrEmpty(auth) || auth != "fangxing/123")  
    {  
        ctx.OutgoingResponse.StatusCode =  
HttpStatusCode.MethodNotAllowed;  
        return false;  
    }  
    return true;  
}

然后在每一个服务契约的实现中，都去调用它。

[WebGet(UriTemplate = "All")]

public List<Task> GetTask()

{

if (!CheckAuthorization())

return null;

return GetData();

}

[WebGet(UriTemplate = "{taskId}")]

public Task GetTaskById(string taskId)

{

if (!CheckAuthorization())

return null;

return GetData().FirstOrDefault(t => t.Id==taskId);

}

现在的服务，如果直接通过浏览器访问，将得到 405 MethodNotAllowed 的错误：

客户端只要相应的验证信加到 RequestHeader 中去，就可以访问了。客户端可以使用单例模式设计 Client 对象。

这样就不用每次调用都去加验证信息了。

var url = "http://localhost:3433/TaskService/All";  
var client = new HttpClient();  
client.DefaultHeaders.Add("Authorization", "fangxing/123");  
var resp = client.Get(url);

* 这里使用的是 Microsoft.Http.HttpClient (WCF REST Starter Kit) 而非 System.Net.WebClient

回头看服务端代码，每个服务实现中都需要加上 CheckAuthorization() 是不是很烦？

OK，我们知道这个 REST WCF服务是承载在一个Web Application上的，通过往 RouteTable 中注册 WebServiceHostFactory 来激活服务对象的。那么只要对这个 WebServiceHostFactory 做些“手脚”，就可以实现服务端验证的统一拦截，代码如下。(一般的 WCF 也可以利用此方法对 MessageHeader 进行拦截校验）

public class SecureWebServiceHostFactory : WebServiceHostFactory  
{  
    protected override ServiceHost CreateServiceHost
(Type serviceType, Uri[] baseAddresses)  
    {  
        var host = base.CreateServiceHost
(serviceType, baseAddresses);  
        host.Authorization.ServiceAuthorizationManager
 = new MyServiceAuthorizationManager();  
        return host;  
    }  
  
    public override ServiceHostBase CreateServiceHost
(string constructorString, Uri[] baseAddresses)  
    {  
        var host = base.CreateServiceHost
(constructorString, baseAddresses);  
        host.Authorization.ServiceAuthorizationManager 
= new MyServiceAuthorizationManager();  
        return host;  
    }  
}  
  
public class MyServiceAuthorizationManager :
 ServiceAuthorizationManager  
{  
    protected override bool CheckAccessCore
(OperationContext operationContext)  
    {  
        var ctx = WebOperationContext.Current;  
        var auth = ctx.IncomingRequest.Headers
[HttpRequestHeader.Authorization];  
        if (string.IsNullOrEmpty(auth) || auth != "fangxing/123")  
        {  
            ctx.OutgoingResponse.StatusCode = 
HttpStatusCode.MethodNotAllowed;  
            return false;  
        }  
        return true;  
    }  
}

RegisterRoutes 里的工厂类也需要相应的修改下：

var securewebServiceHostFactory = new SecureWebServiceHostFactory();  
RouteTable.Routes.Add(new ServiceRoute("TaskService",  
    securewebServiceHostFactory, typeof(TaskService)));

这样服务端代码就可以去掉 CheckAuthorization() 而把验证工作都交给 SecureWebServiceHostFactory 了。

这种验证方式，其实也是现在 Windows Auzer Access Control 的原型。只不过这个 Authoriztion 的服务是专门的Services罢了。

1. 客户端先从发布令牌的服务获取令牌； 2. 客户端拿着令牌提交到现在的服务； 3.服务端将客户端令牌拿到发布令牌的服务上校验。

次浏览