[Java] HttpURLConnection을 이용한 multipart request 전송

package klago.gw.util;
 
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.net.HttpURLConnection;
import java.net.URL;
import java.net.URLConnection;
import java.nio.charset.StandardCharsets;
import java.util.ArrayList;
import java.util.Map;
 
import javax.crypto.Mac;
import javax.crypto.spec.SecretKeySpec;
import javax.xml.bind.DatatypeConverter;
 
import org.apache.log4j.Logger;
import org.json.simple.JSONObject;
import org.json.simple.parser.JSONParser;
 
public class AuthCallUtil {
    
    public static String responseConn(HttpURLConnection connection) {
        
        try {
            
            int responseCode = connection.getResponseCode();
            StringBuilder sb = new StringBuilder();
            
            if (responseCode == HttpURLConnection.HTTP_OK) {
                BufferedReader reader = new BufferedReader(new InputStreamReader(connection.getInputStream(), "UTF-8"), 8);
                String line = null;
                
                while ((line = reader.readLine()) != null) {
                    sb.append(line).append("\n");
                }
                
                reader.close();
            } else {
                return UnAuthCallUtil.readInputStream(connection.getErrorStream());
            }
            
            connection.disconnect();            
            return sb.toString();
            
        }catch(Exception e) {
            Logger.getLogger( AuthCallUtil.class ).error( "AuthCallUtil.responseConn-Error : ", e);
            e.printStackTrace();
        }
        
        return null;
    }
    
    public static void writeFileHeader(ArrayList<File> filesAL, 
                                       PrintWriter writer, 
                                       OutputStream outputStream,
                                       ArrayList<String> fileHeaders,
                                       String lineEnd,
                                       String tail) {
        
        try {
            
            int bytesRead;
            int maxBufferSize = 1024;
            byte buf[] = new byte[maxBufferSize];
            int filesAlSize = filesAL.size();
            
            for (int i = 0; i < filesAlSize; i++) {
                
                writer.append(fileHeaders.get(i));
                writer.flush();
                BufferedInputStream bufferedInputStream = new BufferedInputStream(new FileInputStream(filesAL.get(i)));
                
                while ((bytesRead = bufferedInputStream.read(buf)) != -1) {
                    outputStream.write(buf, 0, bytesRead);
                    writer.flush();
                }
                
                outputStream.write(lineEnd.getBytes());
                outputStream.flush();
                bufferedInputStream.close();
            }
            writer.append(tail);
            writer.flush();
            writer.close();
            outputStream.close();
            
        }catch(Exception e) {
            Logger.getLogger( AuthCallUtil.class ).error( "AuthCallUtil.writeFileHeader-Error : ", e);
            e.printStackTrace();
        }
    }
    public static void writeParamHeader(ArrayList<String> paramHeaders, PrintWriter writer) {
        
        for (int i = 0; i < paramHeaders.size(); i++) {
            writer.append(paramHeaders.get(i));
            writer.flush();
        }
 
    }
    
    public static String[] setFileToFileHeader(Map<String, String> files,
                                            String twoHypen,
                                            String boundary,
                                            String lineEnd,
                                            long fileLength,
                                            String filePart,
                                            String charset,
                                            ArrayList<String> fileHeaders,
                                            ArrayList<File> filesAL){
        String fileHeader = null;
        
        try {
            
            for (Map.Entry<String, String> entry : files.entrySet()) {
                
                File file = new File(entry.getValue());
                fileHeader = twoHypen + boundary + lineEnd
                        + "Content-Disposition: form-data; name=\"" + "file[]" + "\"; filename=\"" + file.getName() + "\"" + lineEnd
                        + "Content-Type: " + URLConnection.guessContentTypeFromName(file.getAbsolutePath()) + lineEnd
                        + "Content-Transfer-Encoding: binary" + lineEnd
                        + lineEnd;
                fileLength += file.length() + lineEnd.getBytes(charset).length;
                filePart += fileHeader;
                
                fileHeaders.add(fileHeader);
                filesAL.add(file);
            }
            
            return new String[] {filePart, String.valueOf(fileLength)};
            
        }catch(Exception e) {
            Logger.getLogger( AuthCallUtil.class ).error( "AuthCallUtil.setFileUpload-Error : ", e);
            e.printStackTrace();
        }
        
        return null;
    }
    
    public static String setParamToParamHeader(Map<String, String> params,
                                         String twoHypen,
                                         String boundary,
                                         String lineEnd,
                                         String charset,
                                         String paramsPart,
                                         ArrayList<String> paramHeaders) {
          
        for (Map.Entry<String, String> entry : params.entrySet()) {
          
            String param = twoHypen + boundary + lineEnd
                    + "Content-Disposition: form-data; name=\"" + entry.getKey() + "\"" + lineEnd
                    + "Content-Type: text/plain; charset=" + charset + lineEnd
                    + lineEnd
                    + entry.getValue() + lineEnd;
            paramsPart += param;
            paramHeaders.add(param);
        }
        
        return paramsPart;
        
    }
    
