zoukankan      html  css  js  c++  java
  • 自定义服务时服务的启动顺序

    在实现自定义服务时,我们很可能会依赖其它服务或核心服务,在这种情况下,要求自定义服务的启动必须在依赖服务启动之后。例如我们在ResolverService服务之上实现自己的服务,就是说我们的服务要使用ResolverService来实现自己的功能。
    那么在自定义服务的
    java 代码
    public int startApp(String[] args) {  
        
    // Now that the service is being started, set the ResolverService  
        
    // object to use handle our queries and send responses.  
        resolver = peerGroup.getResolverService();  
        
    if(resolver == null) {  
            
    return Module.START_AGAIN_PROGRESS;  
        }  
        
    // Add ourselves as a handler using the uniquely constructed  
        
    // handler name.  
        resolver.registerHandler(handlerName, this);  
        
    return Module.START_OK;  

    通过上述代码判断,如果resolver的值为null,那么说明ResolverService还没有初始化,我们返回Module.START_AGAIN_PROGRESS,表示我们的服务还需要再次初始化。如果resolver的值不为null,那么说明ResolverService已经初始化,我们返回Module.START_OK,即可。其它依赖服务与此类似。

    下面的Module接口中对几个常量进行了说明,可以看出Module.START_AGAIN_PROGRESS与Module.START_AGAIN_STALLED的含义基本相同。

    java 代码
      1  /* 
      2   * Copyright (c) 2001-2007 Sun Microsystems, Inc.  All rights reserved. 
      3   *   
      4   *  The Sun Project JXTA(TM) Software License 
      5   *   
      6   *  Redistribution and use in source and binary forms, with or without  
      7   *  modification, are permitted provided that the following conditions are met: 
      8   *   
      9   *  1. Redistributions of source code must retain the above copyright notice, 
     10   *     this list of conditions and the following disclaimer. 
     11   *   
     12   *  2. Redistributions in binary form must reproduce the above copyright notice,  
     13   *     this list of conditions and the following disclaimer in the documentation  
     14   *     and/or other materials provided with the distribution. 
     15   *   
     16   *  3. The end-user documentation included with the redistribution, if any, must  
     17   *     include the following acknowledgment: "This product includes software  
     18   *     developed by Sun Microsystems, Inc. for JXTA(TM) technology."  
     19   *     Alternately, this acknowledgment may appear in the software itself, if  
     20   *     and wherever such third-party acknowledgments normally appear. 
     21   *   
     22   *  4. The names "Sun", "Sun Microsystems, Inc.", "JXTA" and "Project JXTA" must  
     23   *     not be used to endorse or promote products derived from this software  
     24   *     without prior written permission. For written permission, please contact  
     25   *     Project JXTA at http://www.jxta.org
     26   *   
     27   *  5. Products derived from this software may not be called "JXTA", nor may  
     28   *     "JXTA" appear in their name, without prior written permission of Sun. 
     29   *   
     30   *  THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES, 
     31   *  INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND  
     32   *  FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SUN  
     33   *  MICROSYSTEMS OR ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,  
     34   *  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT  
     35   *  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,  
     36   *  OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF  
     37   *  LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING  
     38   *  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,  
     39   *  EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
     40   *   
     41   *  JXTA is a registered trademark of Sun Microsystems, Inc. in the United  
     42   *  States and other countries. 
     43   *   
     44   *  Please see the license information page at : 
     45   *  <http://www.jxta.org/project/www/license.html> for instructions on use of  
     46   *  the license in source files. 
     47   *   
     48   *  ==================================================================== 
     49   *   
     50   *  This software consists of voluntary contributions made by many individuals  
     51   *  on behalf of Project JXTA. For more information on Project JXTA, please see  
     52   *  http://www.jxta.org
     53   *   
     54   *  This license is based on the BSD license adopted by the Apache Foundation.  
     55   */  
     56    
     57  package net.jxta.platform;  
     58    
     59    
     60  import net.jxta.peergroup.PeerGroup;  
     61  import net.jxta.document.Advertisement;  
     62  import net.jxta.id.ID;  
     63  import net.jxta.exception.PeerGroupException;  
     64    
     65    
     66  /** 
     67   * Defines the interface for modules loaded by PeerGroups. Message transports, 
     68   * services and applications need to implement this interface if they are 
     69   * to be loaded and started by a PeerGroup. Service and Application extend 
     70   * Module, PeerGroup implements Service and ShellApp implements Application, as 
     71   * a result both implement Module. 
     72   * 
     73   * <p/>Jxta Modules are given their initialization parameters via the init() 
     74   * method rather than a non-default constructor. 
     75   * 
     76   * <p/>Modules are passed the peer group within which they are created. 
     77   * From the peergroup object, Modules can access all the peer group 
     78   * services. The PeerGroup within which a PeerGroup runs is known as its 
     79   * parent. 
     80   * 
     81   * <p/>The initial root peer group is known as the World Peer Group and is 
     82   * implemented by an object of class Platform, a subclass of PeerGroup. 
     83   * The "parent" PeerGroup of the World Peer Group is null. 
     84   * 
     85   * @see net.jxta.protocol.ModuleImplAdvertisement 
     86   * @see net.jxta.platform.ModuleClassID 
     87   * @see net.jxta.peergroup.PeerGroup 
     88   * @see net.jxta.document.Advertisement 
     89   * @see net.jxta.id.ID 
     90   * @see net.jxta.platform.Application 
     91   * @see net.jxta.service.Service 
     92   **/  
     93  public interface Module {  
     94        
     95      /** 
     96       * <code>startApp()</code> completed successfully. This module claims to now 
     97       * be fully functional and no further invocation of startApp is required. 
     98       **/  
     99      public static final int START_OK = 0;  
    100        
    101      /** 
    102       * This is to be used mostly by co-dependent services when started as 
    103       * a set (such as {@link PeerGroup} services) so that their 
    104       * <code>startApp()</code> method may be invoked multiple times. 
    105       * 
    106       * <p/>This value indicates that startApp must be retried later in order for 
    107       * this module to become fully functional. However, some progress in 
    108       * functionality was accomplished. 
    109       * 
    110       * <p/>This is a strong indication that some other modules may be able 
    111       * to advance or complete their initialization if their 
    112       * <code>startApp()</code> method is invoked again. 
    113       * 
    114       * <p/>The distinction between START_AGAIN_STALLED and START_AGAIN_PROGRESS 
    115       * is only a hint. Each module makes an arbitrary judgment in this 
    116       * respect. It is up to the invoker of startApp to ensure that the 
    117       * starting of a set of modules eventually succeeds or fails. 
    118       **/  
    119      public static final int START_AGAIN_PROGRESS = 1;  
    120        
    121      /** 
    122       * This is to be used mostly by co-dependent services when started as 
    123       * a set (such as {@link PeerGroup} services) so that their startApp 
    124       * method may be invoked multiple times. 
    125       * 
    126       * <p/>This value indicates that startApp must be retried later in order for 
    127       * this module to become fully functional. However, some progress in 
    128       * functionality was accomplished. 
    129       * 
    130       * <p/>If all modules in a set return this value, it is a strong indication 
    131       * that the modules co-dependency is such that it prevents them 
    132       * collectively from starting. 
    133       * 
    134       * <p/>The distinction between START_AGAIN_STALLED and START_AGAIN_PROGRESS 
    135       * is only a hint. Each module makes an arbitrary judgment in this 
    136       * respect. It is up to the invoker of startApp to ensure that the 
    137       * starting of a set of modules eventually succeeds or fails. 
    138       **/  
    139      public static final int START_AGAIN_STALLED = 2;  
    140            
    141      /** 
    142       * This return result is used to indicate that the module refuses to start 
    143       * because it has been configured to be disabled or otherwise cannot run 
    144       * (missing hardware, missing system resources, etc.) The module will not be 
    145       * functional and should be discarded but the failure to load may be ignored  
    146       * by the loader at it's discretion. 
    147       */  
    148      public static final int START_DISABLED = Integer.MIN_VALUE + 100;  
    149        
    150      /** 
    151       * Initialize the module, passing it its peer group and advertisement. 
    152       * 
    153       * <p/>Note: when subclassing one of the existing PeerGroup implementations 
    154       * (which implement Module), it may not be recommended to overload the init 
    155       * method. See the documentation of the PeerGroup class being subclassed. 
    156       * 
    157       *  @param group The PeerGroup from which this Module can obtain services. 
    158       *  If this module is a Service, this is also the PeerGroup of which this 
    159       *  module is a service. 
    160       * 
    161       *  @param assignedID Identity of Module within group. 
    162       *  modules can use it as a the root of their namespace to create 
    163       *  names that are unique within the group but predictable by the 
    164       *  same module on another peer. This is normally the ModuleClassID 
    165       *  which is also the name under which the module is known by other 
    166       *  modules. For a group it is the PeerGroupID itself. 
    167       *  The parameters of a service, in the Peer configuration, are indexed 
    168       *  by the assignedID of that service, and a Service must publish its 
    169       *  run-time parameters in the Peer Advertisement under its assigned ID. 
    170       * 
    171       *  @param implAdv The implementation advertisement for this 
    172       *  Module. It is permissible to pass null if no implementation 
    173       *  advertisement is available. This may happen if the 
    174       *  implementation was selected by explicit class name rather than 
    175       *  by following an implementation advertisement. Modules are not 
    176       *  required to support that style of loading, but if they do, then 
    177       *  their documentation should mention it. 
    178       * 
    179       *  @exception PeerGroupException This module failed to initialize. 
    180       **/  
    181      public void init(PeerGroup group, ID assignedID, Advertisement implAdv) throws PeerGroupException;  
    182        
    183      /** 
    184       * Complete any remaining initialization of the module. The module should 
    185       * be fully functional after <code>startApp()</code> is completed. That is 
    186       * also the opportunity to supply arbitrary arguments (mostly to 
    187       * applications). 
    188       * 
    189       * <p/>If this module is a {@link PeerGroup} service, it may be invoked 
    190       * several times depending on its return value. 
    191       * 
    192       * @param args An array of Strings forming the parameters for this 
    193       * Module. 
    194       * 
    195       * @return int A status indication which may be one of 
    196       * {@link #START_OK}, {@link #START_AGAIN_PROGRESS}, 
    197       * {@link #START_AGAIN_STALLED}, which indicates partial or complete 
    198       * success, or any other value (negative values are 
    199       * recommended for future compatibility), which indicates failure. 
    200       **/  
    201      public int startApp(String[] args);  
    202        
    203      /** 
    204       *  Stop a module. This may be called any time after <code>init()</code> 
    205       *  completes and should not assume that <code>startApp()</code> has been 
    206       *  called or completed. 
    207       * 
    208       *  <p/>The Module cannot be forced to comply, but in the future 
    209       *  we might be able to deny it access to anything after some timeout. 
    210       **/  
    211      public void stopApp();  
    212  } 

  • 相关阅读:
    查看资源加载各环节具体耗时的利器
    WebStorm 格式化代码快捷键
    Android 如何使edittext默认失去焦点
    html语义化练习易牛课堂代码
    html网页练习豆瓣网
    HTML前期学习总结
    视频课阶段基础知识总结
    MQ、JMS 关系的理解
    Jvm参数配置
    Java泛型
  • 原文地址:https://www.cnblogs.com/cuizhf/p/2150235.html
Copyright © 2011-2022 走看看