Java ReaderFactory.newXmlReader方法代码示例

import org.codehaus.plexus.util.ReaderFactory; //导入方法依赖的package包/类
/**
 * Reads the {@link WebappStructure} from the specified file.
 *
 * @param file the file containing the webapp structure
 * @return the webapp structure
 * @throws IOException if an error occurred while reading the structure
 */
public WebappStructure fromXml( File file )
    throws IOException
{
    Reader reader = null;

    try
    {
        reader = ReaderFactory.newXmlReader( file );
        return (WebappStructure) XSTREAM.fromXML( reader );
    }
    finally
    {
        IOUtil.close( reader );
    }
}
 

import org.codehaus.plexus.util.ReaderFactory; //导入方法依赖的package包/类
/**
 * <expressions>
 *   <expression>
 *     <syntax>project.distributionManagementArtifactRepository</syntax>
 *     <origin><![CDATA[
 *   <distributionManagement>
 *     <repository>
 *       <id>some-repo</id>
 *       <url>scp://host/path</url>
 *     </repository>
 *     <snapshotRepository>
 *       <id>some-snap-repo</id>
 *       <url>scp://host/snapshot-path</url>
 *     </snapshotRepository>
 *   </distributionManagement>
 *   ]]></origin>
 *     <usage><![CDATA[
 *   The repositories onto which artifacts should be deployed.
 *   One is for releases, the other for snapshots.
 *   ]]></usage>
 *   </expression>
 * <expressions>
 * @throws IOException
 * @throws XmlPullParserException
 */
private static Map parseExpressionDocumentation( InputStream docStream )
    throws IOException, XmlPullParserException
{
    Reader reader = new BufferedReader( ReaderFactory.newXmlReader( docStream ) );

    ParamdocXpp3Reader paramdocReader = new ParamdocXpp3Reader();

    ExpressionDocumentation documentation = paramdocReader.read( reader, true );

    List expressions = documentation.getExpressions();

    Map bySyntax = new HashMap();

    if ( expressions != null && !expressions.isEmpty() )
    {
        for ( Iterator it = expressions.iterator(); it.hasNext(); )
        {
            Expression expr = (Expression) it.next();

            bySyntax.put( expr.getSyntax(), expr );
        }
    }

    return bySyntax;
}
 

import org.codehaus.plexus.util.ReaderFactory; //导入方法依赖的package包/类
private static Settings readSettingsFile( File settingsFile )
    throws IOException, XmlPullParserException
{
    Settings settings = null;

    Reader reader = null;

    try
    {
        reader = ReaderFactory.newXmlReader( settingsFile );

        SettingsXpp3Reader modelReader = new SettingsXpp3Reader();

        settings = modelReader.read( reader );
    }
    finally
    {
        IOUtil.close( reader );
    }

    return settings;
}
 

import org.codehaus.plexus.util.ReaderFactory; //导入方法依赖的package包/类
/**
 * Reads a file into a String.
 *
 * @param outFile The file to read.
 * @return String The content of the file.
 * @throws java.io.IOException when things go wrong.
 */
public static StringBuilder readXmlFile( File outFile )
    throws IOException
{
    try( Reader reader = ReaderFactory.newXmlReader( outFile ) )
    {
        return new StringBuilder( IOUtil.toString( reader ) );
    }
}
 

import org.codehaus.plexus.util.ReaderFactory; //导入方法依赖的package包/类
private String readFileContents( File file )
    throws IOException
{

    BufferedReader reader = null;
    StringBuilder fileContents = new StringBuilder();

    try
    {
        reader = new BufferedReader( ReaderFactory.newXmlReader( file ) );

        String line = null;

        while ( ( line = reader.readLine() ) != null )
        {
            fileContents.append( line );
        }

        return fileContents.toString();

    }
    finally
    {
        if ( reader != null )
        {
            reader.close();
        }
    }

}
 

import org.codehaus.plexus.util.ReaderFactory; //导入方法依赖的package包/类
/**
 * @param buildException not null
 * @return the fragment XML part where the buildException occurs.
 * @since 1.7
 */
private String findFragment(BuildException buildException) {
    if (buildException == null || buildException.getLocation() == null
            || buildException.getLocation().getFileName() == null) {
        return null;
    }

    File antFile = new File(buildException.getLocation().getFileName());
    if (!antFile.exists()) {
        return null;
    }

    LineNumberReader reader = null;
    try {
        reader = new LineNumberReader(ReaderFactory.newXmlReader(antFile));
        String line = "";
        while ((line = reader.readLine()) != null) {
            if (reader.getLineNumber() == buildException.getLocation().getLineNumber()) {
                return "around Ant part ..." + line.trim() + "... @ " + buildException.getLocation().getLineNumber() + ":"
                        + buildException.getLocation().getColumnNumber() + " in " + antFile.getAbsolutePath();
            }
        }
    } catch (Exception e) {
        getLog().debug(e.getMessage(), e);
        return null;
    } finally {
        IOUtil.close(reader);
    }

    return null;
}
 

