Implementors of this interface are strongly encouraged to extend {@link AbstractService}, {@link AbstractExecutionThreadService}, or {@link AbstractIdleService}, which make the threading and state management easier. @author Jesse Wilson @since Guava release 09 (in release 01 as{@code com.google.common.base.Service})
This class provides the base level common functionality required to access any GData service. It is also designed to act as a base class that can be customized for specific types of GData services. Examples of supported customizations include:
Starting with version 2.3.0, RPC implementations should not try to build on this, but should instead provide code generator plugins which generate code specific to the particular RPC implementation. This way the generated code can be more appropriate for the implementation in use and can avoid unnecessary layers of indirection. @author kenton@google.com Kenton Varda
RESTURLTreeHandlerMapping and mapped to a controller. Multiple URLs can be mapped to the same controller. A service can also be mapped to multiple methods depending on the HTTP request-method. Therefore, relationships between services, controllers and methods can be defined as:
Service (n) --- (1) Controller (1) (1) | | | | | (n) `---(HTTP)--- (n) MethodThis class maps a service to a single controller.
A {@code Service} instance also captures an optional namespace contextconsisting of an optional owner name (or "-" wildcard) and optional app name (or "-" wildcard).
To access {@code Service} members, the {@code Service} instance must beauthenticated by presenting credentials using the {@code login} method, orby constructing the {@code Service} instance using the {@code connect}method, which both creates and authenticates the instance.
A service will generally have some sort of socket it uses to talk to the outside world, and a threading scheme to handle reading in messages from clients and sending messages back out to clients Each service will also implement its own Connection interface.
On startup of an application, services are constructed (see details below). This provides access to the non-transactional core components of the system as well as the other {@code Service}s that have already been created. {@code Service}s are created in a known order based on dependencies: {@code DataService}, {@code WatchdogService}, {@code NodeMappingService}, {@code TaskService}, {@code ClientSessionService}, and the {@code ChannelManager}, finishing with any custom {@code Service}s ordered based on the application's configuration.
All implementations of {@code Service} must have a constructor withparameters of types {@code Properties}, {@code ComponentRegistry}, and {@code TransactionProxy}. This is how the {@code Service} is createdon startup. The {@code Properties} parameter provides application andservice-specific properties. The {@code ComponentRegistry} providesaccess to non-transactional kernel and system components like the {@code TransactionScheduler}. The {@code TransactionProxy} providesaccess to transactional state (when active) and the other available {@code Service}s. If any error occurs in creating a {@code Service}, the constructor may throw any {@code Exception}, causing the application to shutdown.
Note that {@code Service}s are not created in the context of a transaction. If a given constructor needs to do any work transactionally, it may do so by calling {@code TransactionScheduler.runTask}.
Title: Service
Description: Represents the service tier of this application
Copyright: Copyright (c) 2007
Company:
@author John Valentino II @version 1.0Service interface represents a centralized view of a JADE kernel-level service. Most JADE services are actually distributed, and each part of theirs, that is deployed at a given network node (container), is called service slice. The various slices of a service work together to carry out that service's task.
@author Giovanni Rimassa - FRAMeTech s.r.l.
Service objects provide the client view of a Web service. Service acts as a factory of the following:
The ports available on a service can be enumerated using the getPorts method. Alternatively, you can pass a service endpoint interface to the unary getPort method and let the runtime select a compatible port.
Handler chains for all the objects created by a Service can be set by means of a HandlerResolver.
An Executor may be set on the service in order to gain better control over the threads used to dispatch asynchronous callbacks. For instance, thread pooling with certain parameters can be enabled by creating a ThreadPoolExecutor and registering it with the service.
@since JAX-WS 2.0
@see javax.xml.ws.spi.Provider
@see javax.xml.ws.handler.HandlerResolver
@see java.util.concurrent.Executor
A service distinguishes itself from a shipment such that it has only one location. Thus a service is a single point in space (where a service-activity occurs).
Note that two services are equal if they have the same id. @author schroeder
Service represents some service of some kind with a simple start/stop lifecycle.
Represents the root of an Atom Publishing Protocol Introspection Document.
Per APP Draft-08:
The root of an introspection document is the "app:service" element. The "app:service" element is the container for introspection information associated with one or more workspaces. An app:service element MUST contain one or more app:workspace elements. appService = element app:service { appCommonAttributes, ( appWorkspace+ & extensionElement* ) }
A given JVM can contain any number of Service instances; however, they are completely independent of each other and share only the basic JVM facilities and classes on the system class path. @author Craig R. McClanahan @version $Id: Service.java 1058357 2011-01-12 23:49:18Z markt $
Service interface provides a simple abstraction for a Java Application running as a service (in UNIX words, a daemon). This interface can be considered as an extension of the common invocation mechanism used in Java of the main(String argv[]) method, and provides some extensions to it, allowing to perform certain operations that before were not possible to obtain, and commonly used in native services and daemons (such as user-id switching, signal and event handling and so on).
This interface and related classes are not intended to be used in other environment rather than low-level control of the VM environment and its lifecycle (JMX, and JSR-111 will provide those APIs), and must always be accompanied with a binary or wrapper that will be used instead of the usual java(.exe) invocator.
@author Pier Fumagalli, Sun Microsystems INC. @author Copyright © The Apache Software Foundation. String[] onProvideCompletionsFromMyField(String input) { return . . .; }
action(Path, InputData, OutputData) provide services based on the requests. As requests flow through the action they can be filtered, logged, enhanced via extending the InputData, provide custom routing etc. Service represents some service of some kind with a simple start/stop lifecycle.
The binding is then responsible for taking the SOAP Body and binding it to something - JavaBeans, XMLBeans, W3C DOM tree, etc.
The ServiceInfo represents all the metadata that goes along with the service.
@author Arjen Poutsma
@see ServiceInfo
@see org.codehaus.xfire.service.binding.SOAPBinding
This api is experimental and thus the classes and the interfaces returned are subject to change.
The following features are supported:
Service descriptors are identified by an id, version pair. Two service descriptors are considered equal if they have the same id, and version.
The underlying service implementation is a plain old java object, available via {@link #service}.
@author Justin Deoliveira, The Open Planning Project, jdeolive@openplans.orgThis is a published and supported CAS Server 3 API.
Service class provides the top level code generation functionality of Jostraca. This class is used by other classes which provide a code generation service and therefore provides the full functionality of Jostraca in a relatively complex API.
To use Jostraca as a component, try the {@link org.jostraca.Generator} class, which is easier to use than Service.
Service is the internal representation of a Mule Managed service. It is responsible for managing the interaction of events to and from the service as well as managing pooled resources.
WFS wfs = new WFS(dto); Service serv = (Service)WFS; System.out.println(serv.getName());
@author Gabriel Rold�n @author Chris Holmes @version $Id: Service.java,v 1.7 2004/02/09 23:29:42 dmzwiers Exp $ @see WMS @see WFSService interface provides an extension mechanism for Collection implementations. It is to be implented by Service instances that define their own set of methods to perform the necessary action. For an example of what a functional Service interface should look like look at XPathQueryService.
@see org.xmldb.api.modules.XPathQueryService
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |