angular - HttpModule 和 HttpClientModule 的区别

Question

使用哪一个来构建模拟 Web 服务来测试 Angular 4 应用程序？

score 349 · Accepted Answer

如果您使用的是 Angular 4.3.x 及更高版本，请使用HttpClient该类：HttpClientModule

import { HttpClientModule } from '@angular/common/http';

@NgModule({
 imports: [
   BrowserModule,
   HttpClientModule
 ],
 ...

 class MyService() {
    constructor(http: HttpClient) {...}

http它是from模块的升级版本，@angular/http具有以下改进：

拦截器允许将中间件逻辑插入到管道中

不可变的请求/响应对象

请求上传和响应下载的进度事件

您可以在Insider 的 Angular 拦截器和 HttpClient 机制指南中了解它的工作原理。

类型化的同步响应正文访问，包括对 JSON 正文类型的支持

JSON 是一个假定的默认值，不再需要显式解析

基于请求后验证和刷新的测试框架

今后旧的 http 客户端将被弃用。以下是提交消息和官方文档的链接。

还要注意旧的 http 是使用Http类令牌而不是新的注入的HttpClient：

import { HttpModule } from '@angular/http';

@NgModule({
 imports: [
   BrowserModule,
   HttpModule
 ],
 ...

 class MyService() {
    constructor(http: Http) {...}

此外，新的HttpClient似乎需要在运行时，所以如果你使用tslib它，你必须安装它npm i tslib并更新：system.config.jsSystemJS

map: {
     ...
    'tslib': 'npm:tslib/tslib.js',

如果使用 SystemJS，则需要添加另一个映射：

'@angular/common/http': 'npm:@angular/common/bundles/common-http.umd.js',

score 44 · Accepted Answer

不想重复，只是换个方式总结一下（新HttpClient中新增的功能）：

从 JSON 到对象的自动转换
响应类型定义
事件触发
标题的简化语法
拦截器

我写了一篇文章，介绍了旧的“http”和新的“HttpClient”之间的区别。目标是以最简单的方式解释它。

简单的关于 Angular 中的新 HttpClient

score 21 · Accepted Answer

这是一个很好的参考，它帮助我将http请求转换为httpClient.

它比较了两者的差异并给出了代码示例。

这只是我在项目中将服务更改为 httpclient 时处理的一些差异（借用我提到的文章）：

输入

import {HttpModule} from '@angular/http';
import {HttpClientModule} from '@angular/common/http';

请求和解析响应：

@角/http

 this.http.get(url)
      // Extract the data in HTTP Response (parsing)
      .map((response: Response) => response.json() as GithubUser)
      .subscribe((data: GithubUser) => {
        // Display the result
        console.log('TJ user data', data);
      });

@角/普通/http

 this.http.get(url)
      .subscribe((data: GithubUser) => {
        // Data extraction from the HTTP response is already done
        // Display the result
        console.log('TJ user data', data);
      });

注意：您不再需要显式提取返回的数据；默认情况下，如果你返回的数据是 JSON 类型，那么你不需要做任何额外的事情。

但是，如果您需要解析任何其他类型的响应，例如文本或 blob，请确保responseType在请求中添加。像这样：

使用选项发出 GET HTTP 请求`responseType`：

 this.http.get(url, {responseType: 'blob'})
      .subscribe((data) => {
        // Data extraction from the HTTP response is already done
        // Display the result
        console.log('TJ user data', data);
      });

添加拦截器

我还使用拦截器将我的授权令牌添加到每个请求中，参考。

像这样：

@Injectable()
export class MyFirstInterceptor implements HttpInterceptor {

    constructor(private currentUserService: CurrentUserService) { }

    intercept(req: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>> {

        // get the token from a service
        const token: string = this.currentUserService.token;

        // add it if we have one
        if (token) {
            req = req.clone({ headers: req.headers.set('Authorization', 'Bearer ' + token) });
        }

        // if this is a login-request the header is 
        // already set to x/www/formurl/encoded. 
        // so if we already have a content-type, do not 
        // set it, but if we don't have one, set it to 
        // default --> json
        if (!req.headers.has('Content-Type')) {
            req = req.clone({ headers: req.headers.set('Content-Type', 'application/json') });
        }

        // setting the accept header
        req = req.clone({ headers: req.headers.set('Accept', 'application/json') });
        return next.handle(req);
    }
}

这是一个相当不错的升级！

score 1 · Accepted Answer

有一个库允许您使用 HttpClient 和强类型回调。

数据和错误可通过这些回调直接获得。

当您将 HttpClient 与 Observable 一起使用时，您必须在其余代码中使用.subscribe(x=>...) 。

这是因为Observable< HttpResponse< T>>绑定到HttpResponse。

这将http 层与您的其余代码紧密结合在一起。

该库封装了.subscribe(x => ...)部分，并仅通过您的模型公开数据和错误。

使用强类型回调，您只需在其余代码中处理您的模型。

该库称为angular-extended-http-client。

GitHub 上的 angular-extended-http-client 库

NPM 上的 angular-extended-http-client 库

非常容易使用。

示例使用

强类型回调是

成功：

IObservable< T>
IObservableHttpResponse
IObservableHttpCustomResponse< T>

失败：

IObservableError< TError>
IObservableHttpError
IObservableHttpCustomError< TError>

将包添加到您的项目和应用程序模块中

import { HttpClientExtModule } from 'angular-extended-http-client';

并在 @NgModule 导入

  imports: [
    .
    .
    .
    HttpClientExtModule
  ],

你的模型

//Normal response returned by the API.
export class RacingResponse {
    result: RacingItem[];
}

//Custom exception thrown by the API.
export class APIException {
    className: string;
}

您的服务

在您的服务中，您只需使用这些回调类型创建参数。

然后，将它们传递给HttpClientExt的 get 方法。

import { Injectable, Inject } from '@angular/core'
import { RacingResponse, APIException } from '../models/models'
import { HttpClientExt, IObservable, IObservableError, ResponseType, ErrorType } from 'angular-extended-http-client';
.
.

@Injectable()
export class RacingService {

    //Inject HttpClientExt component.
    constructor(private client: HttpClientExt, @Inject(APP_CONFIG) private config: AppConfig) {

    }

    //Declare params of type IObservable<T> and IObservableError<TError>.
    //These are the success and failure callbacks.
    //The success callback will return the response objects returned by the underlying HttpClient call.
    //The failure callback will return the error objects returned by the underlying HttpClient call.
    getRaceInfo(success: IObservable<RacingResponse>, failure?: IObservableError<APIException>) {
        let url = this.config.apiEndpoint;

        this.client.get(url, ResponseType.IObservable, success, ErrorType.IObservableError, failure);
    }
}

你的组件

在您的组件中，注入您的服务并调用getRaceInfo API，如下所示。

  ngOnInit() {    
    this.service.getRaceInfo(response => this.result = response.result,
                                error => this.errorMsg = error.className);

  }

回调中返回的响应和错误都是强类型的。例如。response是RacingResponse类型，error是APIException。

你只在这些强类型回调中处理你的模型。

因此，您的其余代码只知道您的模型。

此外，您仍然可以使用传统路由并从 Service API返回 Observable< HttpResponse<T >。>

score 0 · Accepted Answer

HttpClient是 4.3 附带的新 API，它更新了 API，支持进度事件、默认的 json 反序列化、拦截器和许多其他强大功能。在这里查看更多https://angular.io/guide/http

Http是较旧的 API，最终将被弃用。

由于它们对于基本任务的用法非常相似，因此我建议使用 HttpClient，因为它是更现代且易于使用的替代方案。