Le premier exemple du scénario applicable de l'API WEB ASP.NET

Dans mon blog précédent, je vous ai donné une brève introduction à la relation entre le protocole HTTP et l'API RestFul, ainsi que quelques connaissances de base du protocole HTTP. Sur la base de ces connaissances, venons-en aujourd'hui. Discutez ensemble des scénarios applicables de l'API WEB, puis écrivez notre première interface API WEB et montrez comment y faire un simple appel.

Beaucoup de gens sont confus, pourquoi avons-nous besoin d'une API WEB maintenant que nous avons WCF ? L’API WEB remplacera-t-elle WCF ?

À mon avis, WCF fournit un ensemble d'implémentations RPC. La conception de WCF prend davantage en compte les scénarios SOA et divers problèmes RPC. Beaucoup de gens diront également que l'API RestFul est aussi une sorte de RPC, et qu'il existe également une implémentation de RestFul dans WCF. Dans de nombreux documents, il existe des différences dans les concepts de style entre RPC et RestFul. En fait, je pense que la différence entre les deux est plus subjective et qu'elle est trop complexe et académique. Je me concentre principalement sur certains problèmes d'utilisation réelle. , Il existe de nombreux protocoles pris en charge, y compris les protocoles de la série WS-*, et certains protocoles plus concis, qui fournissent des protocoles de communication dédiés avec de très hautes performances, et WCF fournit également la découverte de services et d'autres fonctions. Je pense que WCF est plus adapté à l'interne. Pour les appels hautes performances, il existe également d'autres solutions RPC parmi lesquelles choisir, telles que gRPC, Avor et thrift, qui sont tous des produits avec le même positionnement que WCF et WEB API est un produit axé sur HTTP ; Style RestFul. Sur cette base, n'importe quel langage, n'importe quel terminal peut être facilement connecté et peut utiliser diverses infrastructures et solutions HTTP très matures pour le développement, le débogage, l'équilibrage de charge et la distribution de contenu. Par conséquent, WEB API est un cadre de développement pour HTTP qui se concentre sur le développement rapide d'API ouvertes de style RestFul. À l'heure actuelle, il semble qu'elle ne puisse pas remplacer WCF. Ils ont chacun leurs propres scénarios appropriés, et l'API WEB ne peut pas être considérée comme un substitut à WCF.

OK, développons maintenant le premier ensemble d'interfaces API WEB ! Les versions utilisant VS2012 et versions ultérieures ont des modèles de création d'API WEB prêts à l'emploi. Vous pouvez simplement suivre la création, il y aura des projets MVC et WEB API dans le projet. L'API WEB dépend de MVC et ne peut pas être créée séparément ! L'API WEB et MVC utilisent des mécanismes de routage similaires, donc dans la route par défaut, l'API WEB utilise

/api/{controller}/{id}

comme route, ajoutez /api / section pour faire la distinction entre MVC et l'API Web.

Ensuite, nous ajoutons un Controller API WEB, nommé PersonController, qui hérite d'ApiController ; lors de la création de ce Controller, nous définissons une ressource : Person, toutes les opérations dans PersonController Elles tournent toutes autour de la ressource Person. Ensuite, nous commençons à définir un ensemble d’opérations d’ajout, de suppression, de modification et de vérification.

Dans Web API, le routage par défaut adopte une convention : le routage est basé sur des prédicats, et le préfixe du nom de la méthode est le prédicat HTTP utilisé pour appeler la méthode. L'exemple de code est le suivant :

/// <summary>

    /// Person 为资源，对Person进行的一组操作    /// </summary>

    public class PersonController : ApiController

    {        private static List<Person> _personLst = new List<Person>();       

        /// <summary>

        /// 获取一个Person        /// </summary>

        /// <param name="id">Person的ID</param>

        /// <returns>Person</returns>

        public Person GetPerson(long id)

        {            return _personLst.Find(x => x.Id == id);

        } 

        /// <summary>

        /// 添加一个Person        /// </summary>

        /// <param name="person">Person</param>

        public void PostAddPerson(Person person)

        {

            _personLst.Add(person);

        } 

        /// <summary>

        /// 修改一个        /// </summary>

        /// <param name="id">Person Id</param>

        /// <param name="person">新</param>

        public void PutModifyPerson(long id, Person person)

        {            var p = _personLst.Find(x => x.Id == id);

            p.Age = person.Age;

            p.Name = person.Name;

            p.Sex = person.Sex;

        } 

        /// <summary>

        /// 删除一个Person        /// </summary>

        /// <param name="id">Person ID</param>

        public void DeletePerson(long id)

        {

            _personLst.RemoveAll(x => x.Id == id);

        }

}

Une simple API pour les opérations CRUD sur les ressources suffit, pas d'analyse est une entrée requise, pas besoin de raccorder la sortie, c'est aussi simple que cela ! Faisons une promenade !

Envoyer une requête : le prédicat est POST, la sémantique est de créer une Personne, la Personne est décrite dans le Corps, et la Tête déclare que le corps est sérialisé via Json.

Réponse reçue : code de réponse 204, appartenant au type 2XX, exécution réussie, aucune donnée dans le corps

Envoi de la requête : le prédicat est GET, la sémantique est une requête La ressource personne, avec l'ID 1, déclare dans la tête qu'elle espère recevoir des données sérialisées à l'aide de XML

Réponse reçue : le code de réponse est 200, l'exécution est réussie, il y a des données dans le corps et les données sont sérialisées en utilisant XML

Envoyer une requête : le prédicat est PUT, la sémantique est de modifier la ressource Person avec l'ID 1, le contenu modifié est dans le Body, le Content-Type indique que le corps utilise la sérialisation Json, dans le corps nous mettons Name Modify sur Test1Changed

