Example usage for com.fasterxml.jackson.core JsonGenerator writeArrayFieldStart

List of usage examples for com.fasterxml.jackson.core JsonGenerator writeArrayFieldStart

  1. HOME
  2. Java
  3. com.fasterxml
  4. com.fasterxml.jackson.core.*
  5. JsonGenerator
  6. writeArrayFieldStart

Introduction

In this page you can find the example usage for com.fasterxml.jackson.core JsonGenerator writeArrayFieldStart.

Prototype

public final void writeArrayFieldStart(String fieldName) throws IOException, JsonGenerationException

Source Link

Document

Convenience method for outputting a field entry ("member") (that will contain a JSON Array value), and the START_ARRAY marker.

Usage

From source file:com.ning.metrics.action.hdfs.reader.HdfsEntry.java

public void toJson(final JsonGenerator generator) throws IOException {
    Iterator<Row> content = null;
    try {/*from w  ww.  java 2  s  .c  o m*/
        content = getContent();
    } catch (IOException ignored) {
    }

    generator.writeStartObject();

    generator.writeObjectField(JSON_ENTRY_PATH, getPath());
    generator.writeObjectField(JSON_ENTRY_MTIME, getModificationDate().getMillis());
    generator.writeObjectField(JSON_ENTRY_SIZE, getSize());
    generator.writeObjectField(JSON_ENTRY_REPLICATION, getReplication());
    generator.writeObjectField(JSON_ENTRY_IS_DIR, isDirectory());
    // Important: need to flush before appending pre-serialized events
    generator.flush();

    generator.writeArrayFieldStart(JSON_ENTRY_CONTENT);
    if (content != null) {
        while (content.hasNext()) {
            content.next().toJSON(generator);
        }
    }
    generator.writeEndArray();

    generator.writeEndObject();
    generator.flush();
}

From source file:org.lambdamatic.internal.elasticsearch.codec.BooleanQuerySerializer.java

@Override
public void serialize(final BooleanQuery booleanQuery, final JsonGenerator generator,
        final SerializerProvider serializers) throws IOException, JsonProcessingException {
    // if the booleanQuery does not contain other boolean queries in its elements, just write the
    // elements as an array
    if (!containsBooleanQueries(booleanQuery)) {
        generator.writeStartArray();/* w w  w  .  j  a  v  a  2 s  .  co  m*/
        for (Query query : booleanQuery.getQueries()) {
            generator.writeObject(query);
        }
        generator.writeEndArray();
    } else {
        // otherwise...
        generator.writeStartObject();
        generator.writeObjectFieldStart("bool");
        switch (booleanQuery.getType()) {
        case AND:
            // TODO: also support 'must_not' if the query is inverted.
            generator.writeArrayFieldStart("must");
            for (Query query : booleanQuery.getQueries()) {
                generator.writeObject(query);
            }
            generator.writeEndArray(); // end of 'must'
            break;
        case OR:
            generator.writeArrayFieldStart("should");
            for (Query query : booleanQuery.getQueries()) {
                generator.writeObject(query);
            }
            generator.writeEndArray();// end of 'should'
            break;
        default:
            throw new CodecException("Unexpected boolean type:" + booleanQuery.getType());
        }
        generator.writeEndObject(); // end of 'bool'
        generator.writeEndObject(); // end of root
    }
}

From source file:com.baidubce.services.bmr.BmrClient.java

/**
 * Create a cluster with the specified options.
 *
 * @param request The request containing all options for creating a BMR cluster.
 * @return The response containing the ID of the newly created cluster.
 *///from w w w  .j  a  va  2s  .c om
