com.fasterxml.jackson.databind.ObjectMapper Java Examples

private void showEditControlFileDialog() {
    try {
        ObjectMapper mapper = new ObjectMapper().configure(SerializationFeature.INDENT_OUTPUT, true);
        String textAreaContent = mapper.writeValueAsString(model.getControlFile());

        JTextArea controlFileContentTextArea = new JTextArea();
        controlFileContentTextArea.setEditable(false);
        controlFileContentTextArea.setText(textAreaContent);
        JScrollPane scrollPane = new JScrollPane(controlFileContentTextArea);
        controlFileContentTextArea.setLineWrap(true);
        controlFileContentTextArea.setWrapStyleWord(true);
        controlFileContentTextArea.setCaretPosition(0);
        scrollPane.setPreferredSize(CONTROL_FILE_VIEWER_DIMENSIONS);

        JOptionPane.showMessageDialog(this,scrollPane,"View Control File",JOptionPane.PLAIN_MESSAGE);
    }
    catch (IOException e){
         JOptionPane.showMessageDialog(this,"Could not load control file.  Please contact support");
    }

}
 

@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
    if (StrUtil.equals(TrueFalseEnum.TRUE.getDesc(), HaloConst.OPTIONS.get(BlogPropertiesEnum.API_STATUS.getProp()))) {
        if (StrUtil.equals(request.getHeader("token"), HaloConst.OPTIONS.get(BlogPropertiesEnum.API_TOKEN.getProp()))) {
            return true;
        } else {
            response.setCharacterEncoding("UTF-8");
            response.setContentType("application/json;charset=utf-8");
            Map<String, Object> map = new HashMap<>(2);
            ObjectMapper mapper = new ObjectMapper();
            map.put("code", 400);
            map.put("msg", "Invalid Token");
            response.getWriter().write(mapper.writeValueAsString(map));
            return false;
        }
    }
    response.sendRedirect("/404");
    return false;
}
 

public static ResourceAdd getSampleResourceAdd(List<CORSOrigin> corsOrigins) {

        ObjectMapper mapper = new ObjectMapper();

        ResourceAdd resourceAdd = new ResourceAdd();
        resourceAdd.setName(CORS_ORIGIN_RESOURCE_NAME);
        List<Attribute> attributeList = new ArrayList<>();
        for (CORSOrigin corsOrigin : corsOrigins) {
            Attribute attribute = new Attribute();
            attribute.setKey(String.valueOf(corsOrigin.hashCode()));
            try {
                String corsOriginString = mapper.writeValueAsString(corsOrigin);
                attribute.setValue(corsOriginString);
            } catch (IOException e) {
                if (log.isDebugEnabled()) {
                    log.debug("Error while converting a CORS Origin to a String.", e);
                }
            }
            attributeList.add(attribute);
        }
        resourceAdd.setAttributes(attributeList);

        return resourceAdd;
    }
 

public JsonNode login(String user, String password)
    throws InvalidKeyException, NoSuchAlgorithmException, InvalidKeySpecException,
        NoSuchPaddingException, IllegalBlockSizeException, BadPaddingException, IOException {

  String authParameters = encryptAuthParameter(user, password);

  // Send login request
  Response response =
      baseResource
          .path("login")
          .queryParam("service", Main.SERVICE)
          .queryParam("auth", authParameters)
          .request(responseType)
          .post(null);

  ObjectNode json = response.readEntity(ObjectNode.class);

  JsonNode node = new ObjectMapper().readTree(json.toString());

  String sessionKey = json.get("session_key").asText();

  // Add the session key to basic auth for all calls
  baseResource.register(HttpAuthenticationFeature.basic(sessionKey, sessionKey));

  return node;
}
 

