接口开发笔记-HTTP协议

要学习接口开发，首先要对HTTP协议有一定的了解。

一、HTTP基础知识

1、概念

HTTP协议是用于传输数据的一种协议，是一种应用层协议，常使用的端口号是80。它采用了请求/响应模型来传递信息。客户端向服务器发送一个HTTP请求，然后服务器会返回一个HTTP响应。在这个过程中，请求和响应都是通过TCP/IP协议传输的。它允许客户端与Web服务、API以及任何基于HTTP的资源进行交互。

2、HTTP请求与响应

HTTP请求和响应是HTTP协议的两个核心组成部分。HTTP请求由客户端（如Web浏览器或HTTP客户端库）发送，用于请求服务器上的资源；而HTTP响应则由服务器返回，包含所请求的资源或关于请求的状态信息。下面将详细解释HTTP请求和响应的基本结构。

2.1、HTTP请求的基本结构

HTTP请求通常由三部分组成：请求行、请求头和请求体。

2.1.1 请求行

请求行包含HTTP方法、请求的URI和HTTP协议版本。其格式如下：

<HTTP方法> <请求的URI> <HTTP协议版本>

• HTTP方法：如GET、POST、PUT、DELETE等，它告诉服务器需要对资源执行的操作。
• 请求的URI：统一资源标识符，它指定了服务器上资源的具体位置。
• HTTP协议版本：指定了使用的HTTP协议版本，通常是HTTP/1.1。

GET /index.html HTTP/1.1

2.1.2 请求头

请求头包含了关于请求的一些附加信息，以键值对的形式存在。请求头字段提供了关于客户端环境、请求来源、请求的服务器期望如何接收响应等的信息。常见的请求头字段包括：

• Host：指定请求的主机名和端口号。
• User-Agent：发送请求的客户端的信息。
• Accept：客户端能够处理的内容类型。
• Accept-Language：客户端接受的自然语言列表。
• Content-Type：当发送POST或PUT请求时，该头字段表示发送的数据类型。
• Content-Length：请求体的长度。
• Authorization：包含客户端提供给服务器的认证信息。

2.1.3 请求体

请求体包含在POST和PUT请求中发送的数据。它通常是请求中发送的实际数据，如表单数据或JSON对象。GET请求通常不包含请求体。

2.2、HTTP响应的基本结构

HTTP响应同样由三部分组成：状态行、响应头和响应体。

2.2.1 状态行

状态行包含HTTP协议版本、状态码和状态消息。其格式如下：

<HTTP协议版本> <状态码> <状态消息>

• HTTP协议版本：与请求行中的协议版本相对应。
• 状态码：一个三位数，用于表示请求的处理结果。
• 状态消息：与状态码对应的文本描述。

HTTP/1.1 200 OK

2.2.2 响应头

响应头包含关于响应的元数据，同样以键值对的形式存在。这些字段提供了关于响应内容、缓存指令、服务器信息等方面的详细信息。常见的响应头字段包括：

• Content-Type：响应主体的媒体类型。
• Content-Length：响应主体的长度。
• Server：服务器软件的信息。
• Cache-Control：指定请求/响应链中所有的缓存机制必须遵守的指令。
• Expires：响应过期的时间。
• ETag：资源的特定版本的标识符，通常用于缓存。

2.2.3 响应体

响应体包含服务器返回的实际数据，如HTML页面、图片、JSON数据等。响应体的格式和内容由Content-Type头字段决定。

2.3、总结

HTTP请求和响应的结构化设计使得客户端和服务器之间的通信更加清晰和灵活。通过发送不同的请求行、请求头和请求体，客户端可以表达各种复杂的请求需求；而服务器则通过状态行、响应头和响应体来返回相应的处理结果或资源数据。在C#中，使用HttpClient类可以方便地发送HTTP请求并接收响应，通过处理这些请求和响应的结构，可以实现各种Web通信功能。

3、HTTP方法

在C#中，HTTP方法（也称为HTTP请求方法或HTTP动词）是用于指定对特定资源应执行的操作的一种方式。这些方法是HTTP协议的一部分，并定义在RFC 7231中。HTTP/1.1规范定义了以下几种方法：GET、POST、PUT、DELETE、HEAD、OPTIONS、TRACE和CONNECT。在C#中，可以通过HttpClient的不同方法（如GetAsync、PostAsync、PutAsync、DeleteAsync等）来发送不同类型的HTTP请求。

