在 Kotlin 中转换为 JsonObject

Question

I have the following Java code:

var jwks = ((List<Object>) keys.getList()).stream()
                            .map(o -> new JsonObject((Map<String, Object>) o))
                            .collect(Collectors.toList());

and would like to translate safely into Kotlin code.

When I copy the code into Intellj, then it translates for me as follows:

val jwks = (keys.list as List<Any?>).stream()
        .map { o: Any? -> JsonObject(o as Map<String?, Any?>?) }
        .collect(Collectors.toList())

Can I do it better or should I let it as is.

Update

Maybe I have to provide more context. What I am trying to do is, to implement JWT Authorization for Vert.x with Keycloak in Kotlin regarding to the tutorial https://vertx.io/blog/jwt-authorization-for-vert-x-with-keycloak/ . I am trying to rewrite the method

private Future<Startup> setupJwtAuth(Startup startup) {

    var jwtConfig = startup.config.getJsonObject("jwt");
    var issuer = jwtConfig.getString("issuer");
    var issuerUri = URI.create(issuer);

    // derive JWKS uri from Keycloak issuer URI
    var jwksUri = URI.create(jwtConfig.getString("jwksUri", String.format("%s://%s:%d%s",
            issuerUri.getScheme(), issuerUri.getHost(), issuerUri.getPort(), issuerUri.getPath() + "/protocol/openid-connect/certs")));

    var promise = Promise.<JWTAuth>promise();

    // fetch JWKS from `/certs` endpoint
    webClient.get(jwksUri.getPort(), jwksUri.getHost(), jwksUri.getPath())
            .as(BodyCodec.jsonObject())
            .send(ar -> {

                if (!ar.succeeded()) {
                    startup.bootstrap.fail(String.format("Could not fetch JWKS from URI: %s", jwksUri));
                    return;
                }

                var response = ar.result();

                var jwksResponse = response.body();
                var keys = jwksResponse.getJsonArray("keys");

                // Configure JWT validation options
                var jwtOptions = new JWTOptions();
                jwtOptions.setIssuer(issuer);

                // extract JWKS from keys array
                var jwks = ((List<Object>) keys.getList()).stream()
                        .map(o -> new JsonObject((Map<String, Object>) o))
                        .collect(Collectors.toList());

                // configure JWTAuth
                var jwtAuthOptions = new JWTAuthOptions();
                jwtAuthOptions.setJwks(jwks);
                jwtAuthOptions.setJWTOptions(jwtOptions);
                jwtAuthOptions.setPermissionsClaimKey(jwtConfig.getString("permissionClaimsKey", "realm_access/roles"));

                JWTAuth jwtAuth = JWTAuth.create(vertx, jwtAuthOptions);
                promise.complete(jwtAuth);
            });

    return promise.future().compose(auth -> {
        jwtAuth = auth;
        return Future.succeededFuture(startup);
    });
}

into Kotlin language.

Answer 1

You can use Kotlin's star projection which basically handles unknown generics in a type-safe way.

(keys.list as List<Map<*, *>>).map { JsonObject(it) }

Since there is no multi-mapping there is no need of Stream/Sequence API.

However, if you want to use lazy-evaluation (each element going through all mapping then next element in same way rather than mapping all element then running next map):

(keys.list as List<Map<*, *>>)
        .asSequence()
        .map { JsonObject(it) }
        .map { /* Maybe some other mapping */ }
        .filter { /* Maybe some filter */ }
        .take(5)  // Or some other intermediate operation
        .toList()  // Finally start the operations and collect

Edit: I forgot that the keys are String , so you can cast to List<Map<String, *>> instead :)