Recevoir la réponse, le code de réponse est 204, l'exécution est réussie

Envoyer requête : le prédicat est GET, la sémantique est une requête Personne avec l'ID 1 Ressource, Accepter indique qu'il espère recevoir des données Json

Réponse reçue : Vous pouvez voir que le Corps est le contenu sérialisé à l'aide de Json, et l'attribut Nom a été remplacé par Test1Changed

Envoyer la demande : le prédicat est DELETE, la sémantique consiste à supprimer la ressource Personne avec l'ID 1

Recevoir la réponse : code de réponse 204, exécution réussi

发送请求：谓词为GET，语义为查询ID为1的Person资源，Accept标明希望接收到Json数据

收到响应：响应码为200，执行成功，响应内容为null，资源已删除

 

这就是我用Fiddler来发送、调用的一组RestFul接口，大家可以看到，整个调用过程使用到了HTTP的语义，用到了谓词路由、内容协商。在增、删、改操作中，我都是使用void作为返回值，根据HTTP Code 判断，大家也可以自定义一些返回数据来做出更进一步的操作描述。

 

在写了这些API后，我们需要在程序中调用，我以C#为例写一组对这些接口调用的实现。在C#中，传统调用HTTP接口一般有两种办法： WebRequest/WebResponse组合的方法调用和WebClient类进行调用。第一种方法抽象程度较低，使用较为繁琐；而WebClient主要面向了WEB网页场景，在模拟Web操作时使用较为方便，但用在RestFul场景下却比较麻烦，在Web API发布的同时，.NET提供了两个程序集：System.Net.Http和System.Net.Http.Formatting。这两个程序集中最核心的类是HttpClient。在.NET4.5中带有这两个程序集，而.NET4需要到Nuget里下载Microsoft.Net.Http和Microsoft.AspNet.WebApi.Client这两个包才能使用这个类，更低的.NET版本就只能表示遗憾了只能用WebRequest/WebResponse或者WebClient来调用这些API了。

       在使用中，System.Net.Http这个程序集提供了HttpClient类以及相关的HTTP调用，而System.Net.Http.Formatting提供了一些针对HttpClient的帮助扩展，更好地支持了内容协商、Content创建等功能。下面我就和大家一起写一下这个例子：

       我们新建一个控制台程序：

       代码如下：

public class Person

    {        public long Id { get; set; }        public string Name { get; set; } 

        public int Age { get; set; } 

        public string Sex { get; set; } 

        public override string ToString()

        {            return $"Id={Id} Name={Name} Age={Age} Sex={Sex}";

        }

    } 

    class Program

    {        static void Main(string[] args)

        {            var client = new HttpClient();

 

            client.BaseAddress = new Uri("http://localhost:22658/"); //基本的API URL
            client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json")); //默认希望响应使用Json序列化
 

 

            Run(client);

 

            Console.ReadLine();

 

        } 

        static async void Run(HttpClient client)

        {            var result = await AddPerson(client);

            Console.WriteLine($"添加结果：{result}"); //添加结果：true

 

            var person = await GetPerson(client);

            Console.WriteLine($"查询结果：{person}"); //查询结果：Id=1 Name=test Age=10 Sex=F
 

            result = await PutPerson(client);

            Console.WriteLine($"更新结果：{result}"); //更新结果：true
 

            result = await DeletePerson(client);

            Console.WriteLine($"删除结果：{result}"); //删除结果：true
        } 

        static async Task<bool> AddPerson(HttpClient client)

        {            return await client.PostAsJsonAsync("api/Person", new Person() { Age = 10, Id = 1, Name = "test", Sex = "F" }) //向Person发送POST请求，Body使用Json进行序列化
                                     .ContinueWith(x => x.Result.IsSuccessStatusCode);  //返回请求是否执行成功，即HTTP Code是否为2XX
        } 

        static async Task<Person> GetPerson(HttpClient client)

        {            return await await client.GetAsync("api/Person/1") //向Person发送GET请求
                .ContinueWith(x => x.Result.Content.ReadAsAsync<Person>(                              //获取返回Body，并根据返回的Content-Type自动匹配格式化器反序列化Body

                    new List<MediaTypeFormatter>() {new JsonMediaTypeFormatter()/*这是Json的格式化器*/

                                                    ,new XmlMediaTypeFormatter()/*这是XML的格式化器*/}));

 

        } 

        static async Task<bool> PutPerson(HttpClient client)

        {            return await client.PutAsJsonAsync("api/Person/1", new Person() { Age = 10, Id = 1, Name = "test1Change", Sex = "F" }) //向Person发送PUT请求，Body使用Json进行序列化
                                    .ContinueWith(x => x.Result.IsSuccessStatusCode);  //返回请求是否执行成功，即HTTP Code是否为2XX
        } 

        static async Task<bool> DeletePerson(HttpClient client)

        {            return await client.DeleteAsync("api/Person/1") //向Person发送DELETE请求
                .ContinueWith(x => x.Result.IsSuccessStatusCode); //返回请求是否执行成功，即HTTP Code是否为2XX
        }

}

 

    这就完成了这组API的调用，是不是非常简单方便？HTTPClient使用全异步的方法，并且他有良好的扩展性，我会在之后的博客中再聊这个问题。

    OK，到此为止一组简单的Restful API和C#的调用客户端就完成了，但这只是开始，Web API是一个很强大的框架，他的扩展点非常丰富，这些扩展能为我们的开发提供很多的帮助，下一篇博文我将为大家带来WEB API中Filter的使用。

    博文中如有不正确的地方欢迎大家指正。

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!