Examples of handle()

• br.com.caelum.brutauth.auth.handlers.RuleHandler.handle()
• br.com.caelum.stella.gateway.visa.VISAVerificacaoRetornoIntegracaoViaHttp.handle()
  @return RetornoIntegracao @throws ProblematicTransactionException caso a resposta não contenha código válido.
• by.stub.handlers.strategy.StubResponseHandlingStrategy.handle()
• by.stub.handlers.strategy.admin.AdminResponseHandlingStrategy.handle()
• by.stub.handlers.strategy.stubs.StubResponseHandlingStrategy.handle()
• cascading.lingual.common.Target.handle()
• cleo.search.util.TermsDedup.handle()
• com.adito.boot.RequestHandler.handle()
  Handle a request @param pathInContext path extracted from the HTTP method line @param pathParams paramters passed @param request request object @param response response object @return handled true if this handler handled te request @throws RequestHandlerException on any exception associated with the handling of the request @throws IOException on any input / output error
• com.alibaba.dubbo.remoting.http.HttpHandler.handle()
  invoke. @param request request. @param response response. @throws IOException @throws ServletException
• com.comphenix.protocol.events.PacketOutputHandler.handle()
  Invoked when a given packet is to be written to the output stream.

  Note that the buffer is initially filled with the output from the default write method.

  In Minecraft 1.6.4, the header is always excluded, whereas it MUST be included in Minecraft 1.7.2. Call {@link NetworkMarker#requireOutputHeader()} to determine this. @param event - the packet that will be outputted. @param buffer - the data that is currently scheduled to be outputted. @return The modified byte array to write. NULL is not permitted.

• com.dodo.blog.ui.ajax.IAjaxRequestHandler.handle()
• com.ebay.erl.mobius.core.model.ReadFieldImpl.handle()
• com.ebay.erl.mobius.core.model.WriteImpl.handle()
• com.glines.socketio.server.Transport.handle()
• com.google.jstestdriver.servlet.fileset.BrowserFileCheck.handle()
• com.google.jstestdriver.servlet.fileset.TestCaseUpload.handle()
• com.granule.utils.OptionsHandler.handle()
• com.hazelcast.client.spi.EventHandler.handle()
• com.hazelcast.nio.SelectionHandler.handle()
• com.hazelcast.nio.tcp.SelectionHandler.handle()
• com.headius.invokebinder.SmartHandle.handle()
  Get the MethodHandle of this SmartHandle. @return the MethodHandle of this SmartHandle
• com.jamieallen.sdisruptor.ExceptionHandler.handle()
• com.jamieallen.sdisruptor.FatalExceptionHandler.handle()
• com.jamieallen.sdisruptor.IgnoreExceptionHandler.handle()
• com.jetdrone.vertx.yoke.Middleware.handle()
  the error is null, then the chain will execute // the next Middleware until the chain is complete, // when that happens a 404 error is returned since no // middleware was found that could handle the request. next.handle(null); } } @param request A YokeRequest which in practice is a extended HttpServerRequest @param next The callback to inform that the next middleware in the chain should be used. A value different fromnull represents an error and in that case the error handler middleware will be executed.
• com.lyncode.xoai.dataprovider.OAIDataProvider.handle()
• com.mysema.query.jdo.JDOQLSerializer.handle()
• com.mysema.query.sql.SQLSerializer.handle()
• com.nardoz.restopengov.ckan.CkanActorHandler.handle()
• com.nardoz.restopengov.standalone.StandaloneActorHandler.handle()
• com.noelios.restlet.http.HttpServerHelper.handle()
  Handles the connector call.
  The default behavior is to create an REST call and delegate it to the attached Restlet. @param httpCall The HTTP server call.
• com.onpositive.gae.baseviewer.taskqueuehandlers.AbstractHandler.handle()
• com.redhat.rcm.maven.plugin.buildmetadata.io.AdditionalLocationsSupport.handle()
  Handles the given file to be copied to the configured locations. @param file the file to copy. @throws MojoExecutionException on any copy problem.
• com.salesforce.ide.core.remote.tooling.ContainerAsyncRequestMessageHandler.handle()
• com.sun.enterprise.jbi.serviceengine.bridge.transport.JBIAdapter.handle()
• com.sun.grid.security.login.TextCallbackHandler.handle()
  Handles the specified set of callbacks. @param callbacks the callbacks to handle @throws IOException if an input or output error occurs. @throws UnsupportedCallbackException if the callback is not aninstance of NameCallback or PasswordCallback
• com.sun.jersey.api.client.Client.handle()
• com.sun.security.auth.callback.DialogCallbackHandler.handle()
  Handles the specified set of callbacks. @param callbacks the callbacks to handle @throws UnsupportedCallbackException if the callback is not aninstance of NameCallback or PasswordCallback
• com.sun.security.auth.callback.TextCallbackHandler.handle()
  Handles the specified set of callbacks. @param callbacks the callbacks to handle @throws IOException if an input or output error occurs. @throws UnsupportedCallbackException if the callback is not aninstance of NameCallback or PasswordCallback
• com.sun.xml.rpc.spi.runtime.Handler.handle()
• com.sun.xml.rpc.spi.runtime.Tie.handle()
• com.sun.xml.ws.server.Tie.handle()
• com.sun.xml.ws.transport.http.servlet.ServletAdapter.handle()
  Version of {@link #handle(WSHTTPConnection)}that takes convenient parameters for servlet. @param context Servlet Context @param request Servlet Request @param response Servlet Response @throws IOException when there is i/o error in handling request
• com.taobao.tddl.dbsync.binlog.LogDecoder.handle()
• com.taobao.zeus.web.platform.client.util.place.PlaceHandler.handle()
• com.tuenti.supernanny.cli.handlers.CliHandler.handle()
• com.vtence.molecule.lib.Middleware.handle()
• com.vtence.molecule.routing.Route.handle()
• de.anomic.crawler.CrawlProfile.handle()
  Gets handle of the CrawlProfile. @return handle of the profile
• de.netseeker.ejoe.handler.ServerHandler.handle()
  Handles a client request @param obj The input object transported by EJOE @return null or an valid return value. If you want return custom datatypes, eg. your own beans and don't want (orare not able) to deploy the classes of these datatypes on the client you can turn on EJOEs remote classloading feature.
• eu.medsea.mimeutil.handler.TextMimeHandler.handle()
  All TextMimeHandler(s) will have this method that has a chance to re-handle what the TextMimeDetector has decided @param mimeType what the current TextMimeType looks like i.e. it'scurrent MimeType and encoding @param content is the actual text you can use to better determine what this text really is @return if true is returned then no more registered TextMimeHandler(s) will fire after this.false means that the next registered TextMimeHandler in the list gets a chance to also change the MimeType and encoding.
• gnu.javax.security.auth.callback.DefaultCallbackHandler.handle()
• groovyx.remote.transport.http.RemoteControlHttpHandler.handle()
• io.socket.implementor.transport.Transport.handle()
• javax.faces.context.ExceptionHandler.handle()
• javax.security.auth.callback.CallbackHandler.handle()
• match.handler.MatchHandler.handle()
• mondrian.rolap.SqlStatement.handle()
  Handles an exception thrown from the ResultSet, implicitly calls {@link #close}, and returns an exception which includes the full stack, including a description of the high-level operation. @param e Exception @return Runtime exception
• net.fortytwo.twitlogic.persistence.TweetPersister.handle()
• net.fortytwo.twitlogic.syntax.TweetAnnotator.handle()
• net.sf.jasperreports.engine.export.data.TextValue.handle()
• net.sf.jasperreports.engine.export.data.TextValueHandler.handle()
• net.sf.jpluck.handlers.ContentHandler.handle()
• net.sf.urlchecker.exception.handling.ExceptionHandler.handle()
  Handle. @param method the method @param exception the exception @param retryCount the retry count @return true, if successful @param < T> a T object.
• net.socialgamer.cah.handlers.Handler.handle()
  Handle a request. @param request The request parameters. @param session The client's session. @return Response data.
• net.solosky.maplefetion.client.NotifyHandler.handle()
  处理消息 @param message 消息对象 @throws FetionException
• net.solosky.maplefetion.client.ResponseHandler.handle()
  处理消息 @param message 消息对象 @throws FetionException
• org.apache.activemq.transport.xmpp.command.Handler.handle()
• org.apache.camel.model.TryDefinition.handle()
  Handles the given exception @param exceptionType the exception @return the try builder
• org.apache.camel.model.TryType.handle()
• org.apache.clerezza.triaxrs.JaxRsHandler.handle()
• org.apache.cocoon.Engine.handle()
  This method is called to start the processing when calling the engine from the Cocoon servlet.
• org.apache.commons.dbutils.ResultSetHandler.handle()
  Turn the ResultSet into an Object. @param rs The ResultSet to handle. It has not been touchedbefore being passed to this method. @return An Object initialized with ResultSet data. It islegal for implementations to return null if the ResultSet contained 0 rows. @throws SQLException
• org.apache.felix.httplite.osgi.ServiceRegistrationHandler.handle()
  Process the request against the registered provider. @param closeConnection if true close connection after handling request @throws IOException on I/O error @throws ServletException on Servlet error
• org.apache.hadoop.hbase.security.HBaseSaslRpcClient.SaslClientCallbackHandler.handle()
• org.apache.hadoop.mapred.MapTaskAttemptImpl.handle()
• org.apache.hadoop.mapreduce.v2.app.job.impl.MapTaskImpl.handle()
• org.apache.hadoop.yarn.event.EventHandler.handle()
• org.apache.hadoop.yarn.server.nodemanager.containermanager.AuxServices.handle()
• org.apache.hadoop.yarn.server.nodemanager.containermanager.application.Application.handle()
• org.apache.hadoop.yarn.server.nodemanager.containermanager.container.Container.handle()
• org.apache.hadoop.yarn.server.nodemanager.containermanager.localizer.LocalizedResource.handle()
• org.apache.hadoop.yarn.server.resourcemanager.rmapp.RMApp.handle()
• org.apache.hadoop.yarn.server.resourcemanager.rmapp.RMAppImpl.handle()
• org.apache.hadoop.yarn.server.resourcemanager.rmapp.attempt.RMAppAttempt.handle()
• org.apache.hadoop.yarn.server.resourcemanager.rmcontainer.RMContainer.handle()
• org.apache.hadoop.yarn.server.resourcemanager.rmcontainer.RMContainerImpl.handle()
• org.apache.hadoop.yarn.server.resourcemanager.rmnode.RMNodeImpl.handle()
• org.apache.hadoop.yarn.server.resourcemanager.scheduler.ResourceScheduler.handle()
• org.apache.hadoop.yarn.server.resourcemanager.scheduler.fifo.FifoScheduler.handle()
• org.apache.http.protocol.HttpRequestHandler.handle()
• org.apache.jmeter.protocol.mongodb.mongo.EvalResultHandler.handle()
• org.apache.mina.statemachine.StateMachine.handle()
  Processes the specified {@link Event} through this {@link StateMachine}. Normally you wouldn't call this directly but rather use {@link StateMachineProxyBuilder} to create a proxy for an interface ofyour choice. Any method calls on the proxy will be translated into {@link Event} objects and then fed to the {@link StateMachine} by theproxy using this method. @param event the {@link Event} to be handled.
• org.apache.olingo.odata2.api.ODataDebugResponseWrapperCallback.handle()
  Handles the output of a response helpful in case of debugging. @param context generic context information @param request the original request @param response the original response @param uriInfo structured parts of the request URI @param exception the exception in case of an error @return the debug response
• org.apache.olingo.odata2.core.ODataRequestHandler.handle()

  Handles the {@link ODataRequest} in a way that it results in a corresponding {@link ODataResponse}.

  This includes delegation of URI parsing and dispatching of the request internally. Building of the {@link ODataContext} takes place outside of this method.

  @param request the incoming request @return the corresponding result
• org.apache.qpid.framing.AMQBody.handle()
• org.apache.qpid.server.store.handler.ConfiguredObjectRecordHandler.handle()
  Handles the given record. @param record @return false is returned if the handler does not wish to handle other record, true otherwise
• org.apache.qpid.server.store.handler.MessageHandler.handle()
• org.apache.rahas.impl.util.SAMLCallbackHandler.handle()
  eve required data from the RahasData inside SAMLAttributeCallback \//Add your SAMLAttributes to the attrCallback here. } @param callback @throws SAMLException
• org.apache.spark.network.client.TransportResponseHandler.handle()
• org.apache.tapestry.services.ComponentActionRequestHandler.handle()
  Handler for a component action request, which returns a response generator used to send the final response to the client. @param logicalPageName the page name containing the component, and the default component to render the response @param nestedComponentId the id of the component within the page @param eventType the type of event to trigger on the component @param context context information to provide to the event handler @parram activationContext activation context for the page
• org.apache.tapestry5.services.PageRenderRequestHandler.handle()
  Invoked to activate and render a page. In certain cases, based on values returned when activating the page, a {@link org.apache.tapestry5.services.ComponentEventResultProcessor} may be used to send an alternate response(typically, a redirect). @param parameters defines the page name and activation context
• org.apache.tez.dag.history.HistoryEventHandler.handle()
• org.apache.uima.ducc.common.jd.plugin.IJdProcessExceptionHandler.handle()
  processId is the process identifier cas is the CAS for which the exception occurred t is the Throwable that occurred properties is a set of associated properties comprising: SequenceNumber - DUCC runtime supplied work item sequence number
• org.apache.uima.ducc.common.jd.plugin.JdProcessExceptionHandler.handle()
• org.apache.xml.security.stax.ext.XMLSecurityHeaderHandler.handle()
• org.asmatron.messengine.action.ActionHandler.handle()
• org.atmosphere.annotation.Processor.handle()
  Invoked by the {@link org.atmosphere.cpr.AnnotationHandler} when an annotation is detected. @param framework the {@link org.atmosphere.cpr.AtmosphereFramework} @param annotatedClass the annotated classes.
• org.atmosphere.socketio.SocketIOSessionOutbound.handle()
  @param request @param response @param session @return @throws IOException
• org.atmosphere.socketio.transport.Transport.handle()
• org.atomojo.app.client.FeedClient.handle()
• org.atomojo.app.client.IntrospectionClient.handle()
• org.axonframework.commandhandling.CommandDispatchInterceptor.handle()
  Invoked each time a command is about to be dispatched on a Command Bus. The given commandMessage represents the command being dispatched. @param commandMessage The command message intended to be dispatched on the Command Bus @return the command message to dispatch on the Command Bus
• org.axonframework.commandhandling.CommandHandlerInterceptor.handle()
  The handle method is invoked each time a command is dispatched through the command bus that the CommandHandlerInterceptor is declared on. The incoming command and contextual information can be found in the given unitOfWork.

  The interceptor is responsible for the continuation of the dispatch process by invoking the {@link org.axonframework.commandhandling.InterceptorChain#proceed(CommandMessage)} method on the giveninterceptorChain.

  Any information gathered by interceptors may be attached to the unitOfWork. This information is made available to the CommandCallback provided by the dispatching component.

  Interceptors are highly recommended not to change the type of the command handling result, as the dispatching component might expect a result of a specific type. @param commandMessage The command being dispatched @param unitOfWork The UnitOfWork in which @param interceptorChain The interceptor chain that allows this interceptor to proceed the dispatch process @return the result of the command handler. May have been modified by interceptors. @throws Throwable any exception that occurs while handling the command

• org.axonframework.eventhandling.EventListener.handle()
  Process the given event. The implementation may decide to process or skip the given event. It is highly unrecommended to throw any exception during the event handling process. @param event the event to handle
• org.axonframework.saga.Saga.handle()
  Handle the given event. The actual result of processing depends on the implementation of the saga.

  Implementations are highly discouraged from throwing exceptions. @param event the event to handle

• org.axonframework.saga.SagaManager.handle()
  Handles the event by passing it to all Saga instances that have an Association Value found in the given event. @param event the event to handle
• org.axonframework.saga.annotation.AsyncAnnotatedSagaManager.handle()
• org.axonframework.test.utils.CallbackBehavior.handle()
  Invoked when the Command Bus receives a Command that is dispatched with a Callback method. The return value of this invocation is used to invoke the callback. @param commandPayload The payload of the Command Message @param commandMetaData The MetaData of the CommandMessage @return any return value to pass to the callback's onSuccess method. @throws Throwable If the onFailure method of the callback must be invoked
• org.chromium.sdk.internal.v8native.protocol.input.data.SomeHandle.handle()
  An integer "handle" of the object. Normally it is unique (for particular suspended-to-resumed period). Some auxiliary objects may have non-unique handles which should be negative.
• org.chromium.sdk.internal.v8native.protocol.input.data.ValueHandle.handle()
• org.cometd.server.transport.AbstractHttpTransport.handle()
• org.crsh.keyboard.KeyHandler.handle()
  Handle a key event. @param type the key type @param sequence the key sequence
• org.crsh.telnet.term.spi.TermIOHandler.handle()
  Handle an IO for the specified termi IO and user principal. @param io the io @param user the principal
• org.directwebremoting.extend.Handler.handle()
  Handle a URL request that has been mapped to this Handler @param request The HTTP request data @param response Where we write the HTTP response data @throws IOException If the write process fails
• org.directwebremoting.servlet.EngineHandler.handle()
• org.directwebremoting.servlet.UrlProcessor.handle()
• org.eclipse.ecf.core.security.CallbackHandler.handle()
• org.eclipse.jetty.server.AbstractHttpConnection.handle()
• org.eclipse.jetty.server.BlockingHttpConnection.handle()
• org.eclipse.jetty.server.Handler.handle()
  Handle a request. @param target The target of the request - either a URI or a name. @param baseRequest The original unwrapped request object. @param request The request either as the {@link Request}object or a wrapper of that request. The {@link HttpChannel#getCurrentHttpChannel()}method can be used access the Request object if required. @param response The response as the {@link Response}object or a wrapper of that request. The {@link HttpChannel#getCurrentHttpChannel()}method can be used access the Response object if required. @throws IOException @throws ServletException
• org.eclipse.jetty.server.handler.ContextHandler.handle()
• org.eclipse.jetty.server.handler.ErrorHandler.handle()
• org.eclipse.php.debug.core.debugger.handlers.IDebugMessageHandler.handle()
  Process the relevant message @param message debug message @param debugTarget The {@link PHPDebugTarget}
• org.eclipse.sapphire.Listener.handle()
• org.eclipse.ui.statushandlers.StatusManager.handle()
  Handles the given status adapter due to the style. Because the facility depends on Workbench, this method will log the status, if Workbench isn't initialized and the style isn't NONE. If Workbench isn't initialized and the style is NONE, the manager will do nothing. @param statusAdapter the status adapter. Both the status adapter and the wrapped status may not be null. @param style the style.Value can be combined with logical OR. One of {@link #NONE}, {@link #LOG}, {@link #SHOW} and {@link #BLOCK}.
• org.exoplatform.portal.portlet.PortletExceptionHandleService.handle()
• org.exoplatform.services.remote.group.MessageHandler.handle()
• org.g4studio.core.resource.ResourceHandler.handle()
• org.gatein.wsrp.wss.cxf.consumer.CurrentUserPasswordCallback.handle()
• org.glassfish.api.naming.NamedNamingObjectProxy.handle()
  Returns the name that will be used to publish this object in the naming maanager @return the name to bind
• org.infinispan.remoting.InboundInvocationHandler.handle()
  Invokes a command on the cache, from a remote source. @param command command to invoke @param response the asynchronous request reference from {@code org.infinispan.remoting.transport.Transport}. A {@code null} value means that the request does not expect a return value. @param preserveOrder @throws Throwable in the event of problems executing the command
• org.jboss.as.cli.CommandContext.handle()
  Executes a command or an operation. Or, if the context is in the batch mode and the command is allowed in the batch, adds the command (or the operation) to the currently active batch. NOTE: errors are not handled by this method, they won't affect the exit code or even be logged. Error handling is the responsibility of the caller. @param line command or operation to handle @throws CommandFormatException in case there was an error handling the command or operation
• org.jboss.as.cli.CommandHandler.handle()
  Executes the command. @param ctx current command context @throws CommandLineException if for any reason the command can't be properly handledthe implementation must throw an instance of CommandLineException.
• org.jboss.as.cli.parsing.CharacterHandler.handle()
• org.jboss.as.domain.management.AuthorizingCallbackHandler.handle()
• org.jboss.as.domain.management.security.DomainCallbackHandler.handle()
• org.jboss.as.protocol.mgmt.AbstractMessageHandler.handle()
  Handle the request using the provided input and output @param connection The connection @param inputStream The request input @throws Exception If any problems occur handling the request
• org.jboss.as.web.security.jaspi.WebJASPICallbackHandler.handle()
• org.jboss.capedwarf.server.api.servlet.RequestHandler.handle()
  Handle request. @param req the request @param resp the response @throws ServletException for any servlet exception @throws IOException for any IO exception
• org.jboss.forge.classloader.mock.sidewaysproxy.Action.handle()
• org.jboss.internal.soa.esb.services.security.UserPassCallbackHandler.handle()
• org.jboss.messaging.core.Queue.handle()
• org.jboss.messaging.core.Receiver.handle()
  A receiver can return an active, "done" or null delivery. The method returns null in case the receiver doesn't accept the message. The return value is unspecified when the message is submitted in the context of a transaction (tx not null). @param observer - the component the delivery should be acknowledged to. @see org.jboss.messaging.core.Delivery @see org.jboss.messaging.core.DeliveryObserver
• org.jboss.messaging.core.Router.handle()
• org.jboss.messaging.core.contract.Distributor.handle()
• org.jboss.messaging.core.contract.Queue.handle()
• org.jboss.messaging.core.contract.Receiver.handle()
  A receiver can return an active, "done" or null delivery. The method returns null in case the receiver doesn't accept the message. The return value is unspecified when the message is submitted in the context of a transaction (tx not null). @param observer - the component the delivery should be acknowledged to. @see org.jboss.messaging.core.contract.Delivery @see org.jboss.messaging.core.contract.DeliveryObserver
• org.jboss.messaging.core.impl.MessagingQueue.handle()
• org.jboss.messaging.core.impl.RoundRobinDistributor.handle()
• org.jboss.messaging.core.local.PagingFilteredQueue.handle()
• org.jboss.messaging.core.local.RoundRobinPointToPointRouter.handle()
• org.jboss.security.auth.callback.AppCallbackHandler.handle()
• org.jboss.security.auth.callback.JASPICallbackHandler.handle()
• org.jboss.ws.extensions.security.auth.callback.UsernameTokenCallbackHandler.handle()
• org.jbpm.simulation.handler.ElementHandler.handle()
• org.jitterbit.integration.client.project.jitterpack.StartupJitterPackHandler.handle()
  Handles the given Jitterpak. @param jp a File representing the Jitterpak @param callback a callback that is notified on the outcome
• org.logicblaze.lingo.jms.ReplyHandler.handle()
  Processes the message, returning true if this is the last method of a lifecycle so that the handler can be discarded
• org.mockito.internal.InternalMockHandler.handle()
• org.mockito.internal.MockitoInvocationHandler.handle()
• org.moparscape.msc.gs.phandler.local.CommandHandler.handle()
• org.moparscape.msc.ls.packethandler.local.CommandHandler.handle()
• org.mortbay.jetty.Handler.handle()
  Handle a request. @param target The target of the request - either a URI or a name. @param request The request either as the {@link Request}object or a wrapper of that request. The {@link HttpConnection#getCurrentConnection()} method can be used access the Request object if required. @param response The response as the {@link Response}object or a wrapper of that request. The {@link HttpConnection#getCurrentConnection()} method can be used access the Response object if required. @param dispatch The dispatch mode: {@link #REQUEST}, {@link #FORWARD}, {@link #INCLUDE}, {@link #ERROR} @throws IOException @throws ServletException
• org.mortbay.jetty.handler.ErrorHandler.handle()
• org.mortbay.jetty.handler.ResourceHandler.handle()
• org.objectweb.joram.mom.util.MessageInterceptor.handle()
  Implement this method to intercept message on server side. @param msg message @return true if continue with the next interceptor, false send the message in DMQ.
• org.openqa.selenium.remote.server.rest.ResultConfig.handle()
• org.openstreetmap.josm.io.remotecontrol.handler.RequestHandler.handle()
  Check permission and parameters and handle request. @throws RequestHandlerForbiddenException @throws RequestHandlerBadRequestException @throws RequestHandlerErrorException
• org.rendersnake.servlet.FormHandler.handle()
  Handle the incoming request sent from a HTML Form. If the form used the variable() construct, then data is available in the field of the receiver. @param request @param response @return a FormResponseAction that specifies what response to give.
• org.restlet.Client.handle()
  Handles a call. @param request The request to handle. @return The returned response.
• org.restlet.Restlet.handle()
  Handles a call. The default behavior is to initialize the Restlet by setting the current context using the {@link Context#setCurrent(Context)}method and by attempting to start it, unless it was already started. If an exception is thrown during the start action, then the response status is set to {@link Status#SERVER_ERROR_INTERNAL}.

  Subclasses overriding this method should make sure that they call super.handle(request, response) before adding their own logic. @param request The request to handle. @param response The response to update.

• org.restlet.Uniform.handle()
  Handles a uniform call. It is important to realize that this interface can be used either on the client-side or on the server-side. @param request The request to handle. @param response The associated response.
• org.restlet.client.Uniform.handle()
  Handles a uniform call. It is important to realize that this interface can be used either on the client-side or on the server-side. @param request The request to handle. @param response The associated response.
• org.restlet.resource.ClientResource.handle()
  Handles the call by invoking the next handler. The prototype request is retrieved via {@link #getRequest()} and cloned and the response is set asthe latest with {@link #setResponse(Response)}. If necessary the {@link #setNext(Uniform)} method is called as well with a {@link Client}instance matching the request protocol. @return The optional response entity. @see #getNext()
• org.restlet.routing.Filter.handle()
  Handles a call by first invoking the beforeHandle() method for pre-filtering, then distributing the call to the next Restlet via the doHandle() method. When the handling is completed, it finally invokes the afterHandle() method for post-filtering. @param request The request to handle. @param response The response to update.
• org.restlet.routing.Redirector.handle()
  Handles a call by redirecting using the selected redirection mode. @param request The request to handle. @param response The response to update.
• org.restlet.routing.Validator.handle()
• org.saiku.olap.query.QueryProperties.QueryProperty.handle()
• org.simpleframework.http.resource.Resource.handle()
  This acts as the main processing method for the resources. Implementations are required to provide the functions that will process the Request and generate a suitable response for that request. This method is also responsible for closing and comitting the Response unless handed (chained) to another Resource. @param req the Request to be processed @param resp the Response to be processed
• org.springframework.batch.core.job.flow.State.handle()
  Handle some business or processing logic and return a status that can be used to drive a flow to the next {@link State}. The status can be any string, but special meaning is assigned to the static constants in {@link FlowExecution}. The context can be used by implementations to do whatever they need to do. The same context will be passed to all {@link State} instances, so implementations should be careful that thecontext is thread-safe, or used in a thread-safe manner. @param executor the context passed in by the caller @return a status for the execution @throws Exception if anything goes wrong
• org.springframework.security.web.access.AccessDeniedHandlerImpl.handle()
• org.springframework.web.servlet.HandlerAdapter.handle()
  Use the given handler to handle this request. The workflow that is required may vary widely. @param request current HTTP request @param response current HTTP response @param handler handler to use. This object must have previously been passedto the supports method of this interface, which must have returned true. @throws Exception in case of errors @return ModelAndView object with the name of the view and the requiredmodel data, or null if the request has been handled directly
• org.springframework.web.servlet.mvc.HttpRequestHandlerAdapter.handle()
• org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter.handle()
• org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter.handle()
• org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter.handle()
• org.springmodules.validation.bean.conf.loader.xml.handler.ClassValidationElementHandler.handle()
  Handles the given element and and manipulates the given configuration appropriately. @param element The element to be handled. @param configuration The configuration to be manipulated.
• org.springmodules.validation.bean.conf.loader.xml.handler.PropertyValidationElementHandler.handle()
  Handles the given element and and manipulates the given configuration appropriately. @param element The element to be handled. @param propertyName The name of the validated property. @param configuration The configuration to be manipulated.
• org.uiautomation.ios.inspector.controllers.IDECommandController.handle()
• org.vertx.java.core.Handler.handle()
  Something has happened, so handle it.
• org.w3c.dom.UserDataHandler.handle()
  This method is called whenever the node for which this handler is registered is imported or cloned. @param operation Specifies the type of operation that is being performed on the node. @param key Specifies the key for which this handler is being called. @param data Specifies the data for which this handler is being called. @param src Specifies the node being cloned, imported, or renamed. This is null when the node is being deleted. @param dst Specifies the node newly created if any, or null.
• org.waveprotocol.wave.client.editor.extract.Repairer.handle()
  Generic handler for any inconsistency exception @param error
• org.wymiwyg.rwcf.Handler.handle()
• org.wymiwyg.wrhapi.Handler.handle()
• org.zkoss.monitor.server.EventBusMessageHandler.handle()
• rabbit.handler.Handler.handle()
  handle a request.
• rabbit.meta.MetaHandler.handle()
  Handle a client request. @param request the http request header. @param htab the supplied argument to the page (CGI-parameters). @param con the Connection that is serving the request. @param tlProxy the TrafficLogger to log proxy traffic on. @param tlClient the TrafficLogger to log client traffic on.
• ratpack.handling.Handler.handle()
  Handles the context. @param context The context to handle @throws Exception if anything goes wrong (exception will be implicitly passed to the context's {@link Context#error(Throwable)} method)
• ratpack.test.handling.RequestFixture.handle()
  Invokes the given handler with a newly created {@link ratpack.handling.Context} based on the state of this fixture.

  The return value can be used to examine the effective result of the handler.

  A result may be one of the following:

  • The sending of a response via one of the {@link ratpack.http.Response#send} methods
  • Rendering to the response via the {@link ratpack.handling.Context#render(Object)}
  • Raising of a client error via {@link ratpack.handling.Context#clientError(int)}
  • Raising of a server error via {@link ratpack.handling.Context#error(Throwable)}
  • Raising of a server error by the throwing of an exception
  • Delegating to the next handler by invoking one of the {@link ratpack.handling.Context#next} methods

  Note that any handlers {@link ratpack.handling.Context#insert inserted} by the handler under test will be invoked. If the last inserted handler delegates to the next handler, the handling will terminate with a result indicating that the effective result was delegating to the next handler.

  This method blocks until a result is achieved, even if the handler performs an asynchronous operation (such as performing {@link ratpack.handling.Context#blocking(java.util.concurrent.Callable) blocking IO}). As such, a time limit on the execution is imposed which by default is 5 seconds. The time limit can be changed via the {@link #timeout(int)} method.If the time limit is reached, a {@link HandlerTimeoutException} is thrown. @param handler the handler to test @return the effective result of the handling @throws HandlerTimeoutException if the handler does not produce a result in the time limit defined by this fixture

• spark.FilterImpl.handle()
  Invoked when a request is made on this filter's corresponding path e.g. '/hello' @param request The request object providing information about the HTTP request @param response The response object providing functionality for modifying the response
• spark.RouteImpl.handle()
  Invoked when a request is made on this route's corresponding path e.g. '/hello' @param request The request object providing information about the HTTP request @param response The response object providing functionality for modifying the response @return The content to be set in the response @throws java.lang.Exception when handle fails
• spark.exception.ExceptionHandlerImpl.handle()
  Invoked when an exception that is mapped to this handler occurs during routing @param exception The exception that was thrown during routing @param request The request object providing information about the HTTP request @param response The response object providing functionality for modifying the response
• sun.misc.SignalHandler.handle()
  Handle the given signal @param sig a signal object
• uk.gov.nationalarchives.droid.core.interfaces.archive.ArchiveHandler.handle()
  Handles an archive input stream. @param request the originator request. @throws IOException if there was an error reading from the input stream

Examples of spark.RouteImpl.handle()

Examples of spark.exception.ExceptionHandlerImpl.handle()

Examples of sun.misc.SignalHandler.handle()

Examples of uk.gov.nationalarchives.droid.core.interfaces.archive.ArchiveHandler.handle()