태그 보관물: httpclient

HttpRequestor

package com.uclick.uc.framework.ipecscm.sapp.event;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.HttpURLConnection;
import java.net.URL;
import java.util.ArrayList;

public class HttpFileSendingTest {
   public static final String CRLF = "\r\n";

   /**
    * 파라미터 목록을 저장하고 있다. 파라미터 이름과 값이 차례대로 저장된다.
    */
   private static ArrayList list = new ArrayList();

   private static String makeDelimeter() {
      return "---------------------------7d115d2a20060c";
   }

   public void addParameter(String parameterName, String parameterValue) {
      if (parameterValue == null)
         throw new IllegalArgumentException("parameterValue can't be null!");

      list.add(parameterName);
      list.add(parameterValue);
   }

   /**
    * 파일 파라미터를 추가한다. 만약 parameterValue가 null이면(즉, 전송할 파일을 지정하지 않는다면 서버에 전송되는
    * filename 은 "" 이 된다.
    *
    * @param parameterName
    *            파라미터 이름
    * @param parameterValue
    *            전송할 파일
    * @exception IllegalArgumentException
    *                parameterValue가 null일 경우
    */
   public void addFile(String parameterName, File parameterValue) {
      // paramterValue가 null일 경우 NullFile을 삽입한다.
      if (parameterValue == null) {
         list.add(parameterName);
         list.add(new NullFile());
      } else {
         list.add(parameterName);
         list.add(parameterValue);
      }
   }

   private class NullFile {
      NullFile() {
      }

      public String toString() {
         return "";
      }
   }

   URL targetURL = null;

   public static void main(String[] args) throws IOException {
      TestClass t = new TestClass();
      t.targetURL = new URL("http://211.110.82.245:8080/admin/listCallIDs.do");
      t.addParameter("test", "test");
      t.addFile("file2", new File("C:\\eclipse.zip"));

      InputStream is = t.sendMultipartPost();

   }

   public InputStream sendMultipartPost() throws IOException {
        HttpURLConnection conn = (HttpURLConnection)targetURL.openConnection();

        // Delimeter 생성
        String delimeter = makeDelimeter();
        byte[] newLineBytes = CRLF.getBytes();
        byte[] delimeterBytes = delimeter.getBytes();
        byte[] dispositionBytes = "Content-Disposition: form-data; name=".getBytes();
        byte[] quotationBytes = "\"".getBytes();
        byte[] contentTypeBytes = "Content-Type: application/octet-stream".getBytes();
        byte[] fileNameBytes = "; filename=".getBytes();
        byte[] twoDashBytes = "--".getBytes();

        conn.setRequestMethod("POST");
        conn.setRequestProperty("Content-Type",
                                "multipart/form-data; boundary="+delimeter);
        conn.setDoInput(true);
        conn.setDoOutput(true);
        conn.setUseCaches(false);

        BufferedOutputStream out = null;
        try {
            out = new BufferedOutputStream(conn.getOutputStream());

            Object[] obj = new Object[list.size()];
            list.toArray(obj);

            for (int i = 0 ; i < obj.length ; i += 2) {
                // Delimeter 전송
                out.write(twoDashBytes);
                out.write(delimeterBytes);
                out.write(newLineBytes);
                // 파라미터 이름 출력
                out.write(dispositionBytes);
                out.write(quotationBytes);
                out.write( ((String)obj[i]).getBytes() );
                out.write(quotationBytes);
                if ( obj[i+1] instanceof String) {
                    // String 이라면
                    out.write(newLineBytes);
                    out.write(newLineBytes);
                    // 값 출력
                    out.write( ((String)obj[i+1]).getBytes() );
                    out.write(newLineBytes);
                } else {
                    // 파라미터의 값이 File 이나 NullFile인 경우
                    if ( obj[i+1] instanceof File) {
                        File file = (File)obj[i+1];
                        // File이 존재하는 지 검사한다.
                        out.write(fileNameBytes);
                        out.write(quotationBytes);
                        out.write(file.getAbsolutePath().getBytes() );
                        out.write(quotationBytes);
                    } else {
                        // NullFile 인 경우
                        out.write(fileNameBytes);
                        out.write(quotationBytes);
                        out.write(quotationBytes);
                    }
                    out.write(newLineBytes);
                    out.write(contentTypeBytes);
                    out.write(newLineBytes);
                    out.write(newLineBytes);
                    // File 데이터를 전송한다.
                    if (obj[i+1] instanceof File) {
                        File file = (File)obj[i+1];
                        // file에 있는 내용을 전송한다.
                        BufferedInputStream is = null;
                        try {
                            is = new BufferedInputStream(
                                     new FileInputStream(file));
                            byte[] fileBuffer = new byte[1024 * 8]; // 8k
                            int len = -1;
                            while ( (len = is.read(fileBuffer)) != -1) {
                                out.write(fileBuffer, 0, len);
                            }
                        } finally {
                            if (is != null) try { is.close(); } catch(IOException ex) {}
                        }
                    }
                    out.write(newLineBytes);
                } // 파일 데이터의 전송 블럭 끝
                if ( i + 2 == obj.length ) {
                    // 마지막 Delimeter 전송
                    out.write(twoDashBytes);
                    out.write(delimeterBytes);
                    out.write(twoDashBytes);
                    out.write(newLineBytes);
                }
            } // for 루프의 끝

            out.flush();
        } finally {
            if (out != null) out.close();
        }
        return conn.getInputStream();
    }
}

