设计模式之服务定位器模式（Service Locator Pattern）

服务定位器模式（Service Locator Pattern）用在我们想使用 JNDI 查询定位各种服务的时候。考虑到为某个服务查找 JNDI 的代价很高，服务定位器模式充分利用了缓存技术。在首次请求某个服务时，服务定位器在 JNDI 中查找服务，并缓存该服务对象。当再次请求相同的服务时，服务定位器会在它的缓存中查找，这样可以在很大程度上提高应用程序的性能。以下是这种设计模式的实体。
服务（Service） - 实际处理请求的服务。对这种服务的引用可以在 JNDI 服务器中查找到。
Context / 初始的 Context - JNDI Context 带有对要查找的服务的引用。
服务定位器（Service Locator） - 服务定位器是通过 JNDI 查找和缓存服务来获取服务的单点接触。
缓存（Cache） - 缓存存储服务的引用，以便复用它们。
客户端（Client） - Client 是通过 ServiceLocator 调用服务的对象。
代码：
1.服务接口

public interface Service {
    public String getName();
    public void execute();
}

public class Service1 implements Service{

    @Override
    public String getName() {
        return "service1";
    }

    @Override
    public void execute() {
        System.out.println("执行服务1的服务");
    }

}

public class Service2  implements Service{

    @Override
    public String getName() {
        return "service2";
    }

    @Override
    public void execute() {
        System.out.println("执行服务2的服务");
    }

}

2.为 JNDI 查询创建 InitialContext

public class InitialContext {
    public Object lookUp(String jndiName) {
        if ("service1".equalsIgnoreCase(jndiName)) {
            System.out.println("Looking up and creating a new Service1 object");
            return new Service1();
        } else if ("service2".equalsIgnoreCase(jndiName)) {
            System.out.println("Looking up and creating a new Service2 object");
            return new Service2();
        }
        return null;
    }
}

3.缓存 Cache

public class Cache {
    private List<Service> services;

    public Cache() {
        services = new ArrayList<>();
    }

    public Service getService(String serviceName) {
        for (Service service : services) {
            if (serviceName.equalsIgnoreCase(service.getName())) {
                System.out.println("return cache service...");
                return service;
            }
        }
        return null;
    }

    public void addService(Service service) {
        boolean flag = false;
        for (Service service1 : services) {
            if (service1.getName().equalsIgnoreCase(service.getName()))
                flag = true;
        }
        if (!flag)
            services.add(service);
    }

}

4.服务定位器

public class ServiceLocator {
    private static Cache cache;
    
    static {
        cache=new Cache();
    }
    
    public static Service getService(String jndiName) {
        Service service=cache.getService(jndiName);
        if(service!=null)
            return service;
        InitialContext context=new InitialContext();
        Service service1=(Service) context.lookUp(jndiName);
        cache.addService(service1);
        return service1;
    }
    
}

5.测试

public class Test {
    public static void main(String[] args) {
        Service service=ServiceLocator.getService("service1");
        service.execute();
        service=ServiceLocator.getService("service1");
        service.execute();
        service=ServiceLocator.getService("service2");
        service.execute();
        service=ServiceLocator.getService("service2");
        service.execute();
    }
}

6.测试结果

Looking up and creating a new Service1 object
执行服务1的服务
return cache service...
执行服务1的服务
Looking up and creating a new Service2 object
执行服务2的服务
return cache service...
执行服务2的服务

7.结论
client客户端通过定位器获取服务，然后调用服务。定位器先去缓存里面取，没有，去初始化Context中取。

转载于
http://www.runoob.com/design-pattern/service-locator-pattern.html