服务定位器模式（Service Locator Pattern）是控制反转原理的实现方式之一。本文详细介绍该模式，并提供了 UML 图和示例 Java 代码。

服务定位器模式

服务定位器模式实现了按需返回服务实例。在该模式中，应用所有需要的服务都会被注册到服务定位器中，并通过 ID 唯一标识。应用需要哪个服务，用这个 ID 就能从服务定位器中得到这个服务的实例。服务定位器模式解耦了服务调用者和具体的服务实现。该模式的 UML 类图可以表示如下：

服务定位器模式包含如下组件：

• Client：服务调用者，向服务定位器发出服务调用请求
• Service Locator：客户端/服务端间通信入口，从 Cache 中返回服务
• Cache：缓存、复用服务
• Initializer：创建、注册服务到 Cache 中
• Service：服务具体实现

Java 示例

让我们看一个具体的例子来理解服务定位器模式，准备代码如下：

// Java program to 
// illustrate Service Design Service 
// Locator Pattern 
  
import java.util.ArrayList; 
import java.util.List; 

首先，定义服务 Service 接口以及两个具体服务实现：

// Service interface 
// for getting name and 
// Executing it. 
  
interface Service { 
    public String getName(); 
    public void execute(); 
}

// Service one implementing Locator 
class ServiceOne implements Service { 
    public void execute() 
    { 
        System.out.println("Executing ServiceOne"); 
    } 
  
    @Override
    public String getName() 
    { 
        return "ServiceOne"; 
    } 
} 
  
// Service two implementing Locator 
class ServiceTwo implements Service { 
    public void execute() 
    { 
        System.out.println("Executing ServiceTwo"); 
    } 
  
    @Override
    public String getName() 
    { 
        return "ServiceTwo"; 
    } 
} 

接着定义 Service Locator 类，该服务器类实现了一个服务 Cache 以及一个服务实例返回函数 getService。getService 函数会优先返回缓存的服务实例，如果没有，则通过 Initializer 创建。

// Locator class 
class ServiceLocator { 
    private static Cache cache; 
  
    static
    { 
        cache = new Cache(); 
    } 
  
    public static Service getService(String name) 
    { 
        Service service = cache.getService(name); 
  
        if (service != null) { 
            return service; 
        } 
  
        InitialContext context = new InitialContext(); 
        Service ServiceOne = (Service)context.lookup(name); 
        cache.addService(ServiceOne); 
        return ServiceOne; 
    } 
} 

上面提到的 Cache 类和 Initializer 类具体实现如下：

class Cache { 
    private List<Service> services; 
  
    public Cache() 
    { 
        services = new ArrayList<Service>(); 
    } 
  
    public Service getService(String serviceName) 
    { 
        for (Service service : services) { 
            if (service.getName().equalsIgnoreCase(serviceName)) { 
                System.out.println("Returning cached "
                                   + serviceName + " object"); 
                return service; 
            } 
        } 
        return null; 
    } 
  
    public void addService(Service newService) 
    { 
        boolean exists = false; 
        for (Service service : services) { 
            if (service.getName().equalsIgnoreCase(newService.getName())) { 
                exists = true; 
            } 
        } 
        if (!exists) { 
            services.add(newService); 
        } 
    } 
} 

// Checking the context 
// for ServiceOne and ServiceTwo 
class InitialContext { 
    public Object lookup(String name) 
    { 
        if (name.equalsIgnoreCase("ServiceOne")) { 
            System.out.println("Creating a new ServiceOne object"); 
            return new ServiceOne(); 
        } 
        else if (name.equalsIgnoreCase("ServiceTwo")) { 
            System.out.println("Creating a new ServiceTwo object"); 
            return new ServiceTwo(); 
        } 
        return null; 
    } 
}

最后是 Client 类，测试代码效果：

// Client class 
class ServiceConsumer { 
    public static void main(String[] args) 
    { 
        Service service = ServiceLocator.getService("ServiceOne"); 
        service.execute(); 
  
        service = ServiceLocator.getService("ServiceTwo"); 
        service.execute(); 
  
        service = ServiceLocator.getService("ServiceOne"); 
        service.execute(); 
  
        service = ServiceLocator.getService("ServiceTwo"); 
        service.execute(); 
    } 
} 

输出结果：

Creating a new ServiceOne object
Executing ServiceOne
Creating a new ServiceTwo object
Executing ServiceTwo
Returning cached ServiceOne object
Executing ServiceOne
Returning cached ServiceTwo object
Executing ServiceTwo

总结

与依赖注入的区别

两种模式都是控制反转原理的实现，即对象不应该知道如何构造其依赖项。不同点在于，对于服务定位器模式，Client 仍然需要对依赖项的创建负责，虽然借助了 Service Locator 来完成。

优缺点

优点：

• 应用可以在运行时，选择添加或移除依赖服务
• 应用和服务间松耦合，唯一的连接仅仅在于服务定位器的服务注册

缺点：

• 服务定位器的服务注册使代码更加复杂，不得不维护比较多的服务唯一标识 ID
• 如果依赖有错误，只能在运行时报错，不能在编译时发现
• 由于应用仍要负责创建依赖项，因此不能 mock 依赖，不方便写测试代码

参考资料

[1] 30分钟学会UML类图
[2] Baeldung: Service Locator Pattern
[3] GeeksforGeeks: Service Locator Pattern