WebSphere中对response.sendError()的处理与Tomcat不同

不同的地方在于，同样的代码【response.sendError(1);】

在Tomcat下，response.getResponseCode()的值是 1，而在Websphere下面则是 500。

而且500这个东西比较尴尬，一般的web框架都会在web.xml里面默认让它迁移到错误页面。

由此，对于调用远端服务器servlet进行验证，需要给出结果的时候，可以根据response.getResponseCode()

进行分支判断的想法就不能借助response.sendError()来实行。

解释下，web后台调用远端服务器的时候一般使用HttpURLConnection，调用完毕之后，需要进行分支处理的时候，

最好使用response.getResponseCode()，而不是通过

BufferedReader rd = new BufferedReader(new InputStreamReader(con.getInputStream(), CommonValue.CHAR_SET));

String line = "";

while ((line = rd.readLine()) != null) {

}

来读这个stream内容，为什么呢，因为有可能返回的stream内容不同，有的时候是字符串，有的时候是一个文件流。

而且InputStream十分不好备份，因为为了备份而提供的两个方法mark()和reset()也是需要先自己实现了之后才能用的。

远端servlet的response不能用刚才的sendError()那用什么呢，用setStatus();

下面给出例子：

本地Server

     public boolean downloadLogFromAp(String apNo) throws Exception {

         super.currentForm.set(WebConst.WS0120Form.CAN_DOWNLOAD_FLG, CommonValue.NULL_SPACE);
         String filepath = CommonValue.NULL_SPACE;
         String httpsURL = CommonValue.NULL_SPACE;

         if (CommonValue.STRING_ONE.equals(apNo)) {

             filepath = PropertyFileReader.getTachiaiProperties("AP01PATH") + super.currentForm.getString(WS0120Form.AP1LOGFILEPATH);
             httpsURL = PropertyFileReader.getTachiaiProperties("AP01URL");
         } else {

             filepath = PropertyFileReader.getTachiaiProperties("AP02PATH") + super.currentForm.getString(WS0120Form.AP2LOGFILEPATH);
             httpsURL = PropertyFileReader.getTachiaiProperties("AP02URL");
         }

         String logfileparam = "logfilepath" + ServletConst.SIGN_OF_EQUALITY + filepath;
         URL myurl = new URL(httpsURL);
         HttpURLConnection con;
         if ("https".equals(httpsURL.substring(0, 5))) {
             con = (HttpsURLConnection) myurl.openConnection();
         } else {
             con = (HttpURLConnection) myurl.openConnection();
         }

         con.setRequestMethod("POST");
         con.setConnectTimeout(60000);
         con.setReadTimeout(60000);
         con.setInstanceFollowRedirects(false);
         con.setUseCaches(false);
         con.setDoOutput(true);

         OutputStream out = con.getOutputStream();
         Writer wout = new OutputStreamWriter(out);
         wout.write(logfileparam);
         //wout.flush();
         wout.close();

         if (con.getResponseCode() == 200) {

             HttpServletResponse response = super.currentResponse;
             response.setHeader("Content-Type", "text/plain");
             String zipfileName = getServerZipFileName(filepath);
             response.setHeader("content-disposition", "attachment;filename=" + URLEncoder.encode(zipfileName, "UTF-8"));
             OutputStream os = response.getOutputStream();
             InputStream is = con.getInputStream();
             DownloadUtil.transfer(is, os);
             con.disconnect();
             return true;
         } else if (con.getResponseCode() == 1) {
             // ログファイルが存在しない場合、エラーメッセージを表示する。
             super.dispatchAction.getActionMessages().add(ActionMessages.GLOBAL_MESSAGE, new ActionMessage(MessageId.MSG_E_001_082));
             con.disconnect();
             return false;
         } else {
             con.disconnect();
             return false;
         }
     }

