ASP.NET MVC 4与Web API实战

需积分: 10 182 浏览量更新于2024-07-25 收藏 1.21MB PDF 举报

"ASP.NET MVC 4 and the Web API 是一本深入介绍ASP.NET Web API的书籍，旨在帮助读者理解和掌握如何使用ASP.NET MVC框架构建服务化应用程序。书中详细讲解了RESTful设计原则、API设计、环境搭建、源码组织、控制器管理、依赖注入、数据库操作以及服务安全等关键知识点。" 在ASP.NET MVC 4中，Web API是一个强大的框架，专门用于构建RESTful（Representational State Transfer）服务，使得开发者可以轻松地创建HTTP服务，这些服务不仅适用于.NET客户端，也支持各种平台的非.NET客户端。本书第一章“ASP.NET MVC作为一个服务框架”介绍了如何利用ASP.NET MVC的特性来构建服务，并探讨了它与传统ASP.NET Web Forms和WCF服务的区别。第二章“什么是RESTful？”深入讨论了RESTful架构风格的核心原则，包括URI作为资源标识、HTTP方法（如GET、POST、PUT、DELETE）作为操作、状态转移的概念，以及如何通过HTTP协议实现无状态服务。第三章“设计示例REST API”指导读者如何规划和设计一个具有代表性且符合REST原则的API。这一章涵盖了资源建模、版本控制、错误处理和HATEOAS（超媒体作为应用状态引擎）等概念。第四章“构建环境和创建源码树”讲解了如何设置开发环境，以及如何组织项目的源代码结构，确保代码的可读性和可维护性。第五章“控制器、依赖和管理数据库工作单元”探讨了控制器的角色，如何处理依赖注入，以及如何利用Unit of Work模式来管理数据库操作，确保数据一致性。第六章“保护服务”关注的是服务的安全性，包括身份验证、授权、防止跨站请求伪造（CSRF）攻击等，确保API只能被授权的用户访问。第七章“将所有部分整合在一起”总结了前面章节的知识，展示了如何综合运用这些技术构建一个完整的Web API应用，包括测试、调试和部署。书后的索引提供了方便读者快速查找特定主题的工具，便于深入学习和查阅。这本书是ASP.NET Web API开发者的重要参考资料，无论你是初学者还是有经验的开发者，都能从中获取宝贵的实践经验和理论知识，提升你的服务端开发能力。

CHAPTER 2 ■ WHAT IS RESTFUL?

But you still must rely on specific messages for operations. In other words, the caller

can’t differentiate between the two different operations available with the /api/tasks

URI—unless the caller already has the contract. You’re still using only the POST HTTP

verb, so the request message itself dictates the desired action.

HTTP Verbs

You must look beyond URIs and their resources to the actions needed by the service.

These actions will help you identify the HTTP verbs you need to use. Continuing to follow

our example, there’s no such thing as a CreateTask HTTP verb. In fact, there’s not even a

Create verb. If you’re going to follow the REST architecture and the HTTP protocol, you

must choose from the verbs available in that protocol, namely:

GET ·

PUT ·

POST ·

DELETE ·

Intuitively, you can quickly eliminate GET and DELETE for the CreateTask action.

But what is the difference in intent between PUT and POST? As shown in Table 2-3, PUT

is designed to create or replace a resource with a known identifier—and hence a known

unique URI. You use a POST when the system is generating the new resource’s identifier.

Table 2-2. Task Service at Level 1 on the RMM

Method URI HTTP verb State changes/contract

CreateTask /api/tasks POST Caller required to know

(e.g., WSDL)

GetTask /api/tasks/1234 POST Caller required to know

(e.g., WSDL)

GetTaskAssignees /api/tasks/1234 POST Caller required to know

(e.g., WSDL)

SearchTasks /api/tasks POST Caller required to know

(e.g., WSDL)

UpdateTask /api/tasks/1234 POST Caller required to know

(e.g., WSDL)

CompleteTask /api/tasks/1234 POST Caller required to know

(e.g., WSDL)

CHAPTER 2 ■ WHAT IS RESTFUL?

Technically speaking, the REST architecture is agnostic about any specific protocol.

That includes the HTTP protocol. In other words, all you need is a protocol that provides

a language and mechanism for describing both states (i.e., representations) and state

