Example usage for io.vertx.core.json JsonObject encode

Introduction

In this page you can find the example usage for io.vertx.core.json JsonObject encode.

Prototype

public String encode() 

Source Link

Document

Encode this JSON object as a string.

Usage

From source file:com.groupon.vertx.redis.RedisCommandHandler.java

License:Apache License

private RedisCommand getRedisCommand(JsonObject jsonCommand, final Message<JsonObject> command,
        final boolean isMulti) {
    RedisCommand redisCommand = null;//w  w  w. ja v  a  2s.  c o m
    try {
        redisCommand = new RedisCommand(jsonCommand);
        log.trace("handleCommand", "createCommand", new String[] { "command", "isMulti" }, jsonCommand.encode(),
                isMulti);
    } catch (Exception ex) {
        log.error("handleCommand", "exception", "unknown", ex);
        command.reply(buildReply("error", null, ex.getMessage()));
    }
    return redisCommand;
}

---

From source file:com.iot.i4.server.I4Server.java

@Override
public void start() throws Exception {
    // Create a mongo client using all defaults (connect to localhost and default port) using the database name "demo".
    JsonObject config = new JsonObject().put("connection_string", "mongodb://localhost:27017").put("db_name",
            "i4");
    mongo = MongoClient.createShared(Vertx.vertx(), config);

    // the load function just populates some data on the storage
    loadData(mongo);/*w w w  .j av  a 2  s  .c  o m*/

    Router router = Router.router(Vertx.vertx());
    router.route().handler(BodyHandler.create());

    //1.findAll payloads
    router.get("/api/payloads").handler(ctx -> {
        mongo.find("payloads", new JsonObject(), lookup -> {
            // error handling
            if (lookup.failed()) {
                ctx.fail(500);
                return;
            }

            // now convert the list to a JsonArray because it will be easier to encode the final object as the response.
            final JsonArray json = new JsonArray();
            for (JsonObject o : lookup.result()) {
                json.add(o);
            }
            ctx.response().putHeader(HttpHeaders.CONTENT_TYPE, "application/json");
            ctx.response().end(json.encode());
        });
    });

    //1. findAll
    router.get("/api/users").handler(ctx -> {
        mongo.find("users", new JsonObject(), lookup -> {
            // error handling
            if (lookup.failed()) {
                ctx.fail(500);
                return;
            }
            // now convert the list to a JsonArray because it will be easier to encode the final object as the response.
            final JsonArray json = new JsonArray();
            for (JsonObject o : lookup.result()) {
                json.add(o);
            }
            ctx.response().putHeader(HttpHeaders.CONTENT_TYPE, "application/json");
            ctx.response().end(json.encode());
        });
    });

    //2.findOne
    router.get("/api/users/:id").handler(ctx -> {
        mongo.findOne("users", new JsonObject().put("_id", ctx.request().getParam("id")), null, lookup -> {
            // error handling
            if (lookup.failed()) {
                ctx.fail(500);
                return;
            }

            JsonObject user = lookup.result();

            if (user == null) {
                ctx.fail(404);
            } else {
                ctx.response().putHeader(HttpHeaders.CONTENT_TYPE, "application/json");
                ctx.response().end(user.encode());
            }
        });
    });

    router.post("/api/users").handler(ctx -> {
        JsonObject newUser = ctx.getBodyAsJson();

        mongo.findOne("users", new JsonObject().put("username", newUser.getString("username")), null,
                lookup -> {
                    // error handling
                    if (lookup.failed()) {
                        ctx.fail(500);
                        return;
                    }

                    JsonObject user = lookup.result();

                    if (user != null) {
                        // already exists
                        ctx.fail(500);
                    } else {
                        mongo.insert("users", newUser, insert -> {
                            // error handling
                            if (insert.failed()) {
                                ctx.fail(500);
                                return;
                            }

                            // add the generated id to the user object
                            newUser.put("_id", insert.result());

                            ctx.response().putHeader(HttpHeaders.CONTENT_TYPE, "application/json");
                            ctx.response().end(newUser.encode());
                        });
                    }
                });
    });

    router.put("/api/users/:id").handler(ctx -> {
        mongo.findOne("users", new JsonObject().put("_id", ctx.request().getParam("id")), null, lookup -> {
            // error handling
            if (lookup.failed()) {
                ctx.fail(500);
                return;
            }

            JsonObject user = lookup.result();

            if (user == null) {
                // does not exist
                ctx.fail(404);
            } else {

                // update the user properties
                JsonObject update = ctx.getBodyAsJson();

                user.put("username", update.getString("username"));
                user.put("firstName", update.getString("firstName"));
                user.put("lastName", update.getString("lastName"));
                user.put("address", update.getString("address"));

                mongo.replace("users", new JsonObject().put("_id", ctx.request().getParam("id")), user,
                        replace -> {
                            // error handling
                            if (replace.failed()) {
                                ctx.fail(500);
                                return;
                            }

                            ctx.response().putHeader(HttpHeaders.CONTENT_TYPE, "application/json");
                            ctx.response().end(user.encode());
                        });
            }
        });
    });

    router.delete("/api/users/:id").handler(ctx -> {
        mongo.findOne("users", new JsonObject().put("_id", ctx.request().getParam("id")), null, lookup -> {
            // error handling
            if (lookup.failed()) {
                ctx.fail(500);
                return;
            }

            JsonObject user = lookup.result();

            if (user == null) {
                // does not exist
                ctx.fail(404);
            } else {

                mongo.remove("users", new JsonObject().put("_id", ctx.request().getParam("id")), remove -> {
                    // error handling
                    if (remove.failed()) {
                        ctx.fail(500);
                        return;
                    }

                    ctx.response().setStatusCode(204);
                    ctx.response().end();
                });
            }
        });
    });
    // Create a router endpoint for the static content.
    router.route().handler(StaticHandler.create());
    Vertx.vertx().createHttpServer().requestHandler(router::accept).listen(8080);
    //Vertx.vertx().createHttpServer().requestHandler(req -> req.response().end("Hello World From I4Server!")).listen(8080);
    System.out.println("Server started & listening to [8080]");
}