import org.codehaus.plexus.util.ReaderFactory; //导入方法依赖的package包/类
/**
 * Reads a file into a String.
 *
 * @param outFile The file to read.
 * @return String The content of the file.
 * @throws java.io.IOException when things go wrong.
 */
public static StringBuilder readXmlFile( File outFile )
    throws IOException
{
    Reader reader = ReaderFactory.newXmlReader( outFile );

    try
    {
        return new StringBuilder( IOUtil.toString( reader ) );
    }
    finally
    {
        IOUtil.close( reader );
    }
}
 

import org.codehaus.plexus.util.ReaderFactory; //导入方法依赖的package包/类
public static Collection<MojoDescriptor> readMojos(InputStream is) throws IOException, XmlPullParserException {
  Reader reader = ReaderFactory.newXmlReader(is);
  org.apache.maven.plugin.descriptor.PluginDescriptor pluginDescriptor;
  try {
    pluginDescriptor = new PluginDescriptorBuilder().build(reader);
  } catch (PlexusConfigurationException e) {
    Throwables.propagateIfPossible(e.getCause(), IOException.class, XmlPullParserException.class);
    throw Throwables.propagate(e);
  }
  List<MojoDescriptor> result = new ArrayList<>();
  for (org.apache.maven.plugin.descriptor.MojoDescriptor mojo : pluginDescriptor.getMojos()) {
    result.add(toMojoDescriptor(mojo));
  }
  return result;
}
 

import org.codehaus.plexus.util.ReaderFactory; //导入方法依赖的package包/类
@Override
public final void parse(final SourceCallback callback) throws ProcessingException, IOException {
    XmlStreamReader reader = ReaderFactory.newXmlReader(coverageFile);
    XMLStreamReader xml = createEventReader(reader);
    try {
        while (xml.hasNext()) {
            xml.next();
            onEvent(xml, callback);
        }
    } catch (XMLStreamException ex) {
        throw new ProcessingException(ex);
    } finally {
        close(xml);
        IOUtil.close(reader);
    }
}
 

import org.codehaus.plexus.util.ReaderFactory; //导入方法依赖的package包/类
public PersistedToolchains build( File userToolchainsFile )
    throws MisconfiguredToolchainException
{
    PersistedToolchains toolchains = null;

    if ( userToolchainsFile != null && userToolchainsFile.isFile() )
    {
        Reader in = null;
        try
        {
            in = ReaderFactory.newXmlReader( userToolchainsFile );
            toolchains = new MavenToolchainsXpp3Reader().read( in );
        }
        catch ( Exception e )
        {
            throw new MisconfiguredToolchainException( "Cannot read toolchains file at "
                + userToolchainsFile.getAbsolutePath(), e );
        }
        finally
        {
            IOUtil.close( in );
        }
    }
    else if ( userToolchainsFile != null )
    {
        logger.debug( "Toolchains configuration was not found at " + userToolchainsFile );
    }

    return toolchains;
}
 

import org.codehaus.plexus.util.ReaderFactory; //导入方法依赖的package包/类
public Lifecycle getLifecycleMapping( String lifecycleId )
    throws IOException, XmlPullParserException
{
    if ( lifecycleMappings == null )
    {
        LifecycleConfiguration lifecycleConfiguration;

        Reader reader = null;
        try
        {
            reader = ReaderFactory.newXmlReader( getDescriptorStream( LIFECYCLE_DESCRIPTOR ) );

            lifecycleConfiguration = new LifecycleMappingsXpp3Reader().read( reader );
        }
        finally
        {
            IOUtil.close( reader );
        }

        lifecycleMappings = new HashMap<String, Lifecycle>();

        for ( Lifecycle lifecycle : lifecycleConfiguration.getLifecycles() )
        {
            lifecycleMappings.put( lifecycle.getId(), lifecycle );
        }
    }

    return lifecycleMappings.get( lifecycleId );
}
 

import org.codehaus.plexus.util.ReaderFactory; //导入方法依赖的package包/类
private PluginDescriptor build( String resource )
    throws IOException, PlexusConfigurationException
{
    Reader reader = ReaderFactory.newXmlReader( getClass().getResourceAsStream( resource ) );

    return new PluginDescriptorBuilder().build( reader );
}
 

