/** * Construct an instance with given {@code bytes} representing the serialized form of a {@link MetaData} * instance. * * @param data data representing the serialized form of a {@link MetaData} instance. * @param dataType The type of data */ public SerializedMetaData(T data, Class<T> dataType) { delegate = new SimpleSerializedObject<>(data, dataType, METADATA_CLASS_NAME, null); }
@Override public SerializedObject<byte[]> readSerializedSaga(ResultSet resultSet) throws SQLException { return new SimpleSerializedObject<>(resultSet.getBytes(1), byte[].class, resultSet.getString(2), resultSet.getString(3)); }
private RemoteExceptionDescription deserializeException(Serializer serializer) { return serializer.deserialize(new SimpleSerializedObject<>(serializedException, byte[].class, exceptionType, exceptionRevision)); }
private Map<String, ?> deserializeMetaData(JobDataMap jobDataMap) { SimpleSerializedObject<byte[]> serializedDeadlineMetaData = new SimpleSerializedObject<>( (byte[]) jobDataMap.get(MESSAGE_METADATA), byte[].class, MetaData.class.getName(), null ); return serializer.deserialize(serializedDeadlineMetaData); }
/** * Returns the serialized token. * * @return the serialized token stored in this entry */ public SerializedObject<T> getSerializedToken() { if (token == null) { return null; } return new SimpleSerializedObject<>(token, (Class<T>) token.getClass(), getTokenType()); }
private static Object deserializeDeadlinePayload(Serializer serializer, JobDataMap jobDataMap) { SimpleSerializedObject<byte[]> serializedDeadlinePayload = new SimpleSerializedObject<>( (byte[]) jobDataMap.get(SERIALIZED_MESSAGE_PAYLOAD), byte[].class, (String) jobDataMap.get(MESSAGE_TYPE), (String) jobDataMap.get(MESSAGE_REVISION) ); return serializer.deserialize(serializedDeadlinePayload); }
private static Map<String, ?> deserializeDeadlineMetaData(Serializer serializer, JobDataMap jobDataMap) { SimpleSerializedObject<byte[]> serializedDeadlineMetaData = new SimpleSerializedObject<>( (byte[]) jobDataMap.get(MESSAGE_METADATA), byte[].class, MetaData.class.getName(), null ); return serializer.deserialize(serializedDeadlineMetaData); }
private Object deserializePayload(JobDataMap jobDataMap) { SimpleSerializedObject<byte[]> serializedPayload = new SimpleSerializedObject<>( (byte[]) jobDataMap.get(SERIALIZED_MESSAGE_PAYLOAD), byte[].class, (String) jobDataMap.get(MESSAGE_TYPE), (String) jobDataMap.get(MESSAGE_REVISION) ); return serializer.deserialize(serializedPayload); }
private Object deserializePayload(Serializer serializer) { return serializer.deserialize(new SimpleSerializedObject<>(serializedPayload, byte[].class, payloadType, payloadRevision)); }
/** * Extracts a {@link ScopeDescriptor} describing the deadline {@link org.axonframework.messaging.Scope}, pulled * from provided {@code jobDataMap}. * * @param serializer the {@link Serializer} used to deserialize the contents of the given {@code} jobDataMap} * into a {@link ScopeDescriptor} * @param jobDataMap the {@link JobDataMap} which should contain a {@link ScopeDescriptor} * @return the {@link ScopeDescriptor} describing the deadline {@link org.axonframework.messaging.Scope}, pulled * from provided {@code jobDataMap} */ public static ScopeDescriptor deadlineScope(Serializer serializer, JobDataMap jobDataMap) { SimpleSerializedObject<byte[]> serializedDeadlineScope = new SimpleSerializedObject<>( (byte[]) jobDataMap.get(SERIALIZED_DEADLINE_SCOPE), byte[].class, (String) jobDataMap.get(SERIALIZED_DEADLINE_SCOPE_CLASS_NAME), null ); return serializer.deserialize(serializedDeadlineScope); } }
@Override @SuppressWarnings("unchecked") public SerializedObject<T> getPayload() { return new SimpleSerializedObject<>(payload, (Class<T>) payload.getClass(), new SimpleSerializedType(payloadType, payloadRevision)); } }
@SuppressWarnings({"NonSerializableObjectPassedToObjectStream", "ThrowFromFinallyBlock"}) @Override public <T> SerializedObject<T> serialize(Object instance, Class<T> expectedType) { ByteArrayOutputStream baos = new ByteArrayOutputStream(); try { ObjectOutputStream oos = new ObjectOutputStream(baos); try { oos.writeObject(instance); } finally { oos.flush(); } } catch (IOException e) { throw new SerializationException("An exception occurred writing serialized data to the output stream", e); } T converted = converter.convert(baos.toByteArray(), expectedType); return new SimpleSerializedObject<>(converted, expectedType, getSerializedType(instance)); }
@Override @SuppressWarnings("unchecked") public SerializedObject<T> getData() { SerializedObject<?> serializedInput = converter.convert(source.getData(), requiredType); return new SimpleSerializedObject<>(upcastFunction.apply((T) serializedInput.getData()), requiredType, getType()); }
@Override public <T> SerializedObject<T> serialize(Object object, Class<T> expectedType) { T result = doSerialize(object, expectedType, xStream); return new SimpleSerializedObject<>(result, expectedType, typeForClass(ObjectUtils.nullSafeTypeOf(object))); }
@Override public SerializedObject<byte[]> getPayload() { String revision = event.getPayload().getRevision(); return new SimpleSerializedObject<>(event.getPayload().getData().toByteArray(), byte[].class, event.getPayload().getType(), "".equals(revision) ? null : revision); }
@Override public <T> SerializedObject<T> serialize(Object object, Class<T> expectedRepresentation) { try { if (String.class.equals(expectedRepresentation)) { //noinspection unchecked return new SimpleSerializedObject<>((T) getWriter().writeValueAsString(object), expectedRepresentation, typeForClass(ObjectUtils.nullSafeTypeOf(object))); } byte[] serializedBytes = getWriter().writeValueAsBytes(object); T serializedContent = converter.convert(serializedBytes, expectedRepresentation); return new SimpleSerializedObject<>(serializedContent, expectedRepresentation, typeForClass(ObjectUtils.nullSafeTypeOf(object))); } catch (JsonProcessingException e) { throw new SerializationException("Unable to serialize object", e); } }
@Override public C getPayload() { String revision = request.getPayload().getRevision(); SerializedObject object = new SimpleSerializedObject<>(request.getPayload().getData().toByteArray(), byte[].class, request.getPayload().getType(), "".equals(revision) ? null : revision); return (C)serializer.deserialize(object); }
/** * Converts the data format of the given {@code original} IntermediateRepresentation to the target data type. * * @param original The source to convert * @param targetType The type of data to convert to * @param <T> the target data type * @return the converted representation */ @SuppressWarnings("unchecked") default <T> SerializedObject<T> convert(SerializedObject<?> original, Class<T> targetType) { if (original.getContentType().equals(targetType)) { return (SerializedObject<T>) original; } return new SimpleSerializedObject<>(convert(original.getData(), original.getContentType(), targetType), targetType, original.getType()); }
@SuppressWarnings("unchecked") public <T> SerializedObject<T> serializePayload(Serializer serializer, Class<T> expectedRepresentation) { synchronized (payloadGuard) { SerializedObject existingForm = serializedPayload.get(serializer); if (existingForm == null) { SerializedObject<T> serialized = serializer.serialize(message.getPayload(), expectedRepresentation); if (message.getPayload() == null) { // make sure the payload type is maintained serialized = new SimpleSerializedObject<>(serialized.getData(), serialized.getContentType(), serializer.typeForClass(message.getPayloadType())); } serializedPayload.put(serializer, serialized); return serialized; } else { return serializer.getConverter().convert(existingForm, expectedRepresentation); } } }
/** * Returns the CommandMessage wrapped in this Message. * * @param serializer The serializer to deserialize message contents with * @return the CommandMessage wrapped in this Message */ public CommandMessage<?> getCommandMessage(Serializer serializer) { SimpleSerializedObject<byte[]> serializedPayload = new SimpleSerializedObject<>(this.serializedPayload, byte[].class, payloadType, payloadRevision); final Object payload = serializer.deserialize(serializedPayload); SerializedMetaData<byte[]> serializedMetaData = new SerializedMetaData<>(this.serializedMetaData, byte[].class); final MetaData metaData = serializer.deserialize(serializedMetaData); return new GenericCommandMessage<>(new GenericMessage<>(commandIdentifier, payload, metaData), commandName); }