HttpClient 4.0 Post 방식 한글깨짐

댓글 남기기

Post Method 로 한글 데이터를 전송하니 깨져서…
구글신의 도움을 받아.

HttpPost httpost = new HttpPost("http://coozplz.blogspot.com"); 
List nvps = new ArrayList();
nvps.add(new BasicNameValuePair("MESSAGE", "안녕하세요"));
httpost.setEntity(new UrlEncodedFormEntity(nvps, "euc-kr"));
httpost.setHeader("Content-type", "application/x-www-form-urlencoded");
HttpClient httpClient = new DefaultHttpClient();
HttpResponse response = httpClient.execute(httpost);

ClientHttpRequest

댓글 남기기

 
package com.myjavatools.web;
  
import java.net.URLConnection;
import java.net.URL;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;
import java.io.File;
import java.io.InputStream;
import java.util.Random;
import java.io.OutputStream;
import java.io.FileInputStream;
import java.util.Iterator;
  
/**
 * Title: Client HTTP Request class
 * Description: this class helps to send POST HTTP requests with various form data,
 * including files. Cookies can be added to be included in the request.
 *
 * @author Vlad Patryshev
 * @version 1.0
 */
public class ClientHttpRequest {
  URLConnection connection;
  OutputStream os = null;
  Map cookies = new HashMap();
  
  protected void connect() throws IOException {
    if (os == null) os = connection.getOutputStream();
  }
  
  protected void write(char c) throws IOException {
    connect();
    os.write(c);
  }
  
  protected void write(String s) throws IOException {
    connect();
    os.write(s.getBytes());
  }
  
  protected void newline() throws IOException {
    connect();
    write("\r\n");
  }
  
  protected void writeln(String s) throws IOException {
    connect();
    write(s);
    newline();
  }
  
  private static Random random = new Random();
  
  protected static String randomString() {
    return Long.toString(random.nextLong(), 36);
  }
  
  String boundary = "---------------------------" + randomString() + randomString() + randomString();
  
  private void boundary() throws IOException {
    write("--");
    write(boundary);
  }
  
  /**
   * Creates a new multipart POST HTTP request on a freshly opened URLConnection
   *
   * @param connection an already open URL connection
   * @throws IOException
   */
  public ClientHttpRequest(URLConnection connection) throws IOException {
    this.connection = connection;
    connection.setDoOutput(true);
    connection.setRequestProperty("Content-Type",
                                  "multipart/form-data; boundary=" + boundary);
  }
  
  /**
   * Creates a new multipart POST HTTP request for a specified URL
   *
   * @param url the URL to send request to
   * @throws IOException
   */
  public ClientHttpRequest(URL url) throws IOException {
    this(url.openConnection());
  }
  