public CreateClusterResponse createCluster(CreateClusterRequest request) {
    checkNotNull(request, "request should not be null.");
    checkStringNotEmpty(request.getImageType(), "The imageType should not be null or empty string.");
    checkStringNotEmpty(request.getImageVersion(), "The imageVersion should not be null or empty string.");
    checkNotNull(request.getInstanceGroups(), "The instanceGroups should not be null.");

    StringWriter writer = new StringWriter();
    try {
        JsonGenerator jsonGenerator = JsonUtils.jsonGeneratorOf(writer);
        jsonGenerator.writeStartObject();
        jsonGenerator.writeStringField("imageType", request.getImageType());
        jsonGenerator.writeStringField("imageVersion", request.getImageVersion());
        jsonGenerator.writeArrayFieldStart("instanceGroups");
        for (InstanceGroupConfig instanceGroup : request.getInstanceGroups()) {
            jsonGenerator.writeStartObject();
            if (instanceGroup.getName() != null) {
                jsonGenerator.writeStringField("name", instanceGroup.getName());
            }
            jsonGenerator.writeStringField("type", instanceGroup.getType());
            jsonGenerator.writeStringField("instanceType", instanceGroup.getInstanceType());
            jsonGenerator.writeNumberField("instanceCount", instanceGroup.getInstanceCount());
            jsonGenerator.writeEndObject();
        }
        jsonGenerator.writeEndArray();
        if (request.getName() != null) {
            jsonGenerator.writeStringField("name", request.getName());
        }
        if (request.getLogUri() != null) {
            jsonGenerator.writeStringField("logUri", request.getLogUri());
        }
        jsonGenerator.writeBooleanField("autoTerminate", request.getAutoTerminate());

        if (request.getApplications() != null) {
            jsonGenerator.writeArrayFieldStart("applications");
            for (ApplicationConfig application : request.getApplications()) {
                jsonGenerator.writeStartObject();
                jsonGenerator.writeStringField("name", application.getName());
                jsonGenerator.writeStringField("version", application.getVersion());
                if (application.getProperties() != null) {
                    jsonGenerator.writeObjectFieldStart("properties");
                    for (Map.Entry<String, Object> entry : application.getProperties().entrySet()) {
                        jsonGenerator.writeObjectField(entry.getKey(), entry.getValue());
                    }
                    jsonGenerator.writeEndObject();
                }
                jsonGenerator.writeEndObject();
            }
            jsonGenerator.writeEndArray();
        }

        if (request.getSteps() != null) {
            jsonGenerator.writeArrayFieldStart("steps");
            for (StepConfig step : request.getSteps()) {
                jsonGenerator.writeStartObject();
                if (step.getName() != null) {
                    jsonGenerator.writeStringField("name", step.getName());
                }
                jsonGenerator.writeStringField("type", step.getType());
                jsonGenerator.writeStringField("actionOnFailure", step.getActionOnFailure());
                jsonGenerator.writeObjectFieldStart("properties");
                for (Map.Entry<String, String> entry : step.getProperties().entrySet()) {
                    jsonGenerator.writeStringField(entry.getKey(), entry.getValue());
                }
                jsonGenerator.writeEndObject();
                jsonGenerator.writeEndObject();
            }
            jsonGenerator.writeEndArray();
        }

        jsonGenerator.writeEndObject();
        jsonGenerator.close();
    } catch (IOException e) {
        throw new BceClientException("Fail to generate json", e);
    }

    byte[] json = null;
    try {
        json = writer.toString().getBytes(DEFAULT_ENCODING);
    } catch (UnsupportedEncodingException e) {
        throw new BceClientException("Fail to get UTF-8 bytes", e);
    }

    InternalRequest internalRequest = this.createRequest(request, HttpMethodName.POST, CLUSTER);
    internalRequest.addHeader(Headers.CONTENT_LENGTH, String.valueOf(json.length));
    internalRequest.addHeader(Headers.CONTENT_TYPE, "application/json");
    internalRequest.setContent(RestartableInputStream.wrap(json));

    if (request.getClientToken() != null) {
        internalRequest.addParameter("clientToken", request.getClientToken());
    }

    return this.invokeHttpClient(internalRequest, CreateClusterResponse.class);
}

From source file:org.pentaho.pdi.engine.serializers.DataEventSerializer.java

