服务定位器模式

最新推荐文章于 2024-08-14 14:16:50 发布
最新推荐文章于 2024-08-14 14:16:50 发布
阅读量539 收藏 1
点赞数
分类专栏： 设计模式 文章标签： 设计模式 服务定位模式 J2EE 模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u013930425/article/details/79879824
版权

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

服务定位器模式（Service Locator Pattern）用在我们想使用 JNDI 查询定位各种服务的时候。考虑到为某个服务查找 JNDI 的代价很高，服务定位器模式充分利用了缓存技术。在首次请求某个服务时，服务定位器在 JNDI 中查找服务，并缓存该服务对象。当再次请求相同的服务时，服务定位器会在它的缓存中查找，这样可以在很大程度上提高应用程序的性能。以下是这种设计模式的实体。

  • 服务（Service）：实际处理请求的服务。对这种服务的引用可以在 JNDI 服务器中查找到。

  • Context / 初始的 Context：JNDI Context 带有对要查找的服务的引用。

  • 服务定位器（Service Locator）：服务定位器是通过 JNDI 查找和缓存服务来获取服务的单点接触。

  • 缓存（Cache）：缓存存储服务的引用，以便复用它们。

  • 客户端（Client）：Client 是通过 ServiceLocator 调用服务的对象。

实现

我将创建 ServiceLocator、InitialContext、Cache、Service 作为表示实体的各种对象。Service1 和 Service2 表示实体服务。
Main，我们的演示类在这里是作为一个客户端，将使用 ServiceLocator 来演示服务定位器设计模式。

服务定位器模式的 UML 图

步骤 1：创建服务接口 Service。

Service.java


    package com.dao.pattern.servicelocator.interfaces;
    
    /**
     * 服务接口
     *
     * @author 阿导
     * @version 1.0
     * @fileName com.dao.pattern.servicelocator.interfaces.Service.java
     * @CopyRright (c) 2018-万物皆导
     * @created 2018-04-07 15:42:00
     */
    public interface Service {
        /**
         * 获取服务名称
         *
         * @author 阿导
         * @time 2018/4/7
         * @CopyRight 万物皆导
         * @param
         * @return java.lang.String
         */
        String getName();
        /**
         * 处理一些事情
         *
         * @author 阿导
         * @time 2018/4/7
         * @CopyRight 万物皆导
         * @param
         * @return void
         */
        void dealSomething();
    }

步骤 2：创建实体服务。

UserService.java


    package com.dao.pattern.servicelocator.impl;
    
    import com.dao.pattern.servicelocator.interfaces.Service;
    
    /**
     * 用户服务
     *
     * @author 阿导
     * @version 1.0
     * @fileName com.dao.pattern.servicelocator.impl.UserService.java
     * @CopyRright (c) 2018-万物皆导
     * @created 2018-04-07 15:43:00
     */
    public class UserService implements Service {
    
        /**
         * 获取服务名称
         *
         * @return java.lang.String
         * @author 阿导
         * @time 2018/4/7
         * @CopyRight 万物皆导
         */
        @Override
        public String getName() {
            return "USER_SERVICE";
        }
    
        /**
         * 处理一些事情
         *
         * @return void
         * @author 阿导
         * @time 2018/4/7
         * @CopyRight 万物皆导
         */
        @Override
        public void dealSomething() {
            System.out.println("这里是用户服务，正在处理用户相关操作。");
        }
    }

