public class Reservation  {

  @ApiModelProperty(value = "")
  private Traveller leadTraveller = null;

  @ApiModelProperty(example = "2", value = "")
  private Integer sourceSystemID = null;

  @ApiModelProperty(value = "")
  private String recordLocation = null;

  @ApiModelProperty(example = "2010", value = "")
  private Integer recordLocatorYear = null;

}

{
    "leadTraveller": {
        "firstNames": "firstNames",
        "lastName": "lastName",
        "email": "email",
        "travellerGUID": "travellerGUID",
        "travellerRefs": [{
            "customerReportingRank": 37,
            "value": "value",
            "description": "description"
        }]
    },
    "sourceSystemID": 38,
    "recordLocation": "recordLocation",
    "recordLocatorYear": 9
}

<dependency>
    <groupId>fctg-ngrp</groupId>
    <artifactId>model-core</artifactId>
    <version>1.0.4-SNAPSHOT-MODEL-CORE</version>
</dependency>
<dependency>
    <groupId>io.vavr</groupId>
    <artifactId>vavr</artifactId>
    <version>0.9.2</version>
    <scope>test</scope>
</dependency>

import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.google.common.io.Files;
import io.vavr.API;
import io.vavr.collection.Array;

import java.io.IOException;
import java.io.PrintWriter;
import java.io.StringWriter;
import java.lang.reflect.Field;
import java.lang.reflect.ParameterizedType;
import java.math.BigDecimal;
import java.nio.charset.StandardCharsets;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.OffsetDateTime;
import java.time.format.DateTimeFormatter;
import java.util.*;
import java.util.stream.Collectors;

/**
 * Sample utility for generating dummy JSON sample code from a JAva class directly.
 */
public class GenerateJSONFromClasses {

    private static final Random R = new Random();

    /**
     * Used to avoid infinite loops.
     */
    private static final Map<Class<?>, Integer> visited = new HashMap<>();

    private static final ObjectMapper mapper = new ObjectMapper();

    public static void main(String[] args) throws IOException {
        Class<Reservation> clazz = Reservation.class;
        generateDummyJSON(clazz, args);
    }

    public static void generateDummyJSON(Class<Reservation> clazz, String... paths) throws IOException {
        StringWriter out = new StringWriter();
        try (PrintWriter writer = new PrintWriter(out)) {
            writer.println(printObj(clazz));
            JsonNode jsonNode = mapper.readTree(out.toString());
            String prettyJson = mapper.writerWithDefaultPrettyPrinter().writeValueAsString(jsonNode);
            if (paths == null || paths.length == 0) {
                System.out.println(prettyJson);
            } else {
                Array.of(paths).map(sPath -> Paths.get(sPath))
                        .map(Path::toFile)
                        .map(API.unchecked(file -> {
                            Files.write(prettyJson, file, StandardCharsets.UTF_8);
                            return file;
                        }));
            }
        }
    }

    private static String printObj(Class<?> clazz) {
        if (!visited.containsKey(clazz) || visited.get(clazz) <= 1) {
            visited.merge(clazz, 1, (integer, integer2) -> integer + integer2);
            Field[] declaredFields = clazz.getDeclaredFields();
            return "{" +
                    Array.of(declaredFields).map(field -> String.format("  \"%s\" : %s%n", field.getName(), printFieldValue(field)))
                            .collect(Collectors.joining(String.format(",%n"))) +
                    "}";
        }
        return "";
    }

    private static Object printFieldValue(Field field) {
        Class<?> fieldType = field.getType();
        if (String.class.equals(fieldType)) {
            return String.format("\"%s\"", field.getName());
        } else if (Integer.class.equals(fieldType)) {
            return R.nextInt(99) + 1;
        } else if (LocalDate.class.equals(fieldType)) {
            return String.format("\"%s\"", LocalDate.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd")));
        } else if (LocalDateTime.class.equals(fieldType)) {
            return String.format("\"%s\"", LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd'T'HH:mm:ss")));
        } else if (OffsetDateTime.class.equals(fieldType)) {
            return String.format("\"%s\"", LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd'T'HH:mm:ss")));
        } else if (Date.class.equals(fieldType)) {
            return System.currentTimeMillis();
        } else if (List.class.equals(fieldType)) {
            ParameterizedType parameterizedType = (ParameterizedType) field.getGenericType();
            Class<?> clazz = (Class<?>) parameterizedType.getActualTypeArguments()[0];
            return String.format("[%s]", printObj(clazz));
        } else if (fieldType.isAssignableFrom(Number.class)) {
            return R.nextDouble() * 10.0;
        } else if (BigDecimal.class.equals(fieldType)) {
            return new BigDecimal(R.nextDouble() * 10.0);
        } else if (Boolean.class.equals(fieldType)) {
            return R.nextBoolean();
        } else {
            return printObj(fieldType);
        }
    }
}