Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## javax.ws.rs.core
Class GenericEntity<T>

    java.lang.Object
      javax.ws.rs.core.GenericEntity<T>

    public class GenericEntity<T>

extends java.lang.Object

Represents a response entity of a generic type `T`.

Normally type erasure removes generic type information such that a `Response` instance that contains, e.g., an entity of type `List<String>` appears to contain a raw `List<?>` at runtime. When the generic type is required to select a suitable `MessageBodyWriter`, this class may be used to wrap the entity and capture its generic type.

There are two ways to create an instance:

1. Create a (typically anonymous) subclass of this class which enables retrieval of the type information at runtime despite type erasure. For example, the following code shows how to create a `Response` containing an entity of type `List<String>` whose generic type will be available at runtime for selection of a suitable `MessageBodyWriter`:

       List<String> list = new ArrayList<String>();
       GenericEntity<List<String>> entity = new GenericEntity<List<String>>(list) {};
       Response response = Response.ok(entity).build();

   where `list` is the instance of `List<String>` that will form the response body and entity is an instance of an anonymous subclass of `GenericEntity`.

2. Create an instance directly by supplying the generic type information with the entity. For example the following code shows how to create a response containing the result of a method invoked via reflection:

       Method method = ...;
       GenericEntity<Object> entity = new GenericEntity<Object>(
           method.invoke(...), method.getGenericReturnType());
       Response response = Response.ok(entity).build();

The above obtains the generic type from the return type of the method, the raw type is the class of entity.

Constructor Summary
`protected` | `GenericEntity(T entity)` Constructs a new generic entity.
`` | `GenericEntity(T entity, java.lang.reflect.Type genericType)` Create a new instance of GenericEntity, supplying the generic type information.

Method Summary
`T` | `getEntity()` Get the enclosed entity
`java.lang.Class<?>` | `getRawType()` Gets the raw type of the enclosed entity.
`java.lang.reflect.Type` | `getType()` Gets underlying `Type` instance.

Methods inherited from class java.lang.Object
`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

Constructor Detail

### GenericEntity

    protected GenericEntity(T entity)

  Constructs a new generic entity. Derives represented class from type parameter. Note that this constructor is protected, users should create a (usually anonymous) subclass as shown above.

  Parameters:
    `entity` - the entity instance, must not be null
  Throws:
    `java.lang.IllegalArgumentException` - if entity is null

### GenericEntity

    public GenericEntity(T entity,
                         java.lang.reflect.Type genericType)

  Create a new instance of GenericEntity, supplying the generic type information. The entity must be assignable to a variable of the supplied generic type, e.g. if `entity` is an instance of `ArrayList<String>` then `genericType` could be the same or a superclass of `ArrayList` with the same generic type like `List<String>`.

  Parameters:
    `entity` - the entity instance, must not be null
    `genericType` - the generic type, must not be null
  Throws:
    `java.lang.IllegalArgumentException` - if the entity is not assignable to a variable of the supplied generic type or if entity or genericType is null.

Method Detail

### getRawType

    public final java.lang.Class<?> getRawType()

  Gets the raw type of the enclosed entity. Note that this is the raw type of the instance, not the raw type of the type parameter. I.e. in the example in the introduction, the raw type is `ArrayList` not `List`.

  Returns:
    the raw type

### getType

    public final java.lang.reflect.Type getType()

  Gets underlying `Type` instance. Note that this is derived from the type parameter, not the enclosed instance. I.e. in the example in the introduction, the type is `List<String>` not `ArrayList<String>`.

  Returns:
    the type

### getEntity

    public final T getEntity()

  Get the enclosed entity

  Returns:
    the enclosed entity

Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

Copyright © 2008 Sun Microsystems, Inc. All Rights Reserved.