@Test
public void testCreateLm() throws CfmConfigException, SoamConfigException {
    MepEntry mep1 = DefaultMepEntry.builder(MEPID1, DeviceId.deviceId("netconf:1.2.3.4:830"),
            PortNumber.portNumber(1), Mep.MepDirection.UP_MEP, MDNAME1, MANAME1).buildEntry();

    expect(mepService.getMep(MDNAME1, MANAME1, MEPID1)).andReturn(mep1).anyTimes();
    replay(mepService);

    ObjectMapper mapper = new ObjectMapper();
    CfmCodecContext context = new CfmCodecContext();
    ObjectNode node = mapper.createObjectNode();
    node.set("lm", context.codec(LossMeasurementCreate.class).encode(lm1, context));

    final WebTarget wt = target();
    final Response response = wt.path("md/" + MDNAME1.mdName() + "/ma/" +
            MANAME1.maName() + "/mep/" + MEPID1.value() + "/lm")
            .request().post(Entity.json(node.toString()));
    assertEquals(201, response.getStatus());
}
 

/**
 * Adds router interfaces to openstack admin service.
 *
 * @param osPort        port
 * @param adminService  openstack admin service
 */
public static void addRouterIface(Port osPort,
                                  OpenstackRouterAdminService adminService) {
    osPort.getFixedIps().forEach(p -> {
        JsonNode jsonTree = new ObjectMapper().createObjectNode()
                .put("id", osPort.getDeviceId())
                .put("tenant_id", osPort.getTenantId())
                .put("subnet_id", p.getSubnetId())
                .put("port_id", osPort.getId());
        try {
            RouterInterface rIface = getContext(NeutronRouterInterface.class)
                    .readerFor(NeutronRouterInterface.class)
                    .readValue(jsonTree);
            if (adminService.routerInterface(rIface.getPortId()) != null) {
                adminService.updateRouterInterface(rIface);
            } else {
                adminService.addRouterInterface(rIface);
            }
        } catch (IOException e) {
            log.error("IOException occurred because of {}", e);
        }
    });
}
 

/**
 * Local notification message handler.
 *
 * @param context Context of the application.
 */
public MessageProcessor(Context context) {
	this.context = context;

	deviceId = Preference.getString(context, DEVICE_ID_PREFERENCE_KEY);
	operationProcessor = new OperationProcessor(context.getApplicationContext());
	mapper = new ObjectMapper();
	mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
	mapper.configure(SerializationFeature.FAIL_ON_EMPTY_BEANS, false);
	this.devicePolicyManager =
			(DevicePolicyManager) context.getSystemService(Context.DEVICE_POLICY_SERVICE);

	if (deviceId == null) {
		DeviceInfo deviceInfo = new DeviceInfo(context.getApplicationContext());
		deviceId = deviceInfo.getDeviceId();
		Preference.putString(context, DEVICE_ID_PREFERENCE_KEY, deviceId);
	}
}
 

@Test
public void testPutWithValidationPassing() throws Exception {
    final String tenant = name.getMethodName();
    tenantRegistry.createTenantContext(tenant);

    final RestDataSourceDefinition dataSourceDefinition = new RestDataSourceDefinition();
    dataSourceDefinition.setType("pojo");

    final GetDatasourceResponse resp = dataSourceController.put(tenant, "ds1", true, dataSourceDefinition);

    final ObjectMapper objectMapper = new ObjectMapper();

    assertEquals(
            "[{'name':'information_schema','uri':'/testPutWithValidationPassing/ds1/s/information_schema'},"
                    + "{'name':'Schema','uri':'/testPutWithValidationPassing/ds1/s/Schema'}]",
            objectMapper.writeValueAsString(resp.getSchemas()).replace('\"', '\''));
}
 

@Test
public void ignoreDuplicateVote() throws Exception {
  Account account = accountCitizen("foo");
  String token = prepareAccessToken(account);

  VoteResource.VoteArticle voteArticle = new VoteResource.VoteArticle();
  voteArticle.articleId = FlakeId.fromString("a");
  voteArticle.newState = VoteState.DOWN;
  voteArticle.previousCount = 100L;
  voteArticle.previousState = VoteState.EMPTY;

  Mockito.doThrow(new DuplicateKeyException("vote dup"))
      .when(voteService)
      .voteArticle(eq(VoteState.DOWN),
          eq(FlakeId.fromString("a")),
          isA(Authorization.class),
          eq(VoteState.EMPTY),
          eq(100L));

  mockMvc.perform(post("/api/vote/article").header(AccountAccessToken.HEADER_KEY, token)
      .contentType(MediaType.APPLICATION_JSON)
      .content(new ObjectMapper().writeValueAsBytes(voteArticle))).andExpect(status().isOk());
}
 

