能否使用InputStream读取计算机临时文件夹中的临时文件？JUnit测试场景下的技术咨询

Absolutely! You can definitely read a temporary file stored in your system's temp directory using an InputStream—this is a perfect fit for your JUnit test scenario, especially since you want large files cleaned up automatically after tests finish. Let's walk through how to make this work smoothly, plus fix a few small issues in your existing code.

Core Answer #

Temporary files created via File.createTempFile() are just regular files under the hood—there's no restriction on reading them with InputStream. As long as you have a valid File reference or path to the temp file, you can open an input stream to read its content just like any other file.

Refined Code & Best Practices #

Your current code has a couple of minor issues (like mismatched parameter types for createTempFile and unmanaged stream resources) that we can fix to make it more robust. Here's an improved version, including the reading logic you need for your test:

1. Test POJO Class #

First, make sure your Test class has proper JAXB annotations (required for serialization):

import jakarta.xml.bind.annotation.XmlRootElement;

@XmlRootElement
public class Test {
    private String name;
    private int age;

    // JAXB requires a no-arg constructor
    public Test() {}

    public Test(String name, int age) {
        this.name = name;
        this.age = age;
    }

    // Getters and setters
    public String getName() { return name; }
    public void setName(String name) { this.name = name; }
    public int getAge() { return age; }
    public void setAge(int age) { this.age = age; }
}

2. Temp File Creation & Serialization #

Use try-with-resources to automatically close streams (avoids resource leaks, especially important for large files) and fix the createTempFile parameter mismatch:

import jakarta.xml.bind.JAXBContext;
import jakarta.xml.bind.JAXBException;
import jakarta.xml.bind.Marshaller;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;

private File createTemporaryXmlFile(Test testClass) throws JAXBException, IOException {
    // Get the system's temp directory path
    String tempDirPath = System.getProperty("java.io.tmpdir");
    File tempDir = new File(tempDirPath);

    // Create a temp .xml file (third parameter is a File, not a String)
    File tempXmlFile = File.createTempFile("myFile", ".xml", tempDir);
    // Mark the file for deletion when the JVM exits
    tempXmlFile.deleteOnExit();

    // Use try-with-resources to auto-close the OutputStream
    try (OutputStream outputStream = new FileOutputStream(tempXmlFile)) {
        JAXBContext jaxbContext = JAXBContext.newInstance(Test.class);
        Marshaller jaxbMarshaller = jaxbContext.createMarshaller();
        jaxbMarshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, Boolean.TRUE);
        // Serialize the POJO to XML
        jaxbMarshaller.marshal(testClass, outputStream);
    }

    return tempXmlFile;
}

3. Read the Temp File with InputStream #

Add this method to read the temp file using InputStream and deserialize it back to your POJO (perfect for validating your test):

import jakarta.xml.bind.Unmarshaller;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;

private Test readTemporaryXmlFile(File tempXmlFile) throws JAXBException, IOException {
    // Again, use try-with-resources for safe stream handling
    try (InputStream inputStream = new FileInputStream(tempXmlFile)) {
        JAXBContext jaxbContext = JAXBContext.newInstance(Test.class);
        Unmarshaller jaxbUnmarshaller = jaxbContext.createUnmarshaller();
        // Deserialize the XML back to your Test object
        return (Test) jaxbUnmarshaller.unmarshal(inputStream);
    }
}

4. JUnit Test Example #

Putting it all together in a JUnit test:

import org.junit.Test;
import static org.junit.Assert.assertEquals;

public class TempFileTest {

    @Test
    public void testXmlSerializationAndDeserialization() throws JAXBException, IOException {
        // Create your test POJO
        Test originalTest = new Test("Roger", 28);

        // Generate the temp XML file
        File tempXmlFile = createTemporaryXmlFile(originalTest);

        // Read and deserialize the temp file
        Test deserializedTest = readTemporaryXmlFile(tempXmlFile);

        // Validate the data matches (your test logic here)
        assertEquals(originalTest.getName(), deserializedTest.getName());
        assertEquals(originalTest.getAge(), deserializedTest.getAge());

        // Optional: Explicitly delete the file immediately after test
        // Useful if you're generating many large files and want to free up disk space fast
        tempXmlFile.delete();
    }
}

Key Notes for Your Scenario #

• Stream Management: Always use try-with-resources for streams—this ensures they're closed properly, even if an exception occurs. For large files, this prevents memory leaks and resource exhaustion.
• Temp File Cleanup: deleteOnExit() works, but it only deletes the file when the JVM exits. If you're running multiple tests in the same JVM instance (common in JUnit suites), the file will stick around until all tests finish. For large files, call tempXmlFile.delete() explicitly after your test to free up disk space right away.
• Large File Handling: If your XML files are extremely large, consider using JAXB with streaming APIs (XMLStreamReader/XMLStreamWriter) to process the file in chunks instead of loading the entire thing into memory. Here's a quick example for reading:

  try (InputStream inputStream = new FileInputStream(tempXmlFile)) {
      XMLInputFactory xmlInputFactory = XMLInputFactory.newInstance();
      XMLStreamReader xmlStreamReader = xmlInputFactory.createXMLStreamReader(inputStream);
  
      JAXBContext jaxbContext = JAXBContext.newInstance(Test.class);
      Unmarshaller jaxbUnmarshaller = jaxbContext.createUnmarshaller();
      Test deserializedTest = jaxbUnmarshaller.unmarshal(xmlStreamReader, Test.class).getValue();
  }
  

内容的提问来源于stack exchange，提问作者Roger