import org.codehaus.plexus.DefaultPlexusContainer; //导入依赖的package包/类
public static @NonNull MavenEmbedder createProjectLikeEmbedder() throws PlexusContainerException {
        final String mavenCoreRealmId = "plexus.core";
        ContainerConfiguration dpcreq = new DefaultContainerConfiguration()
            .setClassWorld( new ClassWorld(mavenCoreRealmId, EmbedderFactory.class.getClassLoader()) )
            .setClassPathScanning( PlexusConstants.SCANNING_INDEX )
            .setName("maven");
        
        DefaultPlexusContainer pc = new DefaultPlexusContainer(dpcreq, new ExtensionModule());
        pc.setLoggerManager(new NbLoggerManager());

        Properties userprops = new Properties();
        userprops.putAll(getCustomGlobalUserProperties());
        EmbedderConfiguration configuration = new EmbedderConfiguration(pc, cloneStaticProps(), userprops, true, getSettingsXml());
        
        try {
            return new MavenEmbedder(configuration);
            //MEVENIDE-634 make all instances non-interactive
//            WagonManager wagonManager = (WagonManager) embedder.getPlexusContainer().lookup(WagonManager.ROLE);
//            wagonManager.setInteractive(false);
        } catch (ComponentLookupException ex) {
            throw new PlexusContainerException(ex.toString(), ex);
        }
    }
 

import org.codehaus.plexus.DefaultPlexusContainer; //导入依赖的package包/类
@Override
protected Object createTest()
    throws Exception
{
    final TestClass testClass = getTestClass();

    final DefaultContainerConfiguration config = new DefaultContainerConfiguration();

    config.setAutoWiring( true );
    config.setClassPathScanning( PlexusConstants.SCANNING_ON );
    config.setComponentVisibility( PlexusConstants.GLOBAL_VISIBILITY );
    config.setName( testClass.getName() );

    final DefaultPlexusContainer container = new DefaultPlexusContainer( config );
    final ClassSpace cs = new URLClassSpace( Thread.currentThread()
                                                   .getContextClassLoader() );

    container.addPlexusInjector( Arrays.<PlexusBeanModule> asList( new PlexusAnnotatedBeanModule(
                                                                                                  cs,
                                                                                                  Collections.emptyMap() ) ) );

    return container.lookup( testClass.getJavaClass() );
}
 

import org.codehaus.plexus.DefaultPlexusContainer; //导入依赖的package包/类
private ManipulationSession createUpdateSession() throws Exception
{
    ManipulationSession session = new ManipulationSession();

    session.setState( new DependencyState( p ) );
    session.setState( new VersioningState( p ) );
    session.setState( new CommonState( p ) );

    final MavenExecutionRequest req =
                    new DefaultMavenExecutionRequest().setUserProperties( p ).setRemoteRepositories( Collections.<ArtifactRepository>emptyList() );

    final PlexusContainer container = new DefaultPlexusContainer();
    final MavenSession mavenSession = new MavenSession( container, null, req, new DefaultMavenExecutionResult() );

    session.setMavenSession( mavenSession );

    return session;
}
 

import org.codehaus.plexus.DefaultPlexusContainer; //导入依赖的package包/类
@Provides @Aether @Singleton
public PlexusContainer aetherContainer() {
    try {
        return new DefaultPlexusContainer(
            new DefaultContainerConfiguration(),
            new AbstractModule() {
                @Override
                protected void configure() {
                    bind(VersionResolver.class).to(VersionResolverImpl.class);
                }

                // DefaultSettingSettingsDecrypter looks for the "maven" name
                @Provides @Singleton @Named("maven")
                public SecDispatcher getDispatcher(DefaultSecDispatcher base) {
                    base.setConfigurationFile("~/.m2/settings-security.xml");
                    return base;
                }
            }
        );
    } catch (PlexusContainerException e) {
        throw new RuntimeException("Unable to load RepositorySystem component by Plexus, cannot establish Aether dependency resolver.", e);
    }
}
 

