Service Locator 模式

什么是Service Locator 模式？

服务定位模式（Service Locator Pattern）是一种软件开发中的设计模式，通过应用强大的抽象层，可对涉及尝试获取一个服务的过程进行封装。该模式使用一个称为"Service Locator"的中心注册表来处理请求并返回处理特定任务所需的必要信息。

场景描述

某类ClassA依赖于服务ServiceA和服务ServiceB，服务的具体类型需在编译时指定。

这种条件下有以下缺点：

  • 尝试替换或更新依赖项，必须更改类的源代码并且重新编译。
  • 依赖项的具体实现必须在编译时可用。
  • 测试该类非常困难，因为类对依赖项有直接的引用，则依赖项不能使用Stub或Mock对象替换。
  • 该类包含用于创建、定位和管理依赖项的重复代码。

设计目标

使用 Service Locator Pattern 来达成以下目标：

  • 把类与依赖项解耦，从而使这些依赖项可被替换或者更新。
  • 类在编译时并不知道依赖项的具体实现。
  • 类的隔离性和可测试性非常好。
  • 类无需负责依赖项的创建、定位和管理逻辑。
  • 通过将应用程序分解为松耦合的模块，达成模块间的无依赖开发、测试、版本控制和部署。

解决方案

创建一个 Service Locator，其包含各服务的引用，并且封装了定位服务的逻辑。在类中使用 Service Locator 来获取所需服务的实例。

Service Locator 模式并不描述如何实例化服务，其描述了一种注册和定位服务的方式。通常情况下，Service Locator 模式与工厂模式（Factory Pattern）和依赖注入模式（Dependency Injection Pattern）等结合使用。

服务定位器应该能够在不知道抽象类的具体类型的情况下定位到服务。例如，它可能会使用字符串或服务接口类型来影射服务，这允许在无需修改类的条件下替换依赖项的具体实现。

实现细节

通常 ServiceLocator 类提供 IServiceLocator 接口的实现单例，并负责管理该实例的创建和访问。ServiceLocator 类提供 IServiceLocator 接口的默认实现，例如 ActivatingServiceLocator 类，可以同时创建和定位服务。

注意事项

在使用 Service Locator 模式之前，请考虑以下几点：

  • 有很多程序中的元素需要管理。
  • 在使用之前必须编写额外的代码将服务的引用添加到服务定位器。
  • 类将对服务定位器有依赖关系。
  • 源代码变的更加复杂和难以理解。
  • 可以使用配置数据来定义运行时的关系。
  • 必须提供服务的实现。因为服务定位器模式将服务消费者与服务提供者解耦，它可能需要提供额外的逻辑。这种逻辑将保证在服务消费者尝试定位服务之前，服务提供者已被安装和注册。

相关模式

  • 依赖注入（Dependency Injection）。这种模式解决了与 Service Locator 模式相同的问题，但它使用不同的方法。
  • 控制反转（Inversion of Control）。Service Locator 模式是这种模式的特殊版本。它将应用程序的传统控制流程反转。它用被调用对象来代替控制过程的调用方。

参考信息

代码示例

Service Locator 的简单实现，使用静态类实现，未使用Singleton设计，仅作Mapping影射

using System;
using System.Collections.Generic;
using System.Globalization;
using System.Reflection;

namespace Infrastructure
{
  /// <summary>
  /// 服务定位器
  /// </summary>
  public static class ServiceLocator
  {
    #region Fields

    private static readonly Dictionary<Type, Type> _mapping
　　　　= new Dictionary<Type, Type>();
    private static readonly Dictionary<Type, object> _resources
　　　　= new Dictionary<Type, object>();
    private static object _operationLock = new object();

    #endregion

    #region Add

    /// <summary>
    /// 添加注册资源
    /// </summary>
    /// <typeparam name="TClass">资源类型</typeparam>
    /// <param name="instance">资源实例</param>
    public static void Add<TClass>(object instance)
        where TClass : class
    {
      Add(typeof(TClass), instance);
    }

