Get the bytes of the string:

obj.toString().getBytes(theCharset);

You should use mapper.readValue to deserialize JSON into an object.

Using raw Jackson without the Jackson-Kotlin module:

val map: Map<String, String> = JSON.readValue("""{"name" :"test"}""",
                      object : TypeReference<Map<String, String>>() {})

This passes in an object expression with superclass TypeReference specifying the the type you are wanting to create with full generics still intact (you method suffers from type erasure).

Instead, if you are using the Jackson-Kotlin module you only need:

val map: Map<String, String> = JSON.readValue("""{"name" :"test"}""")

Since it has helper/extension functions to hide some of the uglier things like TypeReference creation.

You should always use the Jackson-Kotlin module with Kotlin code so that you can instantiate any type of Kotlin object including data classes that have all val parameters and no default constructors, have it understand nullability, and also deal with default values for constructor parameters. A simple stand-alone example:

import com.fasterxml.jackson.module.kotlin.*

val JSON = jacksonObjectMapper() // creates ObjectMapper() and adds Kotlin module in one step

val map: Map<String, String> = JSON.readValue("""{"name" :"test"}""")

Notice the import .* so that it picks up all the extension functions otherwise you need to explicitly import: com.fasterxml.jackson.module.kotlin.readValue

Or in your case the modified code would be:

import com.fasterxml.jackson.module.kotlin.readValue

val objectMapper = jacksonObjectMappe() // instead of ObjectMapper()

... 

@POST @Path("/test")
fun test(@Context request: ContainerRequest): Response {
    val bodyAsString = request.entityStream.bufferedReader().readText() 
    val map: Map<String, Any> = when (request.headers.getFirst("Content-Type")) {
        "application/json" -> objectMapper.readValue(bodyAsString) 
        "application/x-www-form-urlencoded" -> LinkedHashMap()
        else -> throw UnsupportedOperationException()
    }
    //....handle the map
    return Response.status(200).build()
}

The code has also been cleaned up a little to remove the use of a var and to read the entity stream in a more Kotlin friendly way.

Also note that the Content-Type header may be more complicated, it could contain encoding as well such as:

Content-type: application/json; charset=utf-8

So you may want a utility function that checks if the header is "equal to application/json or starts with application/json;" instead of only an equality check.

Lastly you could pass the request.entityStream directly to objectMapper.readValue and never copy it into a string at all. There are various overloads for readValue that are helpful for these types of inputs.

JSR 353 reference implementation

See https://jsonp.java.net/

These are the Maven dependencies:

<dependency>
    <groupId>javax.json</groupId>
    <artifactId>javax.json-api</artifactId>
    <version>1.0</version>
</dependency>

<dependency>
    <groupId>org.glassfish</groupId>
    <artifactId>javax.json</artifactId>
    <version>1.0.4</version>
    <scope>runtime</scope>
</dependency>

And the code sample:

// the JSON classes have package javax.json

ByteArrayOutputStream baos = new ByteArrayOutputStream();

// read JSON into baos

ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
InputStreamReader isr = new InputStreamReader(bais, Charset.forName("UTF-8"));
JsonReader jr = Json.createReader(isr);

JsonStructure js = jr.read();

switch (js.getValueType()) {
    case ARRAY:
        break;
    case OBJECT:
        break;
    case STRING:
        break;
    case NUMBER:
        break;
    case TRUE:
        break;
    case FALSE:
        break;
    case NULL:
        break;
}

FasterXML Jackson

(just a sample that works, most probably not the "best")

Maven dependency:

<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
    <version>2.6.3</version>
</dependency>

Code sample:

// see JsonNodeType
new ObjectMapper().reader().readTree("[]").getNodeType();

byte[] bytes = ....;
ByteArrayOutputStream baos = new ByteArrayOutputStream(bytes.length);
baos.write(bytes, 0, bytes.length);

Method description:

Writes len bytes from the specified byte array starting at offset off to this byte array output stream.