    public static String upload(Map<String, String> params, 
                             Map<String, String> files, 
                             HttpURLConnection connection,
                             String boundary) throws IOException {
        
        final String lineEnd = "\r\n";
        final String twoHypen = "--";
        final String tail = lineEnd + twoHypen + boundary + twoHypen + lineEnd;
        
        String charset = "UTF-8";
        String paramsPart = "";
        String filePart = "";
        String partData = null;
        String[] filePartAndFileLen = null;
        
        long fileLength = 0;
        long requestLength = 0;
                
        OutputStream outputStream = null;
        PrintWriter writer = null;
        
        ArrayList<String> paramHeaders = new ArrayList<>();
        ArrayList<File> filesAL = new ArrayList<>();
        ArrayList<String> fileHeaders = new ArrayList<>();
 
 
        paramsPart = setParamToParamHeader(params, twoHypen, boundary, lineEnd, charset, paramsPart, paramHeaders);
 
        filePartAndFileLen = setFileToFileHeader(files, twoHypen, boundary, lineEnd, fileLength, filePart, charset, fileHeaders, filesAL);
        
        if(filePartAndFileLen != null) {
            filePart = filePartAndFileLen[0];
            fileLength = Long.parseLong(filePartAndFileLen[1]);
        }
        partData = paramsPart + filePart;
 
        requestLength = partData.getBytes(charset).length + fileLength + tail.getBytes(charset).length;
        connection.setRequestProperty("Content-length", "" + requestLength);
        connection.setFixedLengthStreamingMode((int) requestLength);
        connection.connect();
 
        outputStream = new BufferedOutputStream(connection.getOutputStream());
        writer = new PrintWriter(new OutputStreamWriter(outputStream, charset), true);
 
        writeParamHeader(paramHeaders, writer);
 
        writeFileHeader(filesAL, writer, outputStream, fileHeaders, lineEnd, tail);
 
        return responseConn(connection);
    }
 
    public static HttpURLConnection setUploadConn(String requestURL, String boundary, HttpURLConnection connection) {
        
        try {            
            
            URL url = new URL(requestURL);
            connection = (HttpURLConnection) url.openConnection();        
            connection.setDoOutput(true); 
            connection.setDoInput(true);
            connection.setRequestProperty("Content-Type", "multipart/form-data; boundary=" + boundary);
            return connection;
            
        }catch(Exception e) {
            Logger.getLogger( AuthCallUtil.class ).error( "AuthCallUtil.setUploadConn-Error : ", e);
            e.printStackTrace();
        }
        
        return null;
    }
    
    public static String checkResponseCode(HttpURLConnection connection, String result) {
        
        try {
            final int responseCode = connection.getResponseCode();
 
            if (responseCode / 100 != 2) {
                // 400, 401, 501
                result = UnAuthCallUtil.readInputStream(connection.getErrorStream());
            }else{
                result = UnAuthCallUtil.readInputStream(connection.getInputStream());
            }
            
        }catch(Exception e) {
            Logger.getLogger( AuthCallUtil.class ).error( "AuthCallUtil.checkResponseCode-Error : ", e);
            e.printStackTrace();
        }
        
        return result;
    }
    
    public static HttpURLConnection openConnection(String url) {
        
        try {
            
            return (HttpURLConnection) new URL(url).openConnection();
 
        }catch(Exception e) {
            Logger.getLogger( AuthCallUtil.class ).error( "AuthCallUtil.openConnection-Error : ", e);
            e.printStackTrace();
        }
        
        return null;
    }
    
    public static void setPostRequestContentType(HttpURLConnection connection, int requestBodyParamChk) {
        
        if(requestBodyParamChk == 0) {                            
            connection.setRequestProperty("Content-type", "application/x-www-form-urlencoded");
        }else {                            
            //connection.setRequestProperty("Content-type", "multipart/form-data; boundary=" + makeDelimeter());
            connection.setRequestProperty("Content-type", "application/json");
        }
    }
    
    public static void writePostDataToOutStream(HttpURLConnection connection, int requestBodyParamChk, Map<String, Object> param) {
        
        try {
 
            final OutputStream out = connection.getOutputStream();
            
            if(requestBodyParamChk == 0) {                            
                out.write(UnAuthCallUtil.postDataToBytes(param));
            }else {                            
                out.write(UnAuthCallUtil.getJsonStringFromMap(param).toJSONString().getBytes());
            }
            out.flush();
            out.close();
            
        }catch(Exception e) {
            Logger.getLogger( AuthCallUtil.class ).error( "AuthCallUtil.writePostDataToOutStream-Error : ", e);
            e.printStackTrace();
        }
    }
    