OrderService.java


    package com.dao.pattern.servicelocator.impl;
    
    import com.dao.pattern.servicelocator.interfaces.Service;
    
    /**
     * 订单服务
     *
     * @author 阿导
     * @version 1.0
     * @fileName com.dao.pattern.servicelocator.impl.OrderService.java
     * @CopyRright (c) 2018-万物皆导
     * @created 2018-04-07 15:44:00
     */
    public class OrderService implements Service {
    
        /**
         * 获取服务名称
         *
         * @return java.lang.String
         * @author 阿导
         * @time 2018/4/7
         * @CopyRight 万物皆导
         */
        @Override
        public String getName() {
            return "ORDER_SERVICE";
        }
    
        /**
         * 处理一些事情
         *
         * @return void
         * @author 阿导
         * @time 2018/4/7
         * @CopyRight 万物皆导
         */
        @Override
        public void dealSomething() {
            System.out.println("这里是定单服务，正在处理订单相关操作。");
        }
    }

步骤 3：为 JNDI 查询创建 InitialContext。

InitialContext.java


    package com.dao.pattern.servicelocator.core;
    
    import com.dao.pattern.servicelocator.impl.OrderService;
    import com.dao.pattern.servicelocator.impl.UserService;
    import com.dao.pattern.servicelocator.interfaces.Service;
    
    /**
     * 为 JNDI 查询服务
     *
     * @author 阿导
     * @version 1.0
     * @fileName com.dao.pattern.servicelocator.core.InitialContext.java
     * @CopyRright (c) 2018-万物皆导
     * @created 2018-04-07 15:46:00
     */
    public class InitialContext {
        /**
         * 用户服务名
         */
        public static final String USER_SERVICE="USER_SERVICE";
        /**
         * 订单服务名
         */
        public static final String ORDER_SERVICE="ORDER_SERVICE";
    
        /**
         * 根据传入的服务名和存在的服务名进行对比，存在则创建
         *
         * @author 阿导
         * @time 2018/4/7
         * @CopyRight 万物皆导
         * @param jndiName
         * @return com.dao.pattern.servicelocator.interfaces.Service
         */
        public Service queryService(String jndiName){
            if(USER_SERVICE.equalsIgnoreCase(jndiName)){
                System.out.println("查询到用户服务，并创建用户服务");
                return new UserService();
            }else if (ORDER_SERVICE.equalsIgnoreCase(jndiName)){
                System.out.println("查询到订单服务，并创建订单服务");
                return new OrderService();
            }
            return null;
        }
    }

步骤 4：创建缓存 Cache。


    package com.dao.pattern.servicelocator.core;
    
    import com.dao.pattern.servicelocator.interfaces.Service;
    
    import java.util.HashMap;
    
    /**
     * 创建缓存，存入服务名
     *
     * @author 阿导
     * @version 1.0
     * @fileName com.dao.pattern.servicelocator.core.Cache.java
     * @CopyRright (c) 2018-万物皆导
     * @created 2018-04-07 15:53:00
     */
    public class Cache {
        /**
         * 缓存集合，存储服务
         */
        private HashMap<String,Service> mapService;
        {
            mapService=new HashMap<>();
        }
    
        /**
         * 根据服务名进行查询服务
         *
         * @author 阿导
         * @time 2018/4/7
         * @CopyRight 万物皆导
         * @param serviceName
         * @return com.dao.pattern.servicelocator.interfaces.Service
         */
        public Service getService(String serviceName){
            System.out.println("。。。。。尝试从缓存获取服务。。。。。");
            return mapService.getOrDefault(serviceName,null);
        }
        /**
         * 添加服务
         *
         * @author 阿导
         * @time 2018/4/7
         * @CopyRight 万物皆导
         * @param newService
         * @return void
         */
        public void addService(Service newService){
            if(!mapService.keySet().contains(newService.getName())) {
                mapService.put(newService.getName(), newService);
            }
        }
    }

步骤 5：创建服务定位器。

