import com.puppycrawl.tools.checkstyle.ConfigurationLoader; //导入依赖的package包/类
public CheckstyleRunner(String configLocation, String suppressionLocation) {
    try {
        // create a configuration
        DefaultConfiguration config = (DefaultConfiguration) ConfigurationLoader
                .loadConfiguration(configLocation, new PropertiesExpander(System.getProperties()));

        // add the suppression file to the configuration
        DefaultConfiguration suppressions = new DefaultConfiguration("SuppressionFilter");
        suppressions.addAttribute("file", suppressionLocation);
        config.addChild(suppressions);

        this.config = config;
    } catch (CheckstyleException e) {
        throw new RuntimeException(e);
    }
}
 

import com.puppycrawl.tools.checkstyle.ConfigurationLoader; //导入依赖的package包/类
public CheckstyleRunner(String configLocation, String suppressionLocation)
        throws CheckstyleException {
    // create a configuration
    DefaultConfiguration config = (DefaultConfiguration) ConfigurationLoader.loadConfiguration(
            configLocation, new PropertiesExpander(System.getProperties()));

    // add the suppression file to the configuration
    DefaultConfiguration suppressions = new DefaultConfiguration("SuppressionFilter");
    suppressions.addAttribute("file", suppressionLocation);
    config.addChild(suppressions);

    this.config = config;
}
 

import com.puppycrawl.tools.checkstyle.ConfigurationLoader; //导入依赖的package包/类
/**
 * Returns {@link Configuration} based on Google's checks xml-configuration (google_checks.xml).
 * This implementation uses {@link ConfigurationLoader} in order to load configuration
 * from xml-file.
 * @return {@link Configuration} based on Google's checks xml-configuration (google_checks.xml).
 * @throws CheckstyleException if exception occurs during configuration loading.
 */
protected static Configuration getConfiguration() throws CheckstyleException {
    if (configuration == null) {
        configuration = ConfigurationLoader.loadConfiguration(XML_NAME, new PropertiesExpander(
                System.getProperties()));
    }

    return configuration;
}
 

import com.puppycrawl.tools.checkstyle.ConfigurationLoader; //导入依赖的package包/类
private static boolean isValidCheckstyleXml(String fileName, String code,
                                            String unserializedSource)
        throws IOException, CheckstyleException {
    // can't process non-existent examples, or out of context snippets
    if (!code.contains("com.mycompany") && !code.contains("checkstyle-packages")
            && !code.contains("MethodLimit") && !code.contains("<suppress ")
            && !code.contains("<suppress-xpath ")
            && !code.contains("<import-control ")
            && !unserializedSource.startsWith("<property ")
            && !unserializedSource.startsWith("<taskdef ")) {
        // validate checkstyle structure and contents
        try {
            final Properties properties = new Properties();

            properties.setProperty("checkstyle.header.file",
                    new File("config/java.header").getCanonicalPath());

            final PropertiesExpander expander = new PropertiesExpander(properties);
            final Configuration config = ConfigurationLoader.loadConfiguration(new InputSource(
                    new StringReader(code)), expander, false);
            final Checker checker = new Checker();

            try {
                final ClassLoader moduleClassLoader = Checker.class.getClassLoader();
                checker.setModuleClassLoader(moduleClassLoader);
                checker.configure(config);
            }
            finally {
                checker.destroy();
            }
        }
        catch (CheckstyleException ex) {
            throw new CheckstyleException(fileName + " has invalid Checkstyle xml ("
                    + ex.getMessage() + "): " + unserializedSource, ex);
        }
    }
    return true;
}
 

import com.puppycrawl.tools.checkstyle.ConfigurationLoader; //导入依赖的package包/类
@Before
public void setup() throws CheckstyleException {
    baos = new ByteArrayOutputStream();
    final AuditListener listener = new DefaultLogger(baos, OutputStreamOptions.NONE);

    final InputSource inputSource = new InputSource(CheckstyleTest.class.getClassLoader().getResourceAsStream(
            "checkstyle-logging.xml"));
    final Configuration configuration = ConfigurationLoader.loadConfiguration(inputSource,
            new PropertiesExpander(System.getProperties()), IgnoredModulesOptions.EXECUTE);

    checker = new Checker();
    checker.setModuleClassLoader(Checker.class.getClassLoader());
    checker.configure(configuration);
    checker.addListener(listener);
}
 

import com.puppycrawl.tools.checkstyle.ConfigurationLoader; //导入依赖的package包/类
@NotNull
private Checker createChecker(@NotNull AuditListener auditListener) {
    try {
        Checker checker = new Checker();
        ClassLoader moduleClassLoader = Checker.class.getClassLoader();
        String configurationFile = getConfigurationFilename();
        Properties properties = System.getProperties();// loadProperties(new File(System.getProperty(CHECKSTYLE_PROPERTIES_FILE)));
        checker.setModuleClassLoader(moduleClassLoader);
        checker.configure(ConfigurationLoader.loadConfiguration(configurationFile, new PropertiesExpander(properties)));
        checker.addListener(auditListener);
        return checker;
    } catch (CheckstyleException e) {
        throw new ReviewException("Unable to create Checkstyle checker", e);
    }
}
 

