Java 方法调用后控制台输出不工作

我目前正在开发一个基于一些模板文件生成和验证.xml文件的应用程序

我调用的生成这些文件的方法如下所示：

FtlProcessingController ctrl = new FtlProcessingController();
ctrl.process(TEMPLATES, OUTPUT_DIRECTORY, root, metadata);

// Prepare files and data

FtlProcessingController ctrl = new FtlProcessingController();
ctrl.process(TEMPLATES, OUTPUT_DIRECTORY, root, metadata);

// Validate XML files

我不是这个FtlProcessingController类的作者，但是process方法基本上从TEMPLATES目录中获取模板文件，用根对象（一个应答对象树）和

元数据

对象（一个附加数据映射）中的内容填充它们，并将.xml文件输出到输出目录

简而言之，主代码如下所示：

FtlProcessingController ctrl = new FtlProcessingController();
ctrl.process(TEMPLATES, OUTPUT_DIRECTORY, root, metadata);

// Prepare files and data

FtlProcessingController ctrl = new FtlProcessingController();
ctrl.process(TEMPLATES, OUTPUT_DIRECTORY, root, metadata);

// Validate XML files

问题是进程调用后的任何控制台输出都不起作用；控制台中没有显示任何内容

我尝试用一些测试输出来包围调用，并保存

PrintStream

以进行重置：

System.out.println("Console");
PrintStream stdOut = System.out;

FtlProcessingController ctrl = new FtlProcessingController();
ctrl.process(TEMPLATES, OUTPUT_DIRECTORY, root, metadata);

// Test Exception was thrown here.

System.setOut(stdOut);
System.out.println("Console again");

但我只得到：

控制台

我确信在这个调用中没有无限循环或System.exit（），因为文件是成功生成的。我甚至尝试在调用后立即抛出一个异常来确认这一点，并且异常是正常抛出的

我的问题是：与处理方法对System.out的作用无关，在调用

System.setOut（stdOut）

后，我是否应该能够在控制台上再次打印

什么可能会使标准输出混乱，从而导致保存的PrintStream无法工作

谢谢

完整的主代码，对于好奇的人：

public static void main(String[] args) {
    try {
        // Parse answers
        Answer root = AnswerUtils.fromJSON(JSON_FILE, Answer.class);

        ModuleInfo manager = new SimpleModuleInfo(MODULE_MANAGER_ID, MODULE_MANAGER_CATEGORY, MODULE_MANAGER_NAME,
                MODULE_MANAGER_VERSION, MODULE_MANAGER_VERSION);
        ModuleInfo module = new SimpleModuleInfo(MODULE_ID, MODULE_CATEGORY, MODULE_NAME, MODULE_VERSION, INSTANCE);

        List<ModuleInfo> info = new ArrayList<ModuleInfo>();
        info.add(manager);
        info.add(module);
        if (DEPENDENCIES_FILES != null) {
            // property file, with all dependencies as a comma-separated value under the 'dependencies' key
            Properties props = new Properties();
            InputStream in = null;
            try {
                in = new FileInputStream(DEPENDENCIES_FILES);
                props.load(in);
            } finally {
                IOUtils.closeQuietly(in);
            }
            String[] values = StringUtils.split(props.getProperty("dependencies"), ',');
            if (values != null) {
                for (String value : values) {
                    ModuleDependency dep = new ModuleDependency(StringUtils.trim(value));
                    info.add(new SimpleModuleInfo(dep.getIdentifier(), "Category", WordUtils.capitalizeFully(
                            dep.getIdentifier(), new char[] { '-' }), dep.getVersion().toString(), dep
                            .isInstanceDependency() ? module.getInstance() : "Default"));
                }
            }
        }
        Map<String, Object> metadata = getMetadata(HOME, os, arch, module, info.toArray(new ModuleInfo[info.size()]));

        System.out.println("Console");
        PrintStream stdOut = System.out;

        FtlProcessingController ctrl = new FtlProcessingController();
        ctrl.process(TEMPLATES, OUTPUT_DIRECTORY, root, metadata);

        System.setOut(stdOut);
        System.out.println("Console again");

        // Validate XML
        Collection<File> xmlFiles = FileUtils.listFiles(OUTPUT_DIRECTORY, OUTPUT_FILES_EXTENSIONS, WITH_SUBDIRECTORIES);
        for (File file : xmlFiles) {
            System.out.println(file.getAbsolutePath());
            SAXParserFactory factory = SAXParserFactory.newInstance();
            factory.setValidating(false);
            factory.setNamespaceAware(true);
            factory.setFeature(FACTORY_DTD_FEATURE, false);

            SAXParser parser = factory.newSAXParser();

            XMLReader reader = parser.getXMLReader();
            reader.setErrorHandler(new SPErrorHandler());
            reader.parse(file.getAbsolutePath());
        }
        if(true)
            throw new IOException();
    } catch (SAXException se) {
        se.printStackTrace();
    } catch (IOException ioe) {
        ioe.printStackTrace();
    } catch (ParserConfigurationException pce) {
        pce.printStackTrace();
    }
}

