가이드로 제공되는 아래 코드 중 파일 업로드 부분은 샘플 코드로서 보안 관련 처리가 미흡합니다.

파일 업로드 부분은 프로젝트 내부에서 사용하시는 부분을 그대로 사용하시고 아래 코드를 참고하셔서 연동 부분을 처리해주세요. 

import com.google.gson.GsonBuilder;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.apache.commons.fileupload.FileItem;
import org.apache.commons.fileupload.disk.DiskFileItemFactory;
import org.apache.commons.fileupload.servlet.ServletFileUpload;

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Timer;
import java.util.TimerTask;
import java.util.UUID;
import java.util.zip.InflaterInputStream;

public class ImportServlet extends HttpServlet {

    private static final long serialVersionUID = 1L;
    private static final String UPLOAD_DIR_REL_PATH = "import";

	private static final int MEMORY_THRESHOLD = 1024 * 1024 * 3;
	private static final int MAX_FILE_SIZE = 1024 * 1024 * 40;
	private static final int MAX_REQUEST_SIZE = 1024 * 1024 * 50;

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

         // 파일별로 변환결과를 저장할 경로 생성
            String uuid = UUID.randomUUID().toString();
            
            // 경로 생성
            File outputPath = new File(uploadPathif (ServletFileUpload.isMultipartContent(request)) {
		
		    DiskFileItemFactory factory = new DiskFileItemFactory();
		    factory.setSizeThreshold(MEMORY_THRESHOLD);
		    factory.setRepository(new File(System.getProperty("java.io.tmpdir")));
		
		    ServletFileUpload upload = new ServletFileUpload(factory);
		    upload.setHeaderEncoding("UTF-8");
		    upload.setFileSizeMax(MAX_FILE_SIZE);
		    upload.setSizeMax(MAX_REQUEST_SIZE);
		
		    String ROOT_ABS_PATH = request.getSession().getServletContext().getRealPath("");
		    String UPLOAD_DIR_ABS_PATH = ROOT_ABS_PATH + File.separator + yearMonth + File.separator + uuid);
 UPLOAD_DIR_REL_PATH;
		
		    makeDirectory(UPLOAD_DIR_ABS_PATH);
		
		    String storeFileAbsPath = "";
		    if(!outputPath.exists())try {
		        List<FileItem> formItems =  	outputPathupload.mkdirsparseRequest(request);
		
		        if (formItems != }null && formItems.size() > 0) {
		            for (FileItem item : formItems) {
		  // 변환 실행            if executeConverter(storeFile!item.getAbsolutePathisFormField(), outputPath.getAbsolutePath()); {
		           // 변환 후 원본 삭제     String ext       if(storeFile.exists()) {
            	storeFile.delete();
= item.getName().substring(item.getName().lastIndexOf('.'));
		            }        String storeFileName = UUID.randomUUID().toString() + ext;
		            // 변환된 pb파일을 읽어서 serialzie    storeFileAbsPath = UPLOAD_DIR_ABS_PATH       // v2.3.0 부터 파일명이 document.word.pb에서 document.pb로 변경됨+ File.separator + storeFileName;
		               Integer[] serializedData = serializePbData(outputPath + "/document.pb" System.out.println(storeFileAbsPath);
		
		                       item.write(new File(storeFileAbsPath)); // pb파일파일 삭제저장
  		          File pbFile = new File(outputPath + "/document.pb");      }
		      if(pbFile.exists()) {     }
		        }
		  pbFile.delete();  } catch (Exception ex) {
		      }  ex.printStackTrace();
		    }
		
		    // 파일별로 변환결과를 저장할 경로 생성
		    Calendar cal  // return data를 map으로 구성
        = Calendar.getInstance();
		    String yearMonth = String.format("%04d%02d", cal.get(Calendar.YEAR), cal.get(Calendar.MONTH) + 1);
		    MapString mapuuid = new HashMapUUID.randomUUID().toString();
		    String outputDirAbsPath = UPLOAD_DIR_ABS_PATH + File.separator + yearMonth + map.put("serializedData", serializedData);
 File.separator + uuid;
		
		    makeDirectory(outputDirAbsPath);
		
		     map.put("importPath", "/se_jdk15/import/" + yearMonth + "/" + uuid); 변환 실행
		    executeConverter(storeFileAbsPath, outputDirAbsPath);
		
		    // 변환 후 원본 삭제
		    deleteFile(storeFileAbsPath);
		
		    // json변환된 형태로pb파일을 return읽어서 (googleserialzie
gson		 lib 사용)  // v2.3.0 부터 파일명이 document.word.pb에서 document.pb로 변경됨
		    GsonString gsonpbAbsPath = outputDirAbsPath new+ GsonBuilder().create();
  File.separator + "document.pb";
		    Integer[]      PrintWriter out serializedData = response.getWriterserializePbData(pbAbsPath);
		
		    // pb파일 삭제
    out.print(gson.toJson(map));		    deleteFile(pbAbsPath);
		
		    Map map = new out.flushHashMap();
		    map.put("serializedData", serializedData);
		    }
    }
    
