关于socket里chunk问题的解决

前一段时间有人说自己碰到了http协议里的chunk问题，其实你自己实现chunk也可以，就是做个状态位的判断是了。本人实现过，在WTK虚拟机还没有公开的时候，但是wtk公开了你就用wtk里面的源马吧，写的很好，不过公开的代码里竟然少了行代码，这是在让我纳闷，不知道sun是故意的还是粗心，下面的代码增加了proxy支持，实在原有基础上改的，此代码已经应用很多应用，各位网友放心使用，有问题欢迎交流。

支持MIDP1.0和MIDP2.0，如果连接80或者8080端口，请申请证书，代码很多我给注释了，如果需要使用，请自行打开。

用法跟HttpConnection一样，只是在初始化的时候，我给修改成了openX，如果设置proxy，可以直接调用setProxyHost，注意的是，在放置url的时候不要忘记写好端口号。

SocketConnectionExt socktCon = SocketConnectionExt.openX(URL, Connector.READ_WRITE, true);
  System.out.println("URL: " + mURL);
  //socktCon.open(mURL, Connector.READ_WRITE, true);
  if(useProxy) socktCon.setProxyHost("10.0.0.172:80");

 

 

import  javax.microedition.io.StreamConnection;
/**/ /*
 * Copyright (c) 1999-2001 Sun Microsystems, Inc. All Rights Reserved.
 *
 * This software is the confidential and proprietary information of Sun
 * Microsystems, Inc. ("Confidential Information").  You shall not
 * disclose such Confidential Information and shall use it only in
 * accordance with the terms of the license agreement you entered into
 * with Sun.
 *
 * SUN MAKES NO REPRESENTATIONS OR WARRANTIES ABOUT THE SUITABILITY OF THE
 * SOFTWARE, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
 * PURPOSE, OR NON-INFRINGEMENT. SUN SHALL NOT BE LIABLE FOR ANY DAMAGES
 * SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR DISTRIBUTING
 * THIS SOFTWARE OR ITS DERIVATIVES.
 * Use is subject to license terms.
 */

import  java.io.IOException;
import  java.io.InputStream;
import  java.io.OutputStream;
import  java.io.DataInputStream;
import  java.io.DataOutputStream;
import  java.io.ByteArrayOutputStream;

import  java.util.Hashtable;
import  java.util.Enumeration;

import  javax.microedition.io.Connector;

/** */ /**
 * This class implements the necessary functionality
 * for an HTTP connection.
 */
public   class  SocketConnectionExt ... {
    
    private int index; // used by URL parsing functions
    private String url;
    private String protocol;
    private String host;
    private String file;
    private String ref;
    private String query;
    private int port = 80;
    private int responseCode;
    private String responseMsg;
    private Hashtable reqProperties;
    private Hashtable headerFields;
//    private String[] headerFieldNames;
//    private String[] headerFieldValues;
    private String method;
    private int opens;
    private int mode;
    private String proxyHost;
    private boolean proxy = false;
    private boolean connected;

    /**//*
     * In/out Streams used to buffer input and output
     */
    private PrivateInputStream in;
    private PrivateOutputStream out;

    /**//*
     * The data streams provided to the application.
     * They wrap up the in and out streams.
     */
    private DataInputStream appDataIn;
//    private DataOutputStream appDataOut;

    /**//*
     * The streams from the underlying socket connection.
     */
    private StreamConnection streamConnnection;
    private DataOutputStream streamOutput;
    private DataInputStream streamInput;

    /**//*
     * A shared temporary buffer used in a couple of places
     */
    private StringBuffer stringbuffer;
    private String http_version = "HTTP/1.1";

    /** *//**
     * Create a new instance of this class.
     * We are initially unconnected.
     */
    public SocketConnectionExt() ...{
        reqProperties = new Hashtable();
        headerFields = new Hashtable();
        stringbuffer = new StringBuffer(32);
        opens = 0;
        connected = false;
        method = "GET";
        responseCode = -1;
        protocol = "http";
    }
    
    public void setProxyHost(String proxyHost)...{
        this.proxyHost = proxyHost;
        proxy = true;
    }

    public void open(String url, int mode, boolean timeouts)
        throws IOException ...{

        if (opens > 0) ...{
            throw new IOException("already connected");
        }

        opens++;

        if (mode != Connector.READ && mode != Connector.WRITE
            && mode != Connector.READ_WRITE) ...{
            throw new IOException("illegal mode: " + mode);
        }

        this.url = url;
        this.mode = mode;

        parseURL();
    }
    
    public static SocketConnectionExt openX(String url, int mode, boolean timeouts) throws IOException...{
        SocketConnectionExt hcp = new SocketConnectionExt();
        hcp.open(url, mode, timeouts);
        return hcp;
    }

    public void close() throws IOException ...{
        if (--opens == 0 && connected) ...{
            disconnect();
        }
    }

    /**//*
     * Open the input stream if it has not already been opened.
     * @exception IOException is thrown if it has already been
     * opened.
     */
    public InputStream openInputStream() throws IOException ...{

        if (in != null) ...{
            throw new IOException("already open");
        }

        // If the connection was opened and closed before the
        // data input stream is accessed, throw an IO exception
        if (opens == 0) ...{
            throw new IOException("connection is closed");
        }

        // Check that the connection was opened for reading
        if (mode != Connector.READ && mode != Connector.READ_WRITE) ...{
            throw new IOException("write-only connection");
        }

        connect();
        opens++;

        in = new PrivateInputStream();
        return in;
    }

    public DataInputStream openDataInputStream() throws IOException ...{

        if (appDataIn != null) ...{
            throw new IOException("already open");
        }

        // TBD: throw in exception if the connection has been closed.
        if (in == null) ...{
            openInputStream();
        }

        appDataIn = new DataInputStream(in);
        return appDataIn;
    }

    public OutputStream openOutputStream() throws IOException ...{

        if (mode != Connector.WRITE && mode != Connector.READ_WRITE) ...{
            throw new IOException("read-only connection");
        }

        // If the connection was opened and closed before the
        // data output stream is accessed, throw an IO exception
        if (opens == 0) ...{
            throw new IOException("connection is closed");
        }

        if (out != null) ...{
            throw new IOException("already open");
        }

        opens++;
        out = new PrivateOutputStream();
        return out;
    }

    public DataOutputStream openDataOutputStream() throws IOException ...{

        if (mode != Connector.WRITE && mode != Connector.READ_WRITE) ...{
            throw new IOException(