Java Resource类代码示例

import org.raml.model.Resource; //导入依赖的package包/类
@Test
public void shouldFlattenResourceList() throws Exception {
    final Raml raml = new Raml();

    final Resource usersResource = new Resource();
    final Resource userResource = new Resource();
    final Resource userSettingsResource = new Resource();

    usersResource.getResources().put("/{userId}", userResource);
    userResource.getResources().put("/settings", userSettingsResource);

    raml.getResources().put("/users", usersResource);

    final List<Resource> flattenned = ResourceList.of(Lists.newArrayList(usersResource))
            .flatten()
            .collect(toList());

    assertThat(flattenned, containsInAnyOrder(usersResource, userResource, userSettingsResource));
}
 

import org.raml.model.Resource; //导入依赖的package包/类
private String buildTemplate() {
	Resource oResource=action.getResource();
	String oUrl=oResource.getRelativeUri();
	while(oResource.getParentResource()!=null) {
		oResource=oResource.getParentResource();
		oUrl=oResource.getRelativeUri()+oUrl;
	}
	if(!Utils.hasBeenResolved(root.getBaseUri())) {
		oUrl=root.getBaseUri()+oUrl;
	}
	oResource=action.getResource();
	while(oResource!=null) {
		oUrl=Resolver.resolve(oUrl, oResource.getUriParameters(), "[UriParameter]");
		oResource=oResource.getParentResource();
	}
	return oUrl;
}
 

import org.raml.model.Resource; //导入依赖的package包/类
private void createDataObject(Resource resource, DataObjectInfo parentDataObject, Resource parentResource)
{
  String name = extractResourceNameFromUriPath(resource);
  // name can be null when it is  top-level resource consisting of only a slask, or only uri params
  // which should be very unlikely
  name = name==null ? "Root" : name;
  DataObjectInfo doi = new DataObjectInfo(name, resource.getUri());
  doi.setXmlPayload(false);
  dataObjectInfos.add(doi);

  // loop over the various actions (HTTP Verbs) of the resource
  // if the action is GET , we process the REQUEST body and add the attributes
  // found in the request example or request schema reference. The GET resource is also set as
  // findALl method/ If a nested GET resource is found with the path consisting entirely of a path param,
  // we assume this is the "getCanonical" resource. The sample/schema attributes of this nested GET resource
  // will also be added to the data object.
  // if it is a non-GET action, we process the RESPONSE with code 200 or 201 and add the attributes found
  // in the response example or response schema reference
  processResourceActions(resource, doi, parentDataObject, false);
  // loop over nested resources. If the whole nested resource path just consist of uri parameters, and
  // no additional naming, we treat this as additional resources for the current data object, otherwise
  // we treat it as a child resource and we make a recursive call to create new child data object
  processNestedResources(resource, parentDataObject, doi); 
}
 

import org.raml.model.Resource; //导入依赖的package包/类
private void processNestedResources(Resource resource, DataObjectInfo parentDataObject, DataObjectInfo doi)
{
  Map<String, Resource> nestedResources = resource.getResources();
  for (Resource nestedResource : nestedResources.values())
  {
    boolean pathOnlyContainsParams = checkPathOnlyContainsParams(nestedResource);
    if (pathOnlyContainsParams)
    {
      processResourceActions(nestedResource, doi, parentDataObject, true);
      // make recursive call to walk down resource tree
      processNestedResources(nestedResource, parentDataObject, doi);
    }
    else
    {
      // child resource, recursive call to processNestedResources is made inside createDataObject
      createDataObject(nestedResource, doi, resource);
    }
  }
}
 

import org.raml.model.Resource; //导入依赖的package包/类
private void processResourceActions(Resource resource, DataObjectInfo doi, DataObjectInfo parentDataObject, boolean isNestedResource)
{
  Map<ActionType, Action> actions = resource.getActions();
  for (ActionType actionType: actions.keySet())
  {
    Action action = actions.get(actionType);
    if ("GET".equalsIgnoreCase(actionType.name()))
    {
      processGETResponse(resource, doi, parentDataObject, action, isNestedResource);
    }
    else
    {
      processNonGETRequest(resource, doi, parentDataObject, action);
    }
  }
}
 