---

From source file:com.waves_rsp.ikb4stream.communication.web.VertxServer.java

License:Open Source License

/**
 * Reads a request from a routing context, and attach the response to it. It requests the database
 * with DatabaseReader./*ww w  .  j a v a2s.c  om*/
 *
 * @param rc {@link RoutingContext}, which contains the request, and the response
 * @throws NullPointerException if rc is null
 */
private void getAnomalies(RoutingContext rc) {
    Request request;
    try {
        LOGGER.info("Received web request: {}", rc.getBodyAsJson());
        request = parseRequest(rc.getBodyAsJson());
        if (request == null) {
            rc.response().setStatusCode(400).putHeader("Content-type", "application/json;charset:utf-8")
                    .end("{\"error\": \"Invalid address\"}");
            return;
        }
    } catch (DecodeException | NullPointerException e) {
        LOGGER.info("Received an invalid format request : {} ", e.getMessage());
        LOGGER.debug("DecodeException: {}", e);
        rc.fail(400);
        return;
    }
    LOGGER.info("Request : {}", request);
    LOGGER.info("rc= {}", rc);
    rc.response().putHeader("content-type", "application/json");

    getEvent(request, (t, result) -> {
        if (t != null) {
            LOGGER.error("DatabaseReader error: " + t.getMessage());
            return;
        }
        LOGGER.info("Found events: {}", result);
        JsonObject response = new JsonObject("{\"events\":" + result + "}");
        rc.response().end(response.encode());
    });
}

---

From source file:de.elsibay.EbbTicketShowcase.java

License:Open Source License

