Java 为什么将servlet部署到Elastic beanstalk时返回空xml文件？

我已经将servlet部署到AWS Elastic Beanstalk。我正在以http post请求的形式从客户端调用servlet，并将xml文件作为有效负载（使用流）。servlet应该以xml文件作为负载进行响应。我从servlet接收到响应代码200，但xml文件是空的。我做错了什么

在下面找到我的客户机和servlet代码

客户端代码：

public class TaxWebClient {

    static final int BUFFER_SIZE = 4096;

    public static void main(String[] args) throws IOException, URISyntaxException {
        //Takes file path (input file), url and savedir (directory to save output file) as arguments
        String filePath = args[0];
        String uploadUrl = args[1];
        String saveDir = args[2];
        File uploadFile = new File(filePath);
        //
        //File uploadFile = new File(TaxWebClient.class.getResource(filePath).toURI());        

        System.out.println("File to upload: " + filePath);

        HttpURLConnection httpConn = null;
        OutputStream outputStream = null;
        FileInputStream inputStream = null;
        //InputStream inputStream = null;

        try {
            //Creates a HTTP connection
            URL url = new URL(uploadUrl);
            httpConn = (HttpURLConnection) url.openConnection();

            //Set timeout (10 and 15 sec.)
            //httpConn.setConnectTimeout(10000);  
            //httpConn.setReadTimeout(15000);

            //Set output & request type 
            httpConn.setUseCaches(false);
            httpConn.setDoOutput(true);
            httpConn.setRequestMethod("POST");        

            //Set headers
            httpConn.setRequestProperty("Accept", "application/xml");
            httpConn.setRequestProperty("Content-Type", "application/xml; charset=utf-8");

            //Sets file name as a HTTP header
            httpConn.setRequestProperty("fileName", uploadFile.getName());

            //Opens output stream of the HTTP connection for writing data
            outputStream = httpConn.getOutputStream();

            //Opens input stream of the file for reading data
            inputStream = new FileInputStream(uploadFile);

            //Loads file from filePath (arg0) when running as JAR file else JAR file won't work
            //inputStream = TaxWebClient.class.getClassLoader().getResourceAsStream(filePath);

            //Writing data to servlet (outputstream)              
            byte[] bufferInput = new byte[BUFFER_SIZE];         
            int bytesRead = -1;

            System.out.println("Start writing data...");

            while ((bytesRead = inputStream.read(bufferInput)) != -1) {
                outputStream.write(bufferInput, 0, bytesRead);              
            }

            System.out.println("Data was send to servlet.");

        } catch (IOException ioe) {         
            System.out.println("Error:" + ioe.getMessage()); 
            ioe.printStackTrace();

        } finally {
            if (outputStream != null) {
                outputStream.close();
            }
            if (inputStream != null) {
                inputStream.close();
            }           
        }        

        //**RESPONSE**
        //************       
        //Always check HTTP response code from server
        int responseCode = httpConn.getResponseCode();      

        if (responseCode == HttpURLConnection.HTTP_OK) {

            System.out.println("Server's response: " + responseCode);

            InputStream inputStreamFromServlet = null;
            //ByteArrayOutputStream byteOutputStreamFromServlet = null;
            FileOutputStream fileOutputStreamFromServlet = null;
            //OutputStreamWriter outputStreamWriterFromServlet = null;

            //String xmlContentFromServlet = null;

            try {
                //****Getting xml file from response**** 

                //Making output filename from input filename
                String fileNameInputWithOutExtension = FilenameUtils.removeExtension(uploadFile.getName());
                String fileNameOutput = fileNameInputWithOutExtension + "TaxOutput.xml";                                

                File saveFile = new File(saveDir + fileNameOutput);

                //Opens input stream of the response for reading data
                inputStreamFromServlet = httpConn.getInputStream();                       

                //Opens output stream for writing bytes 
                //byteOutputStreamFromServlet = new ByteArrayOutputStream();

                //Opens an output stream for writing file
                fileOutputStreamFromServlet = new FileOutputStream(saveFile);

                //Turns bytes based stream into character based writer
                //outputStreamWriterFromServlet = new OutputStreamWriter(new FileOutputStream(saveFile), "UTF-8");

                //Writes response from servlet (bites) to byte object - the approach is used because the byte object can be used in more situations 
                byte[] bufferOutput = new byte[BUFFER_SIZE];
                int bytesReadOutput = -1;
                System.out.println("Receiving data...");

                //Writes file from input stream
                while ((bytesReadOutput = inputStreamFromServlet.read(bufferOutput)) != -1) {
                    fileOutputStreamFromServlet.write(bufferOutput, 0, bytesReadOutput);
                }           

                System.out.println("Data received.");            

                System.out.println("File written to: " + saveFile.getAbsolutePath());

            } catch (IOException ioe) {         
                System.out.println("Error:" + ioe.getMessage()); 
                ioe.printStackTrace();

            } finally {
                if (fileOutputStreamFromServlet != null) {
                    fileOutputStreamFromServlet.close();
                }
                if (inputStreamFromServlet != null) {
                    inputStreamFromServlet.close();
                }
                /*
                if (byteOutputStreamFromServlet != null) {
                    byteOutputStreamFromServlet.close();
                }
                if (outputStreamWriterFromServlet != null) {
                    outputStreamWriterFromServlet.close();
                }
                */              
            }       
        } else {
            System.out.println("Server returned non-OK code: " + responseCode);
        }        
    }
}

Servlet代码：

public class TaxIncomeCalcServlet extends HttpServlet {

    private static final long serialVersionUID = 1L;

    static final int BUFFER_SIZE = 4096;    

    //Do required initialization of servlet
    public void init() throws ServletException {        

    }   

    protected void doPost(HttpServletRequest request,
            HttpServletResponse response) throws ServletException, IOException {

        //Gets file name from HTTP header and makes new name for output file
        String fileNameInput = request.getHeader("fileName");       

        //Prints out all header values for test purpose
        System.out.println("===== Begin headers =====");
        Enumeration<String> names = request.getHeaderNames();
        while (names.hasMoreElements()) {
            String headerName = names.nextElement();
            System.out.println(headerName + " = " + request.getHeader(headerName));        
        }
        System.out.println("===== End headers =====\n");

        FileOutputStream outputStream = null;
        InputStream inputStream = null;

        try {
            //Opens input stream of the request for reading data
            inputStream = request.getInputStream();

            //Opens an output stream for writing file
            outputStream = new FileOutputStream(fileNameInput);

            byte[] bufferInput = new byte[BUFFER_SIZE];
            int bytesRead = -1;
            System.out.println("Receiving data...");

            while ((bytesRead = inputStream.read(bufferInput)) != -1) {
                outputStream.write(bufferInput, 0, bytesRead);
            }

            System.out.println("Data received.");

        } catch (IOException ioe) {         
            System.out.println("Error:" + ioe.getMessage()); 
            ioe.printStackTrace();

        } finally {
            if (outputStream != null) {
                outputStream.close();
            }
            if (inputStream != null) {
                inputStream.close();
            }           
        }       

        //*****Using file from client in server side calculation*****       
        ByteArrayOutputStream outputStreamFromCalc = new ByteArrayOutputStream();
        String outputXml = "";

        //Using xml input file from request as input to the tax calculation which makes a output xml string
        try {
            try {


                //doing some business calculations resulting in document


                XmlOptions xmlOptions = new XmlOptions();               
                xmlOptions.setCharacterEncoding("UTF-8");
                xmlOptions.setUseDefaultNamespace();
                xmlOptions.setSavePrettyPrint();
                xmlOptions.setSaveOuter();         

                //Saving to output stream to implement xml declaration
                document.save(outputStreamFromCalc, xmlOptions);
                outputStreamFromCalc.close();

                //Making string from output stream
                outputXml = new String(outputStreamFromCalc.toByteArray());

            } catch (IOException e) {
                e.printStackTrace();
            }

        } catch (XmlException e) {
            e.printStackTrace();
        }        

        //**RESPONSE**
        //************ 
        //Opens an output stream for writing file
        ServletOutputStream outputStreamOutput = null;               
        //Opens an input stream for reading data
        InputStream inputStreamOutput = null;            

        try {

            //Converts from string variable to inputstream
            inputStreamOutput = new ByteArrayInputStream(outputXml.getBytes(StandardCharsets.UTF_8));           

            outputStreamOutput = response.getOutputStream();
            response.setContentType("application/xml");
            response.setHeader("Content-Disposition", "attachment; filename=" + fileNameInput);                 

            byte[] bufferOutput = new byte[BUFFER_SIZE];
            int bytesReadOutput = -1;
            System.out.println("Sending xml to client...");

            while ((bytesReadOutput = inputStreamOutput.read(bufferOutput)) != -1) {
                outputStreamOutput.write(bufferOutput, 0, bytesReadOutput);
            }                   

            System.out.println("Data received.");

        } catch (IOException ioe) {         
            System.out.println("Error:" + ioe.getMessage()); 
            ioe.printStackTrace();

        } finally {
            if (outputStreamOutput != null) {
                outputStreamOutput.close();
            }
            if (inputStreamOutput != null) {
                inputStreamOutput.close();
            }           
        }       
    }

