org.glassfish.jersey.server.model

## Class Invocable

- java.lang.Object
- - org.glassfish.jersey.server.model.Invocable

All Implemented Interfaces:
  Parameterized, ResourceModelComponent

    public final class Invocable
    extends Object
    implements Parameterized, ResourceModelComponent

A common interface for invocable resource components. This includes resource methods, sub-resource methods and sub-resource locators bound to a concrete handler class and a Java method (either directly or indirectly) declared & implemented by the handler class.

Invocable component information is used at runtime by a Java method dispatcher when processing requests.

Class defines two kinds of `java methods`: `definition method` and `handling method`. Definition method is the java `Method` that is defined by the user to be executed. This can be java `Method` of the class but also method of the interface. If it is the method of the interface (method handler class is the `class` but method itself is from the `interface`) then the definition method is the method from the inherited `class`. In other words, the handling method is the concrete method but definition method can be its parent abstract definition. However, in most cases these methods are the same.

Author:
  Marek Potociar
See Also:
  `ResourceMethod`, `ResourceMethodDispatcher`

### Method Summary

All Methods Static Methods Instance Methods Concrete Methods
`void` `accept(ResourceModelVisitor visitor)` A component should call the visitor back with an appropriate visitor interface method to give it a chance to process.
`static Invocable` `create(Class<? extends Inflector> inflectorClass)` Create a new resource method invocable model backed by an inflector class.
`static <T> Invocable` `create(Inflector<jakarta.ws.rs.core.Request,T> inflector)` Create a new resource method invocable model backed by an inflector instance.
`static Invocable` `create(MethodHandler handler, Method handlingMethod)` Create a new resource method invocable model.
`static Invocable` `create(MethodHandler handler, Method definitionMethod, boolean encodedParameters)` Create a new resource method invocable model.
`static Invocable` `create(MethodHandler handler, Method definitionMethod, Method handlingMethod, boolean encodedParameters)` Create a new resource method invocable model.
`static Invocable` `create(MethodHandler handler, Method definitionMethod, Method handlingMethod, boolean encodedParameters, Type routingResponseType)` Create a new resource method invocable model.
`List<? extends ResourceModelComponent>` `getComponents()` Should return all existing resource model sub-components.
`Method` `getDefinitionMethod()` Getter for the Java method that should be executed.
`MethodHandler` `getHandler()` Get the model of the resource method handler that will be used to invoke the `handling resource method` on.
`Method` `getHandlingMethod()` Getter for the Java method
`List<Parameter>` `getParameters()` Provides access to all parameters associated with given Parameterized instance.
`Class<?>` `getRawResponseType()` Get the resource method raw response type.
`Class<?>` `getRawRoutingResponseType()` Get the response `Class` of the `handlingMethod` that will be used during the routing for the purpose of selection of the resource method.
`Type` `getResponseType()` Get the resource method generic response type information.
`Type` `getRoutingResponseType()` Get the response type of the `handlingMethod` that will be used during the routing for the purpose of selection of the resource method.
`boolean` `isInflector()` Check if the invocable represents an `inflector processing method`.
`boolean` `requiresEntity()` Provides information on presence of an entity parameter.
`String` `toString()`

### Methods inherited from class java.lang.Object

`clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait`

### Method Detail

#### create

    public static <T> Invocable create(Inflector<jakarta.ws.rs.core.Request,T> inflector)

Create a new resource method invocable model backed by an inflector instance.

Parameters:
  `inflector` - inflector processing the request method.
Returns:
  Invocable.

#### create

    public static Invocable create(Class<? extends Inflector> inflectorClass)

Create a new resource method invocable model backed by an inflector class.

Parameters:
  `inflectorClass` - inflector syb-type processing the request method.
Returns:
  Invocable.

#### create

    public static Invocable create(MethodHandler handler,
                                   Method handlingMethod)

Create a new resource method invocable model. Parameter values will be automatically decoded.

Parameters:
  `handler` - resource method handler.
  `handlingMethod` - handling Java method.
Returns:
  Invocable.

#### create

    public static Invocable create(MethodHandler handler,
                                   Method definitionMethod,
                                   boolean encodedParameters)

Create a new resource method invocable model.

Parameters:
  `handler` - resource method handler.
  `definitionMethod` - method that is defined to be executed on the `handler`.
  `encodedParameters` - `true` if the automatic parameter decoding should be disabled, false otherwise.
Returns:
  Invocable