public HttpLocalDownloadServiceFetcher(
  AsyncHttpClient httpClient,
  ObjectMapper objectMapper,
  SingularityExecutorConfiguration executorConfiguration,
  SingularityS3Configuration s3Configuration
) {
  this.httpClient = httpClient;
  this.objectMapper = objectMapper;
  this.executorConfiguration = executorConfiguration;
  this.localDownloadUri =
    String.format(
      LOCAL_DOWNLOAD_STRING_FORMAT,
      s3Configuration.getLocalDownloadHttpPort(),
      s3Configuration.getLocalDownloadPath()
    );
}
 

private BuildInfo handleBuildInfoResponse(String appName, ObjectMapper mapper, CloseableHttpResponse response) throws IOException, HerokuDeployApiException {
    switch (response.getStatusLine().getStatusCode()) {
        case HttpStatus.SC_NOT_FOUND:
            throw new AppNotFoundException(String.format("App %s could not be found!", appName));

        case HttpStatus.SC_FORBIDDEN:
            throw new InsufficientAppPermissionsException(String.format("Could not access app %s: insufficient permissions", appName));

        case HttpStatus.SC_OK:
        case HttpStatus.SC_CREATED:
            HttpEntity responseEntity = response.getEntity();
            String responseStringBody = Util.readLinesFromInputStream(responseEntity.getContent()).collect(Collectors.joining());

            return mapper.readValue(responseStringBody, BuildInfo.class);

        default:
            throw new HerokuDeployApiException(String.format("Unexpected status code: %d!", response.getStatusLine().getStatusCode()));
    }
}
 

@Test
public void testReplaceWithoutLock() throws Exception {
  server.expect().get().withPath("/api/v1/namespaces/test/configmaps/map1").andReturn(200, new ConfigMapBuilder()
    .withNewMetadata().withResourceVersion("1000").and().build()).always();

  server.expect().put().withPath("/api/v1/namespaces/test/configmaps/map1").andReturn(200, new ConfigMapBuilder()
    .withNewMetadata().withResourceVersion("1001").and().build()).once();

  KubernetesClient client = server.getClient();
  ConfigMap map = client.configMaps().withName("map1").replace(new ConfigMapBuilder()
    .withNewMetadata().withName("map1").and().build());
  assertNotNull(map);
  assertEquals("1001", map.getMetadata().getResourceVersion());

  RecordedRequest request = server.getLastRequest();
  ConfigMap replacedMap = new ObjectMapper().readerFor(ConfigMap.class).readValue(request.getBody().inputStream());
  assertEquals("1000", replacedMap.getMetadata().getResourceVersion());
}
 

public SeedManager(final String joalConfFolder, final ObjectMapper mapper, final ApplicationEventPublisher publisher) throws IOException {
    this.isSeeding = false;
    this.joalFoldersPath = new JoalFoldersPath(Paths.get(joalConfFolder));
    this.torrentFileProvider = new TorrentFileProvider(joalFoldersPath);
    this.configProvider = new JoalConfigProvider(mapper, joalFoldersPath, publisher);
    this.bitTorrentClientProvider = new BitTorrentClientProvider(configProvider, mapper, joalFoldersPath);
    this.publisher = publisher;
    this.connectionHandler = new ConnectionHandler();


    final SocketConfig sc = SocketConfig.custom()
            .setSoTimeout(30000)
            .build();
    final PoolingHttpClientConnectionManager connManager = new PoolingHttpClientConnectionManager();
    connManager.setDefaultMaxPerRoute(100);
    connManager.setMaxTotal(200);
    connManager.setValidateAfterInactivity(1000);
    connManager.setDefaultSocketConfig(sc);
    this.httpClient = HttpClients.custom()
            .setConnectionTimeToLive(1, TimeUnit.MINUTES)
            .setConnectionManager(connManager)
            .setConnectionManagerShared(true)
            .build();
}
 

