import com.intellij.facet.FacetTypeRegistry; //导入依赖的package包/类
private void excludeFrameworkDetection(final Project project, FacetTypeId facetTypeId) {
    final DetectionExcludesConfiguration configuration = DetectionExcludesConfiguration.getInstance(project);
    final FacetType facetType = FacetTypeRegistry.getInstance().findFacetType(facetTypeId);
    final FrameworkType frameworkType = FrameworkDetectionUtil.findFrameworkTypeForFacetDetector(facetType);

    if (frameworkType != null) {
        configuration.addExcludedFramework(frameworkType);
    }
}
 

import com.intellij.facet.FacetTypeRegistry; //导入依赖的package包/类
@Override
public void configure(
    @NotNull final ModifiableFacetModel modifiableFacetModel,
    @NotNull final HybrisModuleDescriptor moduleDescriptor,
    @NotNull final Module javaModule,
    @NotNull final ModifiableRootModel modifiableRootModel
) {
    final File webRoot = moduleDescriptor.getWebRoot();
    if (null == webRoot) {
        return;
    }

    WebFacet webFacet = modifiableFacetModel.getFacetByType(WebFacet.ID);

    if (webFacet == null) {
        final FacetType<WebFacet, FacetConfiguration> webFacetType = FacetTypeRegistry.getInstance().findFacetType(
            WebFacet.ID
        );

        if (!webFacetType.isSuitableModuleType(ModuleType.get(javaModule))) {
            return;
        }

        webFacet = FacetManager.getInstance(javaModule).createFacet(
            webFacetType, webFacetType.getDefaultFacetName(), null
        );

        modifiableFacetModel.addFacet(webFacet);

    } else {
        webFacet.removeAllWebRoots();
        webFacet.getDescriptorsContainer().getConfiguration().removeConfigFiles(
            DeploymentDescriptorsConstants.WEB_XML_META_DATA
        );
    }

    webFacet.setWebSourceRoots(modifiableRootModel.getSourceRootUrls(false));
    webFacet.addWebRootNoFire(VfsUtil.pathToUrl(FileUtil.toSystemIndependentName(webRoot.getAbsolutePath())), "/");
    this.setupFacetDeploymentDescriptor(webFacet, moduleDescriptor);
}
 

import com.intellij.facet.FacetTypeRegistry; //导入依赖的package包/类
public void setMuleFacet(Module module) {
    MuleFacetType type = (MuleFacetType)FacetTypeRegistry.getInstance().findFacetType(MuleFacet.ID);
    MuleFacetConfiguration configuration = type.createDefaultConfiguration();
    configuration.setPathToSdk(MuleSdkManager.getInstance().findFromVersion(muleVersion).getMuleHome());
    Facet facet = type.createFacet(module, type.getPresentableName(), configuration, null);
    ModifiableFacetModel model = FacetManager.getInstance(module).createModifiableModel();
    model.addFacet(facet);
    model.commit();
}
 

import com.intellij.facet.FacetTypeRegistry; //导入依赖的package包/类
public static AnAction[] createAddFacetActions(FacetStructureConfigurable configurable) {
  final List<AnAction> result = new ArrayList<AnAction>();
  final StructureConfigurableContext context = configurable.myContext;
  for (FacetType type : FacetTypeRegistry.getInstance().getSortedFacetTypes()) {
    if (hasSuitableModules(context, type)) {
      result.add(new AddFacetOfTypeAction(type, context));
    }
  }
  return result.toArray(new AnAction[result.size()]);
}
 

import com.intellij.facet.FacetTypeRegistry; //导入依赖的package包/类
public List<FacetType> getFacetTypes() {
  return ContainerUtil.mapNotNull(getFacetIds(), new NullableFunction<String, FacetType>() {
    @Override
    public FacetType fun(String facetId) {
      return FacetTypeRegistry.getInstance().findFacetType(facetId);
    }
  });
}
 

import com.intellij.facet.FacetTypeRegistry; //导入依赖的package包/类
/** Creates all {@link Module modules} annotated with {@link TestModule}. */
private void createTestModules() throws IllegalAccessException {
  for (Field field : getFieldsWithAnnotation(testInstance.getClass(), TestModule.class)) {
    field.setAccessible(true);
    if (!field.getType().equals(Module.class)) {
      throw new IllegalArgumentException(
          "@TestModule can only annotate fields of type com.intellij.openapi.module.Module");
    }

    writeOnMainThread(
        () -> {
          Module module =
              ModuleManager.getInstance(testFixture.getProject())
                  .newModule(
                      testFixture.getProject().getBasePath()
                          + "/"
                          + moduleCounter.incrementAndGet()
                          + ModuleFileType.DOT_DEFAULT_EXTENSION,
                      ModuleType.EMPTY.getId());
          field.set(testInstance, module);

          String facetTypeId = field.getAnnotation(TestModule.class).facetTypeId();
          if (!Strings.isNullOrEmpty(facetTypeId)) {
            FacetType<?, ?> facetType =
                FacetTypeRegistry.getInstance().findFacetType(facetTypeId);
            FacetManager.getInstance(module)
                .addFacet(facetType, facetTypeId, /* underlying= */ null);
          }
        });
  }
}
 

