import org.codehaus.jackson.schema.JsonSchema; //导入依赖的package包/类
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);
}
 

import org.codehaus.jackson.schema.JsonSchema; //导入依赖的package包/类
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;
}
 

import org.codehaus.jackson.schema.JsonSchema; //导入依赖的package包/类
@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;
}
 

import org.codehaus.jackson.schema.JsonSchema; //导入依赖的package包/类
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);
    }
}
 

import org.codehaus.jackson.schema.JsonSchema; //导入依赖的package包/类
public JsonNode getSchema(SerializerProvider paramSerializerProvider, Type paramType)
  throws JsonMappingException
{
  if ((this._valueSerializer instanceof SchemaAware))
    return ((SchemaAware)this._valueSerializer).getSchema(paramSerializerProvider, null);
  return JsonSchema.getDefaultSchemaNode();
}
 

import org.codehaus.jackson.schema.JsonSchema; //导入依赖的package包/类
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;
}
 

import org.codehaus.jackson.schema.JsonSchema; //导入依赖的package包/类
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);
}
 

import org.codehaus.jackson.schema.JsonSchema; //导入依赖的package包/类
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;
}
 

import org.codehaus.jackson.schema.JsonSchema; //导入依赖的package包/类
public JsonNode getSchema(SerializerProvider provider, Type typeHint)
    throws JsonMappingException
{
    return (_valueSerializer instanceof SchemaAware) ?
            ((SchemaAware) _valueSerializer).getSchema(provider, null) :
            JsonSchema.getDefaultSchemaNode();
}
 

import org.codehaus.jackson.schema.JsonSchema; //导入依赖的package包/类
@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;
}
 

import org.codehaus.jackson.schema.JsonSchema; //导入依赖的package包/类
@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);
}
 

import org.codehaus.jackson.schema.JsonSchema; //导入依赖的package包/类
@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;
}
 

import org.codehaus.jackson.schema.JsonSchema; //导入依赖的package包/类
@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("======================");
}
 

import org.codehaus.jackson.schema.JsonSchema; //导入依赖的package包/类
@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("======================");
}
 

import org.codehaus.jackson.schema.JsonSchema; //导入依赖的package包/类
@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("======================");
}
 

import org.codehaus.jackson.schema.JsonSchema; //导入依赖的package包/类
@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("======================");
}
 

import org.codehaus.jackson.schema.JsonSchema; //导入依赖的package包/类
@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("======================");
}
 

import org.codehaus.jackson.schema.JsonSchema; //导入依赖的package包/类
@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;
}
 

import org.codehaus.jackson.schema.JsonSchema; //导入依赖的package包/类
public JsonSchema generateJsonSchema(Class<?> paramClass)
  throws JsonMappingException
{
  return generateJsonSchema(paramClass, copySerializationConfig());
}
 

import org.codehaus.jackson.schema.JsonSchema; //导入依赖的package包/类
public abstract JsonSchema generateJsonSchema(Class<?> paramClass, SerializationConfig paramSerializationConfig, SerializerFactory paramSerializerFactory)
throws JsonMappingException;