Angular 8+ providers在修炼 有大用

TypeProvider | ValueProvider | ClassProvider | ConstructorProvider | ExistingProvider | FactoryProvider | any[];

export interface ClassProvider extends ClassSansProvider {
    /**
     * An injection token. (Typically an instance of `Type` or `InjectionToken`, but can be `any`).
     */
    provide: any;
    /**
     * If true, then injector returns an array of instances. This is useful to allow multiple
     * providers spread across many files to provide configuration information to a common token.
     * 参考拦截器实现
     */
    multi?: boolean;
    /**
     * Class to instantiate for the `token`.
     * 设置注入的对象
     */
    useClass: Type<any>;
}

@NgModule({
  imports: [
    CommonModule,
  ],
  providers: [
    UtilService, //方式一
    {provide: UtilService, useClass: UtilService},//方式二
  ]
})

////////// BCarComponent ////////////
@Component({
  selector: 'b-car',
  template: `
    <div>假如我是BYD，我也车：B: {{description}}</div>
    <c-car></c-car>
  `,
  providers: [
    { provide: CarService, useClass: CarService2 },
    { provide: EngineService, useClass: EngineService2 }
  ]
})

////////// CCarComponent ////////////
@Component({
  selector: 'c-car',
  template: `
     <div>假如我是Bentley，我也车：B: {{description}}</div>
     <div>C: {{description}}</div>
   `,
  providers: [
    { provide: CarService, useClass: CarService3 }
  ]
})

import { Type } from '../type';
/**
 * Creates a token that can be used in a DI Provider.
 *
 * Use an `InjectionToken` whenever the type you are injecting is not reified (does not have a
 * runtime representation) such as when injecting an interface, callable type, array or
 * parameterized type.
 *
 * `InjectionToken` is parameterized on `T` which is the type of object which will be returned by
 * the `Injector`. This provides additional level of type safety.
 *
 * ```
 * interface MyInterface {...}
 * var myInterface = injector.get(new InjectionToken<MyInterface>('SomeToken'));
 * // myInterface is inferred to be MyInterface.
 * ```
 *
 * When creating an `InjectionToken`, you can optionally specify a factory function which returns
 * (possibly by creating) a default value of the parameterized type `T`. This sets up the
 * `InjectionToken` using this factory as a provider as if it was defined explicitly in the
 * application's root injector. If the factory function, which takes zero arguments, needs to inject
 * dependencies, it can do so using the `inject` function. See below for an example.
 *
 * Additionally, if a `factory` is specified you can also specify the `providedIn` option, which
 * overrides the above behavior and marks the token as belonging to a particular `@NgModule`. As
 * mentioned above, `'root'` is the default value for `providedIn`.
 *
 * @usageNotes
 * ### Basic Example
 *
 * ### Plain InjectionToken
 *
 * {@example core/di/ts/injector_spec.ts region='InjectionToken'}
 *
 * ### Tree-shakable InjectionToken
 *
 * {@example core/di/ts/injector_spec.ts region='ShakableInjectionToken'}
 *
 *
 * @publicApi
 */
export declare class InjectionToken<T> {
    protected _desc: string;
    readonly ngInjectableDef: never | undefined;
    constructor(_desc: string, options?: {
        providedIn?: Type<any> | 'root' | null;
        factory: () => T;
    });
    toString(): string;
}
export interface InjectableDefToken<T> extends InjectionToken<T> {
    ngInjectableDef: never;
}

/**
 * A multi-provider token which represents the array of `HttpInterceptor`s that
 * are registered.
 *
 * @publicApi
 */
export declare const HTTP_INTERCEPTORS: InjectionToken<HttpInterceptor[]>;

export class O1Interceptorimplements HttpInterceptor {
   intercept(req: HttpRequest<any>, next: HttpHandler) {
    ///...
   }
   ///...
}
export class O2Interceptorimplements HttpInterceptor {
   intercept(req: HttpRequest<any>, next: HttpHandler) {
    ///...
   }
   ///...
}
export const httpInterceptorProviders = [
    { provide: HTTP_INTERCEPTORS, useClass: O1Interceptor, multi: true },
    { provide: HTTP_INTERCEPTORS, useClass: O2Interceptor, multi: true }
];
通过这种方式，每当发起一个http请求，则自动会执行O1Interceptorimplements.intercept,O2Interceptorimplements.intercept,

/**
 * 系统资源文件
 */
export interface PrjectSysResource {
  resourceId?: string;
  resourceName: string;
  permission: string;
  close: any;
}
export const DI_SYS_RESOURCE1: PrjectSysResource = {
  resourceId: 't-5205-1',
  resourceName: 'Java 学习-1',
  permission: '',
  close: () => {
    console.log('Java 学习-1');
  },
};
export const DI_SYS_RESOURCE2: PrjectSysResource = {
  resourceId: 't-5205-2',
  resourceName: 'Java 学习-2',
  permission: '',
  close: () => {
    console.log('Java 学习-2');
  },
};
// DI Token
export const SYS_RESOURCE_CONFIG = new InjectionToken<PrjectSysResource[]>('sys.resource.config');

@NgModule({
  providers: [
    { provide: SYS_RESOURCE_CONFIG, useValue: DI_SYS_RESOURCE1 },
    { provide: SYS_RESOURCE_CONFIG, useValue: DI_SYS_RESOURCE2, multi: true },
    { provide: NZ_WAVE_GLOBAL_CONFIG, useValue: { disabled: false } },
  ]
})
export class CarService4 extends CarService2 {
  constructor(
    @Optional() @Inject(SYS_RESOURCE_CONFIG) private sysResource: PrjectSysResource
  ) {

  }
  getCar() {
    const car = super.getCar();
    car.name = '资源名称：${this.sysResource.resourceName}  Chizzamm Motors, Calico UltraMax Supreme';
    return car;
  }
}