以下是对每种HTTP方法及其在C#中如何使用的详细解释：

3.1、GET

GET方法用于请求指定的资源。它通常用于请求数据。GET请求的数据会附加在URL之后，并且长度有限制。

在C#中，使用HttpClient类发送GET请求是非常简单的：

using System;  
using System.Net.Http;  
using System.Threading.Tasks;  
  
class Program  
{  
    static async Task Main(string[] args)  
    {  
        using (var client = new HttpClient())  
        {  
            var response = await client.GetAsync("https://example.com/api/data");  
            if (response.IsSuccessStatusCode)  
            {  
                var content = await response.Content.ReadAsStringAsync();  
                Console.WriteLine(content);  
            }  
            else  
            {  
                Console.WriteLine("Error: " + response.StatusCode);  
            }  
        }  
    }  
}

3.2、POST

POST方法用于向指定资源提交数据进行处理请求（例如提交表单或者上传文件）。请求的数据包含在请求体中。

在C#中发送POST请求，可以这样做：

using System;  
using System.Net.Http;  
using System.Net.Http.Headers;  
using System.Text;  
using System.Threading.Tasks;  
  
class Program  
{  
    static async Task Main(string[] args)  
    {  
        using (var client = new HttpClient())  
        {  
            var content = new StringContent("{\"key\":\"value\"}", Encoding.UTF8, "application/json");  
            var response = await client.PostAsync("https://example.com/api/data", content);  
            if (response.IsSuccessStatusCode)  
            {  
                var result = await response.Content.ReadAsStringAsync(); 
                Console.WriteLine(result);  
            }  
            else  
            {  
                Console.WriteLine("Error: " + response.StatusCode);  
            }  
        }  
    }  
}

3.3、PUT

PUT方法用于替换指定资源的所有当前表示。

使用PUT方法的一个例子：

using System;  
using System.Net.Http;  
using System.Net.Http.Headers;  
using System.Text;  
using System.Threading.Tasks;  
  
class Program  
{  
    static async Task Main(string[] args)  
    {  
        using (var client = new HttpClient())  
        {  
            var content = new StringContent("{\"key\":\"newValue\"}", Encoding.UTF8, "application/json");  
            var response = await client.PutAsync("https://example.com/api/data/1", content);  
            if (response.IsSuccessStatusCode)  
            {  
                var result = await response.Content.ReadAsStringAsync(); 
                Console.WriteLine(result);    
            }  
            else  
            {  
                Console.WriteLine("Error: " + response.StatusCode);  
            }  
        }  
    }  
}

3.4、DELETE

DELETE方法用于删除指定的资源。

使用DELETE方法的一个例子：

using System;  
using System.Net.Http;  
using System.Threading.Tasks;  
  
class Program  
{  
    static async Task Main(string[] args)  
    {  
        using (var client = new HttpClient())  
        {  
            var response = await client.DeleteAsync("https://example.com/api/data/1");  
            if (response.IsSuccessStatusCode)  
            {  
                var result = await response.Content.ReadAsStringAsync(); 
                Console.WriteLine(result);    
            }  
            else  
            {  
                Console.WriteLine("Error: " + response.StatusCode);  
            }  
        }  
    }  
}

3.5、HEAD

HEAD方法与GET方法类似，只不过服务器在响应中只返回HTTP头部，不返回实际数据。这通常用于检查资源的存在性或者获取资源的元数据。

3.6、OPTIONS

OPTIONS方法用于描述目标资源的通信选项。客户端可以对特定的资源使用此方法，来查看服务器支持的通信选项。

3.7、TRACE

TRACE方法用于沿着到目标资源的路径执行消息回显。它主要用于测试或诊断。

3.8、CONNECT

CONNECT方法用于建立到由目标资源标识的服务

4、HTTP状态码

HTTP状态码是HTTP协议中的一部分，用于表示HTTP请求的结果状态。当客户端（如Web浏览器）向服务器发送HTTP请求时，服务器会返回一个状态码作为响应的一部分，以告知客户端请求的处理结果。

HTTP状态码由三位数字组成，并分为几个不同的类别，每个类别表示不同的响应类型。以下是对一些常见的HTTP状态码及其在C#中如何处理的详细解释：

1xx：信息性状态码

• 100 Continue：客户端应继续请求或忽略该响应。

2xx：成功状态码

• 200 OK：请求成功。
• 201 Created：请求成功并且服务器创建了新的资源。
• 204 No Content：请求成功，但响应报文不含实体的主体部分。

