httprequest.java

来自「Hecl编程语言是一个高层次的脚本语言的Java实现。其用意是要小」· Java 代码 · 共 686 行 · 第 1/2 页

/* Copyright 2005-2006 by data2c.com

Authors:
Wolfgang S. Kechel - [e-mail]
Jörn Marcks - [e-mail]

Wolfgang S. Kechel, Jörn Marcks

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/

package org.hecl.net;

import java.io.InputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.util.Enumeration;
import java.util.Hashtable;

//#ifdef j2me
import javax.microedition.io.Connector;
import javax.microedition.io.HttpConnection;
//#if cldc > 1.0
import javax.microedition.io.HttpsConnection;
//#endif
//#else
import java.net.HttpURLConnection;
import java.net.URL;
import javax.net.ssl.HttpsURLConnection;
//#endif

public class HttpRequest extends Thread {
    static public final short SETUP = 0;
    static public final short CONNECTED = 1;
    static public final short ERROR = 2;
    static public final short TIMEOUT = 3;
    static public final short OK = 4;
    
//#ifdef j2me
    public static final int HTTP_UNAUTHORIZED = HttpConnection.HTTP_UNAUTHORIZED;
    public static final int HTTP_FORBIDDEN = HttpConnection.HTTP_FORBIDDEN;
//#else
    public static final int HTTP_UNAUTHORIZED = HttpURLConnection.HTTP_UNAUTHORIZED;
    public static final int HTTP_FORBIDDEN = HttpURLConnection.HTTP_FORBIDDEN;
    
    public static final String GET = "GET";
    public static final String POST ="POST";
    public static final String HEAD = "HEAD";
    public static final String OPTIONS = "OPTIONS";
    public static final String PUT = "PUT";
    public static final String DELETE = "DELETE";
    public static final String TRACE = "TRACE";
//#endif
    
    

    public HttpRequest(String url, QueryParam[] params,
		       boolean validate, Hashtable headerfields) {
	qparams = params;
	setup(url,validate,headerfields);
    }
    

    public HttpRequest(String url, String queryData,
		       boolean validate, Hashtable headerfields) {
	qdata = queryData;
	setup(url,validate,headerfields);
    }

    private void setup(String url, boolean validate, Hashtable headerfields) {
	urlstr = url;
	if(headerfields != null) {
	    Enumeration e = headerfields.keys();
	    while(e.hasMoreElements()) {
		String key = (String)e.nextElement();
		requestFields.put(key,(String)headerfields.get(key));
	    }
	}
	if(qdata != null || qparams != null) {
	    requestMethod =
//#ifdef j2me
		HttpConnection.POST
//#else
		POST
//#endif
		;
	} else {
	    if(validate)
		requestMethod =
//#ifdef j2me
		    HttpConnection.HEAD
//#else
		    HEAD
//#endif
		    ;
	}
    }
    
    // Add a header field with key and value when sending a request
    // Must be called before the request.
    public void addRequestField(String key, String value) {
	requestFields.put(key, value);
    }


    // Get the value of a key after the connection is closed.
    // Must be called after the request.
    public String getResponseFieldValue(String key) {
	return (String)responseFields.get(key);
    }


    public Enumeration getResponseFieldNames() {
	return responseFields.keys();
    }
    

    public String getURL() {
	return urlstr;
    }
    

    public static String hexdump(byte[] buf) {
	StringBuffer sb = new StringBuffer();
	
	for(int i=0; i<buf.length; ++i) {
	    byte b = buf[i];
	    
	    sb.append(Integer.toHexString((b&0xf0)>>4));
	    sb.append(Integer.toHexString(b&0x0f));
	    sb.append(' ');
	    if(i!=0 && ((i+1)%8) == 0)
		sb.append(' ');
	    if(i != 0 && ((i+1)%16) == 0)
		sb.append('\n');
	}
	if(sb.charAt(sb.length()-1) != '\n')
	    sb.append('\n');
	return new String(sb);
    }
 

    public synchronized void run() {
	MyHttpConn co = null;
	rc = -1;
	error = null;
	inData = null;

	try {
	    co = new MyHttpConn(urlstr);
	}
	catch (IOException e) {
	    status = ERROR;
	    error = e;
	    e.printStackTrace();
	    System.err.println("HttpRequest.preparation error");
	    return;
	}


	try {
	    if(DEBUGRC)
		System.err.println("Connecting...");
	    co.connect(requestMethod,requestFields,qdata,qparams);
	    status = CONNECTED;
	    if(DEBUGRC)
		System.err.println("Connected");
	    rc = co.getResponseCode();
	    if(DEBUGRC)
		System.err.println("rc="+rc);
	    if(rc == -1) {
		status = ERROR;
		return;
	    }
	    responseFields = co.readHeader();
	    inData = co.readBody();
	    status = OK;
	    
	    // If no charset is given, use the default (see below).
	    String charset = DEFCHARSET;
	    String ct = (String)responseFields.get(CONTENTTYPE);
	    String coding = (String)responseFields.get(CONTENTENCODING);
	    
	    if(ct == null) {
		// should be present, but who nows...
		ct = "text/plain";
		responseFields.put(CONTENTTYPE,ct);
	    }
	    
	    if((ct != null && !ct.toLowerCase().startsWith("text"))
	       || (coding != null &&
		   (coding.indexOf("gzip") >= 0 || coding.indexOf("compress") >= 0))
		) {
		// binary transfer
		responseFields.put("binary","1");
	    } else {
		// textual transfer
		responseFields.put("binary","0");
		if(ct != null) {
		    int begin = ct.toLowerCase().indexOf("charset=");
		    if (begin >= 0) {
			// In a midlet, an empty encoding string would result
			// in an UnsupportedEncodingException when creating a
			// string object.
			begin += 8;	    // # of chars in 'charset='
			int end = ct.indexOf(';', begin);
			if (end == -1) {
			    end = ct.length();
			}
			charset = ct.substring(begin, end);
			//System.err.println("charset in reply="+charset);
		    }
		}
	    }
	    //System.err.println("charset now="+charset +", isocharset="+isISOCharset(charset));
	    
	    // charset is now detected, create a string holding the result.
	    if(charset == DEFCHARSET || isISOCharset(charset)) {
		//System.err.println("internal ISO 8859 decode");
		body = bytesToString(inData,0,inData.length);
		//System.err.println("ISO 8859 decode done");
		charset = DEFCHARSET;
		responseFields.put("charset",charset);
	    } else {
		for(int i=0; i<3; ++i) {
		    switch(i) {
		      case 0:
			break;
		      case 1:
			charset = charset.toLowerCase();
			break;
		      case 2:
			charset = charset.toUpperCase();
			break;
		    }
		    responseFields.put("charset",charset);
		    try {
			//System.err.println("trying to decode with charset="+charset);
			body = new String(inData,charset);
			//System.err.println("decode success");
			break;
		    }
		    catch(Exception e2) {
			body = "xxx-encoding-failed-xxx\n"+e2.getMessage();
		    }
		}
		//System.err.println("decode bytelen="+inData.length);
		//System.err.println("decode strlen="+body.length());
	    }
	}
	catch (Exception e) {
	    status = ERROR;
	    error = e;
	    e.printStackTrace();
	}
	if(DEBUGBODY)
	    System.err.println(getBody());
	if(co != null) {
	    co.close();
	}
	// no longer needed
	inData = null;
    }

    public static byte[] asISOBytes(String s) {
	byte[] buf = new byte[s.length()];
	for(int i=0; i<s.length(); ++i) {
	    char ch = s.charAt(i);
	    buf[i] = (byte)ch;
	}
	return buf;
    }
    
    public static String bytesToString(byte[] buf) {
	return bytesToString(buf,0,buf.length);
    }
    
    public static String bytesToString(byte[] buf,int start,int n) {
	return bytesToStringBuffer(buf,start,n).toString();
    }
    
    public static StringBuffer bytesToStringBuffer(byte[] buf) {
	return bytesToStringBuffer(buf,0,buf.length);
    }
    
    public static StringBuffer bytesToStringBuffer(byte[] buf,int start,int n) {
	StringBuffer sb = new StringBuffer(buf.length);
	//System.err.println("old data:");
	//System.err.println(hexdump(buf));
	for(int i=start; n>0; ++i, --n) {
	    sb.append((char)buf[i]);
	}
	//System.err.println("new data:");
	//System.err.println(hexdump(asISOBytes(sb.toString())));
	return sb;
    }
    
    public int getStatus() {
	return status;
    }
    

    public Exception getException() {
	return error;
    }
    

    public String getBody() {
	return body;
    }
    
//#ifdef notdef
    public byte[] getBytes() {
	return inData;
    }
//#endif

    public int getRC() {
	return rc;
    }


    public static String getStatusText(int status) {
	switch(status) {
	  case SETUP:
	    return "setup";
	  case CONNECTED:
	    return "connected";
	  case ERROR:
	    return "error";
	  case TIMEOUT:
	    return "timeout";
	  case OK: