Java ASTTransformation类代码示例

import org.codehaus.groovy.transform.ASTTransformation; //导入依赖的package包/类
private void initialize(final SourceUnit source) {
    ServiceLoaderUtils.load(getClass().getClassLoader(), "META-INF/annotations/", AnnotationHandler.class, new ServiceLoaderUtils.LineProcessor() {
        @Override
        @SuppressWarnings("unchecked")
        public void process(@Nonnull ClassLoader classLoader, @Nonnull Class<?> type, @Nonnull String line) {
            String[] parts = line.trim().split("=");
            String annotationClassName = parts[0].trim();
            String transformationClassName = parts[1].trim();
            try {
                Class<?> transformationClass = classLoader.loadClass(transformationClassName);
                transformations.put(annotationClassName, (Class<? extends ASTTransformation>) transformationClass);
            } catch (Exception e) {
                source.addException(e);
            }
        }
    });
}
 

import org.codehaus.groovy.transform.ASTTransformation; //导入依赖的package包/类
/**
 * Create a new {@link GroovyCompiler} instance.
 * @param configuration the compiler configuration
 */
public GroovyCompiler(final GroovyCompilerConfiguration configuration) {

	this.configuration = configuration;
	this.loader = createLoader(configuration);

	DependencyResolutionContext resolutionContext = new DependencyResolutionContext();

	AetherGrapeEngine grapeEngine = AetherGrapeEngineFactory.create(this.loader,
			configuration.getRepositoryConfiguration(), resolutionContext);

	GrapeEngineInstaller.install(grapeEngine);

	this.loader.getConfiguration()
			.addCompilationCustomizers(new CompilerAutoConfigureCustomizer());
	if (configuration.isAutoconfigure()) {
		this.compilerAutoConfigurations = ServiceLoader
				.load(CompilerAutoConfiguration.class);
	}
	else {
		this.compilerAutoConfigurations = Collections.emptySet();
	}

	this.transformations = new ArrayList<ASTTransformation>();
	this.transformations
			.add(new DependencyManagementBomTransformation(resolutionContext));
	this.transformations.add(new DependencyAutoConfigurationTransformation(
			this.loader, resolutionContext, this.compilerAutoConfigurations));
	this.transformations.add(new GroovyBeansTransformation());
	if (this.configuration.isGuessDependencies()) {
		this.transformations.add(
				new ResolveDependencyCoordinatesTransformation(resolutionContext));
	}
	for (ASTTransformation transformation : ServiceLoader
			.load(SpringBootAstTransformation.class)) {
		this.transformations.add(transformation);
	}
	Collections.sort(this.transformations, AnnotationAwareOrderComparator.INSTANCE);
}
 

import org.codehaus.groovy.transform.ASTTransformation; //导入依赖的package包/类
@SuppressWarnings({ "rawtypes", "unchecked" })
private void processConversionOperations(LinkedList conversionOperations) {
	int index = getIndexOfASTTransformationVisitor(conversionOperations);
	conversionOperations.add(index, new CompilationUnit.SourceUnitOperation() {
		@Override
		public void call(SourceUnit source) throws CompilationFailedException {
			ASTNode[] nodes = new ASTNode[] { source.getAST() };
			for (ASTTransformation transformation : GroovyCompiler.this.transformations) {
				transformation.visit(nodes, source);
			}
		}
	});
}
 

import org.codehaus.groovy.transform.ASTTransformation; //导入依赖的package包/类
public void addTransform(Class<? extends ASTTransformation> transform, ASTNode node) {
    GroovyASTTransformation annotation = transform.getAnnotation(GroovyASTTransformation.class);
    if (annotation == null) return;

    Set<ASTNode> nodes = getTransformInstances().get(annotation.phase()).get(transform);
    if (nodes == null) {
        nodes = new LinkedHashSet<ASTNode>();
        getTransformInstances().get(annotation.phase()).put(transform, nodes);
    }
    nodes.add(node);
}
 

import org.codehaus.groovy.transform.ASTTransformation; //导入依赖的package包/类
private Map<CompilePhase, Map<Class<? extends ASTTransformation>, Set<ASTNode>>> getTransformInstances() {
    if(transformInstances == null){
        transformInstances = new EnumMap<CompilePhase, Map<Class <? extends ASTTransformation>, Set<ASTNode>>>(CompilePhase.class);
        for (CompilePhase phase : CompilePhase.values()) {
            transformInstances.put(phase, new LinkedHashMap<Class <? extends ASTTransformation>, Set<ASTNode>>());
        }
    }
    return transformInstances;
}
 

import org.codehaus.groovy.transform.ASTTransformation; //导入依赖的package包/类
private void visitAnnotationsOnNode(AnnotatedNode node, ClassNode owner) {
    for (AnnotationNode annotationNode : node.getAnnotations()) {
        Class<? extends ASTTransformation> transformationClass = transformations.get(annotationNode.getClassNode().getName());
        if (transformationClass == null) continue;
        GroovyASTTransformation annotation = transformationClass.getAnnotation(GroovyASTTransformation.class);
        if (annotation == null) continue;
        // Set<ASTNode> nodes = owner.getTransforms(annotation.phase()).get(transformationClass);
        // if (nodes != null && !nodes.isEmpty()) continue;
        owner.addTransform(transformationClass, annotationNode);
    }
}
 

import org.codehaus.groovy.transform.ASTTransformation; //导入依赖的package包/类
@Override
public void addTransform(final Class<? extends ASTTransformation> transform, final ASTNode node) {
    throw new UnsupportedOperationException();
}
 

import org.codehaus.groovy.transform.ASTTransformation; //导入依赖的package包/类
public Map<Class <? extends ASTTransformation>, Set<ASTNode>> getTransforms(CompilePhase phase) {
    return getTransformInstances().get(phase);
}
 

import org.codehaus.groovy.transform.ASTTransformation; //导入依赖的package包/类
/**
 * Return a mutable list of the {@link ASTTransformation}s to be applied during
 * {@link #compile(String...)}.
 * @return the AST transformations to apply
 */
public List<ASTTransformation> getAstTransformations() {
	return this.transformations;
}