import org.raml.model.Resource; //导入依赖的package包/类
private boolean checkPathOnlyContainsParams(Resource childResource)
{
  String uri = childResource.getRelativeUri();
  // replace all params and their enclosing curly brackets with emmpty string
  // also replace "/" with empty string, the remainder is the name, which can be 
  // an empty string if path consists entirely of uri params
  uri = StringUtils.substitute(uri, "/", "");
  Map<String, UriParameter> params = childResource.getUriParameters();
  for (String paramName : params.keySet())
  {
    uri = StringUtils.substitute(uri, "{"+paramName+"}", "");
  }
  if (uri.trim().equals(""))
  {
    uri=null;
  }
  return uri==null;
}
 

import org.raml.model.Resource; //导入依赖的package包/类
private void register(final Resource resource)
{
	final Map<String, ?> methods = getMap(collector, resource.getUri());

	final List<String> rIs = resource.getIs();

	resource.getActions().values().stream().forEach(a -> {
		final Map<String, ?> attributes = getMap(methods, a.getType().toString());

		// a.getIs().forEach(i -> addValue(attributes, "request.is." + i, "true"));
		// rIs.forEach(i -> addValue(attributes, "request.is." + i, "true"));

		a.getQueryParameters().entrySet().forEach(q -> addValue(attributes, "request.query." + q.getKey(),
				q.getValue().getExample(), q.getValue().getDefaultValue()));

		a.getResponses().entrySet().forEach(r -> {
			addValue(attributes, "response.status", r.getKey());
			r.getValue().getHeaders().entrySet().forEach(h -> addValue(attributes, "response.header." + h.getKey(),
					h.getValue().getExample(), h.getValue().getDefaultValue()));
		});

		a.getHeaders().entrySet().forEach(h -> addValue(attributes, "request.header." + h.getKey(),
				h.getValue().getExample(),
				h.getValue().getDefaultValue()));
	});
}
 

import org.raml.model.Resource; //导入依赖的package包/类
@SuppressWarnings("unchecked")
protected static Map<String, Object> getResourceMapping(Resource resource) {
	Map<String, Object> map = (Map<String, Object>) Generator.currentRamlMap;
	List<String> keys = getResourcePaths(resource);
	String uri = null;

	for (String key : keys) {
		if (StringUtils.isEmpty(key)) {
			continue;
		}
		
		uri = key;
		map = (Map<String, Object>) map.get(key);
	}
	
	map.put("uri", uri);
	return map;
}
 

import org.raml.model.Resource; //导入依赖的package包/类
private static List<String> getResourcePaths(Resource resource) {
	List<String> paths = new ArrayList<String>();
	String uri = resource.getUri();
	
	Resource parent = resource.getParentResource();
	if (parent != null) {
		for (String path : getResourcePaths(parent)) {
			paths.add(path);
		}
		uri = uri.replace(parent.getUri(), "");
	}
	
	paths.add(uri);
	
	return paths;
}
 

import org.raml.model.Resource; //导入依赖的package包/类
public void traverse() {
  notifyStartTraversal();
  notifyStartApiInformation();

  for (final Map.Entry<String, Resource> resource : raml.getResources().entrySet()) {
    eachListener(new ListenerFunction() {
      @Override
      public void apply(RamlTraversalListener listener) {
        listener.startResource(resource.getKey(), resource.getValue());
        // ACTIONS etc.
        listener.endResource(resource.getKey(), resource.getValue());
      }
    });
  }

  notifyEndTraversal();
}
 

import org.raml.model.Resource; //导入依赖的package包/类
/**
 * Add all project verticles to the list resources.
 * 
 * @param resources
 * @throws IOException
 * @throws Exception
 */