3xx：重定向状态码

• 301 Moved Permanently：永久性重定向，请求的资源已永久移动到新位置。
• 302 Found：临时性重定向，请求的资源临时从不同的URI响应请求。
• 304 Not Modified：如果客户端发送了一个带条件的GET请求且该请求已被允许，而文档的内容（自上次访问以来或者根据请求的条件）并没有改变，则服务器应当返回这个状态码。

4xx：客户端错误状态码

• 400 Bad Request：请求报文存在语法错误。
• 401 Unauthorized：请求需要用户认证。
• 403 Forbidden：服务器理解请求客户端的请求，但是拒绝执行此请求。
• 404 Not Found：请求的资源在服务器上不存在，但不一定就是请求有错误。
• 405 Method Not Allowed：请求行中指定的请求方法不能被用于请求相应的资源。

5xx：服务器错误状态码

• 500 Internal Server Error：服务器内部错误，无法完成请求。
• 502 Bad Gateway：作为网关或代理工作的服务器尝试执行请求时，从上游服务器接收到无效的响应。
• 503 Service Unavailable：由于临时的服务器维护或者过载，服务器当前无法处理请求。这个状况是临时的，并且将在一段时间以后恢复。

在C#中，使用HttpClient类发送HTTP请求时，可以通过检查HttpResponseMessage对象的StatusCode属性来获取HTTP状态码。下面是一个简单的示例，展示了如何发送请求并处理不同的状态码：

using System;  
using System.Net.Http;  
using System.Threading.Tasks;  
  
class Program  
{  
    static async Task Main(string[] args)  
    {  
        using (var client = new HttpClient())  
        {  
            try  
            {  
                HttpResponseMessage response = await client.GetAsync("https://example.com/api/data");  
                response.EnsureSuccessStatusCode(); // 这会抛出HttpRequestException，如果状态码不在200-299范围内  
  
                // 请求成功，处理响应内容  
                string content = await response.Content.ReadAsStringAsync();  
                Console.WriteLine(content);  
            }  
            catch (HttpRequestException e)  
            {  
                // 处理请求异常，例如网络错误或无效URL  
                Console.WriteLine("\nException Caught!");  
                Console.WriteLine("Message :{0} ", e.Message);  
            }  
            catch (TaskCanceledException e)  
            {  
                // 处理请求超时等取消任务的情况  
                Console.WriteLine("\nTask Canceled!");  
            }  
        }  
    }  
}

在上面的示例中，EnsureSuccessStatusCode()方法会检查HTTP响应的状态码。如果状态码表示错误（即不在200-299范围内），它会抛出一个HttpRequestException异常。我们可以捕获这个异常并根据需要处理它。对于特定的状态码处理，你可以检查HttpResponseMessage.StatusCode属性，并根据需要执行相应的操作。

注意：处理HTTP响应时，除了检查状态码，还应该始终处理可能的异常和网络错误，确保你的应用程序的健壮性。

二、实践编写C#代码

1、使用HttpClient类

HttpClient类是用于发送HTTP请求和接收响应的主要类。下面是一些示例代码，展示了如何使用HttpClient发送GET和POST请求，并处理响应。

首先，确保你的项目引用了System.Net.Http命名空间。

发送GET请求

using System;  
using System.Net.Http;  
using System.Threading.Tasks;  
  
class Program  
{  
    static async Task Main(string[] args)  
    {  
        using (var client = new HttpClient())  
        {  
            try  
            {  
                // 发送GET请求  
                HttpResponseMessage response = await client.GetAsync("https://api.example.com/data");  
                response.EnsureSuccessStatusCode(); // 确保请求成功  
  
                // 读取响应内容  
                string content = await response.Content.ReadAsStringAsync();  
                Console.WriteLine(content);  
            }  
            catch (HttpRequestException e)  
            {  
                // 处理请求异常  
                Console.WriteLine("\nException Caught!");  
                Console.WriteLine("Message :{0} ", e.Message);  
            }  
        }  
    }  
}

发送POST请求

发送POST请求时，通常需要发送一个请求体（如JSON或XML）。以下是一个发送JSON数据的POST请求的示例：

using System;  
using System.Net.Http;  
using System.Net.Http.Headers;  
using System.Text;  
using System.Threading.Tasks;  
using Newtonsoft.Json; // 需要安装Newtonsoft.Json包  
  
