Java ClassOrInterfaceTypeDetailsBuilder.addImplementsType方法代碼示例

import org.springframework.roo.classpath.details.ClassOrInterfaceTypeDetailsBuilder; //導入方法依賴的package包/類
private void createServiceClass(final JavaType interfaceType,
        final JavaType classType) {
    Validate.notNull(classType, "Class type required");
    final String classIdentifier = pathResolver.getFocusedCanonicalPath(
            Path.SRC_MAIN_JAVA, classType);
    if (fileManager.exists(classIdentifier)) {
        return; // Type already exists - nothing to do
    }
    final String classMid = PhysicalTypeIdentifier.createIdentifier(
            classType, pathResolver.getPath(classIdentifier));
    final ClassOrInterfaceTypeDetailsBuilder classTypeBuilder = new ClassOrInterfaceTypeDetailsBuilder(
            classMid, PUBLIC, classType, CLASS);
    classTypeBuilder.addImplementsType(interfaceType);

    typeManagementService
            .createOrUpdateTypeOnDisk(classTypeBuilder.build());
}
 

import org.springframework.roo.classpath.details.ClassOrInterfaceTypeDetailsBuilder; //導入方法依賴的package包/類
private ClassOrInterfaceTypeDetails getRevisionListener() {

        // Check class exists
        ClassOrInterfaceTypeDetails innerClass = governorTypeDetails
                .getDeclaredInnerType(revisionListenerType);

        if (innerClass != null) {
            // If class exists (already push-in) we can do nothing
            return innerClass;
        }

        // Create inner class

        ClassOrInterfaceTypeDetailsBuilder classBuilder = new ClassOrInterfaceTypeDetailsBuilder(
                context.getMetadataId(), Modifier.PUBLIC + Modifier.STATIC,
                revisionListenerType, PhysicalTypeCategory.CLASS);
        classBuilder.addImplementsType(REVISION_LISTENER);

        classBuilder.addMethod(getNewRevisionMethod());

        return classBuilder.build();
    }
 

import org.springframework.roo.classpath.details.ClassOrInterfaceTypeDetailsBuilder; //導入方法依賴的package包/類
private void createPermissionEvaluator(
        final JavaPackage permissionEvaluatorPackage) {
    installPermissionEvaluatorTemplate(permissionEvaluatorPackage);
    final LogicalPath focusedSrcMainJava = LogicalPath.getInstance(
            SRC_MAIN_JAVA, getProjectOperations().getFocusedModuleName());
    JavaType permissionEvaluatorClass = new JavaType(
            permissionEvaluatorPackage.getFullyQualifiedPackageName()
                    + ".ApplicationPermissionEvaluator");
    final String identifier = getPathResolver().getFocusedCanonicalPath(
            Path.SRC_MAIN_JAVA, permissionEvaluatorClass);
    if (getFileManager().exists(identifier)) {
        return; // Type already exists - nothing to do
    }

    final AnnotationMetadataBuilder classAnnotationMetadata = new AnnotationMetadataBuilder(
            ROO_PERMISSION_EVALUATOR);
    final String classMid = PhysicalTypeIdentifier.createIdentifier(
            permissionEvaluatorClass, getPathResolver().getPath(identifier));
    final ClassOrInterfaceTypeDetailsBuilder classBuilder = new ClassOrInterfaceTypeDetailsBuilder(
            classMid, PUBLIC, permissionEvaluatorClass, CLASS);
    classBuilder.addAnnotation(classAnnotationMetadata.build());
    classBuilder.addImplementsType(PERMISSION_EVALUATOR);
    getTypeManagementService().createOrUpdateTypeOnDisk(classBuilder.build());

    getMetadataService().get(PermissionEvaluatorMetadata.createIdentifier(
            permissionEvaluatorClass, focusedSrcMainJava));
}
 

import org.springframework.roo.classpath.details.ClassOrInterfaceTypeDetailsBuilder; //導入方法依賴的package包/類
private void createConverter(final JavaPackage javaPackage,
        final JavaType entity) {
	
	if(pathResolver == null){
		pathResolver = getPathResolver();
	}
	Validate.notNull(pathResolver, "PathResolver is required");
	
	if(shell == null){
		shell = getShell();
	}
	Validate.notNull(shell, "Shell is required");
	
	if(typeManagementService == null){
		typeManagementService = getTypeManagementService();
	}
	Validate.notNull(typeManagementService, "TypeManagementService is required");
	
	// Create type annotation for new converter class
    final JavaType converterType = new JavaType(
            javaPackage.getFullyQualifiedPackageName() + "."
                    + entity.getSimpleTypeName() + "Converter");
    final AnnotationMetadataBuilder annotationBuilder = new AnnotationMetadataBuilder(
            ROO_JSF_CONVERTER);
    annotationBuilder.addClassAttribute("entity", entity);
    final String declaredByMetadataId = PhysicalTypeIdentifier
            .createIdentifier(converterType,
                    pathResolver.getFocusedPath(Path.SRC_MAIN_JAVA));
    final ClassOrInterfaceTypeDetailsBuilder cidBuilder = new ClassOrInterfaceTypeDetailsBuilder(
            declaredByMetadataId, Modifier.PUBLIC, converterType,
            PhysicalTypeCategory.CLASS);
    cidBuilder.addAnnotation(annotationBuilder);
    cidBuilder.addImplementsType(JsfJavaType.CONVERTER);

    typeManagementService.createOrUpdateTypeOnDisk(cidBuilder.build());

    shell.flash(Level.FINE,
            "Created " + converterType.getFullyQualifiedTypeName(),
            JsfOperationsImpl.class.getName());
    shell.flash(Level.FINE, "", JsfOperationsImpl.class.getName());
}
 

import org.springframework.roo.classpath.details.ClassOrInterfaceTypeDetailsBuilder; //導入方法依賴的package包/類
/**
 * This method generates the file PasswordHandler.java with the annotation
 * <code>@GvNIXPasswordHandlerSAFE</code>
 * 
 */
public void generatePasswordHandler(JavaPackage targetPackage) {
    JavaType entity = new JavaType(String.format("%s.PasswordHandler",
            targetPackage.getFullyQualifiedPackageName()));

    Validate.notNull(entity, "Entity required");

    int modifier = Modifier.PUBLIC;

    final String declaredByMetadataId = PhysicalTypeIdentifier
            .createIdentifier(entity,
                    pathResolver.getFocusedPath(Path.SRC_MAIN_JAVA));

    File targetFile = new File(
            typeLocationService
                    .getPhysicalTypeCanonicalPath(declaredByMetadataId));
    Validate.isTrue(!targetFile.exists(), "Type '%s' already exists",
            entity);

    // Prepare class builder
    final ClassOrInterfaceTypeDetailsBuilder cidBuilder = new ClassOrInterfaceTypeDetailsBuilder(
            declaredByMetadataId, modifier, entity,
            PhysicalTypeCategory.CLASS);

    // Prepare annotations array
    List<AnnotationMetadataBuilder> annotations = new ArrayList<AnnotationMetadataBuilder>(
            1);

    // Add @GvNIXPasswordHandlerSAFE annotation
    AnnotationMetadataBuilder gvnixPasswordHandlerAnnotation = new AnnotationMetadataBuilder(
            new JavaType(GvNIXPasswordHandlerSAFE.class));
    annotations.add(gvnixPasswordHandlerAnnotation);

    // Add Implements Type
    cidBuilder.addImplementsType(new JavaType(
            "javax.security.auth.callback.CallbackHandler"));

    // Set annotations
    cidBuilder.setAnnotations(annotations);

    typeManagementService.createOrUpdateTypeOnDisk(cidBuilder.build());

}
 

import org.springframework.roo.classpath.details.ClassOrInterfaceTypeDetailsBuilder; //導入方法依賴的package包/類
/**
 * This method generates the file SafeUser.java with the annotation
 * <code>@GvNIXUserSAFE</code>
 * 
 */
public void generateSafeUser(JavaPackage targetPackage) {
    JavaType entity = new JavaType(String.format("%s.SafeUser",
            targetPackage.getFullyQualifiedPackageName()));

    Validate.notNull(entity, "Entity required");

    int modifier = Modifier.PUBLIC;

    final String declaredByMetadataId = PhysicalTypeIdentifier
            .createIdentifier(entity,
                    pathResolver.getFocusedPath(Path.SRC_MAIN_JAVA));

    File targetFile = new File(
            typeLocationService
                    .getPhysicalTypeCanonicalPath(declaredByMetadataId));
    Validate.isTrue(!targetFile.exists(), "Type '%s' already exists",
            entity);

    // Prepare class builder
    final ClassOrInterfaceTypeDetailsBuilder cidBuilder = new ClassOrInterfaceTypeDetailsBuilder(
            declaredByMetadataId, modifier, entity,
            PhysicalTypeCategory.CLASS);

    // Prepare annotations array
    List<AnnotationMetadataBuilder> annotations = new ArrayList<AnnotationMetadataBuilder>(
            2);

    // Add @GvNIXUserSAFE annotation
    AnnotationMetadataBuilder gvnixUserSafeAnnotation = new AnnotationMetadataBuilder(
            new JavaType(GvNIXUserSAFE.class));
    annotations.add(gvnixUserSafeAnnotation);

    // Add @RooJavaBean annotation
    AnnotationMetadataBuilder javaBeanAnnotation = new AnnotationMetadataBuilder(
            new JavaType(
                    "org.springframework.roo.addon.javabean.RooJavaBean"));
    annotations.add(javaBeanAnnotation);

    // Add Implements Type
    cidBuilder.addImplementsType(new JavaType(
            "org.springframework.security.core.userdetails.UserDetails"));
    cidBuilder.addImplementsType(new JavaType("java.io.Serializable"));

    // Set annotations
    cidBuilder.setAnnotations(annotations);

    typeManagementService.createOrUpdateTypeOnDisk(cidBuilder.build());

}
 

import org.springframework.roo.classpath.details.ClassOrInterfaceTypeDetailsBuilder; //導入方法依賴的package包/類
/**
 * This method generates the file SafeUserAuthority.java with the annotation
 * <code>@GvNIXUserAuthoritySAFE</code>
 * 
 */
public void generateSafeUserAuthority(JavaPackage targetPackage) {
    JavaType entity = new JavaType(String.format("%s.SafeUserAuthority",
            targetPackage.getFullyQualifiedPackageName()));

    Validate.notNull(entity, "Entity required");

    int modifier = Modifier.PUBLIC;

    final String declaredByMetadataId = PhysicalTypeIdentifier
            .createIdentifier(entity,
                    pathResolver.getFocusedPath(Path.SRC_MAIN_JAVA));

    File targetFile = new File(
            typeLocationService
                    .getPhysicalTypeCanonicalPath(declaredByMetadataId));
    Validate.isTrue(!targetFile.exists(), "Type '%s' already exists",
            entity);

    // Prepare class builder
    final ClassOrInterfaceTypeDetailsBuilder cidBuilder = new ClassOrInterfaceTypeDetailsBuilder(
            declaredByMetadataId, modifier, entity,
            PhysicalTypeCategory.CLASS);

    // Prepare annotations array
    List<AnnotationMetadataBuilder> annotations = new ArrayList<AnnotationMetadataBuilder>(
            2);

    // Add @GvNIXUserAuthoritySAFE annotation
    AnnotationMetadataBuilder gvNIXUserAuthSafeAnn = new AnnotationMetadataBuilder(
            new JavaType(GvNIXUserAuthoritySAFE.class));
    annotations.add(gvNIXUserAuthSafeAnn);

    // Add @RooJavaBean annotation
    AnnotationMetadataBuilder javaBeanAnnotation = new AnnotationMetadataBuilder(
            new JavaType(
                    "org.springframework.roo.addon.javabean.RooJavaBean"));
    annotations.add(javaBeanAnnotation);

    // Add Implements Type
    cidBuilder.addImplementsType(new JavaType(
            "org.springframework.security.core.GrantedAuthority"));
    cidBuilder.addImplementsType(new JavaType("java.io.Serializable"));

    // Set annotations
    cidBuilder.setAnnotations(annotations);

    typeManagementService.createOrUpdateTypeOnDisk(cidBuilder.build());

}