    //Ensures that POST method, and not browser default GET method, is used or else failure 405
    public void doGet (HttpServletRequest request, 
            HttpServletResponse response) throws ServletException, IOException {
        doPost(request, response);
    }

    //Do required destroy of servlet
    public void destroy() {

    }
}

公共类TaxIncomeCalcServlet扩展了HttpServlet{
私有静态最终长serialVersionUID=1L；
静态最终整数缓冲区大小=4096；
//执行所需的servlet初始化
public void init（）引发ServletException{
}   
受保护的void doPost（HttpServletRequest请求，
HttpServletResponse响应）引发ServletException，IOException{
//从HTTP头获取文件名，并为输出文件命名
字符串fileNameInput=request.getHeader（“文件名”）；
//出于测试目的，打印出所有标题值
System.out.println（“==beginheaders===”）；
枚举名称=request.getHeaderNames（）；
while（names.hasMoreElements（））{
字符串headerName=names.nextElement（）；
System.out.println（headerName+“=”+request.getHeader（headerName））；
}
System.out.println（“=======结束头========\n”）；
FileOutputStream outputStream=null；
InputStream InputStream=null；
试一试{
//打开读取数据请求的输入流
inputStream=request.getInputStream（）；
//打开输出流以写入文件
outputStream=新的FileOutputStream（fileNameInput）；
字节[]缓冲输入=新字节[缓冲区大小]；
int字节读取=-1；
System.out.println（“接收数据…”）；
而（（bytesRead=inputStream.read（bufferInput））！=-1）{
写入（缓冲输入，0，字节读取）；
}
System.out.println（“数据接收”）；
}捕获（ioe异常ioe）{
System.out.println（“错误：+ioe.getMessage（））；
ioe.printStackTrace（）；
}最后{
if（outputStream！=null）{
outputStream.close（）；
}
如果（inputStream！=null）{
inputStream.close（）；
}           
}       
//*****在服务器端计算中使用来自客户端的文件****
ByteArrayOutputStream outputStreamFromCalc=新建ByteArrayOutputStream（）；
字符串outputXml=“”；
//使用来自请求的xml输入文件作为税务计算的输入，从而生成输出xml字符串
试一试{
试一试{
//进行一些业务计算，生成文档
XmlOptions XmlOptions=新的XmlOptions（）；
setCharacterEncoding（“UTF-8”）；
setUseDefaultNamespace（）；
setSavePrettyPrint（）；
xmlOptions.setSaveOuter（）；
//保存到输出流以实现xml声明
保存（outputStreamFromCalc，xmlOptions）；
outputStreamFromCalc.close（）；
//从输出流生成字符串
outputXml=新字符串（outputStreamFromCalc.toByteArray（））；
}捕获（IOE异常）{
e、 printStackTrace（）；
}
}捕获（XMLE异常）{
e、 printStackTrace（）；
}        
//**回应**
//************ 
//打开输出流以写入文件
ServletOutputStream outputStreamOutput=null；
//打开用于读取数据的输入流
InputStream inputStreamOutput=null；
试一试{
//从字符串变量转换为inputstream
inputStreamOutput=new ByteArrayInputStream（outputXml.getBytes（StandardCharsets.UTF_8））；
outputStreamOutput=response.getOutputStream（）；
setContentType（“应用程序/xml”）；
response.setHeader（“内容处置”、“附件；文件名=“+fileNameInput”）；
字节[]缓冲输出=新字节[缓冲区大小]；
int byteReadOutput=-1；
System.out.println（“将xml发送到客户端…”）；
而（（bytesReadOutput=inputStreamOutput.read（bufferOutput））！=-1）{
outputStreamOutput.write（缓冲输出，0，字节读取输出）；
}                   
System.out.println（“数据接收”）；
}捕获（ioe异常ioe）{
System.out.println（“错误：+ioe.getMessage（））；
ioe.printStackTrace（）；
}最后{
if（outputStreamOutput！=null）{
outputStreamOutput.close（）；
}
if（inputStreamOutput！=null）{
inputStreamOutput.close（）；
}           
}       
}
//确保使用POST方法，而不是浏览器默认的GET方法，否则失败405
公共无效数据集（HttpServletRequest请求，
HttpServletResponse响应）引发ServletException，IOException{
doPost（请求、响应）；
}
//是否需要销毁servlet
公共空间销毁（）{
}
}