public DataEventSerializer() {
    super(DataEvent.class);

    SimpleModule module = new SimpleModule();
    module.addSerializer(DataEvent.class, new JsonSerializer<DataEvent>() {
        @Override//from   w  ww .ja va 2s . c  om
        public void serialize(DataEvent dataEvent, JsonGenerator jsonGenerator,
                SerializerProvider serializerProvider) throws IOException, JsonProcessingException {
            jsonGenerator.writeStartObject();
            Rows rows = (Rows) dataEvent.getData();
            jsonGenerator.writeStringField("model-id", dataEvent.getSource().getId());
            jsonGenerator.writeStringField("type", rows.getType().toString());
            jsonGenerator.writeStringField("state", rows.getState().toString());

            jsonGenerator.writeArrayFieldStart("rows");
            for (Row row : rows) {
                jsonGenerator.writeStartObject();
                jsonGenerator.writeArrayFieldStart("names");
                for (String name : row.getColumnNames()) {
                    jsonGenerator.writeString(name);
                }
                jsonGenerator.writeEndArray();

                jsonGenerator.writeArrayFieldStart("objects");
                for (Object obj : row.getObjects().get()) {
                    jsonGenerator.writeStartObject();
                    if (obj == null) {
                        jsonGenerator.writeStringField("type", "Null");
                        jsonGenerator.writeEndObject();
                        continue;
                    }
                    switch (obj.getClass().getSimpleName()) {
                    case "String":
                        jsonGenerator.writeStringField("type", "String");
                        jsonGenerator.writeStringField("obj", obj.toString());
                        break;
                    case "Date":
                        jsonGenerator.writeStringField("type", "Date");
                        jsonGenerator.writeStringField("obj", DATE_TIME_INSTANCE.format((Date) obj));
                        break;
                    case "Integer":
                        jsonGenerator.writeStringField("type", "Integer");
                        jsonGenerator.writeNumberField("obj", (Integer) obj);
                        break;
                    case "Long":
                        jsonGenerator.writeStringField("type", "Long");
                        jsonGenerator.writeNumberField("obj", (Long) obj);
                        break;
                    case "Double":
                        jsonGenerator.writeStringField("type", "Double");
                        jsonGenerator.writeNumberField("obj", (Double) obj);
                        break;
                    case "BigDecimal":
                        jsonGenerator.writeStringField("type", "BigDecimal");
                        jsonGenerator.writeStringField("obj", obj.toString());
                        break;
                    case "Boolean":
                        jsonGenerator.writeStringField("type", "Boolean");
                        jsonGenerator.writeBooleanField("obj", (Boolean) obj);
                        break;
                    case "byte[]":
                        jsonGenerator.writeStringField("type", "byte[]");
                        jsonGenerator.writeStringField("obj", new String(((byte[]) obj), "UTF-8"));
                        break;
                    default:
                        if (obj instanceof Serializable) {
                            jsonGenerator.writeStringField("type", "Object");

                            ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
                            ObjectOutputStream objectOutputStream = new ObjectOutputStream(outputStream);
                            objectOutputStream.writeObject(obj);
                            objectOutputStream.close();
                            outputStream.close();
                            byte[] bytes = outputStream.toByteArray();
                            jsonGenerator.writeStringField("obj", Base64.encodeBase64String(bytes));
                        }
                    }
                    jsonGenerator.writeEndObject();
                }
                jsonGenerator.writeEndArray();
                jsonGenerator.writeEndObject();

            }
            jsonGenerator.writeEndArray();

            jsonGenerator.writeEndObject();
        }
    });
    module.addDeserializer(DataEvent.class, new StdNodeBasedDeserializer<DataEvent>(DataEvent.class) {
        @Override
        public DataEvent convert(JsonNode jsonNode, DeserializationContext deserializationContext)
                throws IOException {

            Rows.TYPE type = Rows.TYPE.valueOf(jsonNode.get("type").asText());
            Rows.STATE state = Rows.STATE.valueOf(jsonNode.get("state").asText());

            List<Row> rows = new ArrayList<>();

            JsonNode json_rows = jsonNode.get("rows");
            for (JsonNode row : json_rows) {

                List<Class> types = new ArrayList<>();
                List<String> names = new ArrayList<>();
                for (JsonNode name : row.get("names")) {
                    names.add(name.asText());
                }
                List<Object> objects = new ArrayList<>();
                for (JsonNode obj : row.get("objects")) {
                    JsonNode t = obj.get("type");
                    JsonNode rawObject = obj.get("obj");

                    Object object = null;
                    String objType = t.asText();
                    switch (objType) {
                    case "Null":
                        types.add(Void.class);
                        break;
                    case "String":
                        types.add(String.class);
                        object = rawObject.asText();
                        break;
                    case "Integer":
                        types.add(Integer.class);
                        object = rawObject.asInt();
                        break;
                    case "Long":
                        types.add(Long.class);
                        object = rawObject.asLong();
                        break;
                    case "Date":
                        types.add(Date.class);
                        try {
                            object = DATE_TIME_INSTANCE.parse(rawObject.asText());
                        } catch (ParseException e) {
                            e.printStackTrace();
                        }
                        break;
                    case "Double":
                        types.add(Double.class);
                        object = rawObject.asDouble();
                        break;
                    case "BigDecimal":
                        types.add(BigDecimal.class);
                        object = new BigDecimal(rawObject.asText());
                        break;
                    case "Boolean":
                        types.add(Boolean.class);
                        object = rawObject.asBoolean();
                        break;
                    case "byte[]":
                        types.add(byte[].class);
                        object = rawObject.asText().getBytes("UTF-8");
                        break;
                    case "Object":
                        try {
                            types.add(Object.class);
                            object = new ObjectInputStream(
                                    new ByteArrayInputStream(Base64.decodeBase64(rawObject.asText())))
                                            .readObject();
                        } catch (ClassNotFoundException e) {
                            e.printStackTrace();
                        }
                        break;
                    }

                    objects.add(object);
                }

                Row r = new DeserializedRow(names, types, objects);
                rows.add(r);
            }
            Rows rowsObj = new Rows(rows, type, state);

            return new DataEvent(new RemoteSource(jsonNode.get("model-id").asText()), rowsObj);

        }
    });
    mapper.registerModule(module);
}