ServiceLocator.java


    package com.dao.pattern.servicelocator.core;
    
    import com.dao.pattern.servicelocator.interfaces.Service;
    
    /**
     * 创建服务定位器
     *
     * @author 阿导
     * @version 1.0
     * @fileName com.dao.pattern.servicelocator.core.ServiceLocator.java
     * @CopyRright (c) 2018-万物皆导
     * @created 2018-04-07 16:00:00
     */
    public class ServiceLocator {
        /**
         * 声明缓存并分配内存空间
         */
        public static Cache cache;
        static {
            cache=new Cache();
        }
        /**
         * 从服务定位器里面获取服务
         *
         * @author 阿导
         * @time 2018/4/7
         * @CopyRight 万物皆导
         * @param jndiName
         * @return com.dao.pattern.servicelocator.interfaces.Service
         */
        public static Service getService(String jndiName){
            //从缓存获取服务
            Service service = cache.getService(jndiName);
            //未获取到
            if(service==null){
                //通过 JNDI 查询服务
                InitialContext context = new InitialContext();
                service=context.queryService(jndiName);
                //若服务不为空
                if(service!=null) {
                    cache.addService(service);
                }
            }
            //返回服务
            return service;
        }
    }

步骤 6：使用 ServiceLocator 来演示服务定位器设计模式。

Main.java


    package com.dao.pattern.servicelocator.main;
    
    import com.dao.pattern.servicelocator.core.InitialContext;
    import com.dao.pattern.servicelocator.core.ServiceLocator;
    import com.dao.pattern.servicelocator.interfaces.Service;
    
    /**
     * 主程序入口
     *
     * @author 阿导
     * @version 1.0
     * @fileName com.dao.pattern.servicelocator.main.Main.java
     * @CopyRright (c) 2018-万物皆导
     * @created 2018-04-07 16:05:00
     */
    public class Main {
    
        /**
         * 主程序入口
         *
         * @author 阿导
         * @time 2018/4/7
         * @CopyRight 万物皆导
         * @param args
         * @return void
         */
        public static void main(String[] args){
            //第一次获取订单服务
            Service service= ServiceLocator.getService(InitialContext.ORDER_SERVICE);
            service.dealSomething();
            //第一次获取用户服务
            service=ServiceLocator.getService(InitialContext.USER_SERVICE);
            service.dealSomething();
            //第二次获取用户服务
            service= ServiceLocator.getService(InitialContext.ORDER_SERVICE);
            service.dealSomething();
            //第二次获取订单服务
            service=ServiceLocator.getService(InitialContext.USER_SERVICE);
            service.dealSomething();
        }
    
    }

步骤 7：验证输出。

    
    。。。。。尝试从缓存获取服务。。。。。
    查询到订单服务，并创建订单服务
    这里是定单服务，正在处理订单相关操作。
    。。。。。尝试从缓存获取服务。。。。。
    查询到用户服务，并创建用户服务
    这里是用户服务，正在处理用户相关操作。
    。。。。。尝试从缓存获取服务。。。。。
    这里是定单服务，正在处理订单相关操作。
    。。。。。尝试从缓存获取服务。。。。。
    这里是用户服务，正在处理用户相关操作。

需要云服务器的不要错过优惠

阿里云低价购买云服务，值得一看

