Tengo un @Injectableservicio definido en bootstrap. Quiero obtener la instancia del servicio sin usar la inyección del constructor. Intenté usar ReflectiveInjector.resolveAndCreatepero eso parece crear una nueva instancia.

La razón por la que intento hacerlo es que tengo un componente base derivado de muchos componentes. Ahora necesito acceder a un servicio, pero no quiero agregarlo al ctor porque no quiero inyectar el servicio en todos los componentes derivados.

TLDR: necesito un ServiceLocator.GetInstance<T>()

ACTUALIZACIÓN: código actualizado para RC5 +: almacenamiento de la instancia del inyector para su uso en componentes

Sí, ReflectiveInjector.resolveAndCreate()crea una instancia de inyector nueva y no conectada.

Puede inyectar la Injectorinstancia de Angulars y obtener la instancia deseada de ella usando

constructor(private injector:Injector) {
  injector.get(MyService);
}

También puede almacenar Injectoren alguna variable global y luego usar esta instancia de inyector para adquirir instancias proporcionadas, por ejemplo, como se explica en https://github.com/angular/angular/issues/4112#issuecomment-153811572

En el Angular actualizado donde se usan ngModules, puede crear una variable disponible en cualquier parte del código:

export let AppInjector: Injector;

export class AppModule {
  constructor(private injector: Injector) {
    AppInjector = this.injector;
  }
}

Ahora, puede usar el AppInjectorpara encontrar cualquier servicio en cualquier parte de su código.

import {AppInjector} from '../app.module';

const myService = AppInjector.get(MyService);

Otro enfoque consistiría en definir un decorador personalizado (a CustomInjectablepara configurar los metadatos para la inyección de dependencia:

export function CustomComponent(annotation: any) {
  return function (target: Function) {

    // DI configuration
    var parentTarget = Object.getPrototypeOf(target.prototype).constructor;
    var parentAnnotations = Reflect.getMetadata('design:paramtypes', parentTarget);

    Reflect.defineMetadata('design:paramtypes', parentAnnotations, target);

    // Component annotations / metadata
    var annotations = Reflect.getOwnMetadata('annotations', target);
    annotations = annotations || [];
    annotations.push(annotation);
    Reflect.defineMetadata('annotations', annotations, target);
  }
}

Aprovechará los metadatos del constructor principal en lugar de los suyos propios. Puedes usarlo en la clase infantil:

@Injectable()
export class SomeService {
  constructor(protected http:Http) {
  }
}

@Component()
export class BaseComponent {
  constructor(private service:SomeService) {
  }
}

@CustomComponent({
  (...)
})
export class TestComponent extends BaseComponent {
  constructor() {
    super(arguments);
  }

  test() {
    console.log('http = '+this.http);
  }
}

Consulte esta pregunta para obtener más detalles:

• Angular2 usa bibliotecas importadas de la clase base

StoreService .ts

  import { Injectable} from '@angular/core';

    @Injectable()
    export class StoreService {
      static isCreating: boolean = false;
      static instance: StoreService ;

      static getInstance() {
        if (StoreService.instance == null) {
          StoreService.isCreating = true;
          StoreService.instance = new StoreService ();
          StoreService.isCreating = false;
        }
        return StoreService.instance;
      }
      constructor() {
        if (!StoreService.isCreating) {
          throw new Error('You can\'t call new in Singleton instances! Call StoreService.getInstance() instead.');
        }
     }

  MyAlertMethod(){
    alert('hi);
    }
  }

componente.ts

//call this service directly in component.ts as below:-

 StoreService.getInstance().MyAlertMethod();