J2ME连接HTTP，获取网页信息的联网类

时间: 2020-09-18｜42次围观｜0 条评论

import java.io.DataInputStream;
import java.io.IOException;
import java.util.Enumeration;
import java.util.Hashtable;
import java.util.Vector;
import javax.microedition.io.Connector;
import javax.microedition.io.HttpConnection;
import javax.microedition.io.HttpsConnection;
import javax.microedition.lcdui.Display;
import com.ucweb.east.ui.DisplayScreen;
import com.ucweb.log.Logger;

public class HttpConnect extends Thread {
    //http请求常量
    //浏览器可接受的MIME类型
    public static final String REQUSET_HEADER_ACCEPT = "Accept";
    public static final String REQUEST_HEADER_USER_AGENT = "User-Agent";
    //浏览器所希望的语言种类
    public static final String REQUSET_HEADER_CONTENT_LANGUAGE = "Content-Language";
    public static final String REQUSET_HEADER_CONTENT_TYPE = "Content-Type";
    //表示是否需要持久连接
    public static final String REQUSET_HEADER_CONNECTION_OPTION = "Connection";
    //http回应常量
    public static final String RESPONSE_HEADER_DATE = "Date";
    public static final String RESPONSE_HEADER_SERVER = "Server";
    public static final String RESPONSE_HEADER_MODIFIEDDATE = "Last-Modified";
    public static final String RESPONSE_HEADER_CONTENT_ENCODING = "Content-Encoding";
    //表示回应消息正文的长度
    public static final String RESPONSE_HEADER_CONTENT_LENGTH = "Content-Length";
    public static final String RESPONSE_HEADER_CONTENT_TYPE = "Content-Type";
    //重定向的最大次数
    private static final int MAX_REDIRECTS = 7;
    //计算重定向的次数
    private int iRedirectCount = 0;   
    private String iURL;
    private Display iDisplay = null;
    private DisplayScreen iDisplayScreen = null;

    public HttpConnect(String aURL, Display aDis) {
        this.iURL = aURL;
        iDisplay = aDis;
    }

    public void run() {
        String sTempResult;
        try {
            sTempResult = getConnect();
            if (sTempResult == null) {
                sTempResult = "获取不到网页内容";
                Logger.logWarn("获取的网页为空");
            }
            iDisplayScreen = DisplayScreen.getInstance();
            iDisplayScreen.init(sTempResult);
            iDisplay.setCurrent(iDisplayScreen);
        } catch (IOException ex) {
            Logger.logError("线程运行出现异常", ex);
        }
    }

    /**
     * 连接URL地址，并返回网页的源代码
     * @param
     * @return String
     */
    public String getConnect() throws IOException {
        HttpConnection sConn = null;
        DataInputStream sIs = null;
        String sReponseData = null;
        int sStatus = 0;
        int sIdx = 0;
        sIdx = iURL.indexOf("://");
        if (sIdx == -1) {
            throw new IllegalArgumentException("URL must start with the protocol.");
        }
        try {
            sConn = (HttpConnection) Connector.open(iURL);
            this.setRequestMethod(sConn, HttpConnection.GET);
            Hashtable requestHeaderPair = new Hashtable();
            requestHeaderPair.put(REQUSET_HEADER_CONTENT_TYPE, "application/octet-stream");
            //传入MIDP和自身版本号，以便服务器能识别此请求来自MIDP应用程序，并且根据版本号发送相应的相应
            requestHeaderPair.put(REQUEST_HEADER_USER_AGENT, "Profile/MIDP-2.1 Configuration/CLDC-1.0");
            requestHeaderPair.put(REQUSET_HEADER_CONTENT_LANGUAGE, "en-US");
            requestHeaderPair.put(REQUSET_HEADER_ACCEPT, "application/octet-stream");
            requestHeaderPair.put(REQUSET_HEADER_CONNECTION_OPTION, "Keep-Alive");
            this.putRequestHeader(sConn, requestHeaderPair);
            sStatus = sConn.getResponseCode();
            String sRedirection = sConn.getHeaderField("Location");
            //处理返回码301
            if (sStatus == HttpConnection.HTTP_MOVED_PERM || sStatus == HttpsConnection.HTTP_SEE_OTHER) {
                if (sRedirection != null) {
                    iURL = sRedirection;
                    iRedirectCount++;
                    if (iRedirectCount < MAX_REDIRECTS) {
                        try {
                            sConn.close();
                        } catch (IOException ex) {
                            Logger.logWarn("HttpConnect: 在重定向时关闭连接失败.", ex);
                        }
                        return getConnect();
                    }
                }
                //处理返回码302
            } else if (sStatus == HttpConnection.HTTP_MOVED_TEMP) {
                if (sRedirection != null) {
                    iURL = sRedirection;
                    iRedirectCount++;
                    if (iRedirectCount < MAX_REDIRECTS) {
                        try {
                            sConn.close();
                        } catch (IOException ex) {
                            Logger.logWarn("HttpConnect: 在重定向时关闭连接失败.", ex);
                        }
                        closeConnection(sConn, sIs);
                        return getConnect(); //必须加上return，否则会返回空值
                    }
                    //等待10-1000ms，直到状态码从302转变为200。马上处理响应，当作没有错误发生
                } else {
                    long sBeginWait = System.currentTimeMillis();
                    while (System.currentTimeMillis() - sBeginWait < 1000 || sStatus != HttpConnection.HTTP_OK) {
                        sleep(100);
                        sStatus = sConn.getResponseCode();
                    }
                }
            } else if (sStatus != HttpConnection.HTTP_OK) {
                Logger.logInfo("HttpConnect response code: " + sConn.getResponseCode());
            }
            if (sStatus == HttpConnection.HTTP_OK) {
                sIs = sConn.openDataInputStream();
                sReponseData = (String) this.getResponseData(sConn, sIs);
            }
        } catch (Exception ex) {
            Logger.logDebug("Exception: " + ex.getClass() + ": " + ex.getMessage());
        } finally {
            closeConnection(sConn, sIs);
            iRedirectCount = 0;
        }
        return sReponseData;
    }
   