import org.codehaus.plexus.DefaultPlexusContainer; //导入依赖的package包/类
private Set<MavenProject> createNow(Settings settings, File pomFile) throws PlexusContainerException, PlexusConfigurationException, ComponentLookupException, MavenExecutionRequestPopulationException, ProjectBuildingException {
    ContainerConfiguration containerConfiguration = new DefaultContainerConfiguration()
            .setClassWorld(new ClassWorld("plexus.core", ClassWorld.class.getClassLoader()))
            .setName("mavenCore");

    DefaultPlexusContainer container = new DefaultPlexusContainer(containerConfiguration);
    ProjectBuilder builder = container.lookup(ProjectBuilder.class);
    MavenExecutionRequest executionRequest = new DefaultMavenExecutionRequest();
    final Properties properties = new Properties();
    properties.putAll(SystemProperties.getInstance().asMap());
    executionRequest.setSystemProperties(properties);
    MavenExecutionRequestPopulator populator = container.lookup(MavenExecutionRequestPopulator.class);
    populator.populateFromSettings(executionRequest, settings);
    populator.populateDefaults(executionRequest);
    ProjectBuildingRequest buildingRequest = executionRequest.getProjectBuildingRequest();
    buildingRequest.setProcessPlugins(false);
    MavenProject mavenProject = builder.build(pomFile, buildingRequest).getProject();
    Set<MavenProject> reactorProjects = new LinkedHashSet<MavenProject>();

    //TODO adding the parent project first because the converter needs it this way ATM. This is oversimplified.
    //the converter should not depend on the order of reactor projects.
    //we should add coverage for nested multi-project builds with multiple parents.
    reactorProjects.add(mavenProject);
    List<ProjectBuildingResult> allProjects = builder.build(ImmutableList.of(pomFile), true, buildingRequest);
    CollectionUtils.collect(allProjects, reactorProjects, new Transformer<MavenProject, ProjectBuildingResult>() {
        public MavenProject transform(ProjectBuildingResult original) {
            return original.getProject();
        }
    });

    MavenExecutionResult result = new DefaultMavenExecutionResult();
    result.setProject(mavenProject);
    RepositorySystemSession repoSession = new DefaultRepositorySystemSession();
    MavenSession session = new MavenSession(container, repoSession, executionRequest, result);
    session.setCurrentProject(mavenProject);

    return reactorProjects;
}
 

import org.codehaus.plexus.DefaultPlexusContainer; //导入依赖的package包/类
private void initIndexer () {
    if (!inited) {
        try {
            ContainerConfiguration config = new DefaultContainerConfiguration();
         //#154755 - start
         ClassWorld world = new ClassWorld();
         ClassRealm embedderRealm = world.newRealm("maven.embedder", MavenEmbedder.class.getClassLoader()); //NOI18N
            ClassLoader indexerLoader = NexusRepositoryIndexerImpl.class.getClassLoader();
         ClassRealm indexerRealm = world.newRealm("maven.indexer", indexerLoader); //NOI18N
         ClassRealm plexusRealm = world.newRealm("plexus.core", indexerLoader); //NOI18N
         //need to import META-INF/plexus stuff, otherwise the items in META-INF will not be loaded,
         // and the Dependency Injection won't work.
         plexusRealm.importFrom(embedderRealm.getId(), "META-INF/plexus"); //NOI18N
         plexusRealm.importFrom(embedderRealm.getId(), "META-INF/maven"); //NOI18N
         plexusRealm.importFrom(indexerRealm.getId(), "META-INF/plexus"); //NOI18N
         plexusRealm.importFrom(indexerRealm.getId(), "META-INF/maven"); //NOI18N
         config.setClassWorld(world);
                config.setClassPathScanning( PlexusConstants.SCANNING_INDEX );
         //#154755 - end
            embedder = new DefaultPlexusContainer(config);

            ComponentDescriptor<ArtifactContextProducer> desc = new ComponentDescriptor<ArtifactContextProducer>();
            desc.setRoleClass(ArtifactContextProducer.class);
            desc.setImplementationClass(CustomArtifactContextProducer.class);
            ComponentRequirement req = new ComponentRequirement(); // XXX why is this not automatic?
            req.setFieldName("mapper");
            req.setRole(ArtifactPackagingMapper.class.getName());
            desc.addRequirement(req);
            embedder.addComponentDescriptor(desc);
            indexer = embedder.lookup(Indexer.class);
            scanner = embedder.lookup(org.apache.maven.index.Scanner.class);
            searcher = embedder.lookup(SearchEngine.class);
            remoteIndexUpdater = embedder.lookup(IndexUpdater.class);
            contextProducer = embedder.lookup(ArtifactContextProducer.class);
            inited = true;
        } catch (Exception x) {
            Exceptions.printStackTrace(x);
        }
    }
}
 

