Qu'est-ce que l'Opaque Token d'Angular 2 et quel en est l'intérêt ?

Question

Je rencontre des "jetons opaques" comme solution à l'implémentation de constantes globales dans Angular 2, par exemple ici : Définir des constantes globales dans Angular 2

Malgré la lecture de l documents Je n'arrive pas à comprendre ce qui se passe.

L'utilisation d'un OpaqueToken est préférable à l'utilisation de chaînes de caractères comme des collisions possibles causées par plusieurs fournisseurs utilisant la même comme deux jetons différents.

Qu'est-ce que c'est ? Qu'est-ce qu'un token Angular2 pour commencer ? Tout ce que j'obtiens sur Google, ce sont des réponses sur les jetons Web JSON (leur rôle dans l'authentification, etc, etc), que je comprends, mais qui ne sont évidemment pas liés de quelque manière que ce soit.

Qu'est-ce qu'un jeton opaque ? À quoi sert-il ?

P.S. En savoir plus documents sur les jetons opaques utilisés pour fournir des constantes. Ils ne m'ont cependant pas beaucoup aidé.

Answer 1

mettre à jour Angular4

Dans Angular4 OpaqueToken est obsolète et sera remplacé par InjectionToken . InjectionToken permet de passer un paramètre de type générique.

export let APP_CONFIG = new InjectionToken<MyConfig>("app.config");

Voir aussi

• https://blog.thoughtram.io/angular/2016/05/23/opaque-tokens-in-angular-2.html
• https://angular.io/docs/ts/latest/api/core/index/OpaqueToken-class.html (n'est plus en ligne ; réacheminé vers la version archive.org)

original

Qu'est-ce que c'est ? Qu'est-ce qu'un jeton Angular2 pour commencer ?

Qu'est-ce qu'un jeton opaque ? À quoi sert-il ?

Un token est une clé pour les fournisseurs de l'injection de dépendance Angulars. Les fournisseurs sont enregistrés avec une clé et les composants, directives et classes de service instanciés par DI reçoivent des dépendances injectées qui sont recherchées par les clés des fournisseurs.

DI prend en charge les types, les chaînes de caractères, OpaqueToken et des objets comme clés.

export let APP_CONFIG = new OpaqueToken("app.config");

export let APP_CONFIG_2 = {};

providers: [
  MyService, // type is key and value
  {provide: MyService, useClass: MyFancyServiceImpl}, // type is key, `MyFancyServiceImpl` is the value (or rather the information how to create the value
  {provide: 'myservice', useClass: MyService}, // key is a string
  {provide: APP_CONFIG, useValue: {a: 'a', b: 'b'}} // key is an `OpaqueToken`
  {provide: APP_CONFIG_2, useValue: {a: 'a', b: 'b'}} // key is an object

]

// one of these decorators needs to be added to make DI work
@Injectable()
@Component()
@Directive()
@Pipe()
class MyComponent {
  // DI looks up a provider registered with the key `MyService` 
  constructor(private myService: MyService) {} 

  // Same as before but explicit
  constructor(@Inject(MyService) private myService: MyService) {} 

  // DI looks up a provider registered with the key 'myService'
  constructor(@Inject('myservice') private myService: MyService) {} 

  // DI looks up a provider registered with the `OpaqueKey` `APP_CONFIG`
  constructor(@Inject(APP_CONFIG) private myConfig: any) {} 

  // DI looks up a provider registered with the object `APP_CONFIG_2`
  constructor(@Inject(APP_CONFIG_2) private myConfig: any) {} 

La clé de l'objet ( APP_CONFIG_2 ) et le OpaqueToken ( APP_CONFIG ) doivent être exactement la même instance. Une instance différente avec le même contenu ne fonctionnera pas. Il est ainsi facile de savoir où la clé est déclarée et si le fournisseur et la cible d'injection utilisent la même clé.

Pour une chaîne, il peut s'agir d'une instance différente, ce qui présente le risque que la même valeur de chaîne soit utilisée dans différents modules et puisse entraîner des conflits ou l'injection du mauvais fournisseur.

Answer 2

Qu'est-ce qu'un jeton opaque ? À quoi sert-il ?

Token opaque utilisé pour injecter un autre fournisseur (service) portant le même nom.

Cela permet d'éviter les collisions de noms.

     const MY_HTTP_TOKEN: OpaqueToken = new OpaqueToken('Http');

     providers: [
        { provide: MY_HTTP_TOKEN, useClass: Http }
     ]

     constructor(@Inject(MY_HTTP_TOKEN) private myHttpService){}

Answer 3

Un jeton opaque est une classe d'exécution utilisée comme identifiant unique pour les fournisseurs d'injecteurs.

Supposons que vous ayez une valeur, 'secretId', que vous voulez utiliser dans quelques services et composants. Vous ne voulez pas coder en dur cette valeur dans vos services et composants, car elle changera à l'avenir. De plus, vous voulez écrire des tests pour vos services et composants.

Une classe peut être utilisée comme implémentation, type et jeton d'injection. Pour une chaîne de caractères, d'autres expressions littérales, des objets, etc., vous n'avez rien à utiliser comme jeton d'injection. Vous pouvez utiliser une chaîne de caractères comme jeton d'injection, mais il n'y a aucune garantie que cette chaîne sera unique. Avec les jetons opaques, même si deux jetons ont le même nom, ils seront évalués comme des jetons différents.

Answer 4

Je suis nouveau à angular 2, mais je veux essayer d'interpréter ce que j'ai compris de https://blog.thoughtram.io/angular/2016/05/23/opaque-tokens-in-angular-2.html dans un code simple. CMIIW.

...
const CONFIG_ONE = {title: 'My awesome app'};
let configOneToken = 'config';  //'config' is an example of string-type token

const CONFIG_TWO = {title: 'My fantastic app'};
let configTwoToken = 'config';

providers = [
  { provide: configOneToken, useValue: CONFIG_ONE },
  { provide: configTwoToken, useValue: CONFIG_TWO }
];

Ce morceau de code posera un problème (le second l'emportera sur le premier) parce qu'il y a un conflit ( 'config' == 'config' ). C'est peut-être trop évident et insignifiant dans ce code jouet, mais dans un code réel, nous pourrions ne pas être en mesure d'identifier facilement ce conflit lorsque l'un des fournisseurs est défini dans une bibliothèque tierce. Pour résoudre ce problème, nous pouvons utiliser OpaqueToken comme dans le code suivant.

...
const CONFIG_ONE = {title: 'My awesome app'};
const OPAQUE_TOKEN_ONE = new OpaqueToken('config'); //this is an example of object-type token

const CONFIG_TWO = {title: 'My fantastic app'};
const OPAQUE_TOKEN_TWO = new OpaqueToken('config');

providers = [
  { provide: OPAQUE_TOKEN_ONE, useValue: CONFIG_ONE },
  { provide: OPAQUE_TOKEN_TWO, useValue: CONFIG_TWO }
];

Deux instances d'une même classe ne sont jamais égales ( new OpaqueToken('config') != new OpaqueToken('config') ) et donc d'éviter les conflits. Les OpaqueToken n'est rien d'autre qu'une simple classe qui ne fait rien.