From source file:org.pentaho.metaverse.impl.model.kettle.json.AbstractStepMetaJsonSerializer.java

protected void writeExternalResources(T meta, JsonGenerator json, SerializerProvider serializerProvider)
        throws IOException, JsonGenerationException {
    Set<Class<?>> metaClassSet = new HashSet<Class<?>>(1);
    metaClassSet.add(meta.getClass());//w  w  w  .  j  av a2 s  . c  om
    IStepExternalResourceConsumerProvider stepExternalResourceConsumerProvider = getStepExternalResourceConsumerProvider();

    List<IStepExternalResourceConsumer> resourceConsumers = null;
    if (stepExternalResourceConsumerProvider != null) {
        resourceConsumers = stepExternalResourceConsumerProvider.getExternalResourceConsumers(metaClassSet);
    }

    json.writeArrayFieldStart(JSON_PROPERTY_EXTERNAL_RESOURCES);
    if (resourceConsumers != null) {
        for (IStepExternalResourceConsumer resourceConsumer : resourceConsumers) {

            Collection<IExternalResourceInfo> infos = resourceConsumer.getResourcesFromMeta(meta);
            for (IExternalResourceInfo info : infos) {
                json.writeObject(info);
            }
        }
    }
    json.writeEndArray();
}

From source file:de.escalon.hypermedia.spring.hydra.LinkListSerializer.java

private void writeIriTemplate(String rel, String href, List<String> variableNames,
        ActionDescriptor actionDescriptorForHttpGet, JsonGenerator jgen) throws IOException {
    jgen.writeObjectFieldStart(rel);

    jgen.writeStringField("@type", "hydra:IriTemplate");
    jgen.writeStringField("hydra:template", href);
    jgen.writeArrayFieldStart("hydra:mapping");
    writeHydraVariableMapping(jgen, actionDescriptorForHttpGet, variableNames);
    jgen.writeEndArray();// www . jav  a 2  s . c  o  m

    jgen.writeEndObject();
}

From source file:com.sdl.odata.renderer.json.writer.JsonPropertyWriter.java

private void handleProperty(Object data, StructuralProperty property, JsonGenerator generator)
        throws IllegalAccessException, IOException, ODataException {
    Field field = property.getJavaField();
    field.setAccessible(true);/*from ww w. j av  a2s.co  m*/
    Object value = field.get(data);
    LOG.trace("Property name is '{}' and its value is '{}'", property.getName(), value);
    Type type = getType(value);
    if (type == null) {
        String msg = String.format("Field type %s is not found in entity data model", field.getType());
        LOG.error(msg);
        throw new ODataRenderException(msg);
    }

    switch (type.getMetaType()) {
    case PRIMITIVE:
        generator.writeFieldName(property.getName());
        writePrimitive(value, generator);
        break;
    case COMPLEX:
        generator.writeArrayFieldStart(property.getName());
        generateComplex(value, (StructuredType) type, true);
        generator.writeEndArray();
        break;
    default:
        defaultHandling(type);
    }
}

