com.github.javaparser.ast.nodeTypes.NodeWithAnnotations Java Examples

@Override
public <T extends NodeWithAnnotations<?>> T withConfigInjection(T node, String configKey, String defaultValue) {
    node.addAnnotation(new NormalAnnotationExpr(
            new Name("org.eclipse.microprofile.config.inject.ConfigProperty"),
            NodeList.nodeList(
                    new MemberValuePair("name", new StringLiteralExpr(configKey)),
                    new MemberValuePair("defaultValue", new StringLiteralExpr(defaultValue))
            )
    ));
    return node;
}
 

/**
 * Annotates given node with set of roles to enforce security
 *
 * @param node  node to be annotated
 * @param roles roles that are allowed
 */
default <T extends NodeWithAnnotations<?>> T withSecurityRoles(T node, String[] roles) {
    if (roles != null && roles.length > 0) {
        List<Expression> rolesExpr = new ArrayList<>();

        for (String role : roles) {
            rolesExpr.add(new StringLiteralExpr(role.trim()));
        }

        node.addAnnotation(new SingleMemberAnnotationExpr(new Name("javax.annotation.security.RolesAllowed"), new ArrayInitializerExpr(NodeList.nodeList(rolesExpr))));
    }
    return node;
}
 

@Override
public <T extends NodeWithAnnotations<?>> T withConfigInjection(T node, String configKey) {
    node.addAnnotation(new NormalAnnotationExpr(
            new Name("org.eclipse.microprofile.config.inject.ConfigProperty"),
            NodeList.nodeList(
                    new MemberValuePair("name", new StringLiteralExpr(configKey))
            )
    ));
    return node;
}
 

/**
 * 是否存在任意一个注解
 * @param node
 * @param annotationNames
 * @return
 */
public static boolean any(NodeWithAnnotations node, Iterable<String> annotationNames) {
    for (String annotationName : annotationNames) {
        if (node.isAnnotationPresent(annotationName)) {
            return true;
        }
    }
    return false;
}
 

/**
 * 获取注解的属性String类型的值
 * @param node
 * @param annotation
 * @param keys
 * @return
 */
@SuppressWarnings("unchecked")
public static Optional<String> string(NodeWithAnnotations node, String annotation, String ... keys) {
    Optional<AnnotationExpr> optional = node.getAnnotationByName(annotation);
    if (optional.isPresent()) {
        Optional<Expression> expr = AnnotationHelper.attr(optional.get(), keys);
        if (expr.isPresent()) {
            return Optional.of(ExpressionHelper.getStringValue(expr.get()));
        }
    }
    return Optional.empty();
}
 

@Override
public <T extends NodeWithAnnotations<?>> T withOptionalInjection(T node) {
    node.addAnnotation(new NormalAnnotationExpr(new Name("org.springframework.beans.factory.annotation.Autowired"), NodeList.nodeList(new MemberValuePair("required", new BooleanLiteralExpr(false)))));
    return node;
}
 

@Override
protected NodeWithAnnotations getAnnotatedMember() {
    return type;
}
 

@Override
public <T extends NodeWithAnnotations<?>> T withNamed(T node, String name) {
    node.addAnnotation(new SingleMemberAnnotationExpr(new Name("org.springframework.beans.factory.annotation.Qualifier"), new StringLiteralExpr(name)));
    return node;
}
 

@Override
public <T extends NodeWithAnnotations<?>> T withApplicationComponent(T node) {
    node.addAnnotation("org.springframework.stereotype.Component");
    return node;
}
 

@Override
public <T extends NodeWithAnnotations<?>> T withNamedApplicationComponent(T node, String name) {
    node.addAnnotation(new SingleMemberAnnotationExpr(new Name("org.springframework.stereotype.Component"), new StringLiteralExpr(name)));
    return node;
}
 

@Override
public <T extends NodeWithAnnotations<?>> T withSingletonComponent(T node) {
    return withApplicationComponent(node);
}
 

@Override
public <T extends NodeWithAnnotations<?>> T withNamedSingletonComponent(T node, String name) {
    return withNamedApplicationComponent(node, name);
}
 

@Override
public <T extends NodeWithAnnotations<?>> T withInjection(T node) {
    node.addAnnotation("org.springframework.beans.factory.annotation.Autowired");
    return node;
}
 

@Override
public <T extends NodeWithAnnotations<?>> T withNamedInjection(T node, String name) {
    return withNamed(withInjection(node), name);
}
 

static List<Annotation> parseAnnotation(NodeWithAnnotations<? extends Node> nodeWithAnnotations, Member member) {
    NodeList<AnnotationExpr> annotationExprs = nodeWithAnnotations.getAnnotations();

    if (annotationExprs != null && annotationExprs.size() > 0) {
        List<Annotation> annotations = new ArrayList<Annotation>();

        for (AnnotationExpr annotationExpr : annotationExprs) {
            Annotation annotation = null;

            if (annotationExpr instanceof MarkerAnnotationExpr) {
                annotation = new MarkerAnnotation();
            } else if (annotationExpr instanceof SingleMemberAnnotationExpr) {
                SingleMemberAnnotationExpr singleMemberAnnotationExpr = (SingleMemberAnnotationExpr) annotationExpr;

                annotation = new SingleAnnotation();


                SingleAnnotation singleAnnotation = (SingleAnnotation) annotation;
                singleAnnotation.setValue(annotationValueTrim(singleMemberAnnotationExpr.getMemberValue().toString()));
            } else if (annotationExpr instanceof NormalAnnotationExpr) {
                NormalAnnotationExpr normalAnnotationExpr = (NormalAnnotationExpr) annotationExpr;

                annotation = new NormalAnnotation();

                NormalAnnotation normalAnnotation = (NormalAnnotation) annotation;

                List<NormalAnnotation.Pair> pairList = new ArrayList<NormalAnnotation.Pair>();

                for (MemberValuePair memberValuePair : normalAnnotationExpr.getPairs()) {
                    NormalAnnotation.Pair pair = new NormalAnnotation.Pair();
                    pair.setName(memberValuePair.getNameAsString());
                    pair.setValue(annotationValueTrim(memberValuePair.getValue().toString()));
                    pairList.add(pair);
                }
                normalAnnotation.setPairList(pairList);
            }

            if (annotation != null) {
                annotation.setName(annotationExpr.getNameAsString());
                annotation.setMember(member);
                annotations.add(annotation);
            }
        }

        return annotations;
    }
    return null;
}
 

@Override
public <T extends NodeWithAnnotations<?>> T withIncomingMessage(T node, String channel) {
    node.addAnnotation(new NormalAnnotationExpr(new Name("org.springframework.kafka.annotation.KafkaListener"), NodeList.nodeList(new MemberValuePair("topics", new StringLiteralExpr(channel)))));
    return node;
}
 

@Override
public <T extends NodeWithAnnotations<?>> T withApplicationComponent(T node) {
    node.addAnnotation("javax.enterprise.context.ApplicationScoped");
    return node;
}
 

private void processAnnotations(SimpleGroovyParameter param, NodeWithAnnotations<?> n) {
    for (AnnotationExpr an : n.getAnnotations()) {
        param.addAnnotationRef(new SimpleGroovyAnnotationRef(an.getNameAsString(), getAnnotationText(an)));
    }
}
 

@Override
public <T extends NodeWithAnnotations<?>> T withOutgoingMessage(T node, String channel) {
    // currently no-op
    return node;
}
 

@Override
public <T extends NodeWithAnnotations<?>> T withConfigInjection(T node, String configKey) {
    node.addAnnotation(new SingleMemberAnnotationExpr(new Name("org.springframework.beans.factory.annotation.Value"), new StringLiteralExpr("${" + configKey + ":#{null}}")));
    return node;
}
 

@Override
public <T extends NodeWithAnnotations<?>> T withConfigInjection(T node, String configKey, String defaultValue) {
    node.addAnnotation(new SingleMemberAnnotationExpr(new Name("org.springframework.beans.factory.annotation.Value"), new StringLiteralExpr("${" + configKey + ":" + defaultValue + "}")));
    return node;
}
 

private void processAnnotations(SimpleGroovyProgramElementDoc element, NodeWithAnnotations<?> n) {
    for (AnnotationExpr an : n.getAnnotations()) {
        element.addAnnotationRef(new SimpleGroovyAnnotationRef(an.getNameAsString(), getAnnotationText(an)));
    }
}
 

@Override
public <T extends NodeWithAnnotations<?>> T withNamed(T node, String name) {
    node.addAnnotation(new SingleMemberAnnotationExpr(new Name("javax.inject.Named"), new StringLiteralExpr(name)));
    return node;
}
 

@Override
public <T extends NodeWithAnnotations<?>> T withNamedApplicationComponent(T node, String name) {
    return withNamed(withApplicationComponent(node), name);
}
 

@Override
public <T extends NodeWithAnnotations<?>> T withSingletonComponent(T node) {
    node.addAnnotation("javax.inject.Singleton");
    return node;
}
 

@Override
public <T extends NodeWithAnnotations<?>> T withNamedSingletonComponent(T node, String name) {
    return withNamed(withSingletonComponent(node), name);
}
 

@Override
public <T extends NodeWithAnnotations<?>> T withInjection(T node) {
    node.addAnnotation("javax.inject.Inject");
    return node;
}
 

@Override
public <T extends NodeWithAnnotations<?>> T withNamedInjection(T node, String name) {
    return withNamed(withInjection(node), name);
}
 

@Override
public <T extends NodeWithAnnotations<?>> T withOptionalInjection(T node) {
    return withInjection(node);
}
 

@Override
public <T extends NodeWithAnnotations<?>> T withIncomingMessage(T node, String channel) {
    node.addAnnotation(new SingleMemberAnnotationExpr(new Name("org.eclipse.microprofile.reactive.messaging.Incoming"), new StringLiteralExpr(channel)));
    return node;
}