@Override protected boolean canConvertTo(Object payload, @Nullable MessageHeaders headers) { if (!supportsMimeType(headers)) { return false; } AtomicReference<Throwable> causeRef = new AtomicReference<>(); if (this.objectMapper.canSerialize(payload.getClass(), causeRef)) { return true; } logWarningIfNecessary(payload.getClass(), causeRef.get()); return false; }
@Override public boolean canWrite(Class<?> clazz, @Nullable MediaType mediaType) { if (!canWrite(mediaType)) { return false; } AtomicReference<Throwable> causeRef = new AtomicReference<>(); if (this.objectMapper.canSerialize(clazz, causeRef)) { return true; } logWarningIfNecessary(clazz, causeRef.get()); return false; }
public boolean isAbleToStore(Object value) { if (value == null) { return true; } if(JsonNode.class.isAssignableFrom(value.getClass()) || (objectMapper.canSerialize(value.getClass()) && serializePOJOsInVariablesToJson)){ try { return objectMapper.writeValueAsString(value).length()>= minLength; } catch (JsonProcessingException e) { logger.error("Error writing json variable of type " +value.getClass(), e); } } return false; }
public boolean isAbleToStore(Object value) { if (value == null) { return true; } if(JsonNode.class.isAssignableFrom(value.getClass()) || (objectMapper.canSerialize(value.getClass()) && serializePOJOsInVariablesToJson)){ try { return objectMapper.writeValueAsString(value).length()<= maxLength; } catch (JsonProcessingException e) { logger.error("Error writing json variable of type " +value.getClass(), e); } } return false; }
/** * @param clazz the clazz of the object to be serialised/deserialised * @return true if the clazz can be serialised/deserialised */ public static boolean canHandle(final Class clazz) { return getInstance().mapper.canSerialize(clazz); }
@Override public boolean canEncode(ResolvableType elementType, @Nullable MimeType mimeType) { Class<?> clazz = elementType.toClass(); return supportsMimeType(mimeType) && (Object.class == clazz || (!String.class.isAssignableFrom(elementType.resolve(clazz)) && getObjectMapper().canSerialize(clazz))); }
@Override public boolean canWrite(Class<?> clazz, @Nullable MediaType mediaType) { if (!canWrite(mediaType)) { return false; } AtomicReference<Throwable> causeRef = new AtomicReference<>(); if (this.objectMapper.canSerialize(clazz, causeRef)) { return true; } logWarningIfNecessary(clazz, causeRef.get()); return false; }
@Override public void validate(Object var,List<ActivitiException> errors) { //we can consider var json so long as it can be stored as json //this doesn't guarantee a string body to be valid json as jackson will wrap a string to make it valid //also doesn't guarantee it will be persisted as json //could be a pojo and then could be persisted as serializable if user sets serializePOJOsInVariablesToJson to false - see JsonType.java if (!objectMapper.canSerialize(var.getClass())){ String message = var.getClass()+" is not serializable as json"; errors.add(new ActivitiException(message)); logger.error(message); } if (!objectMapper.canDeserialize(objectMapper.constructType(var.getClass()))){ String message = var.getClass()+" is not deserializable as json"; errors.add(new ActivitiException(message)); logger.error(message); } } }
@Override public <T> Codec<T> get(final Class<T> clazz) { final JavaType javaType = TypeFactory.defaultInstance().constructType(clazz); if (!mapper.canSerialize(clazz) || !mapper.canDeserialize(javaType)) { throw new CodecConfigurationException(String.format("%s (javaType: %s) not supported by Jackson Mapper", clazz, javaType)); } return new JacksonCodec<>(clazz, mapper); } };
@Override public boolean canEncode(ResolvableType elementType, @Nullable MimeType mimeType) { Class<?> clazz = elementType.toClass(); return supportsMimeType(mimeType) && (Object.class == clazz || (!String.class.isAssignableFrom(elementType.resolve(clazz)) && getObjectMapper().canSerialize(clazz))); }
@Override public void render(final Object value, final Renderer.Context ctx) throws Exception { if (ctx.accepts(type) && mapper.canSerialize(value.getClass())) { ctx.type(type); renderValue(value, ctx); } }
@Test public void testColumnHandleSerialize() throws Exception { CassandraColumnHandle columnHandle = new CassandraColumnHandle("cassandra", "column", 42, CassandraType.BIGINT, null, false, true, false, false); assertTrue(objectMapper.canSerialize(CassandraColumnHandle.class)); String json = objectMapper.writeValueAsString(columnHandle); testJsonEquals(json, COLUMN_HANDLE_AS_MAP); }
@Test public void testInformationSchemaSerialize() throws Exception { InformationSchemaTableHandle informationSchemaTableHandle = new InformationSchemaTableHandle( "information_schema_catalog", "information_schema_schema", "information_schema_table"); assertTrue(objectMapper.canSerialize(InformationSchemaTableHandle.class)); String json = objectMapper.writeValueAsString(informationSchemaTableHandle); testJsonEquals(json, SCHEMA_AS_MAP); }
@Test public void testSystemSerialize() throws Exception { SystemTableHandle internalHandle = new SystemTableHandle(CONNECTOR_ID, "system_schema", "system_table"); assertTrue(objectMapper.canSerialize(SystemTableHandle.class)); String json = objectMapper.writeValueAsString(internalHandle); testJsonEquals(json, SCHEMA_AS_MAP); }
@Test public void testTableHandleSerialize() throws Exception { CassandraTableHandle tableHandle = new CassandraTableHandle("cassandra", "cassandra_schema", "cassandra_table"); assertTrue(objectMapper.canSerialize(CassandraTableHandle.class)); String json = objectMapper.writeValueAsString(tableHandle); testJsonEquals(json, TABLE_HANDLE_AS_MAP); }
@Test public void testTableHandleSerialize() throws Exception { HiveTableHandle tableHandle = new HiveTableHandle("hive_schema", "hive_table"); assertTrue(objectMapper.canSerialize(HiveTableHandle.class)); String json = objectMapper.writeValueAsString(tableHandle); testJsonEquals(json, TABLE_HANDLE_AS_MAP); }
@Test public void testColumnHandleSerialize() throws Exception { HiveColumnHandle columnHandle = new HiveColumnHandle("column", HiveType.HIVE_FLOAT, parseTypeSignature(StandardTypes.DOUBLE), -1, PARTITION_KEY, Optional.of("comment")); assertTrue(objectMapper.canSerialize(HiveColumnHandle.class)); String json = objectMapper.writeValueAsString(columnHandle); testJsonEquals(json, COLUMN_HANDLE_AS_MAP); }
@Test public void testColumn2HandleSerialize() throws Exception { CassandraColumnHandle columnHandle = new CassandraColumnHandle( "cassandra", "column2", 0, CassandraType.SET, ImmutableList.of(CassandraType.INT), false, false, false, false); assertTrue(objectMapper.canSerialize(CassandraColumnHandle.class)); String json = objectMapper.writeValueAsString(columnHandle); testJsonEquals(json, COLUMN2_HANDLE_AS_MAP); }
@Test public void testSimpleMapping() throws JsonGenerationException, JsonMappingException, IOException { ObjectMapper m = new JsonMapperProvider().get(); assertTrue(m.canSerialize(Any.class)); Struct struct1 = Struct.newBuilder().putFields( "some-key", Value.newBuilder().setStringValue("some-value").build() ).build(); Any source = Any.pack(struct1); StringWriter buf = new StringWriter(); m.writer().writeValue(buf, source); Any dest = m.reader().forType(Any.class).readValue(buf.toString()); assertEquals(source.getTypeUrl(), dest.getTypeUrl()); Struct struct2 = dest.unpack(Struct.class); assertTrue(struct2.containsFields("some-key")); assertEquals( struct1.getFieldsOrThrow("some-key").getStringValue(), struct2.getFieldsOrThrow("some-key").getStringValue() ); } }
@Override protected boolean canConvertTo(Object payload, @Nullable MessageHeaders headers) { if (!supportsMimeType(headers)) { return false; } AtomicReference<Throwable> causeRef = new AtomicReference<>(); if (this.objectMapper.canSerialize(payload.getClass(), causeRef)) { return true; } logWarningIfNecessary(payload.getClass(), causeRef.get()); return false; }