  /**
   * Creates a new multipart POST HTTP request for a specified URL string
   *
   * @param urlString the string representation of the URL to send request to
   * @throws IOException
   */
  public ClientHttpRequest(String urlString) throws IOException {
    this(new URL(urlString));
  }
  
  
  private void postCookies() {
    StringBuffer cookieList = new StringBuffer();
  
    for (Iterator i = cookies.entrySet().iterator(); i.hasNext();) {
      Map.Entry entry = (Map.Entry)(i.next());
      cookieList.append(entry.getKey().toString() + "=" + entry.getValue());
  
      if (i.hasNext()) {
        cookieList.append("; ");
      }
    }
    if (cookieList.length() > 0) {
      connection.setRequestProperty("Cookie", cookieList.toString());
    }
  }
  
  /**
   * adds a cookie to the requst
   * @param name cookie name
   * @param value cookie value
   * @throws IOException
   */
  public void setCookie(String name, String value) throws IOException {
    cookies.put(name, value);
  }
  
  /**
   * adds cookies to the request
   * @param cookies the cookie "name-to-value" map
   * @throws IOException
   */
  public void setCookies(Map cookies) throws IOException {
    if (cookies == null) return;
    this.cookies.putAll(cookies);
  }
  
  /**
   * adds cookies to the request
   * @param cookies array of cookie names and values (cookies[2*i] is a name, cookies[2*i + 1] is a value)
   * @throws IOException
   */
  public void setCookies(String[] cookies) throws IOException {
    if (cookies == null) return;
    for (int i = 0; i < cookies.length - 1; i+=2) {
      setCookie(cookies[i], cookies[i+1]);
    }
  }
  
  private void writeName(String name) throws IOException {
    newline();
    write("Content-Disposition: form-data; name=\"");
    write(name);
    write('"');
  }
  
  /**
   * adds a string parameter to the request
   * @param name parameter name
   * @param value parameter value
   * @throws IOException
   */
  public void setParameter(String name, String value) throws IOException {
    boundary();
    writeName(name);
    newline(); newline();
    writeln(value);
  }
  
  private static void pipe(InputStream in, OutputStream out) throws IOException {
    byte[] buf = new byte[500000];
    int nread;
    int navailable;
    int total = 0;
    synchronized (in) {
      while((nread = in.read(buf, 0, buf.length)) >= 0) {
        out.write(buf, 0, nread);
        total += nread;
      }
    }
    out.flush();
    buf = null;
  }
  
  /**
   * adds a file parameter to the request
   * @param name parameter name
   * @param filename the name of the file
   * @param is input stream to read the contents of the file from
   * @throws IOException
   */
  public void setParameter(String name, String filename, InputStream is) throws IOException {
    boundary();
    writeName(name);
    write("; filename=\"");
    write(filename);
    write('"');
    newline();
    write("Content-Type: ");
    String type = connection.guessContentTypeFromName(filename);
    if (type == null) type = "application/octet-stream";
    writeln(type);
    newline();
    pipe(is, os);
    newline();
  }
  
  /**
   * adds a file parameter to the request
   * @param name parameter name
   * @param file the file to upload
   * @throws IOException
   */
  public void setParameter(String name, File file) throws IOException {
    setParameter(name, file.getPath(), new FileInputStream(file));
  }
  
  /**
   * adds a parameter to the request; if the parameter is a File, the file is uploaded, otherwise the string value of the parameter is passed in the request
   * @param name parameter name
   * @param object parameter value, a File or anything else that can be stringified
   * @throws IOException
   */
  public void setParameter(String name, Object object) throws IOException {
    if (object instanceof File) {
      setParameter(name, (File) object);
    } else {
      setParameter(name, object.toString());
    }
  }
  
  /**
   * adds parameters to the request
   * @param parameters "name-to-value" map of parameters; if a value is a file, the file is uploaded, otherwise it is stringified and sent in the request
   * @throws IOException
   */
  public void setParameters(Map parameters) throws IOException {
    if (parameters == null) return;
    for (Iterator i = parameters.entrySet().iterator(); i.hasNext();) {
      Map.Entry entry = (Map.Entry)i.next();
      setParameter(entry.getKey().toString(), entry.getValue());
    }
  }
  
  /**
   * adds parameters to the request
   * @param parameters array of parameter names and values (parameters[2*i] is a name, parameters[2*i + 1] is a value); if a value is a file, the file is uploaded, otherwise it is stringified and sent in the request
   * @throws IOException
   */
  public void setParameters(Object[] parameters) throws IOException {
    if (parameters == null) return;
    for (int i = 0; i < parameters.length - 1; i+=2) {
      setParameter(parameters[i].toString(), parameters[i+1]);
    }
  }
  