    /**
     * 关闭流
     * @param aConn HttpConnection，aIs DataInputStream
     * @return boolean
     */
    public void closeConnection(HttpConnection aConn,DataInputStream aIs) {
        try{
        if (aIs != null) {
            aIs.close();
        }
        if (aConn != null) {
            aConn.close();
        }
        }catch (Exception ex) {
            Logger.logWarn("关闭连接失败.",ex);
        }
    }

    /**
     * 设置请求Header信息
     * @param aConn HttpConnection，aKey String，aKeyValue String
     * @return boolean
     */
    public boolean putRequestHeaderProperty(HttpConnection aConn, String aKey, String aKeyValue) {     
        try {
            aConn.setRequestProperty(aKey, aKeyValue);
            return true;
        } catch (Exception ex) {
            Logger.logWarn("设置HTTP请求Header的信息异常.",ex);
        }
        return false;
    }

    /**
     * 获取响应Header信息
     * @param aConn HttpConnection，aKey String
     * @return void
     */
    public String getResponseHeaderProperty(HttpConnection aConn, String aKey) {
        return aConn.getRequestProperty(aKey);
    }

    /**
     * 设置请求的Header信息
     * @param aConn HttpConnection，aPropertiesPair Hashtable
     * @return void
     */
    public boolean putRequestHeader(HttpConnection aConn, Hashtable aPropertiesPair) {
        Enumeration sKeyEnumer = aPropertiesPair.keys();
        boolean isResult = true;
        while (sKeyEnumer.hasMoreElements()) {
            String sKeyName = (String) sKeyEnumer.nextElement();
            String sKeyValue = (String) aPropertiesPair.get(sKeyName);
            if (putRequestHeaderProperty(aConn, sKeyName, sKeyValue) == false) {
                isResult = false;
            }
        }
        return isResult;
    }

    /**
     * 设置网络连接的方式
     * @param aConn HttpConnection，aMethodName String
     * @return boolean
     */
    public boolean setRequestMethod(HttpConnection aConn, String aMethodName) {      
        try {
            aConn.setRequestMethod(aMethodName);
            return true;
        } catch (Exception ex) {
            Logger.logWarn("设置网络连接方式出现异常",ex);
            return false;
        }
    }

    /**
     * 获取网页返回的数据，用byte[]流来原封不动读取网页的源代码
     * @param aConn HttpConnection，aIs InputStream
     * @return void
     */
    public Object getResponseData(HttpConnection aConn, DataInputStream sIs) {
        boolean isWap = true;
        byte[] sData = null;
        String sType = null;
        int sLen = 0;
        try {
            sType = aConn.getHeaderField(RESPONSE_HEADER_CONTENT_TYPE);
            sLen = Integer.parseInt(getResponseHeaderProperty(aConn, RESPONSE_HEADER_CONTENT_LENGTH));
        } catch (IOException ex) {
            Logger.logWarn("出现IO异常 " + ex);
        } catch (Exception ex) {
            Logger.logWarn("出现异常", ex);
            sLen = 0;
        }
        if (sLen > 0) {
            int sActual = 0; //每一次实际读取的字节数
            int sBytesread = 0; //总读取的字节数
            sData = new byte[sLen];
            while ((sBytesread != sLen) && (sActual != -1)) {
                try {
                    sActual = sIs.read(sData, sBytesread, sLen - sBytesread);
                    sBytesread += sActual;
                } catch (Exception ex) {
                    Logger.logDebug("读取网页源代码出现异常: " + ex.getMessage());
                    return null;
                }
            }
        } else {
            int sCh = 0;
            Vector sVbuffer = new Vector();
            try {
                while ((sCh = sIs.read()) != -1) {
                    sVbuffer.addElement(new Integer(sCh));
                }
            } catch (Exception ex) {
                Logger.logDebug("读取网页源代码出现异常: " + ex.getMessage());
                return null;
            }
            sLen = sVbuffer.size();
            sData = new byte[sLen];
            for (int i = 0; i < sLen; i++) {
                sData[i] = ((Integer) sVbuffer.elementAt(i)).byteValue();
            }
        }
        String sResult = new String(sData);
        isWap = judgeContentType(sType);
        return setEncode(sResult, sData, sType, isWap);
    }
   
    /**
     * 根据网页的编码进行自动编码转换
     * @param aConn HttpConnection，aIs InputStream
     * @return void
     */
    public String setEncode(String aResult, byte[] aData, String aType, boolean isWap) {
        if (aData.length == 0) {
            Logger.logInfo("要转化编码的数据为空");
            return null;
        }
        if (aType.length() == 0) {
            Logger.logInfo("没有要转化的编码类型");
            return null;
        }
        String sTempType = null;
        if (isWap) {
            int sWapFlagBeginPosition = aResult.indexOf("encoding=");
            if (sWapFlagBeginPosition > 0) {
                //获取双引号之前的字符位置 ，/042表示双引号
                sWapFlagBeginPosition = aResult.indexOf("/042", sWapFlagBeginPosition);
                int sWapFlagEndPosition = aResult.indexOf("/042", sWapFlagBeginPosition + "/042".length());
                if (sWapFlagEndPosition > sWapFlagBeginPosition) {
                    //获取网页的编码格式
                    sTempType = aResult.substring(sWapFlagBeginPosition + "/042".length(), sWapFlagEndPosition);
                }
            } else {
                int sWapTypeBeginPosition = aType.indexOf("charset=");
                sTempType = aType.substring(sWapTypeBeginPosition + "charset=".length());
                sTempType = sTempType.trim();
            }
        } else {
            int sFlagBeginPosition = aResult.indexOf("charset=");
            //获取双引号之前的字符位置 ，/042表示双引号
            int sFlagEndPosition = aResult.indexOf("/042", sFlagBeginPosition);
            if (sFlagEndPosition > sFlagBeginPosition) {
                //获取网页的编码格式
                sTempType = aResult.substring(sFlagBeginPosition + "charset=".length(), sFlagEndPosition);
            }
        }
        System.out.println("编码类型: "+sTempType);
        if (sTempType != null) {
            try {
                //根据编码格式对获取网页的源代码进行编码转换
                aResult = new String(aData, sTempType);
            } catch (Exception ex) {              
                Logger.logWarn("出现编码转换异常", ex);
            }
        }
        return aResult;
    }
   
    /**
     * 判断返回的网页是html还是wml
     * @param  String aType
     * @return boolean
     */
   public boolean judgeContentType(String aType){
       int sContentTypePosition = 0;
       if(iURL.indexOf("wap") > 0){
           return true;
       }
       if(iURL.indexOf("www")> 0 ){
           return false;
       }
       if(aType != null){
           sContentTypePosition = aType.indexOf("wml");
       }
       if(sContentTypePosition > 0){
           return true;
       }else{
           return false;
       }            
   }
   
   
  

}

原文链接：https://blog.csdn.net/linweidong/article/details/5989916

本站声明:网站内容来源于网络,如有侵权,请联系我们,我们将及时处理。

本博客所有文章如无特别注明均为原创。
复制或转载请以超链接形式注明转自起风了，原文地址《J2ME连接HTTP，获取网页信息的联网类》
　 　

还没有人抢沙发呢~