万物皆导_
关注
专栏目录
三十六、服务定位器模式 (Service Locator Pattern)
qq_25843323的博客
01-25 1105
三十六、服务定位器模式 (Service Locator Pattern)
服务定位架构模式
天涯兰的博客
08-23 3043
1. 服务定位基本理念 系统集成（System Integration）是应用系统架构设计的一个重要课题，无论何种行业和应用，系统都可能需要集成对第三方服务的访问。这些第三方服务可能来自外部供应商，也可能来自于同一组织的不同团队，更广义上来讲，同一团队内部也可能需要进行服务的发现和整合，以便不同技术体系结构下的各个模块和组件之间的集成。 系统集成需要解决的主要问题是如何获取并管理第三方服务。第...
设计模式之服务定位器模式
最新发布
yimeixiaolangzai的博客
08-14 478
Service Locator Pattern 是一种设计模式，它提供了一个集中化的机制来获取应用程序中的服务实例。在该模式中，服务定位器（Service Locator）充当了一个注册表，负责管理和提供各种服务对象。这种模式通过延迟实例化（Lazy Instantiation）和依赖倒置（Dependency Inversion）来实现灵活的服务管理和获取。Service Locator Pattern 是一种用于管理和获取服务实例的强大设计模式，尤其适用于大型系统或复杂应用场景。
服务定位器模式（C++实现）
weixin_33681778的博客
07-10 113
原文链接：An Implementation of the Service Locator Pattern in C++ Service Locator 模式背后的基本思想是：有一个对象（即服务定位器）知道如何获得一个应用程序所需的所有服务。也就是说，在我们的例子中，服务定位器应该有一个方法，用于获得一个我们所需要的服务对象实例。从而将客户端代码和实际的实现代码解耦，用户可以在相同的接口上注册不...
requirejs-locate-plugin:通过使用 RequireJS 插件实现服务定位器模式
07-04
通过使用 RequireJS 插件实现服务定位器模式。 这允许请求服务的语义与请求模块融合。 在某种程度上，它是依赖项注入，其中依赖项通过代码即时注入，而不是通过配置声明。 用法 注册服务 'registry' 是一个保留的...
设计模式-服务器定位模式
11-16
服务器定位模式，也称为服务定位器模式，是设计模式的一种，它在iOS开发中扮演着重要的角色，特别是在处理服务请求和依赖注入时。这个模式的主要目标是提供一种方式来查找和管理应用程序中的服务实例。 服务定位器...
Java Service Locator Pattern(服务器定位模式)
mazaiting的博客
09-12 229
服务定位器模式（Service Locator Pattern）用在我们想使用 JNDI 查询定位各种服务的时候。考虑到为某个服务查找 JNDI 的代价很高，服务定位器模式充分利用了缓存技术。在首次请求某个服务时，服务定位器在 JNDI 中查找服务，并缓存该服务对象。当再次请求相同的服务时，服务定位器会在它的缓存中查找，这样可以在很大程度上提高应用程序的性...
设计模式-服务定位器模式
jike11231的博客
03-01 1186
设计模式-策略模式（服务定位器模式）
深度剖析Byteart Retail案例：服务定位器模式
DreamWeaver2015的博客
01-05 159
当系统中的组件需要调用某一服务来完成特定的任务时，通常最简单的做法是使用new关键字来创建该服务的实例，或者通过工厂模式来解耦该组件与服务的具体实现部分，以便通过配置信息等更为灵活的方式获得该服务的实例。然而，这些做法都有着各自的弊端： 在组件中直接维护对服务实例的引用，会造成组件与服务之间的关联依赖，当需要替换服务的具体实现时，不得不修改组件中调用服务的部分并重新编译解决方案；即...
设计模式【服务器定位模式Service Locator Pattern】
11-25 1811
服务定位器模式 服务定位器模式（Service Locator Pattern）用在我们想使用 JNDI 查询定位各种服务的时候。考虑到为某个服务查找 JNDI 的代价很高，服务定位器模式充分利用了缓存技术。在首次请求某个服务时，服务定位器在 JNDI 中查找服务，并缓存该服务对象。当再次请求相同的服务时，服务定位器会在它的缓存中查找，这样可以在很大程度上提高应用程序的性能。以下是这种设计模
php 服务定位,服务定位器模式（Service Locator）
weixin_33162568的博客
03-10 206
服务定位器模式被认为是一种反面模式！服务定位器模式被一些人认为是一种反面模式。它违反了依赖倒置原则。该模式隐藏类的依赖，而不是暴露依赖(如果暴露可通过依赖注入的方式注入依赖)。当某项服务的依赖发生变化时，使用该服务的类的功能将面临被破坏的风险，最终导致系统难以维护。4.2.1. 目的服务定位器模式能够降低代码的耦合度，以便获得可测试、可维护和可扩展的代码。DI 模式和服务定位器模式是 IOC 模式...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值