#### create

    public static Invocable create(MethodHandler handler,
                                   Method definitionMethod,
                                   Method handlingMethod,
                                   boolean encodedParameters)

Create a new resource method invocable model.

Parameters:
  `handler` - resource method handler.
  `definitionMethod` - method that is defined to be executed on the `handler`.
  `handlingMethod` - specific and concrete method to be actually executed as a resource method. If `null` then the `definitionMethod` will be used.
  `encodedParameters` - `true` if the automatic parameter decoding should be disabled, false otherwise.
Returns:
  Invocable.

#### create

    public static Invocable create(MethodHandler handler,
                                   Method definitionMethod,
                                   Method handlingMethod,
                                   boolean encodedParameters,
                                   Type routingResponseType)

Create a new resource method invocable model.

Parameters:
  `handler` - resource method handler.
  `definitionMethod` - method that is defined to be executed on the `handler`.
  `handlingMethod` - specific and concrete method to be actually executed as a resource method. If `null` then the `definitionMethod` will be used.
  `encodedParameters` - `true` if the automatic parameter decoding should be disabled, false otherwise.
  `routingResponseType` - response type that will be used during the routing for purpose of selection of the resource method to be executed. If this parameter is non-`null` then it will override the return type of the `the Java handling method`) for purposes of resource method selection. This might be useful in cases when resource method returns a type `A` but thanks to registered providers (eg. `WriterInterceptor`) it will be always converted to type `B`. Then the method selecting algorithm would check presence of `MessageBodyWriter` for type `A` (which will never be actually needed) and might result in choosing undesired method. If the parameter is `null` then the default response type will be used.
Returns:
  Invocable.

#### getHandler

    public MethodHandler getHandler()

Get the model of the resource method handler that will be used to invoke the `handling resource method` on.

Returns:
  resource method handler model.

#### getHandlingMethod

    public Method getHandlingMethod()

Getter for the Java method

Returns:
  corresponding Java method

#### getDefinitionMethod

    public Method getDefinitionMethod()

Getter for the Java method that should be executed.

Returns:
  corresponding Java method.

#### getResponseType

    public Type getResponseType()

Get the resource method generic response type information.

The returned value provides the Type information that contains additional generic declaration information for generic Java class types.

Returns:
  resource method generic response type information.

#### getRawResponseType

    public Class<?> getRawResponseType()

Get the resource method raw response type.

The returned value provides information about the raw Java class.

Returns:
  resource method raw response type information.

#### isInflector

    public boolean isInflector()

Check if the invocable represents an `inflector processing method`.

Returns:
  `true`, if this invocable represents an inflector invocation, `false` otherwise.

#### requiresEntity

    public boolean requiresEntity()

Description copied from interface: `Parameterized`
Provides information on presence of an entity parameter.

Specified by:
  `requiresEntity` in interface `Parameterized`
Returns:
  true if entity parameter is present, false otherwise

#### getParameters

    public List<Parameter> getParameters()

Description copied from interface: `Parameterized`
Provides access to all parameters associated with given Parameterized instance.

Specified by:
  `getParameters` in interface `Parameterized`
Returns:
  list of actual parameters

#### accept

    public void accept(ResourceModelVisitor visitor)

Description copied from interface: `ResourceModelComponent`
A component should call the visitor back with an appropriate visitor interface method to give it a chance to process.

Specified by:
  `accept` in interface `ResourceModelComponent`
Parameters:
  `visitor` - resource model visitor.

#### getComponents

    public List<? extends ResourceModelComponent> getComponents()

Description copied from interface: `ResourceModelComponent`
Should return all existing resource model sub-components.

Specified by:
  `getComponents` in interface `ResourceModelComponent`
Returns:
  list of all sub-components

#### toString

    public String toString()

Overrides:
  `toString` in class `Object`

#### getRoutingResponseType

    public Type getRoutingResponseType()

Get the response type of the `handlingMethod` that will be used during the routing for the purpose of selection of the resource method. Returned value is in most cases equal to the `response type`. If returned value is different then it overrides the response type for purposes of resource method selection and will be used to look for available `message body writers`.

Returns:
  Response type used for the routing.

#### getRawRoutingResponseType

    public Class<?> getRawRoutingResponseType()

Get the response `Class` of the `handlingMethod` that will be used during the routing for the purpose of selection of the resource method. Returned value is in most cases equal to the `response type`. If returned value is different then it overrides the response type for purposes of resource method selection and will be used to look for available `message body writers`.

Returns:
  Response type used for the routing.