Java JavaResource类代码示例

import org.jboss.forge.addon.parser.java.resources.JavaResource; //导入依赖的package包/类
public static void modifyJavaClass(Project project, String className, Optional<String> packageName,
                                   JavaClassSourceDecorator decorator) {

   final String packageLocation = packageName.orElseGet(() -> project.getFacet(MetadataFacet.class).getProjectGroupName());
   final JavaSourceFacet sourceFacet = project.getFacet(JavaSourceFacet.class);
   final DirectoryResource targetPackage = sourceFacet.getPackage(packageLocation);

   final JavaResource sbAppResource = targetPackage.getChild(className).as(JavaResource.class);
   if (sbAppResource.exists()) {
      JavaClassSource sbApp = Roaster.parse(JavaClassSource.class, sbAppResource.getResourceInputStream());

      decorator.modify(sbApp);

      sourceFacet.saveJavaSource(sbApp);
   }
}
 

import org.jboss.forge.addon.parser.java.resources.JavaResource; //导入依赖的package包/类
public TestPackageNameCompleter(JavaSourceFacet facet) {
    // find package names in the source code
    facet.visitJavaTestSources(new JavaResourceVisitor() {
        @Override
        public void visit(VisitContext context, JavaResource javaResource) {
            try {
                // avoid package-info.java files
                if (!javaResource.getName().contains("package-info")) {
                    JavaClass clazz = javaResource.getJavaType();
                    String packageName = clazz.getPackage();
                    if (packageName != null && !packageNames.contains(packageName)) {
                        packageNames.add(packageName);
                    }
                }
            } catch (FileNotFoundException e) {
                // ignore
            }
        }
    });
}
 

import org.jboss.forge.addon.parser.java.resources.JavaResource; //导入依赖的package包/类
public PackageNameCompleter(JavaSourceFacet facet) {
    // find package names in the source code
    facet.visitJavaSources(new JavaResourceVisitor() {
        @Override
        public void visit(VisitContext context, JavaResource javaResource) {
            try {
                // avoid package-info.java files
                if (!javaResource.getName().contains("package-info")) {
                    JavaClass clazz = javaResource.getJavaType();
                    String packageName = clazz.getPackage();
                    if (packageName != null && !packageNames.contains(packageName)) {
                        packageNames.add(packageName);
                    }
                }
            } catch (FileNotFoundException e) {
                // ignore
            }
        }
    });
}
 

import org.jboss.forge.addon.parser.java.resources.JavaResource; //导入依赖的package包/类
@Override
public void visit(VisitContext visitContext, JavaResource resource) {
    try {
        // avoid package-info.java files
        if (!resource.getName().contains("package-info")) {
            JavaClassSource clazz = resource.getJavaType();
            String fqn = resource.getFullyQualifiedName();
            String name = clazz.getQualifiedName();
            String baseDir = facet.getSourceDirectory().getFullyQualifiedName();

            boolean include = true;
            if (filter != null) {
                Boolean out = filter.apply(name);
                LOG.info("Filter " + name + " -> " + out);
                include = out == null || out;
            }

            if (include) {
                RouteBuilderParser.parseRouteBuilderEndpoints(clazz, baseDir, fqn, endpoints);
            }
        }
    } catch (Throwable e) {
        // ignore
    }
}
 

import org.jboss.forge.addon.parser.java.resources.JavaResource; //导入依赖的package包/类
public RouteBuilderCompleter(JavaSourceFacet facet) {
    // find package names in the source code
    facet.visitJavaSources(new JavaResourceVisitor() {
        @Override
        public void visit(VisitContext context, JavaResource javaResource) {
            try {
                // avoid package-info.java files
                if (!javaResource.getName().contains("package-info")) {
                    JavaClass clazz = javaResource.getJavaType();
                    String superType = clazz.getSuperType();
                    if (superType != null && isRouteBuilder(superType)) {
                        routeBuilders.add(clazz.getQualifiedName());
                        packages.add(clazz.getPackage());
                    }
                }
            } catch (FileNotFoundException e) {
                // ignore
            }
        }
    });
}
 

import org.jboss.forge.addon.parser.java.resources.JavaResource; //导入依赖的package包/类
private void createJavaSourceForComponent(Project project, String schemeName, String packageName, String className) {
    JavaSourceFacet facet = project.getFacet(JavaSourceFacet.class);
    String fqn = packageName + "." + className;

    JavaResource existing = facet.getJavaResource(fqn);
    if (existing != null && existing.exists()) {
        // override existing
        existing.delete();
    }

    // need to parse to be able to extends another class
    final JavaClassSource javaClass = Roaster.create(JavaClassSource.class);
    javaClass.setName(className);
    javaClass.setPackage(packageName);
    javaClass.setSuperType("DjangoComponent");
    javaClass.addImport("io.fabric8.django.component.connector.DjangoComponent");

    // add public no-arg constructor
    javaClass.addMethod().setPublic().setConstructor(true).setBody("super(\"" + schemeName + "\", \"" + fqn + "\");");

    facet.saveJavaSource(javaClass);
}
 

import org.jboss.forge.addon.parser.java.resources.JavaResource; //导入依赖的package包/类
@Override
public void visit(VisitContext context, JavaResource javaResource)
{
   if (!found)
   {
      try
      {
         JavaSource<?> javaSource = javaResource.getJavaType();
         if (javaSource instanceof JavaClass)
         {
            JavaClass<?> javaClass = (JavaClass<?>) javaSource;
            if (javaClass.getName().equals(entityName + "Endpoint") && javaClass.hasAnnotation(Path.class))
            {
               this.path = javaClass.getAnnotation(Path.class).getStringValue();
               found = true;
            }
         }
      }
      catch (FileNotFoundException e)
      {
         throw new RuntimeException(e);
      }
   }
}
 

import org.jboss.forge.addon.parser.java.resources.JavaResource; //导入依赖的package包/类
@Override
public void visit(VisitContext context, JavaResource javaResource)
{
   if (!found)
   {
      try
      {
         JavaSource<?> javaType = javaResource.getJavaType();
         if (javaType.getAnnotation("javax.ws.rs.Path") != null)
         {
            String path = javaType.getAnnotation("javax.ws.rs.Path")
                     .getStringValue();
            String absolutePath = path.endsWith("/") ? path.substring(0, path.lastIndexOf('/')) : path;
            if (absolutePath.equals(proposedPath))
            {
               javaSource = javaType;
               found = true;
            }
         }
      }
      catch (FileNotFoundException e)
      {
         throw new RuntimeException(e);
      }
   }
}
 

import org.jboss.forge.addon.parser.java.resources.JavaResource; //导入依赖的package包/类
@Override
public void validate(UIValidationContext context) {
	Project selectedProject = getSelectedProject(context);
	JavaSourceFacet javaFacet = selectedProject.getFacet(JavaSourceFacet.class);
	try {
		if (null == context.getCurrentInputComponent().getValue())
			return;
		JavaResource javaResource = javaFacet.getJavaResource((String)context.getCurrentInputComponent().getValue());
		if (javaResource.exists()) {
			if (!javaResource.getJavaType().hasAnnotation(Named.class)) {
				context.addValidationError(context.getCurrentInputComponent(), javaResource.getFullyQualifiedName() + " must be annotated with @Named");
			}
		}
	} catch (FileNotFoundException e) {
		context.addValidationError(context.getCurrentInputComponent(), e.getMessage());
	}				
}
 

import org.jboss.forge.addon.parser.java.resources.JavaResource; //导入依赖的package包/类
@Override
public List<JavaClassSource> getAllEntities()
{
   final List<JavaClassSource> result = new ArrayList<>();
   JavaSourceFacet javaSourceFacet = getFaceted().getFacet(JavaSourceFacet.class);
   javaSourceFacet.visitJavaSources(new JavaResourceVisitor()
   {
      @Override
      public void visit(VisitContext context, JavaResource resource)
      {
         try
         {
            JavaType<?> type = resource.getJavaType();
            if (type.hasAnnotation(Entity.class) && type.isClass())
            {
               result.add((JavaClassSource) type);
            }
         }
         catch (FileNotFoundException e)
         {
            throw new IllegalStateException(e);
         }
      }
   });

   return result;
}
 