远端Servlet

 package jp.co.kentaku.kanri.tachiai.web.servlet;

 import java.io.BufferedReader;
 import java.io.File;
 import java.io.FileInputStream;
 import java.io.FileOutputStream;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.InputStreamReader;
 import java.io.OutputStream;
 import java.io.PrintWriter;
 import java.net.URLEncoder;

 import javax.servlet.ServletException;
 import javax.servlet.http.HttpServlet;
 import javax.servlet.http.HttpServletRequest;
 import javax.servlet.http.HttpServletResponse;

 import jp.co.kentaku.common.tools.LogUtil;
 import jp.co.kentaku.kanri.tachiai.common.TachiaiConst;
 import jp.co.kentaku.kanri.tachiai.common.util.DownloadUtil;
 import jp.co.kentaku.kanri.tachiai.renkei.common.ServletConst;

 import org.apache.commons.lang.StringUtils;
 import org.apache.tools.ant.BuildException;
 import org.apache.tools.ant.Project;
 import org.apache.tools.ant.taskdefs.Zip;
 import org.apache.tools.ant.types.FileSet;

 public class LogFileDownloadServlet extends HttpServlet {

     /** シリアル・バージョンID */
     private static final long   serialVersionUID = 1L;

     private static final String FILE_SEPARATOR   = File.separator;

     /**
      * GET方式でサーブレット主処理を行う。
      *
      * @param req リクエスト
      * @param resp レスポンス
      */
     @Override
     protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {

         this.doPost(req, resp);
     }

     /**
      * POST方式でサーブレット主処理を行う。
      *
      * @param req リクエスト
      * @param resp レスポンス
      */
     @Override
     protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {

         LogUtil.debug("jp.co.kentaku", "ログファイルダウンロードサーブレット開始。");
         //ログファイルパスを取得する。
         String filepath = null;
         BufferedReader br = new BufferedReader(new InputStreamReader(req.getInputStream()));
         String line = "";
         if ((line = br.readLine()) != null) {
             if (!StringUtils.isEmpty(line)) {
                 String[] arr = line.split(ServletConst.SIGN_OF_EQUALITY);
                 if (arr.length == 2) {
                     filepath = arr[1];
                 }
             }
         }

         //ログファイル名正確の場合、ログファイルをダウンロードする。
         if (!StringUtils.isEmpty(filepath)) {
             downloadZip(filepath, resp);
         } else {
             resp.setHeader("Content-Type", "text/plain;charset=Shift_JIS");
             PrintWriter out = resp.getWriter();
             out.print("ログファイルダウンロードサーブレットで、ログファイル" + filepath + "がNULLであるから、エラーとする。");
             LogUtil.error("jp.co.kentaku", "ログファイルダウンロードサーブレットで、ログファイル" + filepath + "がNULLであるから、エラーとする。");
             out.flush();
             out.close();
         }

         LogUtil.debug("jp.co.kentaku", "ログファイルダウンロードサーブレット終了。");
     }

     /**
      * ログファイルをダウンロードする
      *
      * @param filepath ダウンロードパス
      * @param response レスポンス
      * @throws IOException 例外
      */
     private void downloadZip(String filepath, HttpServletResponse response) throws IOException {

         boolean isMultiFilesName = isMultiFilesName(filepath);
         File zipfolder = null;
         if (isTargetExists(filepath, isMultiFilesName)) {
             zipfolder = getZipTargetDir(filepath, isMultiFilesName);
             String zippath = zipfolder.getName() + ".zip";
             zipFile(zippath, zipfolder);
             response.setHeader("Content-Type", "application/zip");
             response.setHeader("content-disposition", "attachment;filename=" + URLEncoder.encode(zippath, "UTF-8"));
             OutputStream os = response.getOutputStream();
             File zipfile = new File(zippath);
             InputStream is = new FileInputStream(zipfile);
             DownloadUtil.transfer(is, os);
             zipfile.delete();
             for (File file : zipfolder.listFiles()) {
                 file.delete();
             }
             zipfolder.delete();
             LogUtil.debug("jp.co.kentaku", "ログファイルダウンロードサーブレット経由し、ファイル" + filepath + "をダウンロードした。");
         } else {
             response.setHeader("Content-Type", "text/plain;charset=Shift_JIS");
             response.setStatus(1);
             LogUtil.error("jp.co.kentaku", "ログファイルダウンロードサーブレットで、ログファイル" + filepath + "が存在しないから、エラーとする。");
         }

     }

     /**
      * 圧縮対象フォルダを取得する
      *
      * @param filepath ダウンロードパス
      * @param isMultiFilesName 複数件フラグ
      * @return 圧縮対象フォルダ
      * @throws IOException 例外
      */
     private File getZipTargetDir(String filepath, boolean isMultiFilesName) throws IOException {

         File targetDir = null;
         if (isMultiFilesName) {
             int lastIndex = filepath.lastIndexOf(FILE_SEPARATOR) + 1;
             String toFileName = filepath.substring(lastIndex, filepath.length() - 1);
             File toFolder = new File(TachiaiConst.TachiaiProperties.TACHIAI_DATA_DIR + toFileName + ".log.all");
             if (!toFolder.exists()) {
                 toFolder.mkdirs();
             }
             File fromFolder = new File(filepath.substring(0, lastIndex));
             for (File file : fromFolder.listFiles()) {
                 if (file.isFile() && file.getName().startsWith(toFileName)) {
                     copyFile(new File(fromFolder, file.getName()), new File(toFolder, file.getName()));
                 }
             }
             targetDir = toFolder;

         } else {
             File fromFile = new File(filepath);
             File toFile = new File(TachiaiConst.TachiaiProperties.TACHIAI_DATA_DIR + fromFile.getName());
             if (!toFile.exists()) {
                 toFile.mkdirs();
             }
             copyFile(fromFile, new File(toFile, fromFile.getName()));
             targetDir = toFile;

         }
         return targetDir;
     }

     /**
      * ログファイルを圧縮する
      *
      * @param zippath 圧縮先パス
      * @param zipfolder 圧縮対象フォルダ
      * @throws BuildException 例外
      */
     private void zipFile(String zippath, File zipfolder) throws BuildException {

         //ログファイルをZIPに圧縮する。
         ZipCompressor zc = new ZipCompressor(zippath);
         zc.compress(zipfolder);

     }

     /**
      * 複数件ダウンロードするかどうか
      *
      * @param filepath ダウンロードパス
      * @return 複数件フラグ
      */
     private boolean isMultiFilesName(String filepath) {

         boolean isMultiFiles = false;
         isMultiFiles = !StringUtils.isEmpty(filepath) && filepath.matches("^.+\\*$");
         return isMultiFiles;
     }

     /**
      * ログファイル存在チェック
      *
      * @param filepath ダウンロードパス
      * @param isMultiFilesName 複数件フラグ
      * @return チェック結果
      */
     private boolean isTargetExists(String filepath, boolean isMultiFilesName) {

         boolean isTargetExists = false;
         if (isMultiFilesName) {
             int lastIndex = filepath.lastIndexOf(FILE_SEPARATOR);
             String fileName = filepath.substring(lastIndex + 1, filepath.length() - 1);
             File folder = new File(filepath.substring(0, lastIndex));
             if (folder.exists()) {
                 for (File file : folder.listFiles()) {
                     if (file.getName().startsWith(fileName)) {
                         isTargetExists = true;
                         break;
                     }
                 }
             }
         } else {
             File file = new File(filepath);
             isTargetExists = file.exists();
         }
         return isTargetExists;
     }

     /**
      * ファイルをコピーする
      *
      * @param fromFile コピー元
      * @param toFile コピー先
      * @throws IOException 例外
      */
     private void copyFile(File fromFile, File toFile) throws IOException {

         FileInputStream fis = new FileInputStream(fromFile);
         FileOutputStream fos = new FileOutputStream(toFile);
         try {
             int byteRead = 0;
             byte[] buffer = new byte[1024];
             while ((byteRead = fis.read(buffer)) != -1) {
                 fos.write(buffer, 0, byteRead);
             }
         } finally {
             fis.close();
             fos.flush();
             fos.close();
         }
     }

     /**
      * CSVファイルをZIPに圧縮する用クラス
      *
      * @author zang_yuling
      *
      */
     private static class ZipCompressor {

         private File zipFile;

         /**
          * コンストラクタ
          *
          * @param pathName zipファイアのファイアパス
          */
         public ZipCompressor(String pathName) {

             zipFile = new File(pathName);
         }

         /**
          * ファイアを圧縮する
          *
          * @param file　圧縮されたファイア名
          */
         public void compress(File file) {

             FileSet fileSet = new FileSet();
             Project prj = new Project();
             Zip zip = new Zip();
             zip.setProject(prj);
             zip.setDestFile(zipFile);
             fileSet.setProject(prj);
             fileSet.setDir(file);
             zip.addFileset(fileSet);
             zip.execute();
         }

     }

 }