From source file:org.seedstack.seed.core.internal.data.DataManagerImpl.java

private void dumpAll(List<DataSetMarker<Object>> dataSetMarker, OutputStream outputStream) {
    try {//from ww  w  . j  a  v a 2 s .c  o m
        JsonGenerator jsonGenerator = this.jsonFactory
                .createGenerator(new OutputStreamWriter(outputStream, Charset.forName(UTF_8)));
        ObjectWriter objectWriter = objectMapper.writer();

        jsonGenerator.writeStartArray();

        for (DataSetMarker<Object> objectDataSetMarker : dataSetMarker) {
            // start
            jsonGenerator.writeStartObject();

            // metadata
            jsonGenerator.writeStringField(GROUP, objectDataSetMarker.getGroup());
            jsonGenerator.writeStringField(NAME, objectDataSetMarker.getName());

            // items
            jsonGenerator.writeArrayFieldStart(ITEMS);
            while (objectDataSetMarker.getItems().hasNext()) {
                objectWriter.writeValue(jsonGenerator, objectDataSetMarker.getItems().next());
            }
            jsonGenerator.writeEndArray();

            // end
            jsonGenerator.writeEndObject();
        }

        jsonGenerator.writeEndArray();

        jsonGenerator.flush();
    } catch (Exception e) {
        throw SeedException.wrap(e, DataErrorCode.EXPORT_FAILED);
    }
}

From source file:org.openiot.security.oauth.lsm.LSMOAuth20PermissionController.java