public Map<String, Object> decode(String base64EncodedKey, String content) {
    try {
        byte[] decodedKey = Base64.getDecoder().decode(base64EncodedKey);
        SecretKey key = new SecretKeySpec(decodedKey, 0, decodedKey.length, "AES");
        JWEObject jwe = JWEObject.parse(content);
        jwe.decrypt(new AESDecrypter(key));

        ObjectMapper objectMapper = new ObjectMapper();
        ObjectReader reader = objectMapper.readerFor(Map.class);
        return reader.with(DeserializationFeature.USE_LONG_FOR_INTS)
                .readValue(jwe.getPayload().toString());
    } catch (Exception e) {
        throw new RuntimeException(e);
    }

}
 

@Test
public void test_validate() throws Exception {
  final ObjectMapper mp = new ObjectMapper();

  String json = "{\"type\":\"GeometryCollection\",\"geometries\":[]}";
  GeometryCollection geometryCollection = mp.readValue(json, GeometryCollection.class);
  geometryCollection.validate();

  json = "{\"type\":\"GeometryCollection\",\"geometries\":[" + //
      "{\"type\":\"Point\",\"coordinates\":[0,0,0]}," + //
      "{\"type\":\"MultiPoint\",\"coordinates\":[]}," + //
      "{\"type\":\"MultiPoint\",\"coordinates\":[[0,0,0], [1,1,1]]}" + //
      "]}";
  geometryCollection = mp.readValue(json, GeometryCollection.class);
  geometryCollection.validate();
}
 

/**
 * 把 JSON 解析成 List，如果 List 内部的元素存在 jsonString，继续解析
 *
 * @param json
 * @param mapper 解析工具
 * @return
 * @throws Exception
 */
private static List<Object> json2ListRecursion(String json, ObjectMapper mapper) throws Exception {
    if (json == null) {
        return null;
    }

    List<Object> list = mapper.readValue(json, List.class);

    for (Object obj : list) {
        if (obj != null && obj instanceof String) {
            String str = (String) obj;
            if (str.startsWith("[")) {
                obj = json2ListRecursion(str, mapper);
            } else if (obj.toString().startsWith("{")) {
                obj = json2MapRecursion(str, mapper);
            }
        }
    }

    return list;
}
 

public List<JsonNode> getEvents(String eventType) {
    try {
        final List<JsonNode> events = new ArrayList<>();
        final ObjectMapper objectMapper = new ObjectMapper();
        for (HttpRequest httpRequest : mockServerContainer.getClient().retrieveRecordedRequests(request(INTAKE_V2_URL))) {
            final String bodyAsString = httpRequest.getBodyAsString();
            for (String ndJsonLine : bodyAsString.split("\n")) {
                final JsonNode ndJson = objectMapper.readTree(ndJsonLine);
                if (ndJson.get(eventType) != null) {
                    // as inferred spans are created only after the profiling session ends
                    // they can leak into another test
                    if (!isInferredSpan(ndJson.get(eventType))) {
                        validateEventMetadata(bodyAsString);
                    }
                    events.add(ndJson.get(eventType));
                }
            }
        }
        return events;
    } catch (IOException e) {
        throw new RuntimeException(e);
    }
}
 

@Test(expected = PatchApplicationException.class)
public void throwsPatchApplicationExceptionWhenNotAValidPatch() throws Exception {
  JsonNode road = mapper.readTree("{\"description\":\"description1\"}");

  List<PatchOperation> operations = singletonList(PatchOperation.replace("/description", "description2"));

  JsonNode jsonNodePatch = mapper.readTree("{}");

  ObjectMapper mockObjectMapper = mock(ObjectMapper.class);
  when(mockObjectMapper.convertValue(any(), eq(JsonNode.class))).thenReturn(jsonNodePatch);

  underTest = new JsonPatchApplier(mockObjectMapper);
  underTest.apply(road, operations);
}
 

@Test
public void testSerializationAsTimestamp04Nanosecond() throws Exception
{
    LocalDateTime time = LocalDateTime.of(2005, Month.NOVEMBER, 5, 22, 31, 5, 829837);

    final ObjectMapper m = newMapperBuilder()
            .enable(SerializationFeature.WRITE_DATE_TIMESTAMPS_AS_NANOSECONDS)
            .build();
    String value = m.writeValueAsString(time);
    assertEquals("The value is not correct.", "[2005,11,5,22,31,5,829837]", value);
}
 

