ASP.NET MVC 4与Web API：构建服务导向应用的实战指南

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

ASP.NET MVC 4 and the Web API.pdf 是一本专注于使用Microsoft新一代Web API框架进行专业级Web开发的指南。本书主要围绕ASP.NET MVC（一种基于模型-视图-控制器架构的Web应用程序框架）和RESTful设计原则，探讨如何将ASP.NET MVC转换为服务框架，以便于构建大型、分布式的网络系统，支持移动互联网设备。第1章"ASP.NET MVC as a Service Framework"介绍了自.NET Framework首次发布以来，Microsoft提供了多种服务导向应用开发的方法。从2002年的原始ASP.NET ASMX XML web服务开始，开发者可以创建供.NET和非.NET客户端调用的服务，即使使用的是SOAP的不同版本。这一章可能讲解了如何利用ASP.NET MVC的特点将其设计为服务接口，以增强其可扩展性和灵活性。第二部分深入探讨了RESTful设计，这是Web API的核心原则，它强调资源表述状态转移（Representational State Transfer），使得API设计更加简洁、轻量级，易于理解和消费。章节内容可能包括RESTful架构模式、URI设计、HTTP方法的使用以及如何确保API的幂等性（Idempotency）。在第三章"Designing the Sample REST API"中，作者可能介绍了如何根据第2章的学习来设计一个实际的RESTful API示例，包括确定资源、制定API端点和数据传输格式。这一章可能会涉及API版本控制、错误处理和文档化的重要性。第四章"Building the Environment and Creating the Source Tree"涵盖了开发环境的配置，包括安装必要的工具和库，以及创建项目的源代码结构，确保项目的模块化和可维护性。这部分可能涉及使用Visual Studio或其他IDE，以及Git等版本控制系统。第五章"Controllers, Dependencies, and Managing the Database Unit of Work"重点关注控制器的设计和数据库操作。这里会介绍如何使用依赖注入来管理控制器之间的协作，以及如何利用ADO.NET或Entity Framework进行数据访问，确保数据库操作的隔离和事务管理。第六章"Securing the Service"讨论了Web API的安全性，包括身份验证、授权、HTTPS和OAuth等机制，确保API服务受到保护，防止未授权访问和数据泄露。最后一章"Putting It All Together"是整合所有知识点的实践环节，通过实际案例展示了如何将前面章节学到的内容应用到完整的项目中，包括测试、部署和监控。总结来说，这本书通过逐步指导，帮助读者掌握如何利用ASP.NET MVC 4和Web API构建高效、安全的Web服务，使之适应移动互联网的需求，同时关注了服务设计、架构最佳实践和安全性。无论是初学者还是经验丰富的开发者，都能从中获益匪浅。

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页未读，继续阅读

太空播音员

粉丝: 0
资源: 9

ASP.NET MVC 4与Web API：构建服务导向应用的实战指南

ASP.NET MVC4

Apress.ASP.NET.MVC.4.and.the.Web.API.Feb.2013

ASP.NET MVC4 Web 编程.pdf

ASP.NET MVC4 Web 编程.PDF

Expert ASP.NET Web API 2 for MVC Developers.pdf

ASP.NET+MVC4+Web+编程.pdf(附带源码)）

ASP.NET.MVC.4.Web编程].徐雷等.扫描版.pdf

ASP.NET MVC 利用(aspose+pdfobject.js) 在线预览常用办公文档(word、excel、ppt、pdf)

ASP.NET MVC4开发指南.pdf

ASP.NET Web API 2, 2nd Edition.pdf

最新资源