    /// <summary>
    /// 添加注册资源
    /// </summary>
    /// <param name="typeOfInstance">资源类型</param>
    /// <param name="instance">资源实例</param>
    public static void Add(Type typeOfInstance, object instance)
    {
      if (typeOfInstance == null)
        throw new ArgumentNullException("typeOfInstance");
      if (instance == null)
        throw new ArgumentNullException("instance");

      if (!(typeOfInstance.IsInstanceOfType(instance)))
      {
        throw new InvalidCastException(
            string.Format(CultureInfo.InvariantCulture,
            "Resource does not implement supplied interface: {0}",
　　　　　　　typeOfInstance.FullName));
      }

      lock (_operationLock)
      {
        if (_resources.ContainsKey(typeOfInstance))
        {
          throw new ArgumentException(
              string.Format(CultureInfo.InvariantCulture,
　　　　　　　　"Resource is already existing : {0}", typeOfInstance.FullName));
        }
        _resources[typeOfInstance] = instance;
      }
    }

    #endregion

    #region Get

    /// <summary>
    /// 查找指定类型的资源实例
    /// </summary>
    /// <typeparam name="TClass">资源类型</typeparam>
    /// <returns>资源实例</returns>
    public static TClass Get<TClass>()
        where TClass : class
    {
      return Get(typeof(TClass)) as TClass;
    }

    /// <summary>
    /// 查找指定类型的资源实例
    /// </summary>
    /// <param name="typeOfInstance">The type of instance.</param>
    /// <returns>资源实例</returns>
    public static object Get(Type typeOfInstance)
    {
      if (typeOfInstance == null)
        throw new ArgumentNullException("typeOfInstance");

      object resource;

      lock (_operationLock)
      {
        if (!_resources.TryGetValue(typeOfInstance, out resource))
        {
          throw new ResourceNotFoundException(typeOfInstance.FullName);
        }
      }

      if (resource == null)
      {
        throw new ResourceNotInstantiatedException(typeOfInstance.FullName);
      }

      return resource;
    }

    /// <summary>
    /// 尝试查找指定类型的资源实例
    /// </summary>
    /// <typeparam name="TClass">资源类型</typeparam>
    /// <param name="resource">资源实例</param>
    /// <returns>是否存在指定资源类型的资源实例</returns>
    public static bool TryGet<TClass>(out TClass resource)
        where TClass : class
    {
      bool isFound = false;

      resource = null;
      object target;

      lock (_operationLock)
      {
        if (_resources.TryGetValue(typeof(TClass), out target))
        {
          resource = target as TClass;
          isFound = true;
        }
      }

      return isFound;
    }

    #endregion

    #region Register

    /// <summary>
    /// 注册类型
    /// </summary>
    /// <typeparam name="TClass">实体类型，类型限制为有公共无参构造函数</typeparam>
    public static void RegisterType<TClass>()
      where TClass : class, new()
    {
      lock (_operationLock)
      {
        _mapping[typeof(TClass)] = typeof(TClass);
      }
    }

    /// <summary>
    /// 注册类型
    /// </summary>
    /// <typeparam name="TFrom">资源类型</typeparam>
    /// <typeparam name="TTo">实体类型，类型限制为有公共无参构造函数</typeparam>
    public static void RegisterType<TFrom, TTo>()
      where TFrom : class
      where TTo : TFrom, new()
    {
      lock (_operationLock)
      {
        _mapping[typeof(TFrom)] = typeof(TTo);
        _mapping[typeof(TTo)] = typeof(TTo);
      }
    }

    /// <summary>
    /// 是否已注册此类型
    /// </summary>
    /// <typeparam name="TClass">资源类型</typeparam>
    /// <returns>是否已注册此类型</returns>
    public static bool IsRegistered<TClass>()
    {
      lock (_operationLock)
      {
        return _mapping.ContainsKey(typeof(TClass));
      }
    }

    #endregion

    #region Resolve