private Message<String> createJsonMessage(final Object event) {
    final Map<String, MimeType> headers = Maps.newLinkedHashMap();
    headers.put(MessageHeaders.CONTENT_TYPE, MimeTypeUtils.APPLICATION_JSON);
    try {
        final String json = new ObjectMapper().writeValueAsString(event);
        final Message<String> message = MessageBuilder.withPayload(json).copyHeaders(headers).build();
        return message;
    } catch (final JsonProcessingException e) {
        fail(e.getMessage());
    }
    return null;
}
 

private KafkaReporter(MetricRegistry registry,
                      String name,
                      MetricFilter filter,
                      TimeUnit rateUnit,
                      TimeUnit durationUnit,
                      String kafkaTopic,
                      Properties kafkaProperties) {
    super(registry, name, filter, rateUnit, durationUnit);
    this.registry = registry;
    mapper = new ObjectMapper().registerModule(new MetricsModule(rateUnit,
                                                                 durationUnit,
                                                                 false));
    this.kafkaTopic = kafkaTopic;
    kafkaProducer = new Producer<String, String>(new ProducerConfig(kafkaProperties));
}
 

private ObjectMapper newConfiguredObjectMapper(JmapResponse jmapResponse) {
    ObjectMapper objectMapper = objectMapperFactory.forWriting();
    
    FilterProvider filterProvider = jmapResponse
            .getFilterProvider()
            .orElseGet(SimpleFilterProvider::new)
            .setDefaultFilter(SimpleBeanPropertyFilter.serializeAll())
            .addFilter(PROPERTIES_FILTER, getPropertiesFilter(jmapResponse.getProperties()));
    
    objectMapper.setFilterProvider(filterProvider);

    return objectMapper;
}
 

public DefaultServerSourceManager(LoadBalancerContext loadBalancerContext) {
    NullArgumentChecker.DEFAULT.check(loadBalancerContext, "loadBalancerContext");
    _loadBalancerContext = loadBalancerContext;
    _objectMapper = new ObjectMapper();
    _routeListType = _objectMapper.getTypeFactory().constructCollectionType(List.class, LoadBalancerRoute.class);

    String managerId = loadBalancerContext.managerId();
    TypedDynamicCachedCorrectedProperties properties = loadBalancerContext.properties();
    String propertyKey = generateKey(managerId, ConfigurationKeys.DataFolder);
    _managerLevelDataFolderProperty = properties.getStringProperty(propertyKey, null);

    String loadBalancerId = loadBalancerContext.loadBalancerId();
    propertyKey = generateKey(managerId, loadBalancerId, ConfigurationKeys.DataFolder);
    _dataFolderProperty = properties.getStringProperty(propertyKey, null);
}
 

@Override
public Authentication attemptAuthentication(
        HttpServletRequest req, HttpServletResponse res)
        throws AuthenticationException, IOException, ServletException {

    Map uMap = new ObjectMapper().readValue(req.getInputStream(), Map.class);

    // 返回一个验证令牌
    return getAuthenticationManager().authenticate(
            new UsernamePasswordAuthenticationToken(
                    uMap.get("username"),
                    uMap.get("password")
                    )
    );
}
 

@Test
public void shouldNotRemoveKnownPublicClaimsFromTree() throws Exception {
    String payloadJSON = "{\n" +
            "  \"iss\": \"auth0\",\n" +
            "  \"sub\": \"emails\",\n" +
            "  \"aud\": \"users\",\n" +
            "  \"iat\": 10101010,\n" +
            "  \"exp\": 11111111,\n" +
            "  \"nbf\": 10101011,\n" +
            "  \"jti\": \"idid\",\n" +
            "  \"roles\":\"admin\" \n" +
            "}";
    StringReader reader = new StringReader(payloadJSON);
    JsonParser jsonParser = new JsonFactory().createParser(reader);
    ObjectMapper mapper = new ObjectMapper();
    jsonParser.setCodec(mapper);

    Payload payload = deserializer.deserialize(jsonParser, mapper.getDeserializationContext());

    assertThat(payload, is(notNullValue()));
    assertThat(payload.getIssuer(), is("auth0"));
    assertThat(payload.getSubject(), is("emails"));
    assertThat(payload.getAudience(), is(IsCollectionContaining.hasItem("users")));
    assertThat(payload.getIssuedAt().getTime(), is(10101010L * 1000));
    assertThat(payload.getExpiresAt().getTime(), is(11111111L * 1000));
    assertThat(payload.getNotBefore().getTime(), is(10101011L * 1000));
    assertThat(payload.getId(), is("idid"));

    assertThat(payload.getClaim("roles").asString(), is("admin"));
    assertThat(payload.getClaim("iss").asString(), is("auth0"));
    assertThat(payload.getClaim("sub").asString(), is("emails"));
    assertThat(payload.getClaim("aud").asString(), is("users"));
    assertThat(payload.getClaim("iat").asDouble(), is(10101010D));
    assertThat(payload.getClaim("exp").asDouble(), is(11111111D));
    assertThat(payload.getClaim("nbf").asDouble(), is(10101011D));
    assertThat(payload.getClaim("jti").asString(), is("idid"));
}
 

@Autowired
public DatadogFetchTask(
    ObjectMapper kayentaObjectMapper,
    AccountCredentialsRepository accountCredentialsRepository,
    SynchronousQueryProcessor synchronousQueryProcessor) {
  this.kayentaObjectMapper = kayentaObjectMapper;
  this.accountCredentialsRepository = accountCredentialsRepository;
  this.synchronousQueryProcessor = synchronousQueryProcessor;
}
 

@Override
public T deserialize(JsonParser parser, DeserializationContext ctxt) throws IOException {
    T result;
    try {
        result = clazz.getDeclaredConstructor().newInstance();
    } catch (InstantiationException | IllegalAccessException | NoSuchMethodException | SecurityException | IllegalArgumentException | InvocationTargetException ex) {
        throw new IOException("Error deserializing JSON!", ex);
    }
    // need to make subclass of this class for every Entity subclass with custom field to get expected class!!!
    BeanDescription beanDescription = ctxt.getConfig().introspect(ctxt.constructType(clazz));
    ObjectMapper mapper = (ObjectMapper) parser.getCodec();
    JsonNode obj = mapper.readTree(parser);
    List<BeanPropertyDefinition> properties = beanDescription.findProperties();
    Iterator<Map.Entry<String, JsonNode>> i = obj.fields();

    // First check if we know all properties that are present.
    if (ctxt.isEnabled(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES)) {
        while (i.hasNext()) {
            Map.Entry<String, JsonNode> next = i.next();
            String fieldName = next.getKey();
            Optional<BeanPropertyDefinition> findFirst = properties.stream().filter(p -> p.getName().equals(fieldName)).findFirst();
            if (!findFirst.isPresent()) {
                throw new UnrecognizedPropertyException(parser, "Unknown field: " + fieldName, parser.getCurrentLocation(), clazz, fieldName, null);
            }
        }
    }

    for (BeanPropertyDefinition classProperty : properties) {
        deserialiseProperty(obj, classProperty, properties, mapper, result);
    }
    return result;
}
 

@Test
void shouldConstructFromObjectMapper() {
    BodyFilter bodyFilter = new PrettyPrintingJsonBodyFilter(new ObjectMapper());
    final String filtered = bodyFilter.filter("application/json", compacted);
    assertThat(filtered, is(pretty));

}
 

public static String toJsonWithFormat(Object obj)
    throws JsonProcessingException {
    if (obj == null) {
        LOGGER.warn("Object to be formatted cannot be empty!");
        return null;
    }
    ObjectWriter mapper = new ObjectMapper().writer()
        .withDefaultPrettyPrinter();
    return mapper.writeValueAsString(obj);
}
 

@Test
public void testBuildObjectMapper() {
    ActorRefFactory actorRefFactory = mock(ActorRefFactory.class);
    ScheduledMessageRefFactory scheduledMessageRefFactory = mock(ScheduledMessageRefFactory.class);
    ObjectMapper objectMapper = new ObjectMapperBuilder(actorRefFactory,scheduledMessageRefFactory,"1.0.0").build();
    // check if everything was scanned correctly
    assertNotNull(objectMapper);
}