import org.codehaus.plexus.DefaultPlexusContainer; //导入依赖的package包/类
@Override
    public void init( Context context )
        throws Exception
    {
        super.init( context );
        LOGGER.info( "{} Version {} started.", DPRE, DeploymentRecorderExtensionVersion.getVersion() );

        // Is this always in the context? Based on Maven Core yes.
        String workingDirectory = (String) context.getData().get( "workingDirectory" );
        LOGGER.debug( "{}: workingDirectory: {}", DPRE, workingDirectory );

        Properties systemProperties = (Properties) context.getData().get( "systemProperties" );
        // This is only available from 3.3.+
        String multiModuleProjectDirectory = systemProperties.getProperty( "maven.multiModuleProjectDirectory" );
        rootDirectory = new File( multiModuleProjectDirectory );
        LOGGER.debug( "{}: multiModuleProjectDirectory: {}", DPRE, multiModuleProjectDirectory );

        DefaultPlexusContainer contextContain = (DefaultPlexusContainer) context.getData().get( "context" );
        LOGGER.info( "contextContain: {}", contextContain );

//        LOGGER.info( " fileName: {}", fileName );
//        LOGGER.info( " anOtherFile: {}", anOtherFile );
//        LOGGER.info( " moreParameters: {}", moreParameters );
//        LOGGER.info( " injected: {}", injected );
//        LOGGER.info( " injectsisu: {}", injectsisu );
        

    }
 

import org.codehaus.plexus.DefaultPlexusContainer; //导入依赖的package包/类
/**
 * Test if XMvn WorkspaceReader component can be loaded by Sisu Plexus shim.
 * 
 * @throws Exception
 */
@Before
public void setupPlexusContainer()
    throws Exception
{
    ContainerConfiguration config = new DefaultContainerConfiguration();
    config.setAutoWiring( true );
    config.setClassPathScanning( PlexusConstants.SCANNING_INDEX );
    container = new DefaultPlexusContainer( config );
}
 

import org.codehaus.plexus.DefaultPlexusContainer; //导入依赖的package包/类
private MavenEmbedder(@NotNull DefaultPlexusContainer container,
                      @NotNull Settings settings,
                      @NotNull Logger logger,
                      @NotNull MavenEmbedderSettings embedderSettings) {
  myContainer = container;
  mySettings = settings;
  myLogger = logger;
  myEmbedderSettings = embedderSettings;
  myLocalRepository = createLocalRepository(embedderSettings);

  loadSettings();
}
 

import org.codehaus.plexus.DefaultPlexusContainer; //导入依赖的package包/类
@NotNull
public static MavenEmbedder create(@NotNull final MavenEmbedderSettings embedderSettings) {
  @NotNull final Logger logger = getLogger(embedderSettings);

  DefaultPlexusContainer container = new DefaultPlexusContainer();
  container.setClassWorld(new ClassWorld("plexus.core", embedderSettings.getClass().getClassLoader()));
  container.setLoggerManager(new BaseLoggerManager() {
    @Override
    protected Logger createLogger(final String s) {
      return logger;
    }
  });

  try {
    container.initialize();
    container.start();
  }
  catch (PlexusContainerException e) {
    MavenEmbedderLog.LOG.error(e);
    throw new RuntimeException(e);
  }

  final PlexusComponentConfigurator configurator = embedderSettings.getConfigurator();
  if (configurator != null) {
    configurator.configureComponents(container);
  }

  File mavenHome = embedderSettings.getMavenHome();
  if (mavenHome != null) {
    System.setProperty(PROP_MAVEN_HOME, mavenHome.getPath());
  }

  Settings nativeSettings = buildSettings(container, embedderSettings);

  return new MavenEmbedder(container, nativeSettings, logger, embedderSettings);
}
 