  /**
   * posts the requests to the server, with all the cookies and parameters that were added
   * @return input stream with the server response
   * @throws IOException
   */
  public InputStream post() throws IOException {
    boundary();
    writeln("--");
    os.close();
    return connection.getInputStream();
  }
  
  /**
   * posts the requests to the server, with all the cookies and parameters that were added before (if any), and with parameters that are passed in the argument
   * @param parameters request parameters
   * @return input stream with the server response
   * @throws IOException
   * @see setParameters
   */
  public InputStream post(Map parameters) throws IOException {
    setParameters(parameters);
    return post();
  }
  
  /**
   * posts the requests to the server, with all the cookies and parameters that were added before (if any), and with parameters that are passed in the argument
   * @param parameters request parameters
   * @return input stream with the server response
   * @throws IOException
   * @see setParameters
   */
  public InputStream post(Object[] parameters) throws IOException {
    setParameters(parameters);
    return post();
  }
  
  /**
   * posts the requests to the server, with all the cookies and parameters that were added before (if any), and with cookies and parameters that are passed in the arguments
   * @param cookies request cookies
   * @param parameters request parameters
   * @return input stream with the server response
   * @throws IOException
   * @see setParameters
   * @see setCookies
   */
  public InputStream post(Map cookies, Map parameters) throws IOException {
    setCookies(cookies);
    setParameters(parameters);
    return post();
  }
  
  /**
   * posts the requests to the server, with all the cookies and parameters that were added before (if any), and with cookies and parameters that are passed in the arguments
   * @param cookies request cookies
   * @param parameters request parameters
   * @return input stream with the server response
   * @throws IOException
   * @see setParameters
   * @see setCookies
   */
  public InputStream post(String[] cookies, Object[] parameters) throws IOException {
    setCookies(cookies);
    setParameters(parameters);
    return post();
  }
  
  /**
   * post the POST request to the server, with the specified parameter
   * @param name parameter name
   * @param value parameter value
   * @return input stream with the server response
   * @throws IOException
   * @see setParameter
   */
  public InputStream post(String name, Object value) throws IOException {
    setParameter(name, value);
    return post();
  }
  
  /**
   * post the POST request to the server, with the specified parameters
   * @param name1 first parameter name
   * @param value1 first parameter value
   * @param name2 second parameter name
   * @param value2 second parameter value
   * @return input stream with the server response
   * @throws IOException
   * @see setParameter
   */
  public InputStream post(String name1, Object value1, String name2, Object value2) throws IOException {
    setParameter(name1, value1);
    return post(name2, value2);
  }
  
  /**
   * post the POST request to the server, with the specified parameters
   * @param name1 first parameter name
   * @param value1 first parameter value
   * @param name2 second parameter name
   * @param value2 second parameter value
   * @param name3 third parameter name
   * @param value3 third parameter value
   * @return input stream with the server response
   * @throws IOException
   * @see setParameter
   */
  public InputStream post(String name1, Object value1, String name2, Object value2, String name3, Object value3) throws IOException {
    setParameter(name1, value1);
    return post(name2, value2, name3, value3);
  }
  
  /**
   * post the POST request to the server, with the specified parameters
   * @param name1 first parameter name
   * @param value1 first parameter value
   * @param name2 second parameter name
   * @param value2 second parameter value
   * @param name3 third parameter name
   * @param value3 third parameter value
   * @param name4 fourth parameter name
   * @param value4 fourth parameter value
   * @return input stream with the server response
   * @throws IOException
   * @see setParameter
   */
  public InputStream post(String name1, Object value1, String name2, Object value2, String name3, Object value3, String name4, Object value4) throws IOException {
    setParameter(name1, value1);
    return post(name2, value2, name3, value3, name4, value4);
  }
  
  /**
   * posts a new request to specified URL, with parameters that are passed in the argument
   * @param parameters request parameters
   * @return input stream with the server response
   * @throws IOException
   * @see setParameters
   */
  public static InputStream post(URL url, Map parameters) throws IOException {
    return new ClientHttpRequest(url).post(parameters);
  }
  
  /**
   * posts a new request to specified URL, with parameters that are passed in the argument
   * @param parameters request parameters
   * @return input stream with the server response
   * @throws IOException
   * @see setParameters
   */
  public static InputStream post(URL url, Object[] parameters) throws IOException {
    return new ClientHttpRequest(url).post(parameters);
  }
  