    /// <summary>
    /// 获取类型实例
    /// </summary>
    /// <typeparam name="TClass">资源类型</typeparam>
    /// <returns>类型实例</returns>
    public static TClass Resolve<TClass>()
      where TClass : class
    {
      TClass resource = default(TClass);

      bool existing = TryGet<TClass>(out resource);
      if (!existing)
      {
        ConstructorInfo constructor = null;

        lock (_operationLock)
        {
          if (!_mapping.ContainsKey(typeof(TClass)))
          {
            throw new ResourceNotResolvedException(
              string.Format(CultureInfo.InvariantCulture,
　　　　　　　　"Cannot find the target type : {0}", typeof(TClass).FullName));
          }

          Type concrete = _mapping[typeof(TClass)];
          constructor = concrete.GetConstructor(
　　　　　　　　BindingFlags.Instance | BindingFlags.Public, null, new Type[0], null);
          if (constructor == null)
          {
            throw new ResourceNotResolvedException(
              string.Format(CultureInfo.InvariantCulture,
　　　　　　　　"Public constructor is missing for type : {0}", typeof(TClass).FullName));
          }
        }

        Add<TClass>((TClass)constructor.Invoke(null));
      }

      return Get<TClass>();
    }

    #endregion

    #region Remove

    /// <summary>
    /// 移除指定类型的资源实例
    /// </summary>
    /// <typeparam name="TClass">资源类型</typeparam>
    public static void Remove<TClass>()
    {
      Teardown(typeof(TClass));
    }

    /// <summary>
    /// 移除指定类型的资源实例
    /// </summary>
    /// <param name="typeOfInstance">资源类型</param>
    public static void Remove(Type typeOfInstance)
    {
      if (typeOfInstance == null)
        throw new ArgumentNullException("typeOfInstance");

      lock (_operationLock)
      {
        _resources.Remove(typeOfInstance);
      }
    }

    #endregion

    #region Teardown

    /// <summary>
    /// 拆除指定类型的资源实例及注册映射类型
    /// </summary>
    /// <typeparam name="TClass">资源类型</typeparam>
    public static void Teardown<TClass>()
    {
      Teardown(typeof(TClass));
    }

    /// <summary>
    /// 拆除指定类型的资源实例及注册映射类型
    /// </summary>
    /// <param name="typeOfInstance">资源类型</param>
    public static void Teardown(Type typeOfInstance)
    {
      if (typeOfInstance == null)
        throw new ArgumentNullException("typeOfInstance");

      lock (_operationLock)
      {
        _resources.Remove(typeOfInstance);
        _mapping.Remove(typeOfInstance);
      }
    }

    #endregion

    #region Clear

    /// <summary>
    /// 移除所有资源
    /// </summary>
    public static void Clear()
    {
      lock (_operationLock)
      {
        _resources.Clear();
        _mapping.Clear();
      }
    }

    #endregion
  }
}

Service Locator 测试代码

using System;
using Infrastructure;

namespace ServiceLocatorTest
{
  class Program
  {
    interface IServiceA
    {
      string GetData();
    }

    class ServiceA : IServiceA
    {
      public string GetData()
      {
        return "This data is from ServiceA";
      }
    }

    static void Main(string[] args)
    {
      ServiceLocator.RegisterType<IServiceA, ServiceA>();
      IServiceA serviceA = ServiceLocator.Resolve<IServiceA>();
      string data = serviceA.GetData();
      Console.WriteLine(data);
      Console.ReadKey();
    }
  }
}

时间： 2024-10-04 00:04:41

Service Locator 模式的相关文章

Atitit。如何实现dip， di ，ioc ，Service Locator的区别于联系

Atitit.如何实现dip, di ,ioc  ,Service Locator的区别于联系 1. Dip原则又来自于松耦合思想方向1 2. 要实现dip原则,有以下俩个模式1 3. Ioc和di的区别1 4. Service Locator模式1 5.  Service Locator vs. Dependency Injection2 6. 参考2 1. Dip原则又来自于松耦合思想方向 松耦合系统的好处有两点:一点是它适应变化的灵活性:另一点是当某个服务的内部结构和实现逐渐发生改变时,不