class Program  
{  
    static async Task Main(string[] args)  
    {  
        using (var client = new HttpClient())  
        {  
            try  
            {  
                // 准备POST数据  
                var data = new  
                {  
                    Name = "John Doe",  
                    Age = 30  
                };  
                string jsonContent = JsonConvert.SerializeObject(data);  
                StringContent content = new StringContent(jsonContent, Encoding.UTF8, "application/json");  
  
                // 发送POST请求  
                HttpResponseMessage response = await client.PostAsync("https://api.example.com/data", content);  
                response.EnsureSuccessStatusCode(); // 确保请求成功  
  
                // 读取响应内容  
                string responseContent = await response.Content.ReadAsStringAsync();  
                Console.WriteLine(responseContent);  
            }  
            catch (HttpRequestException e)  
            {  
                // 处理请求异常  
                Console.WriteLine("\nException Caught!");  
                Console.WriteLine("Message :{0} ", e.Message);  
            }  
        }  
    }  
}

在这个POST请求的示例中，我们首先创建了一个匿名对象data，然后使用JsonConvert.SerializeObject方法将其序列化为JSON字符串。然后，我们创建了一个StringContent对象，并指定了内容类型为application/json。最后，我们使用PostAsync方法发送POST请求，并处理响应。

请注意，为了使用JsonConvert类，我们需要安装Newtonsoft.Json包。可以通过NuGet包管理器来安装它。在Visual Studio中，可以通过“工具”->“NuGet包管理器”->“管理解决方案的NuGet包”来安装。

2、处理异常和错误

在C#中，当使用HttpClient类进行HTTP通信时，我们可能会遇到各种异常，如请求超时、连接问题等。为了捕获和处理这些异常，可以使用try-catch块来捕获特定的异常类型，并根据需要执行相应的错误处理逻辑。

下面是一个示例代码，展示了如何捕获和处理与HTTP通信相关的异常：

using System;  
using System.Net.Http;  
using System.Threading.Tasks;  
  
class Program  
{  
    static async Task Main(string[] args)  
    {  
        using (var client = new HttpClient())  
        {  
            client.Timeout = TimeSpan.FromSeconds(10); // 设置请求超时时间为10秒  
  
            try  
            {  
                HttpResponseMessage response = await client.GetAsync("https://api.example.com/data");  
                response.EnsureSuccessStatusCode(); // 确保请求成功  
  
                string content = await response.Content.ReadAsStringAsync();  
                Console.WriteLine(content);  
            }  
            catch (HttpRequestException e)  
            {  
                // HttpRequestException 通常表示请求过程中发生了错误，如连接问题、请求超时等  
                Console.WriteLine("HttpRequestException caught!");  
                Console.WriteLine("Message :{0} ", e.Message);  
  
                // 可以通过检查InnerException来获取更详细的错误信息  
                if (e.InnerException is TaskCanceledException)  
                {  
                    Console.WriteLine("The request was canceled, possibly due to a timeout.");  
                }  
                else if (e.InnerException is System.Net.WebException)  
                {  
                    Console.WriteLine("A WebException was thrown.");  
                }  
                // 其他异常处理逻辑...  
            }  
            catch (TaskCanceledException e)  
            {  
                // TaskCanceledException 通常表示任务被取消，可能是因为超时  
                Console.WriteLine("TaskCanceledException caught!");  
                Console.WriteLine("Message :{0} ", e.Message);  
                Console.WriteLine("CancellationToken.IsCancellationRequested: {0}", e.CancellationToken.IsCancellationRequested);  
                // 如果是因为超时取消的，e.CancellationToken.IsCancellationRequested 将会是 true  
            }  
            catch (Exception e)  
            {  
                // 处理其他类型的异常  
                Console.WriteLine("Exception caught!");  
                Console.WriteLine("Message :{0} ", e.Message);  
            }  
        }  
    }  
}

在这个示例中，我们使用了try-catch块来捕获可能发生的异常。HttpRequestException是一个通用的异常类型，它通常表示在请求过程中发生了错误。你可以通过检查InnerException来获取更详细的错误信息。例如，如果请求被取消（可能是因为超时），InnerException可能是TaskCanceledException类型。

通过设置HttpClient的Timeout属性，可以指定请求的超时时间。如果请求在指定的时间内没有完成，将会抛出一个TaskCanceledException异常。

此外，还有其他类型的异常可能发生，如System.Net.WebException（在较旧的.NET版本中可能更常见），或者其他自定义或未预料的异常。可以根据需要添加更多的catch块来处理这些异常。