changes. However, since this book is about building a REST service with ASP.NET, you’ll

focus on REST with HTTP. Fortunately, the HTTP protocol itself covers most of what you

need. Again, Table 2-3 illustrates the intended use of the verbs within REST.

Let’s walk through some important concepts with this mapping. First, the exact

meaning of each of the four verbs is dependent on the URI. So even though you have only

four verbs, you actually have eight different actions available to you. The difference lies in

whether the URI defines a collection or a unique element.

Second, when creating new instances of the resource (e.g. a new task), PUT is used

with a unique URI in the scenario where the caller generates the new resource’s identifier

before submitting the request to the server. In Table 2-3, the PUT action is used with a

unique element URI to create a new task with the specific identifier, 1234. If instead the

system is to generate the identifier, then the caller uses the POST action and a collection

URI. This also ties into the concept of idempotency.

The PUT and DELETE methods are said to be idempotent; that is, calling them over

and over will produce the same result without any additional side effects. For example,

the caller should be able to call the DELETE action on a specific resource without

receiving any errors and without harming the system. If the resource has already been

deleted, the caller should not receive an error. The same applies to the PUT action. For a

given unique resource (identified by an element URI), submitting a PUT request should

update the resource if it already exists. Or, if it doesn’t exist, the system should create

the resource as submitted. In other words, calling PUT over and over produces the same

result without any additional side effects (i.e., the new task will exist in the system per the

representation provided by the caller, whether the system had to create a new one or it

had to update an existing one).

The GET action is said to be safe. This is not idempotent, per se. Safe means that

nothing in the system is changed at all, which is appropriate for HTTP calls that are meant

to query the system for either a collection of resources or for a specific resource.

Table 2-3. Using HTTP verbs with the Task Resource

HTTP verb (Collection URI)

http://myserver.com/tasks

(Element URI)

http://myserver.com/tasks/1234

GET List of tasks, including URIs to

individual tasks

Get a specific task, identified by the

URI

PUT Replace the entire collection of

tasks

Replace or create the single task

identified by the URI

POST Create a new single task, where

its identifier is generated by the

system

Create a new subordinate under the

task identified by the URI

DELETE Delete the entire collection of

tasks

Delete the tasks identified by the URI

CHAPTER 2 ■ WHAT IS RESTFUL?

It is important that the idempotency of the service’s GET, PUT, and DELETE

operations remain consistent with the HTTP protocol standards. Thus, every effort should

be made to ensure those three actions can be called over and over without error.

Unlike the other three actions, POST is not considered to be idempotent. This is

because POST is used to create a new instance of the identified resource type for every

invocation of the method. Where calling PUT over and over will never result in more

than one resource being created or updated, calling POST will result in new resource

instances—one for each call. This is appropriate for cases where the system must

generate the new resource’s identifier, as well as return it in the response.

As you model your task-management service, you will need to map each resource with

a set of HTTP actions, defining which ones are allowed and which ones aren’t supported.

Now let’s take a new look at the task service. This time around, you’ll use the

available HTTP verbs, which will put you at level 2 on the RMM (see Table 2-4).

Table 2-4. Task Service at Level 2 in the RMM

Method URI HTTP verb State changes/contract

CreateTask /api/tasks POST Caller required to know

(e.g., WSDL)

GetTask /api/tasks/1234 GET Caller required to know

(e.g., WSDL)

GetTaskAssignees /api/tasks/1234/users GET Caller required to know

(e.g., WSDL)

SearchTasks /api/tasks GET Caller required to know

(e.g., WSDL)

UpdateTask /api/tasks/1234 PUT Caller required to know

(e.g., WSDL)

CompleteTask /api/tasks/1234 DELETE Caller required to know

(e.g., WSDL)

At this point, the service is utilizing unique URIs for individual resources, and you’ve

switched to using HTTP verbs instead of custom request message types. That is, each of

the PUT and POST actions mentioned previously will simply take a representation of

a task resource (e.g., XML or JSON). However, the client must still have prior knowledge

of the API in order to traverse the domain and to perform any operations more complex

than creating, updating, or completing a task. In the true nature of the Web, you should

instead fully guide the client, providing all available resources and actions via links and

forms. This is what is meant by “hypermedia as the engine of application state.”

HATEOAS

