service-locator

99% of my dependency is manage with DI pattern via @Autowired Spring annotation. Nevertheless in a particular scenario, I can't determine which implementation to be used until run-time. The most known case, is the multiple implementation of parsers. The first solution is to used multiple @Autowired (ugly mode) Interface Parser { <T> T parse(); } @Component("JsonParser") class JsonParser implements Parser { ... } @Component("XmlParser") class XmlParser implements Parser { ... } class MyService { @Autowired @Qualifier("XmlParser") Parser xmlParser; @Autowired @Qualifier("JsonParser") Parser

I have read often that Service Locators in IOC are an anti-pattern . Last year we introduced IOC (Ninject specifically) to our application at work. The app is legacy, it's very big and it's fragmented. There are lots of ways a class, or a chain of classes can get created. Some are created by the web framework (which is custom), some are created by nHibernate. Lots are just scattered around in weird places. How would we handle the different scenarios and not come up with something thats not at least ServiceLocatorish and not end up with different kernels in different places (scopes like

I've created an ASP.NET Core MVC/WebApi site that has a RabbitMQ subscriber based off James Still's blog article Real-World PubSub Messaging with RabbitMQ . In his article he uses a static class to start the queue subscriber and define the event handler for queued events. This static method then instantiates the event handler classes via a static factory class. using RabbitMQ.Client; using RabbitMQ.Client.Events; using System; using System.Text; namespace NST.Web.MessageProcessing { public static class MessageListener { private static IConnection _connection; private static IModel _channel;

Consider this scenario. I have some business logic that now and then will be required to write to a log. interface ILogger { void Log(string stuff); } interface IDependency { string GetInfo(); } class MyBusinessObject { private IDependency _dependency; public MyBusinessObject(IDependency dependency) { _dependency = dependency; } public string DoSomething(string input) { // Process input var info = _dependency.GetInfo(); var intermediateResult = PerformInterestingStuff(input, info); if (intermediateResult== "SomethingWeNeedToLog") { // How do I get to the ILogger-interface? } var result =

How can I resolve dependencies to a controller that is testable? How it works: A URI is routed to a Controller, a Controller may have dependencies to perform a certain task. <?php require 'vendor/autoload.php'; /* * Registry * Singleton * Tight coupling * Testable? */ $request = new Example\Http\Request(); Example\Dependency\Registry::getInstance()->set('request', $request); $controller = new Example\Controller\RegistryController(); $controller->indexAction(); /* * Service Locator * * Testable? Hard! * */ $request = new Example\Http\Request(); $serviceLocator = new Example\Dependency

I was going through the previous discussion in which there was a detailed discussion on the difference between a service locator and a dependency injector, but still I am not able to get that. Can I get a general response without any code? This code sample applies the Dependency Injection principle: public class UserService : IUserService { private IUserRepository repository; // Constructor taking dependencies public UserService(IUserRepository repository) { this.repository = repository; } } This code sample uses the Service Locator pattern: public class UserService : IUserService { private