map.put("importPath", UPLOAD_DIR_REL_PATH + "/" + yearMonth + "/" + uuid);
		
		    protectedPrintWriter staticout int= executeConverter(String inputFilePath, String outputPath) {response.getWriter();
		    response.setContentType("application/json");
		    String SEDOC_CONVERT_DIR = "C:\\workspace\\seimporter\\sedocConverter\\sedocConverter.exe";
 response.setCharacterEncoding("UTF-8");
		
		    out.print(new GsonBuilder().create().toJson(map));
		 String FONT_DIR = "C:\\workspace\\seimporter\\fonts";
 out.flush();
		}
    }
  String TEMP_DIR = "C:\\workspace\\seimporter\\tmp";

        File tempDir = new File(TEMP_DIR);

	/**
	 * 문서 변환 모듈을 실행합니다.
	 */
    protected static int executeConverter(String inputFilePath, String outputPath) {
       if(!tempDir.exists()) {
            tempDir.mkdirs();
        }

        File fontDir = new File(FONT_DIR);
        if(!fontDir.exists()) {
            fontDir.mkdirs();
        }
        
        // 변환 명령 구성
        String[] cmd = {SEDOC_CONVERT_DIR, "-f", FONT_DIR, inputFilePath, outputPath, TEMP_DIR};
        
        try {
            Timer t = new Timer();
            Process proc = Runtime.getRuntime().exec(cmd);

            TimerTask killer = new TimeoutProcessKiller(proc);
            t.schedule(killer, 20000); // 20초 (변환이 20초 안에 완료되지 않으면 프로세스 종료)

            int exitValue = proc.waitFor();
            killer.cancel();

     String SEDOC_CONVERTER_DIR_ABS_PATH = "변환모듈이 존재하는 디렉토리의 절대경로";
		String FONT_DIR_ABS_PATH = SEDOC_CONVERTER_DIR_ABS_PATH + File.separator + "fonts";
		String TEMP_DIR_ABS_PATH = SEDOC_CONVERTER_DIR_ABS_PATH + File.separator + "temp";
		String SEDOC_CONVERTER_ABS_PATH = SEDOC_CONVERTER_DIR_ABS_PATH + File.separator + "sedocConverter_exe";
		
		makeDirectory(TEMP_DIR_ABS_PATH);
		makeDirectory(FONT_DIR_ABS_PATH);
		
		// 변환 명령 구성
		String[] cmd = {SEDOC_CONVERTER_ABS_PATH, "-f", FONT_DIR_ABS_PATH, inputFilePath, outputPath, TEMP_DIR_ABS_PATH};
		
		try {
		    Timer t = new Timer();
		    Process proc = Runtime.getRuntime().exec(cmd);
		
		    TimerTask killer = new TimeoutProcessKiller(proc);
		    t.schedule(killer, 20000); // 20초 (변환이 20초 안에 완료되지 않으면 프로세스 종료)
		
		    int exitValue = proc.waitFor();
		    killer.cancel();
		
		    return exitValue;
		} catch (Exception e) {
		    e.printStackTrace();
		    return -1;
		}
    }

	/**
	 * 문서 모듈 실행 후 변환된 결과를 Serialize 합니다.
	 */
    protected static Integer[] serializePbData(String pbFilePath) throws IOException {
        List<Integer> serializedData = new ArrayList<Integer>();
	    FileInputStream fis = null;
	    InflaterInputStream ifis = null;
	    Integer[] data = null;
	
	    try {
	        returnfis exitValue;= new FileInputStream(pbFilePath);
	      } catch (Exception e) {
fis.skip(16);
	
	        ifis = new  e.printStackTraceInflaterInputStream(fis);
	        byte[] buffer =  return -1new byte[1024];
	
	       } int len;
	  }      protectedwhile static Integer[] serializePbData(String pbFilePath) throws IOException((len = ifis.read(buffer)) != -1) {
	        List<Integer>  serializedData = newfor ArrayList<Integer>()(int i = 0; i < len; i++) {
	   FileInputStream fis = new FileInputStream(pbFilePath);          IntegerserializedData.add(buffer[] data = null;

  i] & 0xFF);
	      fis.skip(16);      }
	   InflaterInputStream ifis = new InflaterInputStream(fis); }
	
	       byte[] bufferdata = serializedData.toArray(new byte[1024];

Integer[serializedData.size()]);
	    } finally {
	        intif len(ifis != -1null) ifis.close();
	        whileif ((lenfis != ifis.read(buffer)) != -1) {
 null) fis.close();
	    }
	
	    return data;
    }
for
(int i = 0; i < len; i++) {
                serializedData.add(buffer[i] & 0xFF);
            }
        }

        data = serializedData.toArray(new Integer[serializedData.size()]);

        ifis.close();

	/**
	 * 파일을 삭제합니다.
	 */
	private static void deleteFile(String path) {
		File file = new File(path);
	    if (file.exists()) {
			file.delete();
		}
	}
	
	/**
	 * 디렉토리가 없는 경우 디렉토리를 생성합니다.
	 */
	private static void makeDirectory(String dirPath) {
	    File dir = new File(dirPath);
	    if (!dir.exists()) {
	        fisdir.closemkdir();
	         return data;
    }
	}
    
    private static class TimeoutProcessKiller extends TimerTask {
        private Process p;

        public TimeoutProcessKiller(Process p) {
            this.p = p;
        }

        @Override
        public void run() {
            p.destroy();
        }
    }
    
}