publicstaticvoidmain（字符串[]args）{
试一试{
//解析答案
answerroot=AnswerUtils.fromJSON（JSON_文件，Answer.class）；
ModuleInfo manager=新的SimpleModuleInfo（模块管理器ID、模块管理器类别、模块管理器名称、，
模块管理器版本、模块管理器版本）；
ModuleInfo模块=新的SimpleModuleInfo（模块ID、模块类别、模块名称、模块版本、实例）；
列表信息=新的ArrayList（）；
信息添加（经理）；
信息添加（模块）；
if（依赖项_文件！=null）{
//属性文件，所有依赖项在“dependencies”键下以逗号分隔
Properties props=新属性（）；
InputStream in=null；
试一试{
in=新文件输入流（依赖项\ U文件）；
道具载荷（in）；
}最后{
安静地关闭（在）；
}
String[]values=StringUtils.split（props.getProperty（“依赖项”），'，'；
如果（值！=null）{
for（字符串值：值）{
ModuleDependency dep=新的ModuleDependency（StringUtils.trim（值））；
info.add（新的SimpleModuleInfo（dep.getIdentifier（），“Category”，WordUtils.capitalizely(
dep.getIdentifier（），新字符[]{'-'}），dep.getVersion（）.toString（），dep
.isInstanceDependency（）？module.getInstance（）：“默认”）；
}
}
}
Map metadata=getMetadata（HOME、os、arch、module、info.toArray（新ModuleInfo[info.size（））；
System.out.println（“控制台”）；
PrintStream stdOut=System.out；
FtlProcessingController ctrl=新的FtlProcessingController（）；
进程（模板、输出目录、根目录、元数据）；
系统放样（标度）；
System.out.println（“再次控制台”）；
//验证XML
集合xmlFiles=FileUtils.listFiles（输出目录，输出文件扩展名，带子目录）；
for（文件：xmlFiles）{
System.out.println（file.getAbsolutePath（））；
SAXParserFactory=SAXParserFactory.newInstance（）；
工厂设置验证（假）；
factory.setNamespaceAware（true）；
setFeature（factory\u DTD\u FEATURE，false）；
SAXParser parser=factory.newSAXParser（）；
XMLReader=parser.getXMLReader（）；
setErrorHandler（新的SPErrorHandler（））；
parse（file.getAbsolutePath（））；
}
如果（真）
抛出新IOException（）；
}捕获（SAXSE异常）{
se.printStackTrace（）；
}捕获（ioe异常ioe）{
ioe.printStackTrace（）；
}捕获（ParserConfiguration异常pce）{
pce.printStackTrace（）；
}
}

您调用的方法可能会重新分配

System.out

流，这可以通过

System.setOut（PrintStream）

方法完成

如果是这种情况，并且输出在Java控制台中不再可见，则可能是将输出写入日志文件。然而，这种日志记录方法是一个非常糟糕的主意，尤其是在其他人可能最终使用的库中，不应该这样做

---

比这更糟糕的想法是实际关闭

系统.out

流。我想不出任何场景可以证明这样做。

如果在打印“再次控制台”后刷新输出流会发生什么？如果不了解更多关于

FtlProcessingController的信息，这将很难提供帮助。您调用的方法可能会重新分配System.out流。如果是这种情况，并且输出在Java控制台中不再可见，则可能是将输出写入日志文件。然而，这种记录日志的方法是一个非常糟糕的主意，不应该这样做。一个比这更糟糕的想法是实际关闭系统。你有权访问FtlProcessingController类的源代码吗？@Kallja我刚和我的同事深入到FtlProcessingController，我们实际上发现System.out在内部某个地方关闭了，就像你说的。我甚至不知道这样的事情是可能发生的，现在和我一起工作真是太尴尬了…@AlexisLeclerc好吧，那么我将把我的评论作为一个答案发表，这是我的错