jdk8-mips64-public/jaxws: src/share/jaxws_classes/com/sun/xml/internal/ws/api/server/LazyMOMProvider.java@0989ad8c0860 (annotated)

src/share/jaxws_classes/com/sun/xml/internal/ws/api/server/LazyMOMProvider.java@0989ad8c0860 (annotated)

src/share/jaxws_classes/com/sun/xml/internal/ws/api/server/LazyMOMProvider.java

Tue, 09 Apr 2013 14:51:13 +0100

author: alanb
date: Tue, 09 Apr 2013 14:51:13 +0100
changeset 368: 0989ad8c0860
parent 286: f50545b5e2f1
child 637: 9c07ef4934dd
permissions: -rw-r--r--

8010393: Update JAX-WS RI to 2.2.9-b12941
Reviewed-by: alanb, erikj
Contributed-by: miroslav.kos@oracle.com, martin.grebac@oracle.com

 /*
  * Copyright (c) 2011, 2012, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License version 2 only, as
  * published by the Free Software Foundation.  Oracle designates this
  * particular file as subject to the "Classpath" exception as provided
  * by Oracle in the LICENSE file that accompanied this code.
  *
  * This code is distributed in the hope that it will be useful, but WITHOUT
  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  * version 2 for more details (a copy is included in the LICENSE file that
  * accompanied this code).
  *
  * You should have received a copy of the GNU General Public License version
  * 2 along with this work; if not, write to the Free Software Foundation,
  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  *
  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  * or visit www.oracle.com if you need additional information or have any
  * questions.
  */
 package com.sun.xml.internal.ws.api.server;
 import com.sun.xml.internal.ws.server.WSEndpointImpl;
 import java.util.HashSet;
 import java.util.Set;
 import com.sun.org.glassfish.external.amx.AMXGlassfish;
 import com.sun.org.glassfish.external.amx.MBeanListener;
 import com.sun.org.glassfish.gmbal.ManagedObjectManager;
 /**
  * The lazy provider is intended to defer Gmbal API calls until there is a JMX connection. The provider is scope
  * (environment) aware and behaves accordingly to actual scope. The default behaviour does not defers Gmbal API calls.
  *
  * There are two kind of method allowing registration of an object as a listener. One is for {@code WSEndpointImpl}
  * instances (implementing {@code WSEndpointScopeChangeListener}) and the other is for arbitrary objects
  * (implementing {@code DefaultScopeChangeListener}) that want to be notified about scope changes. The distinction is made
  * because of the fact that endpoints should be registered first and other objects (e.g. dependants on endpoints) must
  * be registered after all the endpoints are processed so no inconsistency is present.
  *
  * Glassfish:
  * {@link WebServicesContainer} is one of two classes for which a {@link ManagedObjectManager} instance (see Gmbal API)
  * is created when a webservice application is deployed into the Glassfish. For the purpose of postponing Gmbal API calls
  * the {@code WebServicesContainer} extends {@link MBeanListener.CallbackImpl} so it can register itself as a listener of
  * {@link AMXGlassfish} and receive a notification about a connection of a JMX client to the Glassfish server (see
  * {@code WebServicesContainer#postConstruct} for registration details). The moment the JMX client is connected a notification
  * is sent to the listeners of {@code AMXGlassfish}. When this event is received by {@code WebServiceContainer} (see the
  * callback method {@code mbeanRegistered}) a {@code ManagedObjectManager} instance is created and no further deferring
  * of Gmbal API calls is needed.
  *
  * Metro/JAX-WS:
  * The situation in Metro/JAX-WS is slightly different from the one described above. Metro/JAX-WS can be used as standalone
  * libraries (outside of Glassfish) so no notification from the Glassfish server can be expected in this case. This leads
  * to a situation when Metro/JAX-WS has to be aware of context in which it is used and acts appropriately. There are 3
  * scopes an application using Metro/JAX-WS can be in: {@code STANDALONE}, {@code GLASSFISH_NO_JMX}, {@code GLASSFISH_JMX}
  * ({@link LazyMOMProvider#scope}). The default scope is {@code STANDALONE} and all Gmbal API calls are invoked as they
  * are requested. The other two scopes are applied only when an application is deployed into a Glassfish server. The
  * {@code GLASSFISH_NO_JMX} is set at the moment the application is deployed (see below) and its purpose is to defer Gmbal
  * API calls for as long as possible. For some classes e.g. {@code ManagedObjectManager} proxy classes were introduced to
  * avoid the necessity of creating the real Gmbal objects but if a method is invoked on these proxies the creation of real
  * Gmbal objects is forced even in this scope. The {@code GLASSFISH_JMX} scope is set when a JMX client is connected to
  * the Glassfish server and it processes Gmbal API calls without deferring (as if the application was in the
  * {@code STANDALONE} scope). The entry point for postponing the Gmbal API calls / creating Gmbal objects in Metro/JAX-WS
  * is {@link LazyMOMProvider}. This class is capable of receiving notifications from the Glassfish server
  * ({@code LazyMOMProvider.initMOMForScope}) about the scope change and it also spread this information to its listeners.
  * The listeners of {@code LazyMOMProvider} are of two kinds: {@link LazyMOMProvider.WSEndpointScopeChangeListener} and
  * {@link LazyMOMProvider.DefaultScopeChangeListener}. Extensions of {@link WSEndpoint} (e.g. {@link WSEndpointImpl})
  * should implement the {@code LazyMOMProvider.WSEndpointScopeChangeListener} and register themselves as endpoint listeners
  * of {@code LazyMOMProvider}. Other classes should implement the latter mentioned interface and register themselves as
  * a non-endpoint listener. The differences between these two kind of listeners are described in {@code LazyMOMProvider}
  * class comment. An implementation of {@code LazyMOMProvider.DefaultScopeChangeListener} is provided in Metro
  * ({@link WSEndpointCollectionBasedMOMListener}). As mentioned above this listener register itself as a non-endpoint
  * listener of {@code LazyMOMProvider} ({@code WSEndpointCollectionBasedMOMListener.init}). An instance of this class is
  * used in these factories: {@link SessionManager}, {@link NonceManager} and {@link SequenceManagerFactory}.
  * {@code SessionManager}, {@code NonceManager}, {@code PersistentSequenceManager} and {@code InVmSequenceManager} also
  * (indirectly) implement {@link MOMRegistrationAware} for providing information whether a manager is registered at
  * {@code ManagedObjectManager} or not. Registration of a manager at {@code ManagedObjectManager} can be processed directly
  * (if {@code WSEndpointCollectionBasedMOMListener.canRegisterAtMOM} returns {@code true}) via
  * {@code WSEndpointCollectionBasedMOMListener.registerAtMOM} or is deferred by putting the manager into
  * {@code WSEndpointCollectionBasedMOMListener.registrationAwareMap}. Managers stored in for deferred registration are
  * processed at the moment the {@code LazyMOMProvider} notifies the {@code WSEndpointCollectionBasedMOMListener} about
  * the scope change.
  * The mentioned postponing of Gmbal API calls applies only to the server side of the webservice application.
  */
 public enum LazyMOMProvider {
     INSTANCE;
     /**
      * Possible scopes (environments) in which the provider (and object associated with it) could be in.
      * Default scope is STANDALONE - applied during initialization of classes. For now, only possible scope change for a
      * object can be in this direction: STANDALONE -> GLASSFISH_NO_JMX -> GLASSFISH_JMX.
      */
     public static enum Scope {
         //** Default scope where lazy flag is not applied and all Gmbal API calls are processed immediately. */
         STANDALONE,
         /** In this scope almost all Gmbal API call are deferred until a JMX connection to a Glassfish server is created */
         GLASSFISH_NO_JMX,
         /** Same as STANDALONE. Gmbal API calls are processed immediately. */
         GLASSFISH_JMX
     }
     /**
      * Interface for all object that want to be notified about scope change, introducing required methods.
      */
     public static interface ScopeChangeListener {
         void scopeChanged(Scope scope);
     }
     /**
      * Default interface for all object that want to be notified about scope change. This interface should not be
      * implemented directly.
      */
     public static interface DefaultScopeChangeListener extends ScopeChangeListener {
     }
     /**
      * Interface used for distinguishing between a registration of a WSEndpointImpl rather than of other classes.
      * Webservice Endpoints should get a notification about scope change sooner than the rest of the registered listeners
      * (there is a possibility that other listeners are dependant on Webservice Endpoints).
      */
     public static interface WSEndpointScopeChangeListener extends ScopeChangeListener {
     }
     private final Set<WSEndpointScopeChangeListener> endpointsWaitingForMOM = new HashSet<WSEndpointScopeChangeListener>();
     private final Set<DefaultScopeChangeListener> listeners = new HashSet<DefaultScopeChangeListener>();
     private volatile Scope scope = Scope.STANDALONE;
     /**
      * Initializes this provider with a given scope. If the given scope is different than the one this provider is
      * currently in and the transition between scopes is valid then a event is fired to all registered listeners.
      *
      * @param scope a scope to initialize this provider with
      */
     public void initMOMForScope(LazyMOMProvider.Scope scope) {
         // cannot go backwards between scopes, for possible scope changes see #Scope
         if ((this.scope == Scope.GLASSFISH_JMX)
                 || (scope == Scope.STANDALONE && (this.scope == Scope.GLASSFISH_JMX || this.scope == Scope.GLASSFISH_NO_JMX))
                 || this.scope == scope) {
             return;
         }
         this.scope = scope;
         fireScopeChanged();
     }
     /**
      * Notifies the registered listeners about the scope change.
      */
     private void fireScopeChanged() {
         for (ScopeChangeListener wsEndpoint : endpointsWaitingForMOM) {
             wsEndpoint.scopeChanged(this.scope);
         }
         for (ScopeChangeListener listener : listeners) {
             listener.scopeChanged(this.scope);
         }
     }
     /**
      * Registers the given object as a listener.
      *
      * @param listener a listener to be registered
      */
     public void registerListener(DefaultScopeChangeListener listener) {
         listeners.add(listener);
         if (!isProviderInDefaultScope()) {
             listener.scopeChanged(this.scope);
         }
     }
     /**
      * Returns {@code true} if this provider is in the default scope.
      *
      * @return {@code true} if this provider is in the default scope,
      *          {@code false} otherwise
      */
     private boolean isProviderInDefaultScope() {
         return this.scope == Scope.STANDALONE;
     }
     public Scope getScope() {
         return scope;
     }
     /**
      * Registers a Webservice Endpoint as a listener.
      * Webservice Endpoints should rather register through this method than through LazyMOMProvider#registerListener
      * because generally they need to be notified sooner than arbitrary listener (i.e. object that is dependant on
      * Webservice Endpoint)
      *
      * @param wsEndpoint a Webservice Endpoint to be registered
      */
     public void registerEndpoint(WSEndpointScopeChangeListener wsEndpoint) {
         endpointsWaitingForMOM.add(wsEndpoint);
         if (!isProviderInDefaultScope()) {
             wsEndpoint.scopeChanged(this.scope);
         }
     }
     /**
      * Unregisters a Webservice Endpoint from the list of listeners.
      *
      * @param wsEndpoint a Webservice Endpoint to be unregistered
      */
     public void unregisterEndpoint(WSEndpointScopeChangeListener wsEndpoint) {
         endpointsWaitingForMOM.remove(wsEndpoint);
     }
 }

Mercurial > jdk8-mips64-public > jaxws / annotate

src/share/jaxws_classes/com/sun/xml/internal/ws/api/server/LazyMOMProvider.java@0989ad8c0860 (annotated)

src/share/jaxws_classes/com/sun/xml/internal/ws/api/server/LazyMOMProvider.java