记住，在实际应用中，我们应该根据具体的业务逻辑和错误处理需求来定制异常处理代码。例如，我们可能想要记录错误日志、向用户显示友好的错误消息、重试请求，或者执行其他恢复操作。

3、设置请求头和请求体

在C#中，使用HttpClient类可以很容易地设置自定义的请求头以及发送POST或PUT请求的数据。

设置自定义的请求头

我们可以使用HttpRequestMessage的Headers属性来设置自定义的请求头。

using System;  
using System.Net.Http;  
using System.Threading.Tasks;  
  
class Program  
{  
    static async Task Main(string[] args)  
    {  
        using (var client = new HttpClient())  
        {  
            var request = new HttpRequestMessage(HttpMethod.Get, "https://api.example.com/data");  
            request.Headers.Add("Custom-Header", "CustomValue"); // 设置自定义请求头  
  
            HttpResponseMessage response = await client.SendAsync(request);  
            response.EnsureSuccessStatusCode();  
  
            string content = await response.Content.ReadAsStringAsync();  
            Console.WriteLine(content);  
        }  
    }  
}

在POST或PUT请求中发送数据

对于POST或PUT请求，你通常需要发送一些数据到服务器。这可以通过将HttpContent对象附加到请求消息上来实现。下面是一个使用StringContent发送JSON数据的POST请求示例：

using System;  
using System.Net.Http;  
using System.Net.Http.Headers;  
using System.Text;  
using System.Threading.Tasks;  
using Newtonsoft.Json; // 需要安装Newtonsoft.Json包  
  
class Program  
{  
    static async Task Main(string[] args)  
    {  
        using (var client = new HttpClient())  
        {  
            var data = new { Name = "John Doe", Age = 30 }; // 假设你要发送的数据  
            string jsonContent = JsonConvert.SerializeObject(data); // 将数据序列化为JSON字符串  
  
            var content = new StringContent(jsonContent, Encoding.UTF8, "application/json"); // 创建StringContent对象  
  
            var response = await client.PostAsync("https://api.example.com/data", content); // 发送POST请求  
            response.EnsureSuccessStatusCode();  
  
            string responseBody = await response.Content.ReadAsStringAsync();  
            Console.WriteLine(responseBody);  
        }  
    }  
}

在这个例子中，我们首先创建了一个匿名对象data，它包含我们要发送的数据。然后，我们使用JsonConvert.SerializeObject方法将这个对象序列化为JSON字符串。接下来，我们创建了一个StringContent对象，并指定了字符串内容、编码和媒体类型（在这个例子中是application/json）。最后，我们使用PostAsync方法发送POST请求。

对于PUT请求，你可以使用类似的方法，只需要将PostAsync替换为PutAsync即可。

4、解析响应内容

我们可以使用Newtonsoft.Json（也称为Json.NET）或System.Text.Json来将JSON响应内容解析为C#对象。以下是使用这两种库进行解析的示例：

使用Json.NET (Newtonsoft.Json)

首先，你需要安装Newtonsoft.Json NuGet包。然后，你可以创建一个与JSON响应结构相对应的C#类，并使用JsonConvert.DeserializeObject<T>()方法将JSON字符串解析为该类的对象。

定义C#类：

using System;  
  
public class Person  
{  
    public string Name { get; set; }  
    public int Age { get; set; }  
}

解析JSON字符串：

using Newtonsoft.Json;  
using System;  
using System.Net.Http;  
using System.Threading.Tasks;  
  
class Program  
{  
    static async Task Main(string[] args)  
    {  
        using (var client = new HttpClient())  
        {  
            var response = await client.GetAsync("https://api.example.com/person");  
            response.EnsureSuccessStatusCode();  
  
            string jsonContent = await response.Content.ReadAsStringAsync();  
  
            Person person = JsonConvert.DeserializeObject<Person>(jsonContent);  
  
            Console.WriteLine($"Name: {person.Name}, Age: {person.Age}");  
        }  
    }  
}

使用System.Text.Json

如果使用的是.NET Core 3.0或更高版本，可以使用System.Text.Json来解析JSON。与Newtonsoft.Json类似，你首先需要创建一个与JSON响应结构相对应的C#类，然后使用JsonSerializer.Deserialize<T>()方法进行解析。

定义C#类（与上面相同）：

public class Person  
{  
    public string Name { get; set; }  
    public int Age { get; set; }  
}

解析JSON字符串：

using System;  
using System.Net.Http;  
using System.Text.Json;  
using System.Threading.Tasks;  
  
class Program  
{  
    static async Task Main(string[] args)  
    {  
        using (var client = new HttpClient())  
        {  
            var response = await client.GetAsync("https://api.example.com/person");  
            response.EnsureSuccessStatusCode();  
  
            string jsonContent = await response.Content.ReadAsStringAsync();  
  
            Person person = JsonSerializer.Deserialize<Person>(jsonContent);  
  
            Console.WriteLine($"Name: {person.Name}, Age: {person.Age}");  
        }  
    }  
}

在这两个示例中，我们都首先从API获取JSON响应，然后将其读入字符串。然后，我们使用所选的JSON库将字符串解析为Person对象，并可以访问该对象的属性。

需要注意的是，需要根据实际的JSON响应结构来调整C#类的定义。例如，如果JSON包含嵌套对象或数组，你需要在C#类中添加相应的嵌套类或集合属性。

四、 RESTful API设计

1、RESTful API架构风格

在C#中实现RESTful架构风格，通常涉及到设计和构建遵循REST（Representational State Transfer）原则的Web服务。RESTful架构强调资源的标识、操作的统一接口、无状态通信以及客户端-服务器分离。下面是在C#中实现RESTful架构风格的一些关键方面：

1.1、 客户端-服务器架构

RESTful架构明确区分了客户端和服务器的角色。服务器负责管理和存储资源，而客户端则负责用户交互和显示资源。

1.2、 无状态通信

RESTful服务应该是无状态的，即每个请求都应该包含理解该请求所必需的所有信息。服务器不应该在多个请求之间保留任何客户端上下文信息。这通常意味着每个请求都应该包含所有必要的参数和凭据，以便服务器能够处理该请求。

1.3、 资源的标识

在RESTful架构中，一切都被视为资源，并使用URI（统一资源标识符）进行唯一标识。这些URI应该是直观和可预测的，以便客户端能够轻松地构造和解析它们。

1.4.、统一的接口

RESTful架构使用HTTP协议提供的方法（如GET、POST、PUT、DELETE等）来操作资源。这些HTTP方法定义了创建、读取、更新和删除资源的操作。

1.5、 分层的系统

RESTful架构允许你将系统组件分解为多个层次，每个层次都有其特定的关注点。例如，我们可以有一个负责身份验证和授权的层次，一个负责业务逻辑的层次，以及一个负责数据存储和检索的层次。可以通过创建不同的类和组件来实现这种分层结构，并使用依赖注入等技术来管理它们之间的依赖关系。

1.6、 资源的表示

RESTful服务使用资源表示（通常是JSON或XML格式）来在客户端和服务器之间传输数据。可以使用ASP.NET Core的模型绑定和序列化功能来自动将请求体中的JSON或XML数据映射到C#对象，以及将C#对象序列化为JSON或XML格式的响应体。

1.7、 HATEOAS（超媒体作为应用状态引擎）

虽然HATEOAS在RESTful架构中是一个可选的特性，但它提供了一种让客户端能够发现和使用服务器提供的资源的机制。可以通过在响应中包含链接到其他相关资源的URI来实现HATEOAS。

2.URI设计

URI（统一资源标识符）用于标识Web上的资源。在RESTful架构中，URI应该简洁、直观且易于理解。

1. 使用名词表示资源：URI应该使用名词来表示资源，而不是动词。例如，/users 表示用户资源的集合，而不是 /getUsers。
2. 层次化结构：通过URI的层次结构来表示资源的关系。例如，/users/123/orders 表示用户ID为123的订单。
3. 使用查询参数：对于需要过滤或排序的资源集合，可以使用查询参数。例如，/users?name=John 表示查询名为John的用户。
4. 避免使用文件扩展名：RESTful服务的URI不应该包含文件扩展名（如 .aspx、.php 等），因为RESTful服务不是基于文件的。

3.资源表示

资源表示指的是服务器返回给客户端的数据格式。在RESTful架构中，通常使用JSON或XML作为资源表示的格式。

1. 使用JSON或XML：选择一种广泛支持的格式作为资源表示的标准。JSON因其轻量级和易读性而备受青睐。
2. 自描述性：资源表示应该包含足够的信息，以便客户端理解其结构和含义。例如，可以在JSON对象中包含元数据字段来描述资源的属性。
3. 超链接：在资源表示中包含相关资源的URI，以便客户端能够发现和使用这些相关资源。这有助于实现资源的链接和导航。