.NET 服务器定位模式（Service Locator Pattern）

本文内容 场景 目标 解决方案 实现细节 思考 相关模式 更多信息 参考资料 下载 Demo 场景 你有一个类,该类依赖几个服务 Service(事实上,这些服务可以看做是另几个类),这些服务是在编译阶段指定具体类型的.在接下来的例子中,ClassA 在编译阶段依赖 ServiceA 和ServiceB.下图说明这个问题. 这种情况有如下缺点: 若替换或更新依赖的服务(或类),显然,必须修改源代码,并且重新编译解决方案: 这些依赖的具体实现(依赖的服务的具体实现)必须在编译时可用:The con

【IOC--Common Service Locator】不依赖于某个具体的IoC

你在你的应用程序应用IoC容器了吗,你是否希望不依赖于某个具体的IoC,微软的模式与实践团队在Codeplex上发布的Common Service Locator.Common Service Locator 类库包含应用程序和框架开发者引用Service location共享的接口.这个类库提供了在IOC容器和Service locators之上抽象.使用这个类库允许一个应用程序在没有强引用依赖下间接的访问的能力.它所定义的接口非常简单:{ http://www.cnblogs.com/sha

[Design Pattern] Service Locator Pattern 简单案例

Service Locator Pattern,即服务定位模式,用于定位不同的服务.考虑到 InitialContext::lookup 的成本比较高,提供了 Cache 类缓存以定位到的服务. 代码实现 Service 接口 public interface Service { public String getName(); public void execute(); } Service1, Service2 实现 Service 接口,提供具体服务 public class Servic

依赖注入与Service Locator

为什么需要依赖注入? 普通的ServiceUser来负责直接创建所需Service实现的实例方法.拥有以下的局限 在不同的环境下,ServiceProvider是千差万别的(数据库,临时文件,内存). 所以,不能将ServiceUser作为组件发布(适应不了各种差异环境). 为了将ServiceUser所在单元作为组件发布,必须满足以下的条件. 将ServiceUser与具体的ServiceProvider_Imp解耦(解除编译时依赖).即不能出现new ServiceProvider_Imp(

Service Locator Patten 总结

原网址将会不断更新 :   作程的技术博客  <Service Locator Patten 总结>  it.zuocheng.net  http://www.zuocheng.net/it 核心思想 将构建依赖的接口彻底与依赖者分离,并将此依赖作为"服务"绑定到一个标识符,而后依赖者则可通过这个标识符获取被绑定的依赖. 优点 上层逻辑不依赖于服务接口的具体实现,实现解耦 提高系统的可扩展性 逻辑分层更加简洁清晰,使不同层次的开发人员各司其职,提高团队开发效率 适用场景 与

PHP中应用Service Locator服务定位及单例模式

单例模式将一个对象实例化后,放在静态变量中,供程序调用. 服务定位(ServiceLocator)就是对象工场Factory,调用者对象直接调用Service Locator,与被调用对象减轻了依赖关系,这样如果被调用对象更换时,直接修改ServiceLocator的注册即可,不用修改程序中很多个地方的调用,从而减轻依赖关系. 我在学习单例模式的思路时,有一个疑问总是围绕着自己,单例模式就是静态变量呗,为什么要叫单例模式,有什么好处?静态类+静态方法不是很好? 当我学习了ServiceLocat

Design Pattern - Service Locator Pattern--转载

原文地址:http://www.tutorialspoint.com/design_pattern/service_locator_pattern.htm The service locator design pattern is used when we want to locate various services using JNDI lookup. Considering high cost of looking up JNDI for a service, Service Locato

【转】Understanding Inversion of Control, Dependency Injection and Service Locator Print

原文:https://www.dotnettricks.com/learn/dependencyinjection/understanding-inversion-of-control-dependency-injection-and-service-locator ----------------------------------------------------------------------------------------- Understanding Inversion of