如何为DataHandler添加text/plain MIME类型及测试问题排查

It sounds like your production environment has an implicit configuration that maps the text/plain MIME type to a valid DataContentHandler—something your test setup is missing. Since you want to avoid adding external libraries, here are two straightforward, dependency-free solutions:

Option 1: Register JDK's Built-in TextPlainContentHandler #

Most JDK distributions include a built-in handler for text/plain; you just need to manually register it in your test initialization code. Here's how:

import javax.activation.DataHandler;
import javax.activation.DataContentHandler;
import javax.activation.DataContentHandlerFactory;
import java.util.Map;
import java.util.HashMap;

// Add this to your test setup class or a static initializer
public class TestEnvironmentSetup {
    static {
        DataContentHandlerFactory factory = new DataContentHandlerFactory() {
            private final Map<String, Class<?>> mimeHandlers = new HashMap<>();
            
            {
                // Path may vary slightly by JDK version (this works for most OpenJDK/Oracle JDK builds)
                mimeHandlers.put("text/plain", com.sun.xml.internal.messaging.saaj.packaging.mime.internet.TextPlainContentHandler.class);
            }

            @Override
            public DataContentHandler createDataContentHandler(String mimeType) {
                Class<?> handlerClass = mimeHandlers.get(mimeType);
                if (handlerClass != null) {
                    try {
                        return (DataContentHandler) handlerClass.getDeclaredConstructor().newInstance();
                    } catch (Exception e) {
                        // Fall back to default if initialization fails
                        return null;
                    }
                }
                return null;
            }
        };
        DataHandler.setDataContentHandlerFactory(factory);
    }
}

If the class path above doesn't work for your JDK, try com.sun.xml.messaging.saaj.packaging.mime.internet.TextPlainContentHandler—some distributions use this path instead.

Option 2: Implement a Custom Minimal DataContentHandler #

If the built-in class is unavailable or causing issues, write your own lightweight handler. This requires zero external dependencies and gives you full control over streaming behavior:

import javax.activation.DataContentHandler;
import javax.activation.DataSource;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.Writer;

public class PlainTextStreamingHandler implements DataContentHandler {

    @Override
    public Object getContent(DataSource ds) throws IOException {
        // Return InputStream to support streaming reads
        return ds.getInputStream();
    }

    @Override
    public Object getTransferData(String mimeType, DataSource ds) throws IOException {
        return "text/plain".equals(mimeType) ? getContent(ds) : null;
    }

    @Override
    public String[] getTransferDataFlavors() {
        return new String[]{"text/plain"};
    }

    @Override
    public void writeTo(Object obj, String mimeType, OutputStream os) throws IOException {
        if (obj instanceof String) {
            // Stream the input string (e.g., "Value") to the output
            try (Writer writer = new OutputStreamWriter(os, "UTF-8")) {
                writer.write((String) obj);
                writer.flush();
            }
        } else if (obj instanceof InputStream) {
            // Stream data from an existing input stream
            try (InputStream is = (InputStream) obj) {
                byte[] buffer = new byte[1024];
                int bytesRead;
                while ((bytesRead = is.read(buffer)) != -1) {
                    os.write(buffer, 0, bytesRead);
                }
                os.flush();
            }
        }
    }
}

Then register this custom handler in your test setup:

static {
    DataHandler.setDataContentHandlerFactory(new DataContentHandlerFactory() {
        @Override
        public DataContentHandler createDataContentHandler(String mimeType) {
            return "text/plain".equals(mimeType) ? new PlainTextStreamingHandler() : null;
        }
    });
}

Test the Streaming Behavior #

Use this code to verify that DataHandler now correctly streams "Value" for text/plain:

import javax.activation.DataHandler;
import javax.activation.DataSource;
import java.io.ByteArrayInputStream;
import java.io.InputStream;
import java.io.ByteArrayOutputStream;

public class DataHandlerStreamingTest {
    public static void main(String[] args) throws Exception {
        // Create a DataSource that streams "Value"
        DataSource plainTextSource = new DataSource() {
            @Override
            public InputStream getInputStream() throws IOException {
                return new ByteArrayInputStream("Value".getBytes("UTF-8"));
            }

            @Override
            public OutputStream getOutputStream() throws IOException {
                return null;
            }

            @Override
            public String getContentType() {
                return "text/plain";
            }

            @Override
            public String getName() {
                return "plain-text-stream";
            }
        };

        DataHandler handler = new DataHandler(plainTextSource);
        
        // Test streaming read
        try (InputStream inputStream = (InputStream) handler.getContent()) {
            ByteArrayOutputStream output = new ByteArrayOutputStream();
            byte[] buffer = new byte[1024];
            int bytesRead;
            while ((bytesRead = inputStream.read(buffer)) != -1) {
                output.write(buffer, 0, bytesRead);
            }
            System.out.println("Streaming read result: " + output.toString("UTF-8")); // Should print "Value"
        }

        // Test streaming write
        ByteArrayOutputStream writeOutput = new ByteArrayOutputStream();
        handler.writeTo("Value", "text/plain", writeOutput);
        System.out.println("Streaming write result: " + writeOutput.toString("UTF-8")); // Should print "Value"
    }
}

Why This Works #

Your production environment likely has an activation.properties file (embedded in JDK libraries or a system classpath config) that maps text/plain to a handler. Test environments often don't load this config automatically, so manually registering the handler fills that gap.

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