import org.codehaus.plexus.util.ReaderFactory; //导入方法依赖的package包/类
public void processResource( String resource, InputStream is, List<Relocator> relocators )
    throws IOException
{
    Xpp3Dom newDom;

    try
    {
        BufferedInputStream bis = new BufferedInputStream( is )
        {
            public void close()
                throws IOException
            {
                // leave ZIP open
            }
        };

        Reader reader = ReaderFactory.newXmlReader( bis );

        newDom = Xpp3DomBuilder.build( reader );
    }
    catch ( Exception e )
    {
        throw (IOException) new IOException( "Error parsing components.xml in " + is ).initCause( e );
    }

    // Only try to merge in components if there are some elements in the component-set
    if ( newDom.getChild( "components" ) == null )
    {
        return;
    }

    Xpp3Dom[] children = newDom.getChild( "components" ).getChildren( "component" );

    for ( Xpp3Dom component : children )
    {
        String role = getValue( component, "role" );
        role = getRelocatedClass( role, relocators );
        setValue( component, "role", role );

        String roleHint = getValue( component, "role-hint" );

        String impl = getValue( component, "implementation" );
        impl = getRelocatedClass( impl, relocators );
        setValue( component, "implementation", impl );

        String key = role + ':' + roleHint;
        if ( components.containsKey( key ) )
        {
            // TODO: use the tools in Plexus to merge these properly. For now, I just need an all-or-nothing
            // configuration carry over

            Xpp3Dom dom = components.get( key );
            if ( dom.getChild( "configuration" ) != null )
            {
                component.addChild( dom.getChild( "configuration" ) );
            }
        }

        Xpp3Dom requirements = component.getChild( "requirements" );
        if ( requirements != null && requirements.getChildCount() > 0 )
        {
            for ( int r = requirements.getChildCount() - 1; r >= 0; r-- )
            {
                Xpp3Dom requirement = requirements.getChild( r );

                String requiredRole = getValue( requirement, "role" );
                requiredRole = getRelocatedClass( requiredRole, relocators );
                setValue( requirement, "role", requiredRole );
            }
        }

        components.put( key, component );
    }
}
 

import org.codehaus.plexus.util.ReaderFactory; //导入方法依赖的package包/类
public void processResource( String resource, InputStream is, List<Relocator> relocators )
    throws IOException
{
    Xpp3Dom newDom;

    try
    {
        BufferedInputStream bis = new BufferedInputStream( is )
        {
            public void close()
                throws IOException
            {
                // leave ZIP open
            }
        };

        Reader reader = ReaderFactory.newXmlReader( bis );

        newDom = Xpp3DomBuilder.build( reader );
    }
    catch ( Exception e )
    {
        throw (IOException) new IOException( "Error parsing plugin.xml in " + is ).initCause( e );
    }

    // Only try to merge in mojos if there are some elements in the plugin
    if ( newDom.getChild( "mojos" ) == null )
    {
        return;
    }

    for ( Xpp3Dom mojo : newDom.getChild( "mojos" ).getChildren( "mojo" ) )
    {

        String impl = getValue( mojo, "implementation" );
        impl = getRelocatedClass( impl, relocators );
        setValue( mojo, "implementation", impl );

        Xpp3Dom parameters = mojo.getChild( "parameters" );
        if ( parameters != null )
        {
            for ( Xpp3Dom parameter : parameters.getChildren() )
            {
                String type = getValue( parameter, "type" );
                type = getRelocatedClass( type, relocators );
                setValue( parameter, "type", type );
            }
        }

        Xpp3Dom configuration = mojo.getChild( "configuration" );
        if ( configuration != null )
        {
            for ( Xpp3Dom configurationEntry : configuration.getChildren() )
            {
                String implementation = getAttribute( configurationEntry, "implementation" );
                implementation = getRelocatedClass( implementation, relocators );
                setAttribute( configurationEntry, "implementation", implementation );
            }
        }

        Xpp3Dom requirements = mojo.getChild( "requirements" );
        if ( requirements != null && requirements.getChildCount() > 0 )
        {
            for ( Xpp3Dom requirement : requirements.getChildren() )
            {
                String requiredRole = getValue( requirement, "role" );
                requiredRole = getRelocatedClass( requiredRole, relocators );
                setValue( requirement, "role", requiredRole );
            }
        }
        mojos.add( mojo );
    }
}
 

import org.codehaus.plexus.util.ReaderFactory; //导入方法依赖的package包/类
public ProfilesRoot buildProfiles( File basedir )
    throws IOException, XmlPullParserException
{
    File profilesXml = new File( basedir, PROFILES_XML_FILE );

    ProfilesRoot profilesRoot = null;

    if ( profilesXml.exists() )
    {
        ProfilesXpp3Reader reader = new ProfilesXpp3Reader();
        Reader profileReader = null;
        try
        {
            profileReader = ReaderFactory.newXmlReader( profilesXml );

            StringWriter sWriter = new StringWriter();

            IOUtil.copy( profileReader, sWriter );

            String rawInput = sWriter.toString();

            try
            {
                RegexBasedInterpolator interpolator = new RegexBasedInterpolator();
                interpolator.addValueSource( new EnvarBasedValueSource() );

                rawInput = interpolator.interpolate( rawInput, "settings" );
            }
            catch ( Exception e )
            {
                getLogger().warn( "Failed to initialize environment variable resolver. Skipping environment "
                                      + "substitution in " + PROFILES_XML_FILE + "." );
                getLogger().debug( "Failed to initialize envar resolver. Skipping resolution.", e );
            }

            StringReader sReader = new StringReader( rawInput );

            profilesRoot = reader.read( sReader );
        }
        finally
        {
            IOUtil.close( profileReader );
        }
    }

    return profilesRoot;
}