  /**
   * posts a new request to specified URL, with cookies and parameters that are passed in the argument
   * @param cookies request cookies
   * @param parameters request parameters
   * @return input stream with the server response
   * @throws IOException
   * @see setCookies
   * @see setParameters
   */
  public static InputStream post(URL url, Map cookies, Map parameters) throws IOException {
    return new ClientHttpRequest(url).post(cookies, parameters);
  }
  
  /**
   * posts a new request to specified URL, with cookies and parameters that are passed in the argument
   * @param cookies request cookies
   * @param parameters request parameters
   * @return input stream with the server response
   * @throws IOException
   * @see setCookies
   * @see setParameters
   */
  public static InputStream post(URL url, String[] cookies, Object[] parameters) throws IOException {
    return new ClientHttpRequest(url).post(cookies, parameters);
  }
  
  /**
   * post the POST request specified URL, with the specified parameter
   * @param name parameter name
   * @param value parameter value
   * @return input stream with the server response
   * @throws IOException
   * @see setParameter
   */
  public static InputStream post(URL url, String name1, Object value1) throws IOException {
    return new ClientHttpRequest(url).post(name1, value1);
  }
  
  /**
   * post the POST request to specified URL, with the specified parameters
   * @param name1 first parameter name
   * @param value1 first parameter value
   * @param name2 second parameter name
   * @param value2 second parameter value
   * @return input stream with the server response
   * @throws IOException
   * @see setParameter
   */
  public static InputStream post(URL url, String name1, Object value1, String name2, Object value2) throws IOException {
    return new ClientHttpRequest(url).post(name1, value1, name2, value2);
  }
  
  /**
   * post the POST request to specified URL, with the specified parameters
   * @param name1 first parameter name
   * @param value1 first parameter value
   * @param name2 second parameter name
   * @param value2 second parameter value
   * @param name3 third parameter name
   * @param value3 third parameter value
   * @return input stream with the server response
   * @throws IOException
   * @see setParameter
   */
  public static InputStream post(URL url, String name1, Object value1, String name2, Object value2, String name3, Object value3) throws IOException {
    return new ClientHttpRequest(url).post(name1, value1, name2, value2, name3, value3);
  }
  
  /**
   * post the POST request to specified URL, with the specified parameters
   * @param name1 first parameter name
   * @param value1 first parameter value
   * @param name2 second parameter name
   * @param value2 second parameter value
   * @param name3 third parameter name
   * @param value3 third parameter value
   * @param name4 fourth parameter name
   * @param value4 fourth parameter value
   * @return input stream with the server response
   * @throws IOException
   * @see setParameter
   */
  public static InputStream post(URL url, String name1, Object value1, String name2, Object value2, String name3, Object value3, String name4, Object value4) throws IOException {
    return new ClientHttpRequest(url).post(name1, value1, name2, value2, name3, value3, name4, value4);
  }
}

Apache HttpClient MultiThread

댓글 남기기

HttpParams

HttpParams params = new BasicHttpParams();
SchemeRegistry registry = new SchemeRegistry();

.register(new Scheme(“http”, 8000, new PlainSocketFactory()));
cm = new ThreadSafeClientConnManager(registry);
client = new DefaultHttpClient(cm, params);

example.

HttpPost post = new HttpPost(pushURL);
	
FileBody fileBody = new FileBody(f);	
MultipartEntity reqEntity = new MultipartEntity();	
reqEntity.addPart(mcidFileName, fileBody);	
post.setEntity(reqEntity);



HttpParams params = new BasicHttpParams();	
SchemeRegistry registry = new SchemeRegistry();



registry.register(new Scheme("http", 8000, new PlainSocketFactory()));

// deprecated

// registry.register(new Scheme("http", PlainSocketFactory.getSocketFactory(), 80)); 

ClientConnectionManager cm = new ThreadSafeClientConnManager(registry); 	
HttpClient client = new DefaultHttpClient(cm, params);	
client.getParams().setParameter("http.connection.timeout", 1000);	
client.getParams().setParameter("http.socket.timeout", 1000);	
client.getParams().setParameter("http.protocol.version",HttpVersion.HTTP_1_1);	
client.getConnectionManager().closeIdleConnections(2000,TimeUnit.MILLISECONDS);