@Override
protected ModelAndView handleRequestInternal(final HttpServletRequest request,
        final HttpServletResponse response) throws Exception {

    final String clientId = request.getParameter(OAuthConstants.CLIENT_ID);
    log.debug("clientId : {}", clientId);
    final String accessToken = request.getParameter(OAuthConstants.ACCESS_TOKEN);
    log.debug("accessToken : {}", accessToken);

    final String callerClientId = request.getParameter(CALLER_CLIENT_ID);
    log.debug("callerClientId : {}", callerClientId);
    final String callerAccessToken = request.getParameter(CALLER_ACCESS_TOKEN);
    log.debug("callerAccessToken : {}", callerAccessToken);

    final String userClientId = request.getParameter(USER_CLIENT_ID);
    log.debug("userClientId : {}", userClientId);

    final String userAccessToken = request.getParameter(USER_ACCESS_TOKEN);
    log.debug("userAccessToken : {}", userAccessToken);

    final String targetClientId = request.getParameter(TARGET_CLIENT_ID);
    log.debug("targetClientId : {}", targetClientId);

    response.setContentType("application/json");

    // accessToken is required
    if (StringUtils.isBlank(accessToken)) {
        log.error("missing accessToken");
        writeErrorMessage(response, OAuthConstants.MISSING_ACCESS_TOKEN);
        return null;
    }// w w  w . j ava2s .  co m

    // clientId is required
    if (StringUtils.isBlank(clientId)) {
        log.error("missing clientId");
        writeErrorMessage(response, MISSING_CLIENT_ID);
        return null;
    }

    // userToken is required
    if (StringUtils.isBlank(userAccessToken)) {
        log.error("missing user accessToken");
        writeErrorMessage(response, "missing_userAccessToken");
        return null;
    }

    // target clientId is required
    if (StringUtils.isBlank(targetClientId)) {
        log.error("missing target clientId");
        writeErrorMessage(response, MISSING_CLIENT_ID + "for_target");
        return null;
    }

    // caller accessToken and clientId are required if one of them is provided
    if (!StringUtils.isBlank(callerAccessToken) || !StringUtils.isBlank(callerClientId)) {
        if (StringUtils.isBlank(callerAccessToken)) {
            log.error("missing caller accessToken");
            writeErrorMessage(response, "missing_callerAccessToken");
            return null;
        } else if (StringUtils.isBlank(callerClientId)) {
            log.error("missing caller clientId");
            writeErrorMessage(response, "missing_callerClientId");
            return null;
        }
    }

    // get ticket granting ticket
    final TicketGrantingTicket ticketGrantingTicket = (TicketGrantingTicket) this.ticketRegistry
            .getTicket(accessToken);
    if (ticketGrantingTicket == null || ticketGrantingTicket.isExpired()) {
        log.error("expired accessToken : {}", accessToken);
        writeErrorMessage(response, OAuthConstants.EXPIRED_ACCESS_TOKEN);
        return null;
    }

    // get ticket granting ticket for the user
    final TicketGrantingTicket userTicketGrantingTicket;
    if (StringUtils.equals(accessToken, userAccessToken))
        userTicketGrantingTicket = ticketGrantingTicket;
    else {
        userTicketGrantingTicket = (TicketGrantingTicket) this.ticketRegistry.getTicket(userAccessToken);
        if (userTicketGrantingTicket == null || userTicketGrantingTicket.isExpired()) {
            log.error("expired user accessToken : {}", userAccessToken);
            writeErrorMessage(response, OAuthConstants.EXPIRED_ACCESS_TOKEN + "_for_user");
            return null;
        }
    }

    // Retrieve all registered services
    final Collection<RegisteredService> services = servicesManager.getAllServices();

    // If called accessToken and clientId are provided, check their validity
    if (!StringUtils.isBlank(callerAccessToken)) {
        // get ticket granting ticket for the caller
        final TicketGrantingTicket callerTicketGrantingTicket = (TicketGrantingTicket) this.ticketRegistry
                .getTicket(callerAccessToken);
        if (callerTicketGrantingTicket == null || callerTicketGrantingTicket.isExpired()) {
            log.error("expired accessToken : {}", callerAccessToken);
            writeErrorMessage(response, OAuthConstants.EXPIRED_ACCESS_TOKEN + "_for_caller");
            return null;
        }

        // name of the CAS service for caller
        RegisteredService callerService = null;
        for (final RegisteredService aService : services) {
            if (StringUtils.equals(aService.getName(), callerClientId)) {
                callerService = aService;
                break;
            }
        }

        if (callerService == null) {
            log.error("nonexistent caller clientId : {}", callerClientId);
            writeErrorMessage(response, NONEXISTENT_CLIENT_ID + "for_caller");
            return null;
        }
    }

    // if user clienId is provided, check its validity
    if (!StringUtils.isBlank(userClientId)) {
        RegisteredService userService = null;
        for (final RegisteredService aService : services) {
            if (StringUtils.equals(aService.getName(), userClientId)) {
                userService = aService;
                break;
            }
        }

        if (userService == null) {
            log.error("nonexistent clientId : {}", userClientId);
            writeErrorMessage(response, NONEXISTENT_CLIENT_ID + "_for_user");
            return null;
        }
    }

    // check validity of clientId
    RegisteredService service = null;
    for (final RegisteredService aService : services) {
        if (StringUtils.equals(aService.getName(), clientId)) {
            service = aService;
            break;
        }
    }

    if (service == null) {
        log.error("nonexistent clientId : {}", clientId);
        writeErrorMessage(response, NONEXISTENT_CLIENT_ID);
        return null;
    }

    // check validity of target clientId
    RegisteredService targetService = null;
    for (final RegisteredService aService : services) {
        if (StringUtils.equals(aService.getName(), targetClientId)) {
            targetService = aService;
            break;
        }
    }

    if (targetService == null) {
        log.error("nonexistent target clientId : {}", clientId);
        writeErrorMessage(response, NONEXISTENT_CLIENT_ID + "for_target");
        return null;
    }

    // TODO: check if the TGT is granted to the client?!
    // final TicketGrantingTicket rawTicket =
    // ((AbstractDistributedTicketRegistry.TicketGrantingTicketDelegator)ticketGrantingTicket).getTicket();
    // final Field servicesField =
    // rawTicket.getClass().getDeclaredField("services");
    // servicesField.setAccessible(true);
    // HashMap<String, Service> servicesMap = new HashMap<String,
    // Service>();
    // servicesMap = (HashMap<String, Service>)
    // servicesField.get(rawTicket);
    // log.error("ServiceMaps is empty ? {}", servicesMap.isEmpty());
    // for(Map.Entry<String, Service> entry : servicesMap.entrySet()){
    // AbstractWebApplicationService webAppService =
    // (AbstractWebApplicationService) entry.getValue();
    // log.error("Service for ticket {} is {}", rawTicket.getId(),
    // webAppService.getId());
    // }
    // if (!servicesMap.containsKey(service.getId()) ||
    // !servicesMap.get(service.getId()).equals(service)) {
    // log.error("Ticket is not granted to client : {}", clientId);
    // jsonGenerator.writeStartObject();
    // jsonGenerator.writeStringField("error", TICKET_NOT_GRANTED);
    // jsonGenerator.writeEndObject();
    // jsonGenerator.close();
    // response.flushBuffer();
    // return null;
    // }

    // Check if the caller has permission for retrieving permission information
    if (!targetClientId.equals(clientId)) {
        final Principal principal = ticketGrantingTicket.getAuthentication().getPrincipal();
        if (!isPermitted(principal.getId(), targetService.getId())) {
            log.error("[{} from {}] is not permitted to retrieve permission information on [{}]",
                    principal.getId(), clientId, targetClientId);
            writeErrorMessage(response, "permission_denied");
            return null;
        }
    }

    final JsonFactory jsonFactory = new JsonFactory();
    final JsonGenerator jsonGenerator = jsonFactory.createJsonGenerator(response.getWriter());

    final Principal principal = userTicketGrantingTicket.getAuthentication().getPrincipal();
    final Map<String, Set<String>> permissions = extractPermissions(targetService.getId(), principal.getId());

    jsonGenerator.writeStartObject();
    jsonGenerator.writeStringField(CasWrapperProfile.ID, principal.getId());

    jsonGenerator.writeArrayFieldStart("role_permissions");

    for (final String roleName : permissions.keySet()) {
        jsonGenerator.writeStartObject();
        jsonGenerator.writeArrayFieldStart(roleName);

        for (final String permission : permissions.get(roleName))
            jsonGenerator.writeString(permission);

        jsonGenerator.writeEndArray();
        jsonGenerator.writeEndObject();
    }

    jsonGenerator.writeEndArray();
    jsonGenerator.writeEndObject();
    jsonGenerator.close();
    response.flushBuffer();

    return null;
}