import com.puppycrawl.tools.checkstyle.ConfigurationLoader; //导入依赖的package包/类
public Map<String, List<StyleProblem>> execute() throws CheckstyleException {
	Properties properties;
	if (propertiesFile == null) {
		properties = System.getProperties();
	} else {
		properties = loadProperties(new File(propertiesFile));
	}

	if (configFile == null) {
		configFile = "/google_checks.xml";
	}
	
	// create configurations
	Configuration config = ConfigurationLoader.loadConfiguration(configFile, new PropertiesExpander(properties));

	// create our custom audit listener
	RepositoryMinerAudit listener = new RepositoryMinerAudit();
	listener.setRepositoryPathLength(repository.length());

	ClassLoader moduleClassLoader = Checker.class.getClassLoader();
	RootModule rootModule = getRootModule(config.getName(), moduleClassLoader);

	rootModule.setModuleClassLoader(moduleClassLoader);
	rootModule.configure(config);
	rootModule.addListener(listener);

	// executes checkstyle
	rootModule.process((List<File>) FileUtils.listFiles(new File(repository), EXTENSION_FILE_FILTER, true));
	rootModule.destroy();

	return listener.getFileErrors();
}
 

import com.puppycrawl.tools.checkstyle.ConfigurationLoader; //导入依赖的package包/类
/**
 * Load checkstyle configuration.
 * @param env The environment
 * @return The configuration just loaded
 * @see #validate()
 */
private Configuration configuration(final Environment env) {
    final File cache =
        new File(env.tempdir(), "checkstyle/checkstyle.cache");
    final File parent = cache.getParentFile();
    if (!parent.exists() && !parent.mkdirs()) {
        throw new IllegalStateException(
            String.format(
                "Unable to create directories needed for %s",
                cache.getPath()
            )
        );
    }
    final Properties props = new Properties();
    props.setProperty("cache.file", cache.getPath());
    props.setProperty("header", this.header(env));
    final InputSource src = new InputSource(
        this.getClass().getResourceAsStream("checks.xml")
    );
    final Configuration config;
    try {
        config = ConfigurationLoader.loadConfiguration(
            src,
            new PropertiesExpander(props),
            true
        );
    } catch (final CheckstyleException ex) {
        throw new IllegalStateException("Failed to load config", ex);
    }
    return config;
}
 

import com.puppycrawl.tools.checkstyle.ConfigurationLoader; //导入依赖的package包/类
/**
 * Check one file.
 * @param name The name of the check
 * @param listener The listener
 * @throws Exception If something goes wrong inside
 */
private void check(final String name, final AuditListener listener)
    throws Exception {
    final Checker checker = new Checker();
    final InputSource src = new InputSource(
        this.getClass().getResourceAsStream(
            String.format("%s/config.xml", this.dir)
        )
    );
    checker.setClassLoader(Thread.currentThread().getContextClassLoader());
    checker.setModuleClassLoader(
        Thread.currentThread().getContextClassLoader()
    );
    checker.configure(
        ConfigurationLoader.loadConfiguration(
            src,
            new PropertiesExpander(new Properties()),
            true
        )
    );
    final List<File> files = new ArrayList<>(0);
    files.add(
        new File(
            this.getClass().getResource(
                String.format("%s%s", this.dir, name)
            ).getFile()
        )
    );
    checker.addListener(listener);
    checker.process(files);
    checker.destroy();
}
 

import com.puppycrawl.tools.checkstyle.ConfigurationLoader; //导入依赖的package包/类
@VisibleForTesting
static Configuration toCheckstyleConfiguration(File xmlConfig) throws CheckstyleException {
    return ConfigurationLoader.loadConfiguration(xmlConfig.getAbsolutePath(),
            new PropertiesExpander(new Properties()));
}
 

import com.puppycrawl.tools.checkstyle.ConfigurationLoader; //导入依赖的package包/类
public static Configuration loadConfiguration(String path, Properties props)
        throws CheckstyleException {
    return ConfigurationLoader.loadConfiguration(path, new PropertiesExpander(props));
}
 

import com.puppycrawl.tools.checkstyle.ConfigurationLoader; //导入依赖的package包/类
private Configuration getConfigurationFromStream(InputStream in) throws CheckstyleException {
  return ConfigurationLoader.loadConfiguration(
      new InputSource(in),
      new CheckstylePropertiesResolver(new Properties()), // TODO: pass real properties
      true);
}