try {

    client.execute(post);

    System.out.println(name + " send Ok!!");

} catch (Exception e1) {

    System.out.println(name + " // " + e1);

}

특정 아이피로 HttpClient.excute(HttpPost) 실행

댓글 남기기

안녕하세요. 초급 자바 개발자 입니다. 프로그래밍을 하다 보면 생각해야 할게 정말 많은 것 같습니다. 그 중 많은 부분을 차지 하는게 네트워크 분야 입니다. 이번에 진행되는 프로젝트에서도 네트워크 관련 이슈 사항들이 나왔습니다. 단위 테스트 할 때는 정상적으로 동작하던 솔루션이 통합 테스트에서 안 되는 문제가 발생했습니다. 문제의 원인은 네트워크 라우팅에서 생기는 문제… 고객사에서 라우팅 테이블을 변경 할 수 없다고 합니다. 그래서 나온 대체 방안이 데이터를 보내기 전에 아이피 설정을 변경해서 전송하자 입니다. (이전까지 네트워크 라우팅 문제는 테이블 설정으로 해결을 했습니다. 하지만 서버에 저희 솔루션만 뿐만 아니라 다른 솔루션도 함께 설치가 되어 테이블 변경이 불가능 했습니다.)

먼저 제 노트북의 랜카드 설정을 보시죠. 해당 설정은 무선랜카드와 유선랜카드를 둘다 잡은 경우 입니다.

네트워크 문제로 모든 데이터는 192.168.1.55을 Source로 전송 해야 한다면 아래와 같이 소스를 넣으면 됩니다.

File f = new File(user.getAdminController().getWebDir() + fileName);
HttpPost post = new HttpPost(pushURL);
FileBody fileBody = new FileBody(f);
MultipartEntity reqEntity = new MultipartEntity();
reqEntity.addPart(mcidFileName, fileBody);
post.setEntity(reqEntity);
/*
 * 다수의 랜카드 중에 네트워크 파일 전송이 가능한 아이피로 전송한다.
 * since 2011.03.25
 * author Coozplz
 */
// 반복 횟수를 줄이기 위해 Flag를 설정한다.
boolean isFind = false; 
// 모든 랜카드 정보를 얻는다.
Enumeration networkInterfaces = NetworkInterface.getNetworkInterfaces();
 // 기본은 첫번째로 한다.
InetAddress addr = InetAddress.getLocalHost();
while(networkInterfaces.hasMoreElements()) {
    // 랜카드중에 하나를 꺼낸다.
    NetworkInterface networkInterface = (NetworkInterface) networkInterfaces.nextElement();
    Enumeration ipEnum = networkInterface.getInetAddresses();
    while(ipEnum.hasMoreElements()) {
        InetAddress temp = (InetAddress) ipEnum.nextElement();
        // 아이피가 동일한지 확인한다.
        if(temp.getHostAddress().startsWith("192.168.1.55")){
            addr = temp;
            isFind = true;
            break;
        }
    }
    if(isFind) {
        break;
    }
}
 
HttpClient client = new DefaultHttpClient();
client.getParams().setParameter("http.connection.timeout", 1000);
client.getParams().setParameter("http.socket.timeout", 1000);
client.getParams().setParameter("http.protocol.version", HttpVersion.HTTP_1_1);
client.getConnectionManager().closeIdleConnections(2000, TimeUnit.MILLISECONDS);
 
// 찾은 InetAddress를 설정한다.
client.getParams().setParameter(ConnRouteParams.LOCAL_ADDRESS, addr); 
post.getParams().setParameter(ConnRouteParams.LOCAL_ADDRESS, addr);
 
HttpResponse response = client.execute(post);
client.getConnectionManager().shutdown();

위처럼 하면 192.168.1.55 아이피로 전송을 합니다. 참 쉽죠~~~~

HttpClient3–> httpClient4 파일전송(FileSend)

댓글 남기기