import org.codehaus.plexus.DefaultPlexusContainer; //导入依赖的package包/类
@Override
protected void customizeContainer(PlexusContainer container)
{
  ((DefaultPlexusContainer)container).setLoggerManager(
      new BaseLoggerManager()
      {
        @Override
        protected org.codehaus.plexus.logging.Logger createLogger(String s)
        {
          return new Slf4jLogger(LOG);
        }
      }
  );
}
 

import org.codehaus.plexus.DefaultPlexusContainer; //导入依赖的package包/类
private VersioningState setupSession( final Properties properties, final Map<ProjectRef, String[]> versionMap )
    throws Exception
{
    final ArtifactRepository ar =
        new MavenArtifactRepository( "test", "http://repo.maven.apache.org/maven2", new DefaultRepositoryLayout(),
                                     new ArtifactRepositoryPolicy(), new ArtifactRepositoryPolicy() );

    final MavenExecutionRequest req =
        new DefaultMavenExecutionRequest().setUserProperties( properties )
                                          .setRemoteRepositories( Arrays.asList( ar ) );

    final PlexusContainer container = new DefaultPlexusContainer();

    final MavenSession mavenSession = new MavenSession( container, null, req, new DefaultMavenExecutionResult() );

    session = new ManipulationSession();
    session.setMavenSession( mavenSession );

    final VersioningState state = new VersioningState( properties );
    session.setState( state );

    final Map<String, byte[]> dataMap = new HashMap<>();
    if ( versionMap != null && !versionMap.isEmpty() )
    {
        for ( final Map.Entry<ProjectRef, String[]> entry : versionMap.entrySet() )
        {
            final String path = toMetadataPath( entry.getKey() );
            final byte[] data = setupMetadataVersions( entry.getValue() );
            dataMap.put( path, data );
        }
    }

    final Location mdLoc = MavenLocationExpander.EXPANSION_TARGET;
    final Transport mdTrans = new StubTransport( dataMap );

    modder =
        new TestVersionCalculator( new ManipulationSession(), mdLoc, mdTrans, temp.newFolder( "galley-cache" ) );

    return state;
}
 

import org.codehaus.plexus.DefaultPlexusContainer; //导入依赖的package包/类
private void setMavenSession()
    throws Exception
{
    final MavenExecutionRequest req =
        new DefaultMavenExecutionRequest().setUserProperties( userCliProperties )
                                          .setRemoteRepositories( Collections.<ArtifactRepository> emptyList() );

    final PlexusContainer container = new DefaultPlexusContainer();
    final MavenSession mavenSession = new MavenSession( container, null, req, new DefaultMavenExecutionResult() );

    session.setMavenSession( mavenSession );

}
 

import org.codehaus.plexus.DefaultPlexusContainer; //导入依赖的package包/类
private static PlexusContainer initContainer()
{
	try
	{
		return new DefaultPlexusContainer();
	}
	catch(PlexusContainerException e)
	{
		log.error("Error initializing Maven", e);
		return null;
	}
}
 

import org.codehaus.plexus.DefaultPlexusContainer; //导入依赖的package包/类
@Test
public final void testMinimalSolutionConfiguration() throws Exception 
{
    ( (DefaultPlexusContainer) getContainer() ).getLoggerManager().setThreshold( Logger.LEVEL_DEBUG );
    CppCheckMojo cppCheckMojo = ( CppCheckMojo ) lookupConfiguredMojo( CppCheckMojo.MOJO_NAME, 
            "/unit/cppcheck/sln-single-platform-single-config-pom.xml" );

    cppCheckMojo.execute();
}
 

