Java JsType类代码示例

import jsinterop.annotations.JsType; //导入依赖的package包/类
@GwtIncompatible
private static final boolean isJsObject(Class<?> type) {
    JsType jsType = type.getAnnotation(JsType.class);
    if (jsType == null) {
        return false;
    }
    if (!jsType.isNative()) {
        return false;
    }
    if (!JsPackage.GLOBAL.equals(jsType.namespace())) {
        return false;
    }
    if (!"Object".equals(jsType.name())) {
        return false;
    }
    return true;
}
 

import jsinterop.annotations.JsType; //导入依赖的package包/类
/**
 * Generate and save the Java file for the typeElement passed to the constructor
 * @param directiveTypeElement The {@link VueDirective} class to
 * generate {@link VueDirectiveOptions} from
 */
public void generate(TypeElement directiveTypeElement)
{
    ClassName optionsClassName = GenerationNameUtil.directiveOptionsName(directiveTypeElement);

    Builder componentClassBuilder = TypeSpec
        .classBuilder(optionsClassName)
        .addModifiers(Modifier.PUBLIC, Modifier.FINAL)
        .superclass(VueDirectiveOptions.class)
        .addAnnotation(JsType.class)
        .addJavadoc("VueComponent Directive Options for directive {@link $S}",
            directiveTypeElement.getQualifiedName().toString());

    // Initialize constructor
    MethodSpec.Builder constructorBuilder =
        MethodSpec.constructorBuilder().addModifiers(Modifier.PUBLIC);

    // Add the Java Component Instance initialization
    constructorBuilder.addStatement("this.$L = new $T()",
        "vuegwt$javaDirectiveInstance",
        TypeName.get(directiveTypeElement.asType()));

    // Call the method to copy hooks functions
    constructorBuilder.addStatement("this.copyHooks()");

    // Finish building the constructor
    componentClassBuilder.addMethod(constructorBuilder.build());

    // Build the DirectiveOptions class
    GenerationUtil.toJavaFile(filer,
        componentClassBuilder,
        optionsClassName,
        directiveTypeElement);
}
 

import jsinterop.annotations.JsType; //导入依赖的package包/类
/**
 * Create and return the builder for the JsType of our {@link VueComponent}.
 * @param component The {@link VueComponent} we are generating for
 * @param jsTypeClassName The name of the generated JsType class
 * @return A Builder to build the class
 */
private Builder getComponentJsTypeBuilder(TypeElement component, ClassName jsTypeClassName)
{
    Builder componentJsTypeBuilder = TypeSpec
        .classBuilder(jsTypeClassName)
        .addModifiers(Modifier.PUBLIC)
        .superclass(TypeName.get(component.asType()));

    // Add @JsType annotation. This ensure this class is included.
    // As we use a class reference to use our Components, this class would be removed by GWT
    // tree shaking.
    componentJsTypeBuilder.addAnnotation(AnnotationSpec
        .builder(JsType.class)
        .addMember("namespace", "\"VueGWT.javaComponentConstructors\"")
        .addMember("name", "$S", component.getQualifiedName().toString().replaceAll("\\.", "_"))
        .build());

    // Add a block that registers the VueFactory for the VueComponent
    componentJsTypeBuilder.addStaticBlock(CodeBlock
        .builder()
        .addStatement("$T.onReady(() -> $T.register($S, () -> $T.get()))",
            VueGWT.class,
            VueGWT.class,
            component.getQualifiedName(),
            componentFactoryName(component))
        .build());

    return componentJsTypeBuilder;
}
 

import jsinterop.annotations.JsType; //导入依赖的package包/类
@Override
protected List<CodeBlock> createInitMethod(TypeElement component, Builder vueFactoryBuilder)
{
    JsType jsType = component.getAnnotation(JsType.class);
    if (jsType == null || !jsType.isNative())
    {
        messager.printMessage(Kind.ERROR,
            component.asType().toString()
                + " @JsComponent must have a @JsType annotation with isNative to true");
        return null;
    }
    if (!JsPackage.GLOBAL.equals(jsType.namespace()))
    {
        messager.printMessage(Kind.ERROR,
            component.asType().toString()
                + " @JsType annotation on @JsComponent must have namespace set to JsPackage.GLOBAL");
        return null;
    }

    JsComponent jsComponent = component.getAnnotation(JsComponent.class);

    MethodSpec.Builder initBuilder =
        MethodSpec.methodBuilder("init").addModifiers(Modifier.PRIVATE);

    if ("Function".equals(jsType.name()))
    {
        initForComponentConstructor(jsComponent, initBuilder);
    }
    else if ("Object".equals(jsType.name()))
    {
        initForComponentOptions(jsComponent, initBuilder);
    }
    else
    {
        messager.printMessage(Kind.ERROR,
            component.asType().toString()
                + " @JsType annotation on @JsComponent must have name set to either Function or Object.");
    }

    vueFactoryBuilder.addMethod(initBuilder.build());
    return new LinkedList<>();
}
 

import jsinterop.annotations.JsType; //导入依赖的package包/类
/**
 * Return weather a given field is visible in JS (JsInterop).
 * It will be the case if it's public and it's class has the {@link JsType} annotation, or
 * if it has the {@link JsProperty} annotation.
 * @param field The field to check
 * @return true if it is visible (JsInterop), false otherwise
 */
public static boolean isFieldVisibleInJS(VariableElement field)
{
    return (hasAnnotation(field.getEnclosingElement(), JsType.class) && field
        .getModifiers()
        .contains(Modifier.PUBLIC)) || hasAnnotation(field, JsProperty.class);
}
 

import jsinterop.annotations.JsType; //导入依赖的package包/类
/**
 * Return weather a given method is visible in JS (JsInterop).
 * It will be the case if it's public and it's class/interface has the {@link JsType}
 * annotation, or
 * if it has the {@link JsMethod} annotation.
 * @param method The method to check
 * @return true if it is visible (JsInterop), false otherwise
 */
public static boolean isMethodVisibleInJS(ExecutableElement method)
{
    return (hasAnnotation(method.getEnclosingElement(), JsType.class) && method
        .getModifiers()
        .contains(Modifier.PUBLIC)) || hasAnnotation(method, JsMethod.class);
}