    public static void setEtcConnectionPropAndConnect(HttpURLConnection connection, String method, String url, JSONObject headerParamObj, String transactionId) {
        
        try {            
            
            connection.setConnectTimeout(UnAuthCallUtil.CONNECTION_TIMEOUT);
            connection.setRequestMethod(method);
            setEtcProperty(connection, url, headerParamObj, transactionId);
            
        }catch(Exception e) {
            Logger.getLogger( AuthCallUtil.class ).error( "AuthCallUtil.setEtcConnectionPropAndConnect-Error : ", e);
            e.printStackTrace();
        }
    }
    
    public static String getApiUrl(String url) {
        
        String[] urlSplit = url.split("/", -1);
        String apiUrl = null;
        
        if(urlSplit.length > 4) {
            apiUrl = "/" + urlSplit[3] + "/" + urlSplit[4];
        }
        
        return apiUrl;
    }
 
    public static String makeDelimeter() {
        return "===" + System.currentTimeMillis() + "===";
    }
    
    public static JSONObject jsonStringToJsonObj(String jsonStr) {
        
        try {
            
            JSONObject parseObj = null;
            
            if(jsonStr != null) {
                parseObj = (JSONObject) new JSONParser().parse(jsonStr);
            }
            if(parseObj != null) {            
                return (JSONObject) parseObj.get("resultData");
            }
            
        }catch(Exception e) {
            Logger.getLogger( AuthCallUtil.class ).error( "AuthCallUtil.jsonStringToJsonObj-Error : ", e);
            e.printStackTrace();
        }
        
        return null;
    }
    
    public static String hmac(String key, String value) {
        try {
            
            SecretKeySpec keySpec = new SecretKeySpec(key.getBytes(StandardCharsets.UTF_8), "HmacSHA256"); 
            Mac mac = Mac.getInstance("HmacSHA256"); mac.init(keySpec); 
            byte[] encrypted = mac.doFinal(value.getBytes(StandardCharsets.UTF_8));
            String base64Binary = DatatypeConverter.printBase64Binary(encrypted);
            return base64Binary;
            
        }catch(Exception e) {
            Logger.getLogger( AuthCallUtil.class ).error( "AuthCallUtil.hmac-Error : ", e);
            e.printStackTrace();
        }
        
        return null;
    }
    
    public static String execute(String method, String url, Map<String, Object> param, String headerParam, int requestBodyParamChk) {
        HttpURLConnection connection = null;
        
        String result ="";
        int methodCase = 0;
        String transactionId = UnAuthCallUtil.makeTransactionId();
        JSONObject headerParamObj = jsonStringToJsonObj(headerParam);
        
        if(headerParamObj == null) {
            result = "{\"error\": headerParamObj is null}";
            return result;
        }
        
        if(url == null || url.equals("")) {
            result = "{\"error\": url이 없습니다}";
            return result;
        }
        
        if(method == null || method.equals("")) {
            result = "{\"error\": method가 없습니다}";
            return result;
        }
        
        if(requestBodyParamChk > 1 || requestBodyParamChk < 0) {
            requestBodyParamChk = 0;
        }
        
        if(method.toUpperCase().equals("POST")) {
            methodCase = 1;
        }
        
        
        try {
            switch (methodCase) {
                //GET
                case 0:
                    
                    if(param != null) {                        
                        connection = openConnection(url.concat("?").concat(UnAuthCallUtil.formEncode(param)));
                    }else {
                        connection = openConnection(url);
                    }
                    
                    setEtcConnectionPropAndConnect(connection, method, url, headerParamObj, transactionId);
                    connection.connect();
 
                    break;
                //POST
                case 1:
                
                    connection = openConnection(url);
                    connection.setDoOutput(true);
                    
                    setPostRequestContentType(connection, requestBodyParamChk);
                    setEtcConnectionPropAndConnect(connection, method, url, headerParamObj, transactionId);
                    connection.connect();
 
                    
                    if(param != null) {
                        writePostDataToOutStream(connection, requestBodyParamChk, param);
                    }
                    
                    break;
            }
            
            result = checkResponseCode(connection, result);
        
        } catch (Exception e) {
            Logger.getLogger( AuthCallUtil.class ).error( "AuthCallUtil.execute--Error : ", e);
            result = "{\"error\": " + e + "}";
            return result;
        } finally {
            if (connection != null) connection.disconnect();
        }
        
        return result;
    }
    
    public static String executeUpload(Map<String, String> param, Map<String, String> files, String url, String headerParam) throws IOException, ClassNotFoundException {
 
        final String boundary = makeDelimeter();
 
        String transactionId = UnAuthCallUtil.makeTransactionId();
        JSONObject headerParamObj = jsonStringToJsonObj(headerParam);
        HttpURLConnection connection = null;
        String result = null;
        
        if(headerParamObj == null) {
            result = "{\"error\": headerParamObj is null}";
            return result;
        }
        
        if(url == null || url.equals("")) {
            result = "{\"error\": url이 없습니다}";
            return result;
        }
        
        connection = setUploadConn(url, boundary, connection);
        setEtcConnectionPropAndConnect(connection, "POST", url, headerParamObj, transactionId);
        
        return upload(param, files, connection, boundary);        
    }
}