自定义服务时服务的启动顺序

在实现自定义服务时，我们很可能会依赖其它服务或核心服务，在这种情况下，要求自定义服务的启动必须在依赖服务启动之后。例如我们在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   } 

 

 

 

转载于:https://www.cnblogs.com/cuizhf/archive/2011/08/23/2150235.html