현재 사용중인 어플리케이션은 사진파일을 전화기로 전송하면 전화기에서 받은 사진파일을 보여주는 어플리케이션입니다. 지금까지 문제 없이 잘 사용하고 있었는데 웹 서버에 응답이 없는 전화기에 파일을 전송하려고 하다 보니 타임아웃 설정을 해도 커넥션이 종료되지 않는 문제가 생겼습니다. 커넥션이 종료가 되지 않으니 프로세스에는 계속 남아 있는 추가적인 문제까지…. 그래서 ‘조금 더 좋겠지’ 라는 막연한 기대감으로 HttpClient4.0 으로 버전업을 시도 했습니다.

// HttpClient 3.0 Source
String pushURL = "http://127.0.0.1/PushFile";
File f = new File("C:\\TEST\\beauty.jpg");
PostMethod filePost = new PostMethod(pushURL);
filePost.setFollowRedirects(false);
Part[] parts = { new FilePart("beauty.jpg", f) };
HttpMethodParams params = filePost.getParams();
filePost.setRequestEntity(new MultipartRequestEntity(parts, params));
HttpClientParams clientParams = new HttpClientParams();
clientParams.setSoTimeout(2000);
clientParams.setConnectionManagerTimeout(2000);
HttpClient client = new HttpClient(clientParams);
client.getParams().setParameter("http.connection.timeout", 2000);
client.getParams().setParameter("http.socket.timeout", 2000);
int status = client.executeMethod(filePost); // HANGING

타임 아웃을 설정을 했지만 로깅을 해보면 client.executeMethod에서 응답을 기다리고 있어서 프로세스가 진행되지 않았습니다.. 그래서 HttpClient4.0으로 컨버팅 시도(고고싱~~)

// HttpClient 4.0 Source
File f = new File("C:\\test\\beauty.jpg");
HttpPost post = new HttpPost("http://127.0.0.1/PushFile");
FileBody fileBody = new FileBody(f);
MultipartEntity reqEntity = new MultipartEntity();
reqEntity.addPart("beauty.jpg", fileBody);
post.setEntity(reqEntity);
HttpClient client = new DefaultHttpClient();
client.getParams().setParameter("http.connection.timeout", 2000);
client.getParams().setParameter("http.socket.timeout", 2000);
HttpResponse response = client.execute(post);

일단 변환은 완료했습니다. FileEntry를 써야 하나 해서 일단 쓰고 테스트를 진행하니 출력이 안돼서apache 샘플 코드를 보고 수정 했습니다. [SAMPLE]

이렇게 변경을 하면 처음에 LOCK걸리는 현상이 동일하게 발생됩니다. 그래서 별도의 쓰레드를 사용해서 LOCK 을 해제해봤습니다.[완전허접]

 
/**
 * {@link HttpClient} 객체가 응답을 받기 위해 2초 이상
 * 대기를 하면 강제로 종료한다.
 * @author CoozPlz
 *
 */
public class HttpClientAbortWorker extends Thread{
    Logger logger = Logger.getLogger(HttpClientAbortWorker.class);
    /** 소멸시킬 클라이언트 */
    HttpClient client;
    public HttpClientAbortWorker(HttpClient client) {
        super();
        this.client = client;
    }
    
    public void run() {
        try {
            /*
             * 2초간 대기 합니다. 
             * 이미지 전송하는 쓰레드는 돌고 있기 정상적인 케이스에는
             * 클라이언트가 정상적으로 종료됩니다.
             */
            Thread.sleep(2000);
        } catch (InterruptedException e) {
        }
        if(client != null) {
            try {
                // client 객체를 종료합니다. 
                client.getConnectionManager().shutdown();
            } catch (Exception e) {
            }
        }
        
    }
}

이제 LOCK을 해제하는 메소드를 추가한 쓰레드를 생성했습니다. 그렇게 되면 원본 코드에 추가를 하겠습니다.

// execute를 하기전에 쓰레드를 동작시킨다.
new HttpClientAbortWorker(client).start();
HttpResponse response = client.execute(post);

이렇게 하면 InterruptedIOException 이 발생됩니다. 예외가 발생되는데 어찌나 기쁘던지..ㅋㅋ

조금 더 확인 해본 결과 예외가 발생 안될 때도 있네요. -_-

Coozplz Blog

Simple is the Best

태그 보관물: httpclient

HttpRequestor

HttpClient 4.0 Post 방식 한글깨짐

ClientHttpRequest

Apache HttpClient MultiThread

특정 아이피로 HttpClient.excute(HttpPost) 실행

HttpClient3–> httpClient4 파일전송(FileSend)