“关闭”输出流

Question

不幸的是，我正在使用一个任性的库，它会将信息打印到 System.out （或偶尔打印到 System.err ）。防止这种情况最简单的方法是什么？

我一直在考虑创建一个到内存的输出流，在每次调用其中一个麻烦方法之前替换 System.out 和 err ，稍后恢复它们，然后忽略创建的流的缓冲区。有没有更简单、更优雅的方法？

编辑：我不想重定向所有输出 - 这很容易完成。我只想忽略某些库调用可能生成的输出。

Answer 1

我最终做了类似的事情：

PrintStream out = System.out;
System.setOut(new PrintStream(new OutputStream() {
    @Override public void write(int b) throws IOException {}
}));
try {
    <library call>
} finally {
    System.setOut(out);
}

感谢 AlexR 和 stacker 将我重定向到这个简短的解决方案。

Answer 2

永久消除这些不需要的打印的一种方法是使用字节码操作从有问题的库中删除打印语句。例如，可以使用 ASM （或其他更高级别且更易于使用的AOP 框架）。

您可以在运行时执行此操作，也可以将其作为重写库的类文件的一次性操作。请参阅 ASM 的文档以了解具体操作方法。这是一个概念证明。它的作用是将所有对 System.out 的引用替换为对 PrintStream 的引用，而后者不执行任何操作。

首先是测试。他们使用我的项目中的一些实用程序类来帮助测试字节码转换（测试它需要创建一个自定义类加载器并将字节码转换应用于正确的类，但不应用于任何其他类）。

package net.orfjackal.dimdwarf.aop;

import net.orfjackal.dimdwarf.aop.conf.*;
import org.junit.*;
import org.objectweb.asm.*;
import org.objectweb.asm.util.CheckClassAdapter;

import java.io.*;
import java.lang.instrument.ClassFileTransformer;
import java.lang.reflect.*;

import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.*;

public class RemoveCallsToSystemOutTest {

    private PrintStream originalOut;
    private ByteArrayOutputStream collectedOut;

    @Before
    public void collectSystemOut() {
        originalOut = System.out;
        collectedOut = new ByteArrayOutputStream();
        System.setOut(new PrintStream(collectedOut));
    }

    @After
    public void restoreOriginalSystemOut() {
        System.setOut(originalOut);
    }

    @Test
    public void the_target_class_prints_when_not_manipulated() throws Exception {
        String safetyCheck = callPrintSomething(TroublesomePrinter.class);

        assertThat(safetyCheck, is("it did execute"));
        assertThat(collectedOut.size(), is(greaterThan(0)));
    }

    @Test
    public void the_target_class_does_not_print_when_it_has_been_manipulated() throws Exception {
        String safetyCheck = callPrintSomething(instrumentClass(TroublesomePrinter.class));

        assertThat(safetyCheck, is("it did execute"));
        assertThat(collectedOut.size(), is(0));
    }

    private static String callPrintSomething(Class<?> clazz) throws Exception {
        Method m = clazz.getMethod("printSomething");
        m.setAccessible(true);
        return (String) m.invoke(null);
    }

    private static Class<?> instrumentClass(Class<?> cls) throws ClassNotFoundException {
        ClassFileTransformer transformer = new AbstractTransformationChain() {
            protected ClassVisitor getAdapters(ClassVisitor cv) {
                cv = new CheckClassAdapter(cv);
                cv = new RemoveCallsToSystemOut(cv);
                return cv;
            }
        };
        ClassLoader loader = new TransformationTestClassLoader(cls.getPackage().getName() + ".*", transformer);
        return loader.loadClass(cls.getName());
    }
}

class TroublesomePrinter {
    public static String printSomething() {
        System.out.println("something");
        return "it did execute";
    }
}

然后就是实施。请注意，在没有首先理解此代码的情况下，您不应该使用它。不要巧合地编程。

class SilentSystem {
    public static final PrintStream out = new PrintStream(new OutputStream() {
        public void write(int b) {
        }
    });
}

class RemoveCallsToSystemOut extends ClassAdapter {

    public RemoveCallsToSystemOut(ClassVisitor cv) {
        super(cv);
    }

    @Override
    public MethodVisitor visitMethod(int access, String name, String desc, String signature, String[] exceptions) {
        return new MyMethodAdapter(super.visitMethod(access, name, desc, signature, exceptions));
    }

    private static class MyMethodAdapter extends MethodAdapter {
        public MyMethodAdapter(MethodVisitor mv) {
            super(mv);
        }

        @Override
        public void visitFieldInsn(int opcode, String owner, String name, String desc) {
            if (opcode == Opcodes.GETSTATIC
                    && owner.equals("java/lang/System")
                    && name.equals("out")
                    && desc.equals("Ljava/io/PrintStream;")) {
                super.visitFieldInsn(opcode, "net/orfjackal/dimdwarf/aop/SilentSystem", name, desc);
            } else {
                super.visitFieldInsn(opcode, owner, name, desc);
            }
        }
    }
}

Answer 3

File file  = new File(filename);
PrintStream printStream = new PrintStream(new FileOutputStream(file));
System.setOut(printStream);

Answer 4

有两种方法。
1.最简单的方法是运行程序并将所有输出重定向到 /dev/null （如果您使用的是 unix）或将被删除的特殊文件（对于 windows）
这种方法虽然简单，但是意味着你的所有输出都将化为乌有。如果你的程序使用 STDOUT 来做好事，你就不能使用这种方式。

1. 您可以使用 java API 设置 STDOUT。

   系统.setOut(输出)
   System.setErr(out)

现在您可以实现自己的OutputStream：

import java.io.IOException;
import java.io.OutputStream;
import java.util.regex.Pattern;


public class FilterOutputStream extends OutputStream {
    private OutputStream out;
    private Pattern filterOut;
    public FilterOutputStream(OutputStream out, Pattern filterOut) {
        this.out = out;
        this.filterOut = filterOut;
    }


    @Override
    public void write(int b) throws IOException {
        String callerClassName = new Throwable().getStackTrace()[1].getClassName();
        if (filterOut.matcher(callerClassName).find()) {
            return;
        }
        out.write(b);
    }

}

这更好，因为您可以过滤掉不相关的输出并打印好的信息。