import org.jboss.forge.addon.parser.java.resources.JavaResource; //导入依赖的package包/类
protected Result addEndpointJava(Project project, JavaSourceFacet facet, JavaResource file, String uri,
                                 String endpointInstanceName, String routeBuilder, String cursorPosition) throws Exception {

    JavaClassSource clazz = file.getJavaType();

    // we do not want to change the current code formatting so we need to search
    // replace the unformatted class source code
    StringBuilder sb = new StringBuilder(clazz.toUnformattedString());

    int pos = Integer.valueOf(cursorPosition);

    // move to end if pos is after the content
    pos = Math.min(sb.length(), pos);

    LOG.info("Adding endpoint at pos: " + pos + " in file: " + routeBuilder);

    // check if prev and next is a quote and if not then add it automatic
    int prev = pos - 1;
    int next = pos + 1;
    char ch = sb.charAt(prev);
    char ch2 = next < sb.length() ? sb.charAt(next) : ' ';
    if (ch != '"' && ch2 != '"') {
        uri = "\"" + uri + "\"";
    }

    // insert uri at position
    sb.insert(pos, uri);

    // use this code currently to save content unformatted
    file.setContents(sb.toString());

    return Results.success("Added endpoint " + uri + " in " + routeBuilder);
}
 

import org.jboss.forge.addon.parser.java.resources.JavaResource; //导入依赖的package包/类
private String addJavaVerticle(Project project, String packageName, String className, boolean isMain) {
  JavaSourceFacet source = project.getFacet(JavaSourceFacet.class);

  String topLevelPackage;
  if (packageName == null) {
    topLevelPackage = source.getBasePackage();
  } else {
    topLevelPackage = packageName;
  }

  if (className.endsWith(".java")) {
    className = className.substring(0, className.length() - ".java".length());
  }

  JavaClassSource mainVerticle = Roaster.create(JavaClassSource.class)
      .setPackage(topLevelPackage)
      .setAbstract(false)
      .setName(className)
      .setSuperType("io.vertx.core.AbstractVerticle");
  mainVerticle
      .addImport("io.vertx.core.*");
  mainVerticle.addMethod().setName("start").setBody(
      "vertx.createHttpServer().requestHandler(req -> req.response().end(\"Hello World!\")).listen(8080);")
      .setPublic()
      .addAnnotation(Override.class);

  JavaResource resource = source.saveJavaSource(mainVerticle.getEnclosingType());

  if (isMain) {
    ForgeUtils.addPropertyToProject(project, "vertx.verticle", topLevelPackage + "." + className);
  }
  addJavaVerticleTest(project,packageName,className);
  return resource.toString();
}
 

import org.jboss.forge.addon.parser.java.resources.JavaResource; //导入依赖的package包/类
@Test
public void testExecution() throws Exception
{
   Assert.assertTrue(project.hasFacet(WildFlySwarmFacet.class));
   try (CommandController controller = uiTestHarness.createCommandController(CreateMainClassCommand.class,
            project.getRoot()))
   {
      controller.initialize();
      controller.setValueFor("targetPackage", "org.example");
      Assert.assertTrue(controller.isValid());
      final AtomicBoolean flag = new AtomicBoolean();
      controller.getContext().addCommandExecutionListener(new AbstractCommandExecutionListener()
      {
         @Override
         public void postCommandExecuted(UICommand command, UIExecutionContext context, Result result)
         {
            if (result.getMessage().equals("Main Class org.example.Main was created"))
            {
               flag.set(true);
            }
         }
      });
      controller.execute();
      Assert.assertTrue("Class not created", flag.get());
   }
   JavaResource javaResource = project.getFacet(JavaSourceFacet.class).getJavaResource("org.example.Main");
   Assert.assertTrue(javaResource.exists());
   WildFlySwarmFacet facet = project.getFacet(WildFlySwarmFacet.class);
   Assert.assertEquals("org.example.Main", facet.getConfiguration().getMainClass());
}
 

import org.jboss.forge.addon.parser.java.resources.JavaResource; //导入依赖的package包/类
public List<String> scan(JavaResource resource) throws FileNotFoundException {
	Set<String> result = new HashSet<>();
	
	for(Import imp : resource.getJavaSource().getImports()) {
		for(Map.Entry<String, String[]> entry : categories.entrySet()) {
			for(String pack : entry.getValue()) {
				if(imp.getPackage().startsWith(pack)) {
					result.add(entry.getKey());
				}
			}
		}
	}
	return new ArrayList<>(result);
}
 

import org.jboss.forge.addon.parser.java.resources.JavaResource; //导入依赖的package包/类
private JavaClassSource getJavaClass(String qualifiedType)
{
   JavaSourceFacet java = this.project.getFacet(JavaSourceFacet.class);
   try
   {
      JavaResource resource = java.getJavaResource(qualifiedType);
      JavaClassSource javaClass = resource.getJavaType();
      return javaClass;
   }
   catch (FileNotFoundException fileEx)
   {
      throw new RuntimeException(fileEx);
   }
}