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

即原来要通过JNDI查询定位服务成本很高，所以通过一系列手段将服务缓存起来，让服务更快返回，这也是缓存服务的一种最佳实践。

服务定位器模式的实例

定义多种服务

  1. class Service1 {
  2.     execute(){
  3.        console.log("Executing Service1");
  4.     }
  6.     getName() {
  7.        return "Service1";
  8.     }
  9. }
  10. class Service2 {
  11.     execute(){
  12.        console.log("Executing Service2");
  13.     }
  15.     getName() {
  16.        return "Service2";
  17.     }
  18. }

定义查询服务功能

  1. class InitialContext {
  2.     lookup(jndiName){
  3.         switch(jndiName.toUpperCase()) {
  4.             case "SERVICE1":
  5.                 console.log("Looking up and creating a new Service1 object");
  6.                 return new Service1();
  7.             case "SERVICE2":
  8.                 console.log("Looking up and creating a new Service2 object");
  9.                 return new Service2();
  10.             default:
  11.                 return null;
  12.         } 
  13.     }
  14. }

定义服务缓存

  1.  class Cache {
  2.     constructor(){
  3.        this.services = [];
  4.     }
  5.     getService(serviceName){
  6.        for (const service of this.services) {
  7.           if(service.getName().toUpperCase()==serviceName.toUpperCase()){
  8.              console.log("Returning cached  "+serviceName+" object");
  9.              return service;
  10.           }
  11.        }
  12.        return null;
  13.     }
  14.     addService(newService){
  15.        let exists = false;
  16.        for (const service of this.services) {
  17.         if(service.getName().toUpperCase()==newService.getName().toUpperCase()){
  18.              exists = true;
  19.           }
  20.        }
  21.        if(!exists){
  22.           this.services.push(newService);
  23.        }
  24.     }
  25. }

定义服务定位器，其功能是在获取服务时，优先从缓存中获取，若不存在再查询并加入缓存

  1. class ServiceLocator {
  2.     static getService(jndiName){
  3.        const service = ServiceLocator.cache.getService(jndiName);
  4.        if(service != null){
  5.           return service;
  6.        }
  7.        const context = new InitialContext();
  8.        const service1 = context.lookup(jndiName);
  9.        ServiceLocator.cache.addService(service1);
  10.        return service1;
  11.     }
  12. }
  13. ServiceLocator.cache = new Cache();

通过服务定位器获取服务后执行

  1. let service = ServiceLocator.getService("Service1");
  2. service.execute();
  3. service = ServiceLocator.getService("Service2");
  4. service.execute();
  5. service = ServiceLocator.getService("Service1");
  6. service.execute();
  7. service = ServiceLocator.getService("Service2");
  8. service.execute();

服务定位器模式的优势

缓存服务和数据的最佳实践