private void addProjectEndpoints(Map<String, Resource> resources) throws IOException {
	NodeEndpoint nodeEndpoint = Mockito.spy(new NodeEndpoint());
	initEndpoint(nodeEndpoint);
	String projectBasePath = "/{project}";
	addEndpoints(projectBasePath, resources, nodeEndpoint);

	TagFamilyEndpoint tagFamilyEndpoint = Mockito.spy(new TagFamilyEndpoint());
	initEndpoint(tagFamilyEndpoint);
	addEndpoints(projectBasePath, resources, tagFamilyEndpoint);

	NavRootEndpoint navEndpoint = Mockito.spy(new NavRootEndpoint());
	initEndpoint(navEndpoint);
	addEndpoints(projectBasePath, resources, navEndpoint);

	WebRootEndpoint webEndpoint = Mockito.spy(new WebRootEndpoint());
	initEndpoint(webEndpoint);
	addEndpoints(projectBasePath, resources, webEndpoint);

	ReleaseEndpoint releaseEndpoint = Mockito.spy(new ReleaseEndpoint());
	initEndpoint(releaseEndpoint);
	addEndpoints(projectBasePath, resources, releaseEndpoint);

	GraphQLEndpoint graphqlEndpoint = Mockito.spy(new GraphQLEndpoint());
	initEndpoint(graphqlEndpoint);
	addEndpoints(projectBasePath, resources, graphqlEndpoint);

	ProjectSearchEndpointImpl projectSearchEndpoint = Mockito.spy(new ProjectSearchEndpointImpl());
	initEndpoint(projectSearchEndpoint);
	addEndpoints(projectBasePath, resources, projectSearchEndpoint);

	ProjectSchemaEndpoint projectSchemaEndpoint = Mockito.spy(new ProjectSchemaEndpoint());
	initEndpoint(projectSchemaEndpoint);
	addEndpoints(projectBasePath, resources, projectSchemaEndpoint);

	ProjectMicroschemaEndpoint projectMicroschemaEndpoint = Mockito.spy(new ProjectMicroschemaEndpoint());
	initEndpoint(projectMicroschemaEndpoint);
	addEndpoints(projectBasePath, resources, projectMicroschemaEndpoint);

}
 

import org.raml.model.Resource; //导入依赖的package包/类
public static MethodSpec baseResource(Resource resource, String basePackage, String confFName, String reqSupplFName) {
    return MethodSpec.methodBuilder(uncapitalize(classPart(resource)))
            .returns(ClassName.get(basePackage + "." + packageName(resource), className(resource)))
            .addStatement("return new $N($N.$N.get())", className(resource), confFName, reqSupplFName)
            .addModifiers(PUBLIC)
            .build();
}
 

import org.raml.model.Resource; //导入依赖的package包/类
public static MethodSpec childResource(Resource resource, String basePackage, String reqSpecFName) {
    String methodName = uncapitalize(classPart(resource));
    
    return MethodSpec.methodBuilder(methodName)
            .returns(ClassName.get(basePackage + "." + packageName(resource), className(resource)))
            .addStatement("return new $N($N)", className(resource), reqSpecFName)
            .addModifiers(PUBLIC)
            .build();
}
 

import org.raml.model.Resource; //导入依赖的package包/类
public static ApiResourceClass forResource(Resource resource) {
    ApiResourceClass apiClass = new ApiResourceClass();
    apiClass.resource = resource;
    apiClass.packageName = packageName(resource);
    apiClass.className = className(resource);
    return apiClass;
}
 

import org.raml.model.Resource; //导入依赖的package包/类
public static String classPart(Resource resource) {
    if (resource == null) {
        return "";
    }

    String name = isNotEmpty(resource.getDisplayName())
            ? sanitize(resource.getDisplayName())
            : sanitize(resource.getRelativeUri())
            .replace(".", "");

    return capitalize(name.contains("/") ? substringAfterLast(name, "/") : name);
}