import org.codehaus.plexus.DefaultPlexusContainer; //导入依赖的package包/类
@NonNull static MavenEmbedder createOnlineEmbedder() throws PlexusContainerException {
        final String mavenCoreRealmId = "plexus.core";
        ContainerConfiguration dpcreq = new DefaultContainerConfiguration()
            .setClassWorld( new ClassWorld(mavenCoreRealmId, EmbedderFactory.class.getClassLoader()) )
            .setClassPathScanning( PlexusConstants.SCANNING_INDEX )
            .setName("maven");

        DefaultPlexusContainer pc = new DefaultPlexusContainer(dpcreq);
        pc.setLoggerManager(new NbLoggerManager());

        Properties userprops = new Properties();
        userprops.putAll(getCustomGlobalUserProperties());
        EmbedderConfiguration req = new EmbedderConfiguration(pc, cloneStaticProps(), userprops, false, getSettingsXml());

//        //TODO remove explicit activation
//        req.addActiveProfile("netbeans-public").addActiveProfile("netbeans-private"); //NOI18N


//        req.setConfigurationCustomizer(new ContainerCustomizer() {
//
//            public void customize(PlexusContainer plexusContainer) {
//                    //MEVENIDE-634
//                    ComponentDescriptor desc = plexusContainer.getComponentDescriptor(KnownHostsProvider.ROLE, "file"); //NOI18N
//                    desc.getConfiguration().getChild("hostKeyChecking").setValue("no"); //NOI18N
//
//                    //MEVENIDE-634
//                    desc = plexusContainer.getComponentDescriptor(KnownHostsProvider.ROLE, "null"); //NOI18N
//                    desc.getConfiguration().getChild("hostKeyChecking").setValue("no"); //NOI18N
//            }
//        });

        try {
            return new MavenEmbedder(req);
            //MEVENIDE-634 make all instances non-interactive
//            WagonManager wagonManager = (WagonManager) embedder.getPlexusContainer().lookup(WagonManager.ROLE);
//            wagonManager.setInteractive(false);
        } catch (ComponentLookupException ex) {
            throw new PlexusContainerException(ex.toString(), ex);
        }
//            try {
//                //MEVENIDE-634 make all instances non-interactive
//                WagonManager wagonManager = (WagonManager) embedder.getPlexusContainer().lookup(WagonManager.ROLE);
//                wagonManager.setInteractive( false );
//                wagonManager.setDownloadMonitor(new ProgressTransferListener());
//            } catch (ComponentLookupException ex) {
//                ErrorManager.getDefault().notify(ex);
//            }
    }
 

import org.codehaus.plexus.DefaultPlexusContainer; //导入依赖的package包/类
@PostConstruct
public void initialize()
    throws PlexusSisuBridgeException
{
    DefaultContainerConfiguration conf = new DefaultContainerConfiguration();

    conf.setAutoWiring( containerAutoWiring );
    conf.setClassPathScanning( containerClassPathScanning );
    conf.setComponentVisibility( containerComponentVisibility );

    conf.setContainerConfigurationURL( overridingComponentsXml );

    ClassWorld classWorld = new ClassWorld();

    ClassLoader tccl = Thread.currentThread().getContextClassLoader();

    containerRealm = new ClassRealm( classWorld, "maven", tccl );

    // olamy hackhish but plexus-sisu need a URLClassLoader with URL filled

    if ( tccl instanceof URLClassLoader )
    {
        URL[] urls = ( (URLClassLoader) tccl ).getURLs();
        for ( URL url : urls )
        {
            containerRealm.addURL( url );
        }
    }

    conf.setRealm( containerRealm );

    //conf.setClassWorld( classWorld );

    ClassLoader ori = Thread.currentThread().getContextClassLoader();

    try
    {
        Thread.currentThread().setContextClassLoader( containerRealm );
        plexusContainer = new DefaultPlexusContainer( conf );
    }
    catch ( PlexusContainerException e )
    {
        throw new PlexusSisuBridgeException( e.getMessage(), e );
    }
    finally
    {
        Thread.currentThread().setContextClassLoader( ori );
    }
}
 

import org.codehaus.plexus.DefaultPlexusContainer; //导入依赖的package包/类
public DefaultPlexusContainer plexus() {
    if (lazyPlexus == null) {
        lazyPlexus = Maven.container();
    }
    return lazyPlexus;
}
 

import org.codehaus.plexus.DefaultPlexusContainer; //导入依赖的package包/类
public static DefaultPlexusContainer container() {
    return container(null, null, Logger.LEVEL_DISABLED);
}
 

import org.codehaus.plexus.DefaultPlexusContainer; //导入依赖的package包/类
@BeforeMethod
public void setUp() throws ComponentLookupException, PlexusContainerException {
    PlexusContainer container = new DefaultPlexusContainer();
    keysMap = container.lookup(KeysMap.class);
}