From source file:org.h2gis.drivers.geojson.GeoJsonWriteDriver.java

/**
 * Write the spatial table to GeoJSON format.
 *
 * @param progress/*from  w  ww  .  ja va 2  s  .  c o  m*/
 * @throws SQLException
 */
private void writeGeoJson(ProgressVisitor progress) throws SQLException, IOException {
    FileOutputStream fos = null;
    try {
        fos = new FileOutputStream(fileName);
        // Read Geometry Index and type
        final TableLocation parse = TableLocation.parse(tableName,
                JDBCUtilities.isH2DataBase(connection.getMetaData()));
        List<String> spatialFieldNames = SFSUtilities.getGeometryFields(connection, parse);
        if (spatialFieldNames.isEmpty()) {
            throw new SQLException(String.format("The table %s does not contain a geometry field", tableName));
        }

        // Read table content
        Statement st = connection.createStatement();
        try {
            JsonFactory jsonFactory = new JsonFactory();
            JsonGenerator jsonGenerator = jsonFactory.createGenerator(new BufferedOutputStream(fos),
                    JsonEncoding.UTF8);

            // header of the GeoJSON file
            jsonGenerator.writeStartObject();
            jsonGenerator.writeStringField("type", "FeatureCollection");
            writeCRS(jsonGenerator,
                    SFSUtilities.getAuthorityAndSRID(connection, parse, spatialFieldNames.get(0)));
            jsonGenerator.writeArrayFieldStart("features");

            ResultSet rs = st.executeQuery(String.format("select * from `%s`", tableName));

            try {
                ResultSetMetaData resultSetMetaData = rs.getMetaData();
                int geoFieldIndex = JDBCUtilities.getFieldIndex(resultSetMetaData, spatialFieldNames.get(0));

                cacheMetadata(resultSetMetaData);
                while (rs.next()) {
                    writeFeature(jsonGenerator, rs, geoFieldIndex);
                }
                progress.endStep();
                // footer
                jsonGenerator.writeEndArray();
                jsonGenerator.writeEndObject();
                jsonGenerator.flush();
                jsonGenerator.close();

            } finally {
                rs.close();
            }
        } finally {
            st.close();
        }
    } catch (FileNotFoundException ex) {
        throw new SQLException(ex);

    } finally {
        try {
            if (fos != null) {
                fos.close();
            }
        } catch (IOException ex) {
            throw new SQLException(ex);
        }
    }
}