public static void main(String[] args) throws JsonMappingException { ObjectMapper jsonMapper = new ObjectMapper(); AnnotationIntrospector introspector = new AnnotationIntrospector.Pair(new JaxbAnnotationIntrospector(), new JacksonAnnotationIntrospector()); jsonMapper.setAnnotationIntrospector(introspector); JsonSchema schema = jsonMapper.generateJsonSchema(Testi.class); if(Testi.class.getAnnotation(XmlRootElement.class)!=null && !Testi.class.getAnnotation(XmlRootElement.class).name().equals("##default")) schema.getSchemaNode().put("name", Testi.class.getAnnotation(XmlRootElement.class).name()); else if(Testi.class.getAnnotation(XmlType.class)!=null && !Testi.class.getAnnotation(XmlType.class).name().equals("##default")) schema.getSchemaNode().put("name", Testi.class.getAnnotation(XmlType.class).name()); else schema.getSchemaNode().put("name", Testi.class.getSimpleName()); String schemaJson = schema.toString(); System.out.println(schemaJson); }
public JsonNode getSchema(SerializerProvider provider, Type typeHint) throws JsonMappingException { ObjectNode o = createSchemaNode("array", true); if (typeHint != null) { JavaType javaType = TypeFactory.type(typeHint); if (javaType.isArrayType()) { Class<?> componentType = ((ArrayType) javaType).getContentType().getRawClass(); JsonSerializer<Object> ser = provider.findValueSerializer(componentType); JsonNode schemaNode = (ser instanceof SchemaAware) ? ((SchemaAware) ser).getSchema(provider, null) : JsonSchema.getDefaultSchemaNode(); o.put("items", schemaNode); } } return o; }
@SuppressWarnings("unchecked") @Override public JsonNode getSchema(SerializerProvider provider, Type typeHint) throws JsonMappingException { ObjectNode o = createSchemaNode("object", true); if (typeHint instanceof ParameterizedType) { Type[] typeArgs = ((ParameterizedType) typeHint).getActualTypeArguments(); if (typeArgs.length == 2) { JavaType enumType = TypeFactory.type(typeArgs[0]); JavaType valueType = TypeFactory.type(typeArgs[1]); ObjectNode propsNode = JsonNodeFactory.instance.objectNode(); Class<Enum<?>> enumClass = (Class<Enum<?>>) enumType.getRawClass(); for (Enum<?> enumValue : enumClass.getEnumConstants()) { JsonSerializer<Object> ser = provider.findValueSerializer(valueType.getRawClass()); JsonNode schemaNode = (ser instanceof SchemaAware) ? ((SchemaAware) ser).getSchema(provider, null) : JsonSchema.getDefaultSchemaNode(); propsNode.put(provider.getConfig().getAnnotationIntrospector().findEnumValue((Enum<?>)enumValue), schemaNode); } o.put("properties", propsNode); } } return o; }
public DeploymentRequestHandler() { m_mapper = new ObjectMapper(); //Mixin for to not output passwords. m_mapper.getSerializationConfig().addMixInAnnotations(UsersType.User.class, IgnorePasswordMixIn.class); //We want jackson to stop closing streams m_mapper.configure(JsonGenerator.Feature.AUTO_CLOSE_TARGET, false); try { JsonSchema schema = m_mapper.generateJsonSchema(DeploymentType.class); m_schema = schema.toString(); } catch (JsonMappingException ex) { m_log.warn("Failed to generate JSON schema: ", ex); } }
public JsonNode getSchema(SerializerProvider paramSerializerProvider, Type paramType) throws JsonMappingException { if ((this._valueSerializer instanceof SchemaAware)) return ((SchemaAware)this._valueSerializer).getSchema(paramSerializerProvider, null); return JsonSchema.getDefaultSchemaNode(); }
public JsonNode getSchema(SerializerProvider paramSerializerProvider, Type paramType) throws JsonMappingException { ObjectNode localObjectNode = createSchemaNode("array", true); JavaType localJavaType = null; if (paramType != null) { localJavaType = paramSerializerProvider.constructType(paramType).getContentType(); if ((localJavaType == null) && ((paramType instanceof ParameterizedType))) { Type[] arrayOfType = ((ParameterizedType)paramType).getActualTypeArguments(); if (arrayOfType.length == 1) localJavaType = paramSerializerProvider.constructType(arrayOfType[0]); } } if ((localJavaType == null) && (this._elementType != null)) localJavaType = this._elementType; if (localJavaType != null) { Class localClass = localJavaType.getRawClass(); JsonNode localJsonNode = null; if (localClass != Object.class) { JsonSerializer localJsonSerializer = paramSerializerProvider.findValueSerializer(localJavaType, this._property); boolean bool = localJsonSerializer instanceof SchemaAware; localJsonNode = null; if (bool) localJsonNode = ((SchemaAware)localJsonSerializer).getSchema(paramSerializerProvider, null); } if (localJsonNode == null) localJsonNode = JsonSchema.getDefaultSchemaNode(); localObjectNode.put("items", localJsonNode); } return localObjectNode; }
public JsonSchema generateJsonSchema(Class<?> paramClass, SerializationConfig paramSerializationConfig, SerializerFactory paramSerializerFactory) throws JsonMappingException { if (paramClass == null) throw new IllegalArgumentException("A class must be provided"); StdSerializerProvider localStdSerializerProvider = createInstance(paramSerializationConfig, paramSerializerFactory); if (localStdSerializerProvider.getClass() != getClass()) throw new IllegalStateException("Broken serializer provider: createInstance returned instance of type " + localStdSerializerProvider.getClass() + "; blueprint of type " + getClass()); JsonSerializer localJsonSerializer = localStdSerializerProvider.findValueSerializer(paramClass, null); if ((localJsonSerializer instanceof SchemaAware)); for (JsonNode localJsonNode = ((SchemaAware)localJsonSerializer).getSchema(localStdSerializerProvider, null); !(localJsonNode instanceof ObjectNode); localJsonNode = JsonSchema.getDefaultSchemaNode()) throw new IllegalArgumentException("Class " + paramClass.getName() + " would not be serialized as a JSON object and therefore has no schema"); return new JsonSchema((ObjectNode)localJsonNode); }
public JsonNode getSchema(SerializerProvider paramSerializerProvider, Type paramType) throws JsonMappingException { ObjectNode localObjectNode1 = createSchemaNode("object", true); if ((paramType instanceof ParameterizedType)) { Type[] arrayOfType = ((ParameterizedType)paramType).getActualTypeArguments(); if (arrayOfType.length == 2) { JavaType localJavaType1 = paramSerializerProvider.constructType(arrayOfType[0]); JavaType localJavaType2 = paramSerializerProvider.constructType(arrayOfType[1]); ObjectNode localObjectNode2 = JsonNodeFactory.instance.objectNode(); Enum[] arrayOfEnum = (Enum[])localJavaType1.getRawClass().getEnumConstants(); int i = arrayOfEnum.length; int j = 0; if (j < i) { Enum localEnum = arrayOfEnum[j]; JsonSerializer localJsonSerializer = paramSerializerProvider.findValueSerializer(localJavaType2.getRawClass(), this._property); if ((localJsonSerializer instanceof SchemaAware)); for (JsonNode localJsonNode = ((SchemaAware)localJsonSerializer).getSchema(paramSerializerProvider, null); ; localJsonNode = JsonSchema.getDefaultSchemaNode()) { localObjectNode2.put(paramSerializerProvider.getConfig().getAnnotationIntrospector().findEnumValue(localEnum), localJsonNode); j++; break; } } localObjectNode1.put("properties", localObjectNode2); } } return localObjectNode1; }
public JsonNode getSchema(SerializerProvider provider, Type typeHint) throws JsonMappingException { return (_valueSerializer instanceof SchemaAware) ? ((SchemaAware) _valueSerializer).getSchema(provider, null) : JsonSchema.getDefaultSchemaNode(); }
@Override public JsonNode getSchema(SerializerProvider provider, Type typeHint) throws JsonMappingException { /* 15-Jan-2010, tatu: This should probably be rewritten, given that * more information about content type is actually being explicitly * passed. So there should be less need to try to re-process that * information. */ ObjectNode o = createSchemaNode("array", true); JavaType contentType = null; if (typeHint != null) { JavaType javaType = TypeFactory.type(typeHint); contentType = javaType.getContentType(); if (contentType == null) { // could still be parametrized (Iterators) if (typeHint instanceof ParameterizedType) { Type[] typeArgs = ((ParameterizedType) typeHint).getActualTypeArguments(); if (typeArgs.length == 1) { contentType = TypeFactory.type(typeArgs[0]); } } } } if (contentType == null && _elementType != null) { contentType = _elementType; } if (contentType != null) { JsonSerializer<Object> ser = provider.findValueSerializer(contentType); JsonNode schemaNode = (ser instanceof SchemaAware) ? ((SchemaAware) ser).getSchema(provider, null) : JsonSchema.getDefaultSchemaNode(); o.put("items", schemaNode); } return o; }
@Override public JsonSchema generateJsonSchema(Class<?> type, SerializationConfig config, SerializerFactory jsf) throws JsonMappingException { if (type == null) { throw new IllegalArgumentException("A class must be provided."); } /* First: we need a separate instance, which will hold a copy of the * non-shared ("local") read-only lookup Map for fast * class-to-serializer lookup */ StdSerializerProvider inst = createInstance(config, jsf); // sanity check to avoid weird errors; to ensure sub-classes do override createInstance if (inst.getClass() != getClass()) { throw new IllegalStateException("Broken serializer provider: createInstance returned instance of type "+inst.getClass()+"; blueprint of type "+getClass()); } /* no need for embedded type information for JSON schema generation (all * type information it needs is accessible via "untyped" serializer) */ JsonSerializer<Object> ser = inst.findValueSerializer(type); JsonNode schemaNode = (ser instanceof SchemaAware) ? ((SchemaAware) ser).getSchema(inst, null) : JsonSchema.getDefaultSchemaNode(); if (!(schemaNode instanceof ObjectNode)) { throw new IllegalArgumentException("Class " + type.getName() + " would not be serialized as a JSON object and therefore has no schema."); } return new JsonSchema((ObjectNode) schemaNode); }
@Override public JsonNode getSchema(SerializerProvider provider, Type typeHint) throws JsonMappingException { ObjectNode o = createSchemaNode("object", true); //todo: should the classname go in the title? //o.put("title", _className); ObjectNode propertiesNode = o.objectNode(); for (int i = 0; i < _props.length; i++) { BeanPropertyWriter prop = _props[i]; Type hint = prop.getRawSerializationType(); if (hint == null) { hint = prop.getGenericPropertyType(); } // Maybe it already has annotated/statically configured serializer? JsonSerializer<Object> ser = prop.getSerializer(); if (ser == null) { // nope Class<?> serType = prop.getRawSerializationType(); if (serType == null) { serType = prop.getPropertyType(); } ser = provider.findValueSerializer(serType); } JsonNode schemaNode = (ser instanceof SchemaAware) ? ((SchemaAware) ser).getSchema(provider, hint) : JsonSchema.getDefaultSchemaNode(); o.put("items", schemaNode); propertiesNode.put(prop.getName(), schemaNode); } o.put("properties", propertiesNode); return o; }
@Test public void generateSimpleResponse( ) throws JsonMappingException { ObjectMapper mapper = new ObjectMapper(); JsonSchema jsonSchema = mapper.generateJsonSchema(Response.class); System.out.println("Response:"); System.out.println(""); System.out.println(jsonSchema.toString()); System.out.println(""); System.out.println("======================"); }
@Test public void generateLoginResponse( ) throws JsonMappingException { ObjectMapper mapper = new ObjectMapper(); JsonSchema jsonSchema = mapper.generateJsonSchema(LoginResponse.class); System.out.println("Login Response:"); System.out.println(""); System.out.println(jsonSchema.toString()); System.out.println(""); System.out.println("======================"); }
@Test public void generateFetchResponse( ) throws JsonMappingException { ObjectMapper mapper = new ObjectMapper(); JsonSchema jsonSchema = mapper.generateJsonSchema(FetchMessagesResponse.class); System.out.println("Fetch Response:"); System.out.println(""); System.out.println(jsonSchema.toString()); System.out.println(""); System.out.println("======================"); }
@Test public void generateMessageResponse( ) throws JsonMappingException { ObjectMapper mapper = new ObjectMapper(); JsonSchema jsonSchema = mapper.generateJsonSchema(Message.class); System.out.println("Message:"); System.out.println(""); System.out.println(jsonSchema.toString()); System.out.println(""); System.out.println("======================"); }
@Test public void generateAccountResponse( ) throws JsonMappingException { ObjectMapper mapper = new ObjectMapper(); JsonSchema jsonSchema = mapper.generateJsonSchema(Account.class); System.out.println("Account:"); System.out.println(""); System.out.println(jsonSchema.toString()); System.out.println(""); System.out.println("======================"); }
@Override public JsonNode getSchema(SerializerProvider provider, Type typeHint) throws JsonMappingException { ObjectNode o = createSchemaNode("object", true); //todo: should the classname go in the title? //o.put("title", _className); ObjectNode propertiesNode = o.objectNode(); for (int i = 0; i < _props.length; i++) { BeanPropertyWriter prop = _props[i]; JavaType propType = prop.getSerializationType(); // 03-Dec-2010, tatu: SchemaAware REALLY should use JavaType, but alas it doesn't... Type hint = (propType == null) ? prop.getGenericPropertyType() : propType.getRawClass(); // Maybe it already has annotated/statically configured serializer? JsonSerializer<Object> ser = prop.getSerializer(); if (ser == null) { // nope Class<?> serType = prop.getRawSerializationType(); if (serType == null) { serType = prop.getPropertyType(); } ser = provider.findValueSerializer(serType, prop); } JsonNode schemaNode = (ser instanceof SchemaAware) ? ((SchemaAware) ser).getSchema(provider, hint) : JsonSchema.getDefaultSchemaNode(); if(prop.getAnnotation(XmlAttribute.class)!=null && schemaNode instanceof ObjectNode) ((ObjectNode)schemaNode).put("isattr", true); propertiesNode.put(prop.getName(), schemaNode); } o.put("properties", propertiesNode); if(typeHint instanceof Class) { Class<?> claz = (Class<?>)typeHint; if(claz.getAnnotation(XmlRootElement.class)!=null && !claz.getAnnotation(XmlRootElement.class).name().equals("##default")) o.put("name", claz.getAnnotation(XmlRootElement.class).name()); else if(claz.getAnnotation(XmlType.class)!=null && !claz.getAnnotation(XmlType.class).name().equals("##default")) o.put("name", claz.getAnnotation(XmlType.class).name()); else o.put("name", claz.getSimpleName()); } return o; }
public JsonSchema generateJsonSchema(Class<?> paramClass) throws JsonMappingException { return generateJsonSchema(paramClass, copySerializationConfig()); }
public JsonSchema generateJsonSchema(Class<?> paramClass, SerializationConfig paramSerializationConfig) throws JsonMappingException { return this._serializerProvider.generateJsonSchema(paramClass, paramSerializationConfig, this._serializerFactory); }
public abstract JsonSchema generateJsonSchema(Class<?> paramClass, SerializationConfig paramSerializationConfig, SerializerFactory paramSerializerFactory) throws JsonMappingException;
/** * Generate <a href="http://json-schema.org/">Json-schema</a> * instance for specified class. * * @param t The class to generate schema for * @return Constructed JSON schema. */ public JsonSchema generateJsonSchema(Class<?> t) throws JsonMappingException { return generateJsonSchema(t, copySerializationConfig()); }
/** * Generate <a href="http://json-schema.org/">Json-schema</a> * instance for specified class, using specific * serialization configuration * * @param t The class to generate schema for * @return Constructed JSON schema. */ public JsonSchema generateJsonSchema(Class<?> t, SerializationConfig cfg) throws JsonMappingException { return _serializerProvider.generateJsonSchema(t, cfg, _serializerFactory); }
/** * Generate <a href="http://json-schema.org/">Json-schema</a> for * given type. * * @param type The type for which to generate schema */ public abstract JsonSchema generateJsonSchema(Class<?> type, SerializationConfig config, SerializerFactory jsf) throws JsonMappingException;
