आउटपुट स्ट्रीम

Question

"बंद करें" मैं एक तरफा लाइब्रेरी का उपयोग कर रहा हूं, दुर्भाग्य से, System.out (या कभी-कभी System.err) पर जानकारी प्रिंट करता है। इसे रोकने का सबसे आसान तरीका क्या है?

मैं याद करने के लिए उत्पादन धारा बनाने के बारे में सोच रहा हूँ,, troublemaking तरीकों में से एक के लिए हर कॉल से पहले System.out और err की जगह उन्हें बाद में फिर, और अभी बनाया धारा के बफर ध्यान न दें। क्या कोई आसान, अधिक सुरुचिपूर्ण तरीका है?

संपादित करें: मैं सभी आउटपुट को रीडायरेक्ट नहीं करना चाहता - यह आसानी से पूरा हो गया है। मैं केवल कुछ लाइब्रेरी कॉल द्वारा उत्पन्न आउटपुट को अनदेखा करना चाहता हूं।

Answer 1

मैं की तरह कुछ कर रही समाप्त हो गया।

Answer 2

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

Answer 3

2 तरीके हैं। 1. सबसे आसान तरीका है अपने प्रोग्राम को चलाने और सभी आउटपुट को/dev/null (यदि आप यूनिक्स पर हैं) पर रीडायरेक्ट करते हैं या विशेष फ़ाइल को हटाया जाएगा (विंडोज़ के लिए) इस तरह से सरल है लेकिन इसका मतलब है कि आपका सभी उत्पादन कुछ भी नहीं जा रहा है। यदि आपका प्रोग्राम अच्छी चीजों के लिए STDOUT का उपयोग करता है तो आप इस तरह से उपयोग नहीं कर सकते हैं।

1. आप जावा एपीआई का उपयोग करके STDOUT सेट कर सकते हैं।

   System.setOut (बाहर) System.setErr (बाहर)

अब आप अपने खुद के 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); 
    } 

} 

यह बेहतर है, क्योंकि आप अप्रासंगिक उत्पादन को फ़िल्टर कर सकते हैं और अच्छी जानकारी प्रिंट करें।

Answer 4

एक तरह से उन अवांछित प्रिंट से छुटकारा पाने के स्थायी रूप सेबाईटकोड हेरफेर उपयोग करने के लिए परेशानी पुस्तकालय से प्रिंट बयान को दूर करने के लिए होगा। यह उदाहरण के लिए ASM (या अन्य उच्च स्तर में से एक और AOP ढांचे का उपयोग करने में आसान) का उपयोग कर किया जा सकता है।

आप या तो रनटाइम पर या पुस्तकालय की कक्षा फ़ाइलों को फिर से लिखने के एक बार के ऑपरेशन के रूप में कर सकते हैं। कैसे पता लगाने के लिए एएसएम के दस्तावेज़ीकरण का संदर्भ लें। अवधारणा का सबूत यहां है। यह क्या करता है कि यह System.out पर PrintStream के संदर्भ में सभी संदर्भों को प्रतिस्थापित करता है जो कुछ भी नहीं करता है।

पहले परीक्षण। वे my project से कुछ उपयोगिता कक्षाओं का उपयोग बाइटकोड परिवर्तनों के परीक्षण में सहायता के लिए करते हैं (परीक्षण के लिए एक कस्टम क्लास लोडर बनाने और बाइटकोड ट्रांसफॉर्मेशन को दाएं वर्ग में लागू करने की आवश्यकता होती है लेकिन किसी भी अन्य वर्ग नहीं)।

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"; 
    } 
} 

और फिर कार्यान्वयन। कृपया ध्यान दें कि आपको इसे समझने के बिना इस कोड का उपयोग नहीं करना चाहिए। program by coincidence मत करो। मुझे इस छोटे से समाधान के लिए पुनः निर्देशित के लिए

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 के लिए धन्यवाद और स्टेकर:

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); 
      } 
     } 
    } 
}