com.gruelbox.transactionoutbox.DefaultInvocationSerializer Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of transactionoutbox-core Show documentation
Show all versions of transactionoutbox-core Show documentation
A safe implementation of the transactional outbox pattern for Java (core library)
package com.gruelbox.transactionoutbox;
import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
import com.google.gson.JsonArray;
import com.google.gson.JsonDeserializationContext;
import com.google.gson.JsonDeserializer;
import com.google.gson.JsonElement;
import com.google.gson.JsonObject;
import com.google.gson.JsonParseException;
import com.google.gson.JsonSerializationContext;
import com.google.gson.JsonSerializer;
import com.google.gson.TypeAdapter;
import com.google.gson.stream.JsonReader;
import com.google.gson.stream.JsonToken;
import com.google.gson.stream.JsonWriter;
import java.io.IOException;
import java.io.Reader;
import java.io.Writer;
import java.lang.reflect.Modifier;
import java.lang.reflect.Type;
import java.math.BigDecimal;
import java.text.ParseException;
import java.text.ParsePosition;
import java.time.*;
import java.time.format.DateTimeFormatter;
import java.time.temporal.ChronoUnit;
import java.util.Calendar;
import java.util.Date;
import java.util.GregorianCalendar;
import java.util.HashMap;
import java.util.Locale;
import java.util.Map;
import java.util.Set;
import java.util.TimeZone;
import java.util.UUID;
import lombok.Builder;
import lombok.extern.slf4j.Slf4j;
/**
* A locked-down serializer which supports a limited list of primitives and simple JDK value types.
* Only the following are supported:
*
*
* - {@link Invocation} itself
*
- Primitive types such as {@code int} or {@code double} or the boxed equivalents
*
- {@link String}
*
- {@link java.util.Date}
*
- {@link java.util.UUID}
*
- The {@code java.time} classes:
*
* - {@link java.time.DayOfWeek}
*
- {@link java.time.Duration}
*
- {@link java.time.Instant}
*
- {@link java.time.LocalDate}
*
- {@link java.time.LocalDateTime}
*
- {@link java.time.ZonedDateTime}
*
- {@link java.time.Month}
*
- {@link java.time.MonthDay}
*
- {@link java.time.Period}
*
- {@link java.time.Year}
*
- {@link java.time.YearMonth}
*
- {@link java.time.ZoneOffset}
*
- {@link java.time.DayOfWeek}
*
- {@link java.time.temporal.ChronoUnit}
*
* - Arrays specifically typed to one of the above types
*
- Any types specifically passed in, which must be GSON compatible.
*
*/
@Slf4j
public final class DefaultInvocationSerializer implements InvocationSerializer {
private final Gson gson;
@Builder
DefaultInvocationSerializer(Set> serializableTypes, Integer version) {
this.gson =
new GsonBuilder()
.registerTypeAdapter(
Invocation.class,
new InvocationJsonSerializer(
serializableTypes == null ? Set.of() : serializableTypes,
version == null ? 2 : version))
.registerTypeAdapter(Date.class, new UtcDateTypeAdapter())
.registerTypeAdapter(LocalDateTime.class, new LocalDateTimeTypeAdapter())
.registerTypeAdapter(ZonedDateTime.class, new ZonedDateTimeTypeAdapter())
.registerTypeAdapter(Instant.class, new InstantTypeAdapter())
.registerTypeAdapter(Duration.class, new DurationTypeAdapter())
.registerTypeAdapter(LocalDate.class, new LocalDateTypeAdapter())
.registerTypeAdapter(MonthDay.class, new MonthDayTypeAdapter())
.registerTypeAdapter(Period.class, new PeriodTypeAdapter())
.registerTypeAdapter(Year.class, new YearTypeAdapter())
.registerTypeAdapter(YearMonth.class, new YearMonthAdapter())
.excludeFieldsWithModifiers(Modifier.TRANSIENT, Modifier.STATIC)
.create();
}
@Override
public void serializeInvocation(Invocation invocation, Writer writer) {
try {
gson.toJson(invocation, writer);
} catch (Exception e) {
throw new IllegalArgumentException("Cannot serialize " + invocation, e);
}
}
@Override
public Invocation deserializeInvocation(Reader reader) {
return gson.fromJson(reader, Invocation.class);
}
private static final class InvocationJsonSerializer
implements JsonSerializer, JsonDeserializer {
private final int version;
private final Map, String> classToName = new HashMap<>();
private final Map> nameToClass = new HashMap<>();
InvocationJsonSerializer(Set> serializableClasses, int version) {
this.version = version;
addClassPair(byte.class, "byte");
addClassPair(short.class, "short");
addClassPair(int.class, "int");
addClassPair(long.class, "long");
addClassPair(float.class, "float");
addClassPair(double.class, "double");
addClassPair(boolean.class, "boolean");
addClassPair(char.class, "char");
addClass(Byte.class);
addClass(Short.class);
addClass(Integer.class);
addClass(Long.class);
addClass(Float.class);
addClass(Double.class);
addClass(Boolean.class);
addClass(Character.class);
addClass(BigDecimal.class);
addClass(String.class);
addClass(Date.class);
addClass(UUID.class);
addClass(DayOfWeek.class);
addClass(Duration.class);
addClass(Instant.class);
addClass(LocalDate.class);
addClass(LocalDateTime.class);
addClass(ZonedDateTime.class);
addClass(Month.class);
addClass(MonthDay.class);
addClass(Period.class);
addClass(Year.class);
addClass(YearMonth.class);
addClass(ZoneOffset.class);
addClass(DayOfWeek.class);
addClass(ChronoUnit.class);
addClass(Transaction.class);
addClassPair(TransactionContextPlaceholder.class, "TransactionContext");
serializableClasses.forEach(clazz -> addClassPair(clazz, clazz.getName()));
}
private void addClass(Class clazz) {
addClassPair(clazz, clazz.getSimpleName());
}
private void addClassPair(Class clazz, String name) {
classToName.put(clazz, name);
nameToClass.put(name, clazz);
String arrayClassName = toArrayClassName(clazz);
Class arrayClass = toClass(clazz.getClassLoader(), arrayClassName);
classToName.put(arrayClass, arrayClassName);
nameToClass.put(arrayClassName, arrayClass);
}
private String toArrayClassName(Class clazz) {
if (clazz.isArray()) {
return "[" + clazz.getName();
} else if (clazz == boolean.class) {
return "[Z";
} else if (clazz == byte.class) {
return "[B";
} else if (clazz == char.class) {
return "[C";
} else if (clazz == double.class) {
return "[D";
} else if (clazz == float.class) {
return "[F";
} else if (clazz == int.class) {
return "[I";
} else if (clazz == long.class) {
return "[J";
} else if (clazz == short.class) {
return "[S";
} else {
return "[L" + clazz.getName() + ";";
}
}
private Class toClass(ClassLoader classLoader, String name) {
try {
return classLoader != null ? Class.forName(name, false, classLoader) : Class.forName(name);
} catch (ClassNotFoundException e) {
throw new RuntimeException(
"Cannot determine array type for "
+ name
+ " using "
+ (classLoader == null ? "root classloader" : "base classloader"),
e);
}
}
@Override
public JsonElement serialize(Invocation src, Type typeOfSrc, JsonSerializationContext context) {
if (version == 1) {
log.warn("Serializing as deprecated version {}", version);
return serializeV1(src, typeOfSrc, context);
}
JsonObject obj = new JsonObject();
obj.addProperty("c", src.getClassName());
obj.addProperty("m", src.getMethodName());
JsonArray params = new JsonArray();
JsonArray args = new JsonArray();
int i = 0;
for (Class parameterType : src.getParameterTypes()) {
params.add(nameForClass(parameterType));
Object arg = src.getArgs()[i];
if (arg == null) {
JsonObject jsonObject = new JsonObject();
jsonObject.add("t", null);
jsonObject.add("v", null);
args.add(jsonObject);
} else {
JsonObject jsonObject = new JsonObject();
jsonObject.addProperty("t", nameForClass(arg.getClass()));
jsonObject.add("v", context.serialize(arg));
args.add(jsonObject);
}
i++;
}
obj.add("p", params);
obj.add("a", args);
obj.add("x", context.serialize(src.getMdc()));
return obj;
}
JsonElement serializeV1(Invocation src, Type typeOfSrc, JsonSerializationContext context) {
JsonObject obj = new JsonObject();
obj.addProperty("c", src.getClassName());
obj.addProperty("m", src.getMethodName());
JsonArray params = new JsonArray();
int i = 0;
for (Class parameterType : src.getParameterTypes()) {
JsonObject jsonObject = new JsonObject();
jsonObject.addProperty("t", nameForClass(parameterType));
jsonObject.add("v", context.serialize(src.getArgs()[i]));
params.add(jsonObject);
i++;
}
obj.add("p", params);
obj.add("x", context.serialize(src.getMdc()));
return obj;
}
@Override
public Invocation deserialize(
JsonElement json, Type typeOfT, JsonDeserializationContext context)
throws JsonParseException {
JsonObject jsonObject = json.getAsJsonObject();
String className = jsonObject.get("c").getAsString();
String methodName = jsonObject.get("m").getAsString();
JsonArray jsonParams = jsonObject.get("p").getAsJsonArray();
Class[] params = new Class[jsonParams.size()];
for (int i = 0; i < jsonParams.size(); i++) {
JsonElement param = jsonParams.get(i);
if (param.isJsonObject()) {
// For backwards compatibility
params[i] = classForName(param.getAsJsonObject().get("t").getAsString());
} else {
params[i] = classForName(param.getAsString());
}
}
JsonElement argsElement = jsonObject.get("a");
if (argsElement == null) {
// For backwards compatibility
argsElement = jsonObject.get("p");
}
JsonArray jsonArgs = argsElement.getAsJsonArray();
Object[] args = new Object[jsonArgs.size()];
for (int i = 0; i < jsonArgs.size(); i++) {
JsonElement arg = jsonArgs.get(i);
JsonElement argType = arg.getAsJsonObject().get("t");
if (argType != null) {
JsonElement argValue = arg.getAsJsonObject().get("v");
Class argClass = classForName(argType.getAsString());
try {
args[i] = context.deserialize(argValue, argClass);
} catch (Exception e) {
throw new RuntimeException(
"Failed to deserialize arg [" + argValue + "] of type [" + argType + "]", e);
}
}
}
Map mdc = context.deserialize(jsonObject.get("x"), Map.class);
return new Invocation(className, methodName, params, args, mdc);
}
private Class classForName(String name) {
var clazz = nameToClass.get(name);
if (clazz == null) {
throw new IllegalArgumentException("Cannot deserialize class - not found: " + name);
}
return clazz;
}
private String nameForClass(Class clazz) {
var name = classToName.get(clazz);
if (name == null) {
throw new IllegalArgumentException(
"Cannot serialize class - not found: " + clazz.getName());
}
return name;
}
}
static final class ZonedDateTimeTypeAdapter extends TypeAdapter {
@Override
public void write(final JsonWriter out, final ZonedDateTime value) throws IOException {
out.value(value.format(DateTimeFormatter.ISO_ZONED_DATE_TIME));
}
@Override
public ZonedDateTime read(final JsonReader in) throws IOException {
return ZonedDateTime.parse(in.nextString(), DateTimeFormatter.ISO_ZONED_DATE_TIME);
}
}
static final class LocalDateTimeTypeAdapter extends TypeAdapter {
@Override
public void write(JsonWriter out, LocalDateTime value) throws IOException {
out.value(value.format(DateTimeFormatter.ISO_LOCAL_DATE_TIME));
}
@Override
public LocalDateTime read(JsonReader in) throws IOException {
return LocalDateTime.parse(in.nextString(), DateTimeFormatter.ISO_LOCAL_DATE_TIME);
}
}
static final class InstantTypeAdapter extends TypeAdapter {
@Override
public void write(JsonWriter out, Instant value) throws IOException {
out.value(DateTimeFormatter.ISO_INSTANT.format(value));
}
@Override
public Instant read(JsonReader in) throws IOException {
return DateTimeFormatter.ISO_INSTANT.parse(in.nextString(), Instant::from);
}
}
static final class DurationTypeAdapter extends TypeAdapter {
@Override
public void write(JsonWriter out, Duration value) throws IOException {
out.value(value.get(ChronoUnit.SECONDS));
}
@Override
public Duration read(JsonReader in) throws IOException {
return Duration.of(in.nextLong(), ChronoUnit.SECONDS);
}
}
static final class LocalDateTypeAdapter extends TypeAdapter {
@Override
public void write(JsonWriter out, LocalDate value) throws IOException {
out.value(DateTimeFormatter.ISO_LOCAL_DATE.format(value));
}
@Override
public LocalDate read(JsonReader in) throws IOException {
return DateTimeFormatter.ISO_LOCAL_DATE.parse(in.nextString(), LocalDate::from);
}
}
static final class MonthDayTypeAdapter extends TypeAdapter {
private final DateTimeFormatter formatter = DateTimeFormatter.ofPattern("d/M");
@Override
public void write(JsonWriter out, MonthDay value) throws IOException {
out.value(value.format(formatter));
}
@Override
public MonthDay read(JsonReader in) throws IOException {
return MonthDay.parse(in.nextString(), formatter);
}
}
static final class PeriodTypeAdapter extends TypeAdapter {
@Override
public void write(JsonWriter out, Period value) throws IOException {
out.value(value.toString());
}
@Override
public Period read(JsonReader in) throws IOException {
return Period.parse(in.nextString());
}
}
static final class YearTypeAdapter extends TypeAdapter {
@Override
public void write(JsonWriter out, Year value) throws IOException {
out.value(value.getValue());
}
@Override
public Year read(JsonReader in) throws IOException {
return Year.of(in.nextInt());
}
}
static final class YearMonthAdapter extends TypeAdapter {
@Override
public void write(JsonWriter out, YearMonth value) throws IOException {
out.value(value.toString());
}
@Override
public YearMonth read(JsonReader in) throws IOException {
return YearMonth.parse(in.nextString());
}
}
static final class UtcDateTypeAdapter extends TypeAdapter {
private final TimeZone UTC_TIME_ZONE = TimeZone.getTimeZone("UTC");
@Override
public void write(JsonWriter out, Date date) throws IOException {
if (date == null) {
out.nullValue();
} else {
String value = format(date, true, UTC_TIME_ZONE);
out.value(value);
}
}
@Override
public Date read(JsonReader in) throws IOException {
try {
if (in.peek() == JsonToken.NULL) {
in.nextNull();
return null;
}
String date = in.nextString();
// Instead of using iso8601Format.parse(value), we use Jackson's date parsing
// This is because Android doesn't support XXX because it is JDK 1.6
return parse(date, new ParsePosition(0));
} catch (ParseException e) {
throw new JsonParseException(e);
}
}
// Date parsing code from Jackson databind ISO8601Utils.java
// https://github.com/FasterXML/jackson-databind/blob/master/src/main/java/com/fasterxml/jackson/databind/util/ISO8601Utils.java
private static final String GMT_ID = "GMT";
/**
* Format date into yyyy-MM-ddThh:mm:ss[.sss][Z|[+-]hh:mm]
*
* @param date the date to format
* @param millis true to include millis precision otherwise false
* @param tz timezone to use for the formatting (GMT will produce 'Z')
* @return the date formatted as yyyy-MM-ddThh:mm:ss[.sss][Z|[+-]hh:mm]
*/
private static String format(Date date, boolean millis, TimeZone tz) {
Calendar calendar = new GregorianCalendar(tz, Locale.US);
calendar.setTime(date);
// estimate capacity of buffer as close as we can (yeah, that's pedantic ;)
int capacity = "yyyy-MM-ddThh:mm:ss".length();
capacity += millis ? ".sss".length() : 0;
capacity += tz.getRawOffset() == 0 ? "Z".length() : "+hh:mm".length();
StringBuilder formatted = new StringBuilder(capacity);
padInt(formatted, calendar.get(Calendar.YEAR), "yyyy".length());
formatted.append('-');
padInt(formatted, calendar.get(Calendar.MONTH) + 1, "MM".length());
formatted.append('-');
padInt(formatted, calendar.get(Calendar.DAY_OF_MONTH), "dd".length());
formatted.append('T');
padInt(formatted, calendar.get(Calendar.HOUR_OF_DAY), "hh".length());
formatted.append(':');
padInt(formatted, calendar.get(Calendar.MINUTE), "mm".length());
formatted.append(':');
padInt(formatted, calendar.get(Calendar.SECOND), "ss".length());
if (millis) {
formatted.append('.');
padInt(formatted, calendar.get(Calendar.MILLISECOND), "sss".length());
}
int offset = tz.getOffset(calendar.getTimeInMillis());
if (offset != 0) {
int hours = Math.abs((offset / (60 * 1000)) / 60);
int minutes = Math.abs((offset / (60 * 1000)) % 60);
formatted.append(offset < 0 ? '-' : '+');
padInt(formatted, hours, "hh".length());
formatted.append(':');
padInt(formatted, minutes, "mm".length());
} else {
formatted.append('Z');
}
return formatted.toString();
}
/**
* Zero pad a number to a specified length
*
* @param buffer buffer to use for padding
* @param value the integer value to pad if necessary.
* @param length the length of the string we should zero pad
*/
private static void padInt(StringBuilder buffer, int value, int length) {
String strValue = Integer.toString(value);
buffer.append("0".repeat(Math.max(0, length - strValue.length())));
buffer.append(strValue);
}
/**
* Parse a date from ISO-8601 formatted string. It expects a format
* [yyyy-MM-dd|yyyyMMdd][T(hh:mm[:ss[.sss]]|hhmm[ss[.sss]])]?[Z|[+-]hh:mm]]
*
* @param date ISO string to parse in the appropriate format.
* @param pos The position to start parsing from, updated to where parsing stopped.
* @return the parsed date
* @throws ParseException if the date is not in the appropriate format
*/
private static Date parse(String date, ParsePosition pos) throws ParseException {
Exception fail;
try {
int offset = pos.getIndex();
// extract year
int year = parseInt(date, offset, offset += 4);
if (checkOffset(date, offset, '-')) {
offset += 1;
}
// extract month
int month = parseInt(date, offset, offset += 2);
if (checkOffset(date, offset, '-')) {
offset += 1;
}
// extract day
int day = parseInt(date, offset, offset += 2);
// default time value
int hour = 0;
int minutes = 0;
int seconds = 0;
int milliseconds =
0; // always use 0 otherwise returned date will include millis of current time
if (checkOffset(date, offset, 'T')) {
// extract hours, minutes, seconds and milliseconds
hour = parseInt(date, offset += 1, offset += 2);
if (checkOffset(date, offset, ':')) {
offset += 1;
}
minutes = parseInt(date, offset, offset += 2);
if (checkOffset(date, offset, ':')) {
offset += 1;
}
// second and milliseconds can be optional
if (date.length() > offset) {
char c = date.charAt(offset);
if (c != 'Z' && c != '+' && c != '-') {
seconds = parseInt(date, offset, offset += 2);
// milliseconds can be optional in the format
if (checkOffset(date, offset, '.')) {
milliseconds = parseInt(date, offset += 1, offset += 3);
}
}
}
}
// extract timezone
String timezoneId;
if (date.length() <= offset) {
throw new IllegalArgumentException("No time zone indicator");
}
char timezoneIndicator = date.charAt(offset);
if (timezoneIndicator == '+' || timezoneIndicator == '-') {
String timezoneOffset = date.substring(offset);
timezoneId = GMT_ID + timezoneOffset;
offset += timezoneOffset.length();
} else if (timezoneIndicator == 'Z') {
timezoneId = GMT_ID;
offset += 1;
} else {
throw new IndexOutOfBoundsException("Invalid time zone indicator " + timezoneIndicator);
}
TimeZone timezone = TimeZone.getTimeZone(timezoneId);
if (!timezone.getID().equals(timezoneId)) {
throw new IndexOutOfBoundsException();
}
Calendar calendar = new GregorianCalendar(timezone);
calendar.setLenient(false);
calendar.set(Calendar.YEAR, year);
calendar.set(Calendar.MONTH, month - 1);
calendar.set(Calendar.DAY_OF_MONTH, day);
calendar.set(Calendar.HOUR_OF_DAY, hour);
calendar.set(Calendar.MINUTE, minutes);
calendar.set(Calendar.SECOND, seconds);
calendar.set(Calendar.MILLISECOND, milliseconds);
pos.setIndex(offset);
return calendar.getTime();
// If we get a ParseException it'll already have the right message/offset.
// Other exception types can convert here.
} catch (IndexOutOfBoundsException | IllegalArgumentException e) {
fail = e;
}
String input = (date == null) ? null : ("'" + date + "'");
throw new ParseException(
"Failed to parse date [" + input + "]: " + fail.getMessage(), pos.getIndex());
}
/**
* Check if the expected character exist at the given offset in the value.
*
* @param value the string to check at the specified offset
* @param offset the offset to look for the expected character
* @param expected the expected character
* @return true if the expected character exist at the given offset
*/
private static boolean checkOffset(String value, int offset, char expected) {
return (offset < value.length()) && (value.charAt(offset) == expected);
}
/**
* Parse an integer located between 2 given offsets in a string
*
* @param value the string to parse
* @param beginIndex the start index for the integer in the string
* @param endIndex the end index for the integer in the string
* @return the int
* @throws NumberFormatException if the value is not a number
*/
private static int parseInt(String value, int beginIndex, int endIndex)
throws NumberFormatException {
if (beginIndex < 0 || endIndex > value.length() || beginIndex > endIndex) {
throw new NumberFormatException(value);
}
// use same logic as in Integer.parseInt() but less generic we're not supporting negative
// values
int i = beginIndex;
int result = 0;
int digit;
if (i < endIndex) {
digit = Character.digit(value.charAt(i++), 10);
if (digit < 0) {
throw new NumberFormatException("Invalid number: " + value);
}
result = -digit;
}
while (i < endIndex) {
digit = Character.digit(value.charAt(i++), 10);
if (digit < 0) {
throw new NumberFormatException("Invalid number: " + value);
}
result *= 10;
result -= digit;
}
return -result;
}
}
}
© 2015 - 2025 Weber Informatics LLC | Privacy Policy