As you look at Tables 2-3 and 2-4, you can see that certain GET operations will return

collections of resources. One of the guiding principles of REST with HTTP is that callers

make transitions through application state only by navigating hypermedia provided

CHAPTER 2 ■ WHAT IS RESTFUL?

by the server. In other words, given a root or starting URI, the caller should be able to

navigate the collection of resources without needing prior knowledge of the URI scheme.

Thus, whenever a resource is returned from the service, whether in a collection or by

itself, the returned data should include the URI required to turn around and perform

another GET to retrieve just that resource.

Here’s an example of an XML response message that illustrates how each element in

the collection should contain a URI to the resource:

<?xml version="1.0" encoding="utf-8"?>

<Tasks>

</Task>

</Task>

</Tasks>

It is typically appropriate to return only a few attributes or pieces of data when

responding with a collection, such as in the preceding example. Now the caller can use

the URI to query a specific resource to retrieve all attributes of that resource. For example,

the Tasks collection response (as just shown) might only contain the Task’s Id and a URI

to fetch the Task resource. But when calling GET to get a specific Task, the response might

include TaskCategory, DateCreated, TaskStatus, TaskOwner, and so on.

Taking this approach can be a little trickier when using strongly typed model objects

in .NET (or any other OO language). This is because we need to define at least two

different variants of the Task type. The typical pattern is to have a TaskInfo class and

a Task class, where the TaskInfo class exists only to provide basic information about a

Task. The collection might look like this:

<?xml version="1.0" encoding="utf-8"?>

<Tasks>

</TaskInfo>

</TaskInfo>

</Tasks>

And the single resource might look like this:

<?xml version="1.0" encoding="utf-8"?>

<Task Id="1234" Status="Active" DateCreated="2011-08-15" Owner="Sally"

Category="Projects" >

</Task>

CHAPTER 2 ■ WHAT IS RESTFUL?

Utilizing two different types like this is not a requirement for REST or any other

service API-style. You may find that you don’t need to separate collection type definitions

from other definitions. Or, you may find that you need many more than two. It all depends

on the usage scenarios and how many different attributes exist on the resource. For

example, if the Task resource included only five or six attributes, then you probably

wouldn’t create a separate type for the collection objects. But if the Task object were to

include 100 or more attributes (as is typical in any real-life financial application), then it

might be a good idea to create more than one variation of the Task type.

Within the realm of HATEOAS, you also want to guide the user as to the actions

available on a resource. You just saw how you can use a <link> element to provide a

reference for fetching task details. You can expand this concept to include all available

resources and actions. Remember, when browsing a web site, a user needs to have prior

knowledge only of the root address to traverse the entire site. You want to provide a

similar experience to callers in the API.

Here’s what a full HATEOAS-compliant XML response might look like for the

TaskInfo type:

<?xml version="1.0" encoding="utf-8"?>

<Tasks>

</TaskInfo>

</TaskInfo>

</Tasks>

Note that the links available to each task are a little different. This is because you

don’t need to complete an already completed task. Instead, you need to offer a link to

reopen it. Also, you don’t want to allow updates on a completed task, so that link is not

present in the completed task.

LINK phILOSOphY

I want to offer a disclaimer and a word of warning for the topic of links in REST

messages. You find that, over the past several years, the debate over how the HTTP

verbs are supposed to be used can be quite heated at times. This debate also

extends into how to best design URIs to be most RESTful—without degenerating

into SOAP-style API.

剩余140页未读，继续阅读

UncleTuu

粉丝: 0
资源: 2

ASP.NET MVC 4与Web API实战

ASP.NET MVC 4 and the Web API: Building a REST Service from Start to Finish

ASP.NET MVC4中调用WebAPI实战教程

asp.net-mvc-4-web-api:Jamie Kurtz的“ ASP.NET MVC 4和Web API”的源代码-mvc source code

ASP.NET MVC4 WebApi ProductsApp

asp.net mvc 4 web api 上传文件

ASP.NET MVC4调用WebAPI实战教程

ASP.NET MVC4与Web API构建REST服务

ASP.NET MVC 4与Web API：构建服务框架指南

ASP.NET MVC 4与Web API：构建服务框架详解

ASP.NET MVC 4与Web API：构建网络接口服务

最新资源