@Override
public void start(Future<Void> startFuture) throws Exception {

    SessionStore sessionStore = LocalSessionStore.create(vertx);
    Router backendRouter = Router.router(vertx);
    backendRouter.route().handler(LoggerHandler.create(LoggerHandler.DEFAULT_FORMAT));
    CookieHandler cookieHandler = CookieHandler.create();
    SessionHandler sessionHandler = SessionHandler.create(sessionStore);
    // the CORS OPTION request must not set cookies
    backendRouter.get().handler(cookieHandler);
    backendRouter.get().handler(sessionHandler);
    backendRouter.post().handler(cookieHandler);
    backendRouter.post().handler(sessionHandler);

    // setup CORS
    CorsHandler corsHandler = CorsHandler.create("http(s)?://" + WEBSERVER_HOST + ":" + WEBSERVER_PORT)
            .allowCredentials(true).allowedHeader(HttpHeaders.ACCEPT.toString())
            .allowedHeader(HttpHeaders.ORIGIN.toString()).allowedHeader(HttpHeaders.AUTHORIZATION.toString())
            .allowedHeader(HttpHeaders.CONTENT_TYPE.toString()).allowedHeader(HttpHeaders.COOKIE.toString())
            .exposedHeader(HttpHeaders.SET_COOKIE.toString()).allowedMethod(HttpMethod.POST)
            .allowedMethod(HttpMethod.PUT).allowedMethod(HttpMethod.GET).allowedMethod(HttpMethod.DELETE);

    // setup event bus bridge
    TicketEventbusBridge sebb = new TicketEventbusBridge(sessionStore);
    backendRouter.mountSubRouter("/eventbus", sebb.route(vertx));

    // dummy eventbus services
    vertx.eventBus().consumer("ping", (Message<JsonObject> msg) -> {
        msg.reply(new JsonObject().put("answer", "pong " + msg.body().getString("text", "")));
    });/* w w w  . j av  a 2  s. co  m*/

    vertx.setPeriodic(5000, id -> {
        vertx.eventBus().send("topic", new JsonObject().put("timestamp", new Date().getTime()));
    });

    // session manager for login
    backendRouter.route("/api/*").handler(corsHandler);
    backendRouter.route("/api/*").method(HttpMethod.POST).method(HttpMethod.PUT).handler(BodyHandler.create());

    backendRouter.route("/api/session").handler((RoutingContext rc) -> {
        JsonObject user = rc.getBodyAsJson();
        String sessionId = rc.session().id();
        rc.session().put("user", user);
        rc.response().end(user.copy().put("sessionId", sessionId).encodePrettily());
    });

    // dummy ping REST service
    backendRouter.route("/api/ping").handler((RoutingContext rc) -> {
        JsonObject replyMsg = new JsonObject();
        replyMsg.put("timestamp", new Date().getTime());
        Cookie sessionCookie = rc.getCookie(SessionHandler.DEFAULT_SESSION_COOKIE_NAME);
        if (sessionCookie != null) {
            replyMsg.put("sessionId", sessionCookie.getValue());
        }
        rc.response().end(replyMsg.encode());
    });

    // start backend on one port
    vertx.createHttpServer().requestHandler(backendRouter::accept).listen(BACKENDSERVER_PORT,
            BACKENDSERVER_HOST, (AsyncResult<HttpServer> async) -> {
                System.out
                        .println(async.succeeded() ? "Backend Server started" : "Backend Server start FAILED");
            });

    // static files on other port
    Router staticFilesRouter = Router.router(vertx);
    staticFilesRouter.route("/*").handler(StaticHandler.create("src/main/www").setCachingEnabled(false));
    vertx.createHttpServer().requestHandler(staticFilesRouter::accept).listen(WEBSERVER_PORT, WEBSERVER_HOST,
            (AsyncResult<HttpServer> async) -> {
                System.out.println(async.succeeded()
                        ? "Web Server started\ngoto http://" + WEBSERVER_HOST + ":" + WEBSERVER_PORT + "/"
                        : "Web Server start FAILED");
            });
}

---

From source file:de.notizwerk.Consumer.java

License:Open Source License

@Override
public void start(Future<Void> startFuture) throws Exception {

    setUpFileSystem(v -> {//from  w  w  w .  j  a va2  s  .  co m
        vertx.eventBus().consumer("consumer", (Message<JsonObject> msg) -> {
            messagesInTick++;
            receivedMessages++;
            file.write(Buffer.buffer(msg.body().encode()));
            msg.reply("ok");
        });
        vertx.setPeriodic(REPORT_DELAY_IN_MSEC, (id) -> {
            long messageRate = Math.floorDiv(messagesInTick * 1000, REPORT_DELAY_IN_MSEC);
            messagesInTick = 0;
            JsonObject stats = new JsonObject().put("name", name).put("id", name)
                    .put("timestamp", AppStarter.TIME_FORMATTER.format(ZonedDateTime.now()))
                    .put("messageRate", messageRate).put("receivedMessages", receivedMessages);
            file.write(Buffer.buffer(stats.encode() + String.format("%n")));
            vertx.eventBus().publish("consumer.stats", stats);
        });
        startFuture.complete();
    });
}

---

From source file:de.notizwerk.Producer.java

License:Open Source License

private void report(Long id) {
    long messageRate = Math.floorDiv(generatedMessagesInTick * 1000, REPORT_DELAY_IN_MSEC);
    generatedMessagesInTick = 0;//w  w  w . j  a v a 2s. c om
    JsonObject stats = new JsonObject().put("name", name).put("id", name).put("throttle", msgPerSec)
            .put("timestamp", AppStarter.TIME_FORMATTER.format(ZonedDateTime.now()))
            .put("generatedMessages", generatedMessages).put("sentMessages", sentMessages)
            .put("undeliveredMessages", undeliveredMessages).put("messageRate", messageRate);

    file.write(Buffer.buffer(stats.encode() + String.format("%n")));
    vertx.eventBus().publish("producer.stats", stats);

}

---

From source file:de.openflorian.alarm.AlarmFaxEventMessageCodec.java

License:Open Source License

@Override
public void encodeToWire(Buffer buffer, AlarmFaxEvent event) {
    JsonObject jsonToEncode = new JsonObject();
    jsonToEncode.put(JSON_PROPERTY_FILENAME, event.getResultFile().getAbsolutePath());

    // Encode object to string
    String jsonToStr = jsonToEncode.encode();
    // Length of JSON: is NOT characters count
    int length = jsonToStr.getBytes().length;

    // Write data into given buffer
    buffer.appendInt(length);/*  w  ww  . j  a  v  a 2s . c  om*/
    buffer.appendString(jsonToStr);
}

---

From source file:doug.iotdemo.server.web.WebServer.java

License:Open Source License

private void handleFetch(RoutingContext context) {
    ScanRequest scanRequest = new ScanRequest().withTableName(sensorTableName);
    db.scanAsync(scanRequest, new AsyncHandler<ScanRequest, ScanResult>() {
        @Override// w ww .j av a 2  s .  co  m
        public void onSuccess(ScanRequest request, ScanResult result) {
            JsonObject states = new JsonObject();
            for (Map<String, AttributeValue> item : result.getItems()) {
                AttributeValue stateValue = item.get("state");
                if (stateValue != null) {
                    JsonObject sensorObj = new JsonObject();
                    sensorObj.put("state", Integer.valueOf(stateValue.getN()));

                    if (item.get("time") != null) {
                        long time = Long.parseLong(item.get("time").getN());
                        long count = Long.parseLong(item.get("count").getN());
                        long thresh = time / count;
                        sensorObj.put("thresh", thresh);
                    }

                    states.put(item.get("sensor").getS(), sensorObj);
                }
            }
            context.response().end(states.encode());
        }

        @Override
        public void onError(Exception exception) {
            StringWriter msg = new StringWriter();
            exception.printStackTrace(new PrintWriter(msg));
            context.response().setStatusCode(500).end(msg.toString());
        }
    });
}

---

From source file:gribbit.response.JSONResponse.java

License:Open Source License

public JSONResponse(HttpResponseStatus status, JsonObject jsonObject) {
    super(status);
    this.contentStr = jsonObject.encode();
}

---

From source file:io.apiman.gateway.platforms.vertx3.common.config.VertxEngineConfig.java

License:Apache License

protected Map<String, String> toFlatStringMap(JsonObject jsonObject) {
    if (jsonObject == null)
        return Collections.emptyMap();

    Map<String, String> outMap = new LinkedHashMap<>();
    // TODO figure out why this workaround is necessary.
    jsonMapToProperties("", new JsonObject(jsonObject.encode()).getMap(), outMap);
    substituteValues(outMap);/* w w  w . jav a2s. com*/
    return outMap;
}

---

• «
• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• »