import com.intellij.facet.FacetTypeRegistry; //导入依赖的package包/类
@Override
public void configure(
    @NotNull final ModifiableFacetModel modifiableFacetModel,
    @NotNull final HybrisModuleDescriptor moduleDescriptor,
    @NotNull final Module javaModule,
    @NotNull final ModifiableRootModel modifiableRootModel
) {
    Validate.notNull(javaModule);
    Validate.notNull(modifiableFacetModel);
    Validate.notNull(moduleDescriptor);
    Validate.notNull(modifiableFacetModel);

    SpringFacet springFacet = modifiableFacetModel.getFacetByType(SpringFacet.FACET_TYPE_ID);

    if (springFacet == null) {
        final FacetType<SpringFacet, SpringFacetConfiguration> springFacetType = FacetTypeRegistry
            .getInstance().findFacetType(SpringFacet.FACET_TYPE_ID);

        if (!springFacetType.isSuitableModuleType(ModuleType.get(javaModule))) {
            return;
        }

        springFacet = springFacetType.createFacet(
            javaModule, springFacetType.getDefaultFacetName(), springFacetType.createDefaultConfiguration(), null
        );

        modifiableFacetModel.addFacet(springFacet);
    } else {
        springFacet.removeFileSets();
    }

    final String facetId = moduleDescriptor.getName() + SpringFacet.FACET_TYPE_ID.toString();
    final SpringFileSet springFileSet = springFacet.addFileSet(facetId, facetId);

    for (String springFile : moduleDescriptor.getSpringFileSet()) {
        final VirtualFile vf = VfsUtil.findFileByIoFile(new File(springFile), true);

        if (null != vf) {
            springFileSet.addFile(vf);
        }
    }
    final CustomSetting.BOOLEAN setting = springFacet.findSetting(LocalXmlModel.PROCESS_EXPLICITLY_ANNOTATED);

    if (setting != null) {
        setting.setBooleanValue(false);
    }
}
 

import com.intellij.facet.FacetTypeRegistry; //导入依赖的package包/类
@NotNull
public static XposedFacetType getFacetType() {
    return (XposedFacetType)FacetTypeRegistry.getInstance().findFacetType(ID);
}
 

import com.intellij.facet.FacetTypeRegistry; //导入依赖的package包/类
@Override
public Icon getCreateElementIcon() {
  return FacetTypeRegistry.getInstance().findFacetType(myFacetType).getIcon();
}
 

import com.intellij.facet.FacetTypeRegistry; //导入依赖的package包/类
@Override
protected Icon getItemIcon(F item) {
  return FacetTypeRegistry.getInstance().findFacetType(myFacetType).getIcon();
}
 

import com.intellij.facet.FacetTypeRegistry; //导入依赖的package包/类
public static BuildoutFacetType getInstance() {
  return (BuildoutFacetType)FacetTypeRegistry.getInstance().findFacetType(ID);
}
 

import com.intellij.facet.FacetTypeRegistry; //导入依赖的package包/类
@NotNull
public static AndroidFacetType getFacetType() {
  return (AndroidFacetType)FacetTypeRegistry.getInstance().findFacetType(ID);
}
 

import com.intellij.facet.FacetTypeRegistry; //导入依赖的package包/类
private void mockFacetRegistry(Container applicationServices) {
  applicationServices.register(FacetTypeRegistry.class, new FacetTypeRegistryImpl());
  registerExtensionPoint(FacetType.EP_NAME, FacetType.class)
      .registerExtension(new AndroidFacetType());
}
 

import com.intellij.facet.FacetTypeRegistry; //导入依赖的package包/类
private void registerFacet()
{
    FacetTypeRegistry facetTypeRegistry = FacetTypeRegistry.getInstance();
    facetTypeRegistry.registerFacetType( polygeneFacetType );
}
 

import com.intellij.facet.FacetTypeRegistry; //导入依赖的package包/类
private void unregisterFacet()
{
    FacetTypeRegistry facetTypeRegistry = FacetTypeRegistry.getInstance();
    facetTypeRegistry.unregisterFacetType( polygeneFacetType );
}
 

import com.intellij.facet.FacetTypeRegistry; //导入依赖的package包/类
public static FacetType<SlingModuleFacet, SlingModuleFacetConfiguration> getFacetType() {
    return FacetTypeRegistry.getInstance().findFacetType(ID);
}
 

import com.intellij.facet.FacetTypeRegistry; //导入依赖的package包/类
public static FacetType<AppEngineFlexibleFacet, AppEngineFlexibleFacetConfiguration>
    getFacetType() {
  return FacetTypeRegistry.getInstance().findFacetType(AppEngineFlexibleFacetType.ID);
}
 

import com.intellij.facet.FacetTypeRegistry; //导入依赖的package包/类
public static FacetType<AppEngineStandardFacet, AppEngineStandardFacetConfiguration>
    getFacetType() {
  return FacetTypeRegistry.getInstance().findFacetType(AppEngineStandardFacetType.ID);
}
 

import com.intellij.facet.FacetTypeRegistry; //导入依赖的package包/类
@NotNull
public static DefracFacetType getFacetType() {
  return (DefracFacetType) FacetTypeRegistry.getInstance().findFacetType(ID);
}
 

import com.intellij.facet.FacetTypeRegistry; //导入依赖的package包/类
public static XmlBeansFacetType getFacetType() {
  return (XmlBeansFacetType)FacetTypeRegistry.getInstance().findFacetType(FACET_TYPE_ID);
}