/** * Constructs a new SagaEntry for the given {@code saga}. The given saga must be serializable. The provided * saga is not modified by this operation. * * @param saga The saga to store * @param sagaIdentifier The saga identifier * @param serializer The serialization mechanism to convert the Saga to a byte stream * @param contentType The saga content type to serialize to */ public AbstractSagaEntry(Object saga, String sagaIdentifier, Serializer serializer, Class<T> contentType) { this.sagaId = sagaIdentifier; SerializedObject<T> serialized = serializer.serialize(saga, contentType); this.serializedSaga = serialized.getData(); this.sagaType = serialized.getType().getName(); this.revision = serialized.getType().getRevision(); }
/** * Resolve the class name from the given {@code serializedType}. This method may be overridden to customize * the names used to denote certain classes, for example, by leaving out a certain base package for brevity. * * @param serializedType The serialized type to resolve the class name for * @return The fully qualified name of the class to load */ protected String resolveClassName(SerializedType serializedType) { return serializedType.getName(); }
@Override public boolean test(DomainEventData<?> snapshot) { final SerializedType payloadType = snapshot.getPayload().getType(); final String payloadRevision = payloadType.getRevision(); final String aggregateRevision; try { aggregateRevision = resolver.revisionOf(serializer.classForType(payloadType)); } catch (Exception e) { // Unable to resolve a revision, ignoring this snapshot return false; } return Objects.equals(payloadRevision, aggregateRevision); } }
@SuppressWarnings("unchecked") @Override public <S, T> T deserialize(SerializedObject<S> serializedObject) { if (SerializedType.emptyType().equals(serializedObject.getType())) { return null; } if (UnknownSerializedType.class.isAssignableFrom(classForType(serializedObject.getType()))) { return (T) new UnknownSerializedType(this, serializedObject); } return (T) doDeserialize(serializedObject, xStream); }
private String getSagaTypeName(Class<?> sagaType) { return serializer.typeForClass(sagaType).getName(); }
@Override public boolean test(DomainEventData<?> snapshot) { final SerializedType payloadType = snapshot.getPayload().getType(); final String payloadRevision = payloadType.getRevision(); final String aggregateRevision; try { aggregateRevision = resolver.revisionOf(serializer.classForType(payloadType)); } catch (Exception e) { // Unable to resolve a revision, ignoring this snapshot return false; } return Objects.equals(payloadRevision, aggregateRevision); } }
@SuppressWarnings("unchecked") @Override public <S, T> T deserialize(SerializedObject<S> serializedObject) { if (SerializedType.emptyType().equals(serializedObject.getType())) { return null; } if (UnknownSerializedType.class.isAssignableFrom(classForType(serializedObject.getType()))) { return (T) new UnknownSerializedType(this, serializedObject); } SerializedObject<InputStream> converted = converter.convert(serializedObject, InputStream.class); ObjectInputStream ois = null; try { ois = new ObjectInputStream(converted.getData()); return (T) ois.readObject(); } catch (ClassNotFoundException | IOException e) { throw new SerializationException("An error occurred while deserializing: " + e.getMessage(), e); } finally { IOUtils.closeQuietly(ois); } }
private static void putDeadlineMessage(JobDataMap jobData, DeadlineMessage deadlineMessage, Serializer serializer) { jobData.put(DEADLINE_NAME, deadlineMessage.getDeadlineName()); jobData.put(MESSAGE_ID, deadlineMessage.getIdentifier()); jobData.put(MESSAGE_TIMESTAMP, deadlineMessage.getTimestamp().toEpochMilli()); SerializedObject<byte[]> serializedDeadlinePayload = serializer.serialize(deadlineMessage.getPayload(), byte[].class); jobData.put(SERIALIZED_MESSAGE_PAYLOAD, serializedDeadlinePayload.getData()); jobData.put(MESSAGE_TYPE, serializedDeadlinePayload.getType().getName()); jobData.put(MESSAGE_REVISION, serializedDeadlinePayload.getType().getRevision()); SerializedObject<byte[]> serializedDeadlineMetaData = serializer.serialize(deadlineMessage.getMetaData(), byte[].class); jobData.put(MESSAGE_METADATA, serializedDeadlineMetaData.getData()); }
private String sagaTypeName(Class<?> sagaType) { return serializer.typeForClass(sagaType).getName(); }
@Override public boolean test(DomainEventData<?> snapshot) { final SerializedType payloadType = snapshot.getPayload().getType(); final String payloadRevision = payloadType.getRevision(); final String aggregateRevision; try { aggregateRevision = resolver.revisionOf(serializer.classForType(payloadType)); } catch (Exception e) { // Unable to resolve a revision, ignoring this snapshot return false; } return Objects.equals(payloadRevision, aggregateRevision); } }
@Override public <S, T> T deserialize(SerializedObject<S> serializedObject) { try { if (SerializedType.emptyType().equals(serializedObject.getType())) { return null; } Class<?> type = classForType(serializedObject.getType()); if (UnknownSerializedType.class.isAssignableFrom(type)) { return (T) new UnknownSerializedType(this, serializedObject); } if (JsonNode.class.equals(serializedObject.getContentType())) { return getReader(type) .readValue((JsonNode) serializedObject.getData()); } SerializedObject<byte[]> byteSerialized = converter.convert(serializedObject, byte[].class); return getReader(type).readValue(byteSerialized.getData()); } catch (IOException e) { throw new SerializationException("Error while deserializing object", e); } }
@Override public JobDataMap toJobData(Object event) { JobDataMap jobData = new JobDataMap(); EventMessage eventMessage = (EventMessage) event; jobData.put(MESSAGE_ID, eventMessage.getIdentifier()); jobData.put(MESSAGE_TIMESTAMP, eventMessage.getTimestamp().toEpochMilli()); SerializedObject<byte[]> serializedPayload = serializer.serialize(eventMessage.getPayload(), byte[].class); jobData.put(SERIALIZED_MESSAGE_PAYLOAD, serializedPayload.getData()); jobData.put(MESSAGE_TYPE, serializedPayload.getType().getName()); jobData.put(MESSAGE_REVISION, serializedPayload.getType().getRevision()); SerializedObject<byte[]> serializedMetaData = serializer.serialize(eventMessage.getMetaData(), byte[].class); jobData.put(MESSAGE_METADATA, serializedMetaData.getData()); return jobData; }
/** * Indicates whether the given {@code serializedObject} represents a serialized form of a MetaData object, * such as the ones created by this class (see {@link #SerializedMetaData(Object, Class)}. * * @param serializedObject The object to check for Meta Data * @return {@code true} if the serialized objects represents serialized meta data, otherwise * {@code false}. */ public static boolean isSerializedMetaData(SerializedObject<?> serializedObject) { return serializedObject != null && serializedObject.getType() != null && METADATA_CLASS_NAME.equals(serializedObject.getType().getName()); }
@SuppressWarnings("unchecked") @Override public <S, T> T deserialize(SerializedObject<S> serializedObject) { if (SerializedType.emptyType().equals(serializedObject.getType())) { return null; } return (T) doDeserialize(serializedObject, xStream); }
/** * Initializes a ReplyMessage containing a reply to the command with given {commandIdentifier} and given * {@code commandResultMessage}. * * @param commandIdentifier the identifier of the command to which the message is a reply * @param commandResultMessage the result message of command process * @param serializer the serializer to serialize the message contents with */ public ReplyMessage(String commandIdentifier, CommandResultMessage<?> commandResultMessage, Serializer serializer) { this.commandIdentifier = commandIdentifier; SerializedObject<byte[]> metaData = commandResultMessage.serializeMetaData(serializer, byte[].class); this.serializedMetaData = metaData.getData(); SerializedObject<byte[]> payload = commandResultMessage.serializePayload(serializer, byte[].class); this.serializedPayload = payload.getData(); this.payloadType = payload.getType().getName(); this.payloadRevision = payload.getType().getRevision(); SerializedObject<byte[]> exception = commandResultMessage.serializeExceptionResult(serializer, byte[].class); this.serializedException = exception.getData(); this.exceptionType = exception.getType().getName(); this.exceptionRevision = exception.getType().getRevision(); }
private static void putDeadlineScope(JobDataMap jobData, ScopeDescriptor deadlineScope, Serializer serializer) { SerializedObject<byte[]> serializedDeadlineScope = serializer.serialize(deadlineScope, byte[].class); jobData.put(SERIALIZED_DEADLINE_SCOPE, serializedDeadlineScope.getData()); jobData.put(SERIALIZED_DEADLINE_SCOPE_CLASS_NAME, serializedDeadlineScope.getType().getName()); }