[转贴自yesky]
一、J2ME中需要的Java基础知识
　　现在有大部分人，都是从零开始学J2ME的，学习J2ME的时候，总是从Java基础开始学习，而且现在讲Java基础的书籍中都是以J2SE来讲基础，这就给学习造成了一些不必要的麻烦，下面将J2ME中用到的和不需要的Java基础知识做一个简单的说明。
　　J2ME中使用到的Java基础知识：
　　 1、Java语法基础：包括基本数据类型、关键字、运算符等等
　　 2、面向对象的思想：类和对象的概念，继承和多态等等。
　　 3、异常处理
　　 4、多线程
　　J2ME中没有用到的Java基础知识：
　　 1、JDK中javac和java命令的使用

JAVA手机网[www.cnjm.net]

　　 2、Java基础中的很多类在J2ME中没有，或者类中的方法做了大量的精简。所以建议在J2ME中熟悉类库。

JAVA手机网[www.cnjm.net]

　　 3、Applet、AWT、Swing这些知识在J2ME中根本使用不到。

JAVA手机网[www.cnjm.net]

　　简单说这么多，希望学J2ME的朋友们能少走一些弯路，不足之处希望大家积极指正和补充。
　　二、J2ME中暂时无法完成的功能
　　列一些J2ME中暂时无法完成的功能，希望大家能积极补充：

JAVA手机网[www.cnjm.net]

　　 1、在手机中不更改代码实现移植，主要指游戏。
　　 2、动态修改按钮文字。

JAVA手机网[www.cnjm.net]

　　 3、在Canvas上接受中文输入。

JAVA手机网[www.cnjm.net]

　　 4、操作本地资源、例如地址本、已收短信息等。

JAVA手机网[www.cnjm.net]

　　 5、制作破坏性的手机病毒。
　　 6、其他等待大家来补充。
　　三、J2ME的跨平台性
　　J2ME技术源于Java，所以也具有JVM的优势，可以在支持Java的平台上进行移植，但是现在的J2ME技术在跨平台上却做的很糟糕，我们来简单看一下原因：
　　1、手机的屏幕尺寸不一：
　　这个主要在界面制作上。如果你使用的是高级用户界面，比如你做的是应用开发或者用户登陆、用户注册这样的通用功能时，一般没有什么问题。
　　如果你使用的是低级用户界面，比如你做的是游戏，那么你就需要考虑这个问题了。

JAVA手机网[www.cnjm.net]

JAVA手机网[www.cnjm.net]

　　2、厂商的扩展API不统一：

JAVA手机网[www.cnjm.net]

　　例如Nokia的扩展API类库UI系列，在别的手机上或者没有实现，或者包名不同等等。
　　3、手机平台上实现的bug：
　　例如Nokia的7650在实现双缓冲上有bug，那么在这种机型上运行的软件就不能使用双缓冲。其他NOKIA上的一些bug，可以参看：http://www.cnjm.net/resfetch/EKayXl5MlY2NaSIHXDqIdRYYOhhiXo2ZYQgiaQcmaY1ha4iyCKZijcsVFcqNFWSNy6SNZMvczstkOmF1THk_
　　4、手机性能问题。
　　不同手机的可用内存、最大jar文件都有要求，例如Nokia S40的大部分手机支持的最大jar文件为64K，最大可用内容为210K。
　　所以现在的手机软件，特别是游戏都提供支持的机型列表，也才有了手机游戏移植人员的存在。
　　四、学习J2ME可以从事的工作种类
　　现在J2ME技术可以说相当的火暴，这里介绍一些学好了J2ME之后可以从事的工作的种类：
　　1、J2ME游戏开发人员
　　根据游戏策划或者文档要求，在某种特定的机型(以Nokia S40或S60居多)开发游戏程序。这是现在大部分J2ME程序员从事的工作。
　　需要熟练掌握：高级用户界面、低级用户界面、线程，如果是网络游戏，还需要熟练网络编程。
　　2、J2ME应用开发人员

JAVA手机网[www.cnjm.net]

　　现在的移动应用还不是很多，但是还是出现了一些，特别是移动定位以及移动商务相关的内容。需要熟练掌握：高级用户界面、线程和网络编程。
　　3、J2ME游戏移植人员
　　参照源代码，将可以在一个平台上可以运行的游戏移植到其他平台上去。例如将Nokia S40的游戏移植到S60上，或者索爱的T618等等。主要是控制屏幕坐标，有些可能需要替换一些API。
　　需要熟悉各平台之间的差异以及相关的技术参数，比如屏幕大小、最大jar文件尺寸等等。
　　五、J2ME程序设计的几个原则
　　1、使用面向对象编程。
　　虽然使用面向过程编程可以减小文件的尺寸，但是为了以后维护的方便和利于扩展，还是要使用面向对象编程。
　　2、使用MVC模式
　　将模型、界面和控制分离。现在很多的程序将三者合一，但是如果你做的程序比较大的话，还是建议你进行分离。

JAVA手机网[www.cnjm.net]

　　3、自动存储用户设定
　　使用RMS来存储用户的信息，例如存储用户上次输入的用户名、密码、用户对于系统的设定等，这样不仅可以减少用户的输入，而且对用户友好。很多程序甚至做了自动登陆等。
　　4、一些系统设置允许用户关闭。如背景音乐、背景灯显示等。

JAVA手机网[www.cnjm.net]

　　5、将低级用户界面的绘制动作放在一个独立的线程里面去。
　　6、在需要大量时间才能完成的工作时，给用户一个等待界面。

JAVA手机网[www.cnjm.net]

　　六、从模拟器到真机测试
　　对于J2ME开发者来说，模拟器给我们带来了很多方便，比如可以在模拟器中调试程序以及很方便的察看程序的效果，但是模拟器也给我们带来了一些问题，比如模拟器实现的bug等等，所以进行真机测试是必须的。
　　1、为什么要进行真机测试？

JAVA手机网[www.cnjm.net]

　　因为模拟器程序可能存在bug，以及真机的性能有限，所以必须进行真机测试。
　　2、如何将程序传输到机器中？
　　将程序传输到机器中有如下方式：
　　 a)　OTA下载
　　 b)　使用数据线传输

JAVA手机网[www.cnjm.net]

　　 c)　红外传输

JAVA手机网[www.cnjm.net]

　　 d)　蓝牙
　　你可以根据条件，选择合适的方式。
　　3、 真机测试主要测什么？

JAVA手机网[www.cnjm.net]

　　真机测试的内容很多，主要测试以下几个方面：
　　 a)　程序的功能
　　 b)　程序的操作性，是否易操作

JAVA手机网[www.cnjm.net]

JAVA手机网[www.cnjm.net]

　　 c)　程序的大小,比如Nokia S40系列的手机大部分接受的最大文件尺寸为64K
　　 d)　程序运行速度，速度是否可以忍受。

JAVA手机网[www.cnjm.net]

　　七、从WTK到厂商SDK
　　对于J2ME爱好者来说，基本上大家都是从SUN的WTK(J2ME Wireless Toolkit)开始的，但是对于实际应用来说，仅仅使用WTK是远远不够的，所以在学习过程中，必须完成从WTK到SDK的跨越。
　　1、厂商SDK的下载地址？
　　·Nokia
　　Nokia不愧为手机行业的老大，对于j2me的支持也是一流的，有专门的网站提供SDK和各种文档说明。
　　网址是：http://www.cnjm.net/resfetch/Dbvxamo8cwoKpIh4z44.G4iEykM.MYiOPzEbCpMx8QrKGwv7TD.xao4N
　　·Siemens

JAVA手机网[www.cnjm.net]

　　Siemens对于J2ME的支持也不错，它提供了SDK，模拟器需要独立安装。下载地址如下：
http://www.cnjm.net/resfetch/BVBDcHC9yrySkj0S7e24pIs9PnCLEqR77T4GZi5wS8qLLu0upMpLjS6SvRIGcD7qku0-i6RLPsq9OjfEPqTCQkUOt6kgPoukIC6kuEJFDnqpxC59cEJFDnqpvYuNDhSpPYuNDrepcIuNDuu3t7epOouNDrc_
　　·SonyEricsson

JAVA手机网[www.cnjm.net]

　　SonyEricsson SDK以及自己的模拟器，下载地址为：
　[url]http://developer.sonyericsson.com/site/global/docstools/java/p_java.jsp/url]
http://www.cnjm.net/resfetch/BEe.ZGSB34qK5B9NqS2pZHWSH9stlFti26l4xsYfsFt4H-RbeLCKlGLEYi0fgeRisGSKlB-SsC0fQ5RFv6lkW0PGgQ__
　　·Motorola
　　Motorola提供了专门的SDK，内部包含模拟器，下载地址为：
http://www.cnjm.net/resfetch/EKayXl5MlY2NPj4-OiYHXgeIBxZiazqIByaNJgdeB2sHImGNTIh1gAcmYjrBdUw_

JAVA手机网[www.cnjm.net]

　　·SamSung

JAVA手机网[www.cnjm.net]

　　SamSung也提供了专门的SDK和模拟器，下载地址为：
http://www.cnjm.net/resfetch/CnUnZGQjjsPDP7oJunRUI7phlNiAL9hs4OwvVP9FdLqUb1Qvw7rg7MOjYVTgZPn9VOC6w...2MP..9j5L4BF4JRL2CPfI.kvuuBs-UU.BC4p.v4_
　　·NEC：
　　NEC也提供了集成模拟器的SDK，下载地址为：

JAVA手机网[www.cnjm.net]

http://www.cnjm.net/resfetch/Ig9UMDBaS5eXGxsbLMm43HD4NMZquMmDLNzh-JfcyQ__
　　2、厂商SDK和WTK有什么不同？

JAVA手机网[www.cnjm.net]

　　厂商SDK最简单的理解就是在WTK的基础上增加了自己的模拟器和自己的扩展API。也就是说，你在使用厂商的SDK时，可以使用厂商的扩展类库，例如Nokia的UI类库，和厂商自己的模拟器而已。每个厂商的扩展API都不多，而且不尽相同。
　　3、如何使用？
　　有些厂商SDK的使用都和WTK相同，例如SamSung。Nokia提供了独立的界面来开发，但是这个界面在实际开发中使用不多。

JAVA手机网[www.cnjm.net]

　　4、厂商SDK的问题

JAVA手机网[www.cnjm.net]

　　厂商SDK实现过程中，有一些bug，而且和真机实现不一致。例如NOKIA的混音播放问题等等。
　　八、在J2ME中获得手机IMEI的方法
　　IMEI是Internation mobile entity identification的简称，在手机中输入*#06#可以显示该数字，长度为15位，全球唯一，永远不会冲突，所以可以作为识别用户的一个标志。

JAVA手机网[www.cnjm.net]

　　下面是在J2ME中获得IMEI的方法：
　　1、MOTO系列的手机可以通过读取系统的IMEI属性获得，代码如下：

JAVA手机网[www.cnjm.net]

　　 String imei = System.getProperty("IMEI");
　　2、SIEMENS系列的手机可以通过读取系统的com.siemens.IMEI属性获得，代码如下：
　　 String imei = System.getProperty("com.siemens.IMEI");
　　九、J2ME网络连接中显示问题的解决办法

JAVA手机网[www.cnjm.net]

JAVA手机网[www.cnjm.net]

　　在网络编程中，有些时候会出现一些在没有接收到网络数据就显示界面的，造成界面显示不符合要求（例如公告显示，会先显示公告的背景图片再显示公告信息），这里提一个简单的解决办法给大家：

JAVA手机网[www.cnjm.net]

　　解决这种情况的方法分成三个步骤：
　　1、在需要显示的界面中，调用发送网络数据的方法。每次显示时调用该构造方法，不调用Display的setCurrent方法显示。

JAVA手机网[www.cnjm.net]

　　2、显示等待界面(例如进度条等)，给用户提示，在进行网络连接。
　　3、在处理网络反馈的数据完以后，调用Display的setCurrent方法显示显示当前界面。

作者：陈跃峰

出自：http://blog.csdn.net/mailbomb

1、 Nokia3300不支MMA(声音处理)类库。

2、 Image.getGraphics()方法在不同的软件版本中工作不同，该方法无法在新版本的7650、3650和N-Gage中正常工作。即这些机器中无法实现双缓冲技术。

3、 Nokia7650、3650和N-Gage，无法控制背景灯和震动。

4、 同时播放声音在S60模拟器上可以运行，但是真机不支持。

5、 7650不支持WMA(短信息API)。

6、 在7210SDK1.0中softkey1和softkey2也产生left和right按键代码。

7、 在S60中堆内存不同。一般S60设备有2M，而3600只有1.6M。

8、 记录集枚举问题。在S40SDK和真机中，使用RecordStore.deleteRecord(id)以后，枚举工作不正常。

9、 Nokia6230 MIDP Concept SDK beta0.2不支持CLDC1.1。

10、 NUL字符(0x00)在TextBox中有问题。S401.0 SDK和真机中都存在该问题。

11、 如果MIDlet在后台运行时，MIDI声音不停止。S601.0中存在该问题。

12、 当正在运行的MIDlet被系统Screen隐含调用的类选择显示屏幕时有问题。在S60 1.0中存在该问题。

13、 S40界面风格中的字体大小不一致。在S40 1.0SDK和真机，以及7250i、3100、6108、6200中。

14、 Item.getLable()方法在ChoiceGroup中无法返回正确的label。

15、 在Nokia MIDP 1.0中，DeviceControl.setLights(0,0)没有关闭键区灯。屏幕等关闭，而键区等依然亮着。涉及具有翻页键盘的S40 1.0设备。

16、 在S60 1.0设备中，Date对象无法返回当前时间。

详细文档参看：

http://www.forum.nokia.com/ndsCookieBuilder?fileParamID=3895

作者:cleverpig(作者的Blog:http://blog.matrix.org.cn/page/cleverpig)
原文:http://www.matrix.org.cn/resource/article/44/44154_j2me.html
关键字:j2me，页面，编码，乱码
一、摘要
根据xinshouj2me在j2me版提出的“httpconnection网络连接的问题”，本人分析了一下：由于www.163.com上的页面编码为gb2312，所以使用utf8读取由于编码方式不同会得到乱码。于是本人根据page的编码灵活进行编码转化，在此与大家共享、讨论。
二、代码分析
1.HttpConnectionHandler接口类
最好根据page的编码灵活进行编码转化，于是本人定义了一个HttpConnectionHandler接口类：
HttpConnectionHandler.java

				
package com.bjinfotech.practice.j2me.httpConnection;

import java.util.Hashtable;
import javax.microedition.io.HttpConnection;

/**
 * Http连接处理器接口
 * @author cleverpig
 *
 */
public interface HttpConnectionHandler {
        //http请求常量
        public static final String RQH_HOST="X-Online-Host";
        public static final String RQH_ACCEPT="Accept";
        public static final String RQH_CONTENT_LANGUAGE="Content-Language";
        public static final String RQH_CONTENT_TYPE="Content-Type";
        public static final String RQH_CONNECTION_OPTION="Connection";
        //http回应常量
        public static final String RSH_DATE="Date";
        public static final String RSH_SERVER="Server";
        public static final String RSH_MODIFIEDDATE="Last-Modified";
        public static final String RSH_CONTENT_ENCODING="Content-Encoding";
        public static final String RSH_CONTENT_LENGTH="Content-Length";
        public static final String RSH_CONTENT_TYPE="Content-Type";
        
        public boolean putRequestHeaderProperty(
                        HttpConnection conn,
                        String key,
                        String keyValue);
        
        public String getResponseHeaderProperty(
                        HttpConnection conn,
                        String key);
        
        public boolean setRequestMethod(
                        HttpConnection conn,
                        String methodName);
        
        public boolean putRequestHeader(
                        HttpConnection conn,
                        Hashtable propertiesPair);
        
        public Hashtable getResponseHeader(
                        HttpConnection conn,
                        String[] propertyNames);
        
        public boolean sendRequestData(
                        HttpConnection conn,
                        Object sendData);
        
        public Object getResponseData(HttpConnection conn);
        
}

package com.bjinfotech.practice.j2me.httpConnection;

import java.io.DataOutputStream;
import java.io.DataInputStream;
import java.util.Hashtable;
import java.util.Vector;
import java.util.Enumeration;
import javax.microedition.io.HttpConnection;

/**
 * http连接处理器实现
 * @author cleverpig
 *
 */
public class HTML_HttpConnectionHandlerImpl implements HttpConnectionHandler{
        private String message="";
        
        public HTML_HttpConnectionHandlerImpl(){
        }
        
        public boolean putRequestHeaderProperty(
                        HttpConnection conn,
                        String key,
                        String keyValue){
                message="";
                try{
                        conn.setRequestProperty(key,keyValue);
                        return true;
                }
                catch(Exception ex){
                        message=ex.getMessage();
                }
                return false;
        }
        
        public String getResponseHeaderProperty(
                        HttpConnection conn,
                        String key){
                return conn.getRequestProperty(key);
        }
        
        public boolean putRequestHeader(
                        HttpConnection conn,
                        Hashtable propertiesPair){
                Enumeration keyEnumer=propertiesPair.keys();
                boolean result=true;
                while(keyEnumer.hasMoreElements()){
                        String keyName=(String)keyEnumer.nextElement();
                        String keyValue=(String)propertiesPair.get(keyName);
                        if (putRequestHeaderProperty(conn,keyName,keyValue)==false){
                                result=false;
                        }
                }
                return result;
        }
        
        public boolean setRequestMethod(
                        HttpConnection conn,
                        String methodName){
                message="";
                try{
                        conn.setRequestMethod(methodName);
                        return true;
                }
                catch(Exception ex){
                        message=ex.getMessage();
                        return false;
                }
        }
        
        public Hashtable getResponseHeader(
                        HttpConnection conn,
                        String[] propertyNames){
                Hashtable result=new Hashtable();
                for(int i=0;i<propertyNames.length;i++){
                        String keyValue=conn.getRequestProperty(propertyNames[i]);
                        result.put(propertyNames[i],keyValue);
                }
                return result;
        }
        
        public boolean sendRequestData(
                        HttpConnection conn,
                        Object sendData){
                message="";
                try{
                        DataOutputStream os=conn.openDataOutputStream();
                        os.writeUTF((String)(sendData));
                        os.flush();
                        return true;
                }
                catch(Exception ex){
                        message=ex.getMessage();
                        return false;
                }
        }
        
        public Object getResponseData(HttpConnection conn){
                DataInputStream is=null;
                message="";
                try{
                        is=conn.openDataInputStream();
                }
                catch(Exception ex){
                        message=ex.getMessage();
                        return null;
                }
                
                byte[] data=null;
                String type=getResponseHeaderProperty(conn,RSH_CONTENT_TYPE);
                int len = 0;
                try{
                        len=Integer.parseInt(getResponseHeaderProperty(conn,RSH_CONTENT_LENGTH));
                }
                catch(Exception ex){
                        len=0;
                }
                if (len > 0) {
             int actual = 0;
             int bytesread = 0 ;
             data = new byte[len];
             while ((bytesread != len) && (actual != -1)) {
                     try{
                             actual = is.read(data, bytesread, len - bytesread);
                             bytesread += actual;
                     }
                     catch(Exception ex){
                             message=ex.getMessage();
                             return null;
                     }
             }
        } else {
            int ch;
            Vector vbuffer=new Vector();
            try{
                    while ((ch = is.read()) != -1) {
                            vbuffer.addElement(new Integer(ch));
                    }
            }
                       catch(Exception ex){
                                message=ex.getMessage();
                                return null;
                       }
            len=vbuffer.size();
            data = new byte[len];
            for(int i=0;i<len;i++){
                    data[i]=((Integer)vbuffer.elementAt(i)).byteValue();
            }
        }
        
        String result=new String(data);
        int flagBeginPosition=result.indexOf("charset=");
        int flagEndPosition=result.indexOf("\">",flagBeginPosition);
        if (flagEndPosition>flagBeginPosition){
                type=result.substring(flagBeginPosition+"charset=".length(),flagEndPosition);
        }
        System.out.println("获得html字符集:"+type);
        if (type!=null){
                
                try{
                        result=new String(data,type);
                }
                catch(Exception ex){
                        message=ex.getMessage();
                }
        }
        return result;
        }
        
        public String getMessage(){
                return message;
        }
        
        
}

package com.bjinfotech.practice.j2me.httpConnection;

import javax.microedition.midlet.MIDlet;
import javax.microedition.midlet.MIDletStateChangeException;
import javax.microedition.io.HttpConnection;
import javax.microedition.io.Connector;
import java.util.Hashtable;

public class HttpConnectionMIDlet extends MIDlet {

        public HttpConnectionMIDlet() {
                super();
        }

        
        protected void startApp() throws MIDletStateChangeException {
                HTML_HttpConnectionHandlerImpl handler=new HTML_HttpConnectionHandlerImpl();
                try{
                        String host="10.11.3.99";
                        String url="http://10.11.3.99:8080/test_gbk.html";
//                        String url="http://10.11.3.99:8080/test_gb2312.html";
//                        String url="http://10.11.3.99:8080/test_utf8.html";
                        
                        HttpConnection conn=(HttpConnection)Connector.open(url);
                        if (conn.getResponseCode()==HttpConnection.HTTP_OK){
                                System.out.println("建立连接成功");
                                
                                Hashtable requestHeaderPair=new Hashtable();
                                requestHeaderPair.put(
                                                HTML_HttpConnectionHandlerImpl.RQH_HOST,
                                                host);
                                requestHeaderPair.put(
                                                HTML_HttpConnectionHandlerImpl.RQH_CONTENT_TYPE,
                                                "application/octet-stream");
                                requestHeaderPair.put(
                                                HTML_HttpConnectionHandlerImpl.RQH_CONTENT_LANGUAGE,
                                                "en-US");
                                requestHeaderPair.put(
                                                HTML_HttpConnectionHandlerImpl.RQH_ACCEPT,
                                                "application/octet-stream");
                                requestHeaderPair.put(
                                                HTML_HttpConnectionHandlerImpl.RQH_CONNECTION_OPTION,
                                                "Keep-Alive");
                                handler.putRequestHeader(conn,requestHeaderPair);
                                handler.setRequestMethod(conn,HttpConnection.GET);
                                handler.sendRequestData(conn,"GET / HTTP/1.1");
                                if (conn.getResponseCode()==HttpConnection.HTTP_OK){
                                        System.out.println("发送请求成功");
                                        
                                        System.out.println("获得回应数据");
                                        String reponseData=(String)handler.getResponseData(conn);
                                        System.out.println(reponseData);
                                }
                                else{
                                        System.out.println("发送请求失败");
                                        System.out.println("错误信息:"+handler.getMessage());
                                }
                        }
                        else{
                                System.out.println("建立连接失败");
                        }
                }
                catch(Exception ex){
                        System.out.println("错误信息:"+handler.getMessage());
                        ex.printStackTrace();
                }
                

        }
        
        protected void pauseApp() {
                

        }

        protected void destroyApp(boolean arg0) throws MIDletStateChangeException {
                

        }

}

一、“NetConnection”简介：
转述Matrix上zhengyun_ustc所述：“你的HttpConnection是否封装的足够健壮呢？遇到各种情况，你是否有信心应对呢？譬如说，你要请求的Response包实在太大，以至于运营商给你掐了告诉你说超时；譬如说你是不是总要自己写一个线程来专门作http连接？譬如说有一些移动运营商设置了caching proxy servers，妨碍了你的测试。”
为了解决这个问题，一位日本程序员“JAY-F”针对MIDP1.0提供了一种robust的“NetConnection”封装。这个HttpConnnection类负责管理连接并易于使用。
二、“NetConnection”特性：
1. 跨过Proxy-server阻碍：
一些移动网络放置了代理服务器用来提高访问速度，但是它的cache也成为了开发人员测试/调试程序的一大障碍。“NetConnection”类使用一个简单的http request属性将server上的代理功能关闭掉。
2. 使用线程分离的连接模式：
本类可以使用单线程、多线程两种模式运行，只要设置一个简单的标志即可。
3. 支持Http request range：
由于服务商在其网络上可能存在一些针对回应数据最大长度的限制，所以“NetConnection”类提供了构造request URL的功能使回应数据分为多个数据包。从而去除了前面的限制。
三、netConnection是如何实现的？
1。netConnection类结构分析：
此类实现了Runnable接口，其运行模式支持多线程模式：当前只能由一个线程使用资源，其它线程wait。
此类使用了一些静态成员变量：

				
        //当前只能由一个线程使用singleton。
        private static NetConnection singleton = new NetConnection();

        private static HttpConnection httpConn;

        private static String url;

        private static String method;

        private static byte[] data;
                

        private static String contentType;
        

        private static long lowRange;
        

        private static long highRange;
        

        private static boolean disableProxy;
        

        private static boolean detached;
        
        private static byte[] response;

//线程run方法
public void run()

//当前运行的线程执行完毕后，通报给其它的由于等待资源而wait状态的线程
private synchronized void forceNotify() 

//当资源正在被其它线程使用时，当前线程进入wait状态
private synchronized void forceWait()

//关闭http连接
private static void severConnection()

/**
 * 实现了连接逻辑。
 * 调用者可以在分离的线程中使用netConnection类的静态连接。
 * @throws IllegalStateException 如果此方法直接其它类调用则抛出该异常
 */
public void run() {
        
        if (url == null) {
                throw new IllegalStateException("Cannot invoke this method!");
        }

        
        DataOutputStream dos = null;
        DataInputStream dis = null;
        StringBuffer buffer = null;

        try {

                int permissions = 0;
                
                //根据method值，设置Connector的权限（READ/READ_WRITE）
                if (HttpConnection.GET.equals(method)) {
                        permissions = Connector.READ;
                } else if (HttpConnection.POST.equals(method)) {
                        permissions = Connector.READ_WRITE;
                }
                
                //如果关闭server代理功能，则构造noProxyUrl。
                //原理：使用timestamp作为该URL中no-proxy参数值，
                //        致使server视其为client发来的新请求。
                if (disableProxy) {
                        
                        boolean hasQueryParams = false;
                        
                        char[] ca = url.toCharArray();
                        //判断原URL中是否含有参数
                        for (int loop = 0; loop < url.length(); loop++) {
                                
                                if (ca[loop] == '?') {
                                        hasQueryParams = true;
                                        break;
                                }
                        }
                        
                        //由于需要多次字符串拼接，所以使用可提供效率的StringBuffer类
                        StringBuffer noProxyUrl = new StringBuffer();

                        //将原URL内容复制到noProxyUrl
                        noProxyUrl.append(url);

                        //如果原URL中含有参数，
                        //  则需要在noProxyUrl中增加"&"，
                        //  否则直接在noProxyUrl中增加"?"，
                        //  这样做为了后面增加no-proxy参数做准备。
                        if (hasQueryParams) {
                                noProxyUrl.append("&");
                        } else {
                                noProxyUrl.append("?");
                        }

                        //增加no-proxy参数
                        noProxyUrl.append("no-proxy=");
                        noProxyUrl.append(System.currentTimeMillis()); // timestamp
                        
                        //将构造好的noProxyUrl复制到原URL
                        url = noProxyUrl.toString();
                }
                
                

                // 打开Http 连接
                httpConn = (HttpConnection) Connector.open(url, permissions, true);
                //设置request方法
                httpConn.setRequestMethod(method);

                //如果request权限为READ（即request方法为GET），
                //则需要设置http request属性的Range。
                //原理：设置http request属性的Range后的，
                //        server接收到该request后将把response数据分成小部分发回。
                //        从而避免了部分运营商对http response size的限制。
                if (permissions == Connector.READ) {        
                        if (lowRange > -1 && lowRange < highRange) {
                                StringBuffer range = new StringBuffer();
                                
                                range.append("bytes=");
                                range.append(lowRange);
                                range.append("-");
                                range.append(highRange);
                                
                                httpConn.setRequestProperty("Range", range.toString());
                        }
                //否则，request权限为READ_WRITE（即request方法为POST），
                //那么设置request的Content-Type属性。
                } else if (permissions == Connector.READ_WRITE) {
                        // POST request
                        httpConn.setRequestProperty("Content-Type", contentType);
                        dos = httpConn.openDataOutputStream();
                        dos.write(data);
                }
        
        } catch (Exception e) {
        
                exceptionPipe = e;
                //如果程序运行在多线程模式，则在异常发生后需要唤醒其它睡眠的线程继续run
                if (detached) {
                        forceNotify();
                }
                
                return;
                
        } finally {

                try {
                        try {
                                if (dos != null) {
                                        // 关闭dos
                                        dos.close();
                                }
                        } catch (Exception e) {
                                // 如果程序运行在多线程模式，则在异常发生后需要唤醒其它睡眠的线程继续run
                                if (exceptionPipe == null) {
                                        exceptionPipe = e;
                                        
                                        if (detached) {
                                                forceNotify();
                                        }
                                        return;
                                }
                        } finally {
                                dos = null;
                        }
                        
                        // 读取http连接的回应代码
                        int responseCode = httpConn.getResponseCode();
                        
                        //当request方法为GET，并设置了request range时，接收到的回应代码为HTTP_PARTIAL
                        //当request方法为POST，接收到的回应代码为HTTP_OK
                        //如果上述两种回应代码均没有收到，则表明连接失败或者出问题
                        if (responseCode != HttpConnection.HTTP_OK
                                        && responseCode != HttpConnection.HTTP_PARTIAL) {

                                if (exceptionPipe == null) {
                                        StringBuffer errorCode = new StringBuffer();
                                        errorCode.append("Response code from server: ");
                                        errorCode.append(responseCode);
                                        errorCode.append("\nMessage: [");
                                        errorCode.append(httpConn.getResponseMessage());
                                        errorCode.append("]");
                                        
                                        exceptionPipe = new IOException(errorCode.toString());
                                        
                                        if (detached) {
                                                forceNotify();
                                        }
                                        return;
                                }
                        }

                        //如果收到了上述的两种回应代码之一，则可以继续读取server的response数据
                        dis = httpConn.openDataInputStream();

                        //循环读取repsonse数据
                        int ch;
                        buffer = new StringBuffer();
                while ((ch = dis.read()) != -1) {
                        buffer.append((char) ch);
                }

                //将response数据进行必要的编码转换                 
                        response = buffer.toString().getBytes("ISO8859_1");
                        //接收到回应后，表明整个http会话过程结束，线程将结束。
                        //如果程序运行在多线程模式，则此时需要唤醒其它睡眠的线程继续run
                        if (detached) {
                                forceNotify();
                        }
                        
                        return;

                } catch (Exception e) {
                        
                        if (exceptionPipe == null) {
                                exceptionPipe = e;
                                
                                if (detached) {
                                        forceNotify();
                                }
                                
                                return;
                        }
                } finally {
                    
                        try {
                                if (dis != null) {
                                        // 关闭dis
                                        dis.close();
                                }
                        } catch (Exception e) {
                                // 若关闭dis时发生异常，则进行异常处理
                                if (exceptionPipe == null) {
                                        exceptionPipe = e;
                                        
                                        if (detached) {
                                                forceNotify();
                                        }
                                        return;
                                }
                        } finally {
                                dis = null;
                        }
                        
                        try {
                                if (httpConn != null) {
                                        //关闭http连接
                                        httpConn.close();

                                        httpConn = null;
                                }
                        } catch (Exception e) {

                                if (exceptionPipe == null) {
                                        exceptionPipe = e;
                                        
                                        if (detached) {
                                                forceNotify();
                                        }
                                        return;
                                }
                        }
                }
        }
}

Mime-Typ Dateiendung(en) Bedeutung
application/acad *.dwg AutoCAD-Dateien (nach NCSA)
application/applefile AppleFile-Dateien
application/astound *.asd *.asn Astound-Dateien
application/dsptype *.tsp TSP-Dateien
application/dxf *.dxf AutoCAD-Dateien (nach CERN)
application/futuresplash *.spl Flash Futuresplash-Dateien
application/gzip *.gz GNU Zip-Dateien
application/listenup *.ptlk Listenup-Dateien
application/mac-binhex40 *.hqx Macintosh Binär-Dateien
application/mbedlet *.mbd Mbedlet-Dateien
application/mif *.mif FrameMaker Interchange Format Dateien
application/msexcel *.xls *.xla Microsoft Excel Dateien
application/mshelp *.hlp *.chm Microsoft Windows Hilfe Dateien
application/mspowerpoint *.ppt *.ppz *.pps *.pot Microsoft Powerpoint Dateien
application/msword *.doc *.dot Microsoft Word Dateien
application/octet-stream *.bin *.exe *.com *.dll *.class Ausführbare Dateien
application/oda *.oda Oda-Dateien
application/pdf *.pdf Adobe PDF-Dateien
application/postscript *.ai *.eps *.ps Adobe Postscript-Dateien
application/rtc *.rtc RTC-Dateien
application/rtf *.rtf Microsoft RTF-Dateien
application/studiom *.smp Studiom-Dateien
application/toolbook *.tbk Toolbook-Dateien
application/vocaltec-media-desc *.vmd Vocaltec Mediadesc-Dateien
application/vocaltec-media-file *.vmf Vocaltec Media-Dateien
application/x-bcpio *.bcpio BCPIO-Dateien
application/x-compress *.z -Dateien
application/x-cpio *.cpio CPIO-Dateien
application/x-csh *.csh C-Shellscript-Dateien
application/x-director *.dcr *.dir *.dxr -Dateien
application/x-dvi *.dvi DVI-Dateien
application/x-envoy *.evy Envoy-Dateien
application/x-gtar *.gtar GNU tar-Archiv-Dateien
application/x-hdf *.hdf HDF-Dateien
application/x-httpd-php *.php *.phtml PHP-Dateien
application/x-javascript *.js serverseitige JavaScript-Dateien
application/x-latex *.latex Latex-Quelldateien
application/x-macbinary *.bin Macintosh Binärdateien
application/x-mif *.mif FrameMaker Interchange Format Dateien
application/x-netcdf *.nc *.cdf Unidata CDF-Dateien
application/x-nschat *.nsc NS Chat-Dateien
application/x-sh *.sh Bourne Shellscript-Dateien
application/x-shar *.shar Shell-Archiv-Dateien
application/x-shockwave-flash *.swf *.cab Flash Shockwave-Dateien
application/x-sprite *.spr *.sprite Sprite-Dateien
application/x-stuffit *.sit Stuffit-Dateien
application/x-supercard *.sca Supercard-Dateien
application/x-sv4cpio *.sv4cpio CPIO-Dateien
application/x-sv4crc *.sv4crc CPIO-Dateien mit CRC
application/x-tar *.tar tar-Archivdateien
application/x-tcl *.tcl TCL Scriptdateien
application/x-tex *.tex TEX-Dateien
application/x-texinfo *.texinfo *.texi TEXinfo-Dateien
application/x-troff *.t *.tr *.roff TROFF-Dateien (Unix)
application/x-troff-man *.man *.troff TROFF-Dateien mit MAN-Makros (Unix)
application/x-troff-me *.me *.troff TROFF-Dateien mit ME-Makros (Unix)
application/x-troff-ms *.me *.troff TROFF-Dateien mit MS-Makros (Unix)
application/x-ustar *.ustar tar-Archivdateien (Posix)
application/x-wais-source *.src WAIS Quelldateien
application/x-www-form-urlencoded HTML-Formulardaten an CGI
application/zip *.zip ZIP-Archivdateien
audio/basic *.au *.snd Sound-Dateien
audio/echospeech *.es Echospeed-Dateien
audio/tsplayer *.tsi TS-Player-Dateien
audio/voxware *.vox Vox-Dateien
audio/x-aiff *.aif *.aiff *.aifc AIFF-Sound-Dateien
audio/x-dspeeh *.dus *.cht Sprachdateien
audio/x-midi *.mid *.midi MIDI-Dateien
audio/x-mpeg *.mp2 MPEG-Dateien
audio/x-pn-realaudio *.ram *.ra RealAudio-Dateien
audio/x-pn-realaudio-plugin *.rpm RealAudio-Plugin-Dateien
audio/x-qt-stream *.stream -Dateien
audio/x-wav *.wav Wav-Dateien
drawing/x-dwf *.dwf Drawing-Dateien
image/cis-cod *.cod CIS-Cod-Dateien
image/cmu-raster *.ras CMU-Raster-Dateien
image/fif *.fif FIF-Dateien
image/gif *.gif GIF-Dateien
image/ief *.ief IEF-Dateien
image/jpeg *.jpeg *.jpg *.jpe JPEG-Dateien
image/tiff *.tiff *.tif TIFF-Dateien
image/vasa *.mcf Vasa-Dateien
image/vnd.wap.wbmp *.wbmp Bitmap-Dateien (WAP)
image/x-freehand *.fh4 *.fh5 *.fhc Freehand-Dateien
image/x-portable-anymap *.pnm PBM Anymap Dateien
image/x-portable-bitmap *.pbm PBM Bitmap Dateien
image/x-portable-graymap *.pgm PBM Graymap Dateien
image/x-portable-pixmap *.ppm PBM Pixmap Dateien
image/x-rgb *.rgb RGB-Dateien
image/x-windowdump *.xwd X-Windows Dump
image/x-xbitmap *.xbm XBM-Dateien
image/x-xpixmap *.xpm XPM-Dateien
message/external-body Nachricht mit externem Inhalt
message/http HTTP-Headernachricht
message/news Newsgroup-Nachricht
message/partial Nachricht mit Teilinhalt
message/rfc822 Nachricht nach RFC 1822
model/vrml *.wrl Visualisierung virtueller Welten
multipart/alternative mehrteilige Daten gemischt
multipart/byteranges mehrteilige Daten mit Byte-Angaben
multipart/digest mehrteilige Daten / Auswahl
multipart/encrypted mehrteilige Daten verschlüsselt
multipart/form-data mehrteilige Daten aus HTML-Formular (z.B. File-Upload)
multipart/mixed mehrteilige Daten gemischt
multipart/parallel mehrteilige Daten parallel
multipart/related mehrteilige Daten / verbunden
multipart/report mehrteilige Daten / Bericht
multipart/signed mehrteilige Daten / bezeichnet
multipart/voice-message mehrteilige Daten / Sprachnachricht
text/comma-separated-values *.csv komma-separierte Datendateien
text/css *.css CSS Stylesheet-Dateien
text/html *.htm *.html *.shtml -Dateien
text/javascript *.js JavaScript-Dateien
text/plain *.txt reine Textdateien
text/richtext *.rtx Richtext-Dateien
text/rtf *.rtf Microsoft RTF-Dateien
text/tab-separated-values *.tsv tabulator-separierte Datendateien
text/vnd.wap.wml *.wml WML-Dateien (WAP)
application/vnd.wap.wmlc *.wmlc WMLC-Dateien (WAP)
text/vnd.wap.wmlscript *.wmls WML-Scriptdateien (WAP)
application/vnd.wap.wmlscriptc *.wmlsc WML-Script-C-dateien (WAP)
text/xml-external-parsed-entity extern geparste XML-Dateien
text/x-setext *.etx SeText-Dateien
text/x-sgml *.sgm *.sgml SGML-Dateien
text/x-speech *.talk *.spc Speech-Dateien
video/mpeg *.mpeg *.mpg *.mpe MPEG-Dateien
video/quicktime *.qt *.mov Quicktime-Dateien
video/vnd.vivo *viv *.vivo Vivo-Dateien
video/x-msvideo *.avi Microsoft AVI-Dateien
video/x-sgi-movie *.movie Movie-Dateien
workbook/formulaone *.vts *.vtts FormulaOne-Dateien
x-world/x-3dmf *.3dmf *.3dm *.qd3d *.qd3 3DMF-Dateien
x-world/x-vrml *.wrl VRML-Dateien

[转载于cnjm]

http://www.cnjm.net/tech/article960.html

在实际开发MOTO的产品的时候，会遇到一些细节问题。很烦人，但是往往难到不少人。下面就是我从自己实际开发经历中获得的一些问题的解决。
1. Motorola V系列的J2ME的图标显示
Motorola的V系列手机j2me程序图标大小必须是15*15的大小.而且必须在MIDlet-Icon中填出图标名字.不能只在MIDlet-1中填写.Nokia的手机的确只填写这里就可以了.

2. 存储空间的限制问题
Motorola的手机的RMS存储空间如果不在MIDlet-Data-Size中具体给出,那么默认的就只有8K还是12K,我记不清楚了。所以，必须再MIDlet-Data-Size中给出具体的RMS需要大小。一般MOTO的手机，最大支持64K的RMS空间。
3.Motorola的网络下载问题
在中国卖的MOTO的手机，网络连接点都是默认固定到CMWAP上的。所以，一般的J2ME网络连接的方法，是无法通过CMWAP的网关的。解决的办法有两个。
1）更改手机上的连接点。其实你只要自己随便建立一个新的连接点，什么信息都不用填写，然后将默认的连接点设置在上面，它就可以自动成为CMNET连接点。那么一般的J2ME网络访问方式就可以了。
2）采用CMWAP的连接方式。这个就要求程序上有所改动了。
比如我要下载这样一个数据文件: http://211.136.87.234/1.png
那么其代码方式就是:
c= (HttpConnection)Connector.open("http://10.0.0.172:80/1.png,Connector.READ,true);
c.setRequestProperty("X-Online-Host", "211.136.87.234");
c.setRequestProperty("Accept", "*/*");
is = c.openInputStream();
10.0.0.172是移动的CMWAP网关。

4.使用WTK104打包的时候没有MIDP2.0的支持.

移动的百宝箱的测试的时候，建议最好使用WTK打包，这样，CLASS文件调用的API最纯净。但是MOTO的手机大部分都是MIDP2.0的，而WTK104只支持MIDP1.0。打包的时候会出现错误。
解决的办法和NOKIA的一样。手动把几个MIDP2.0的API加到WTK里面的lib\midpapi.zip和wtklib\emptyapi.zip里面。用WinRar软件，直接从MOTO的SDK中，拖进去就可以了。

原作：http://www.javaeye.com/topic/44418     作者：wuhua

在j2medev上见到一篇关于CMNET和CMWAP网络连接。   现在我根据我的实际经验总结下它们。
1。CMNET，这个就不用怎么样介绍了，跟电脑上Internet没什么区别。
直接用这个这样的代码就Ok了

java 代码

1. try {  
2.              http = (HttpConnection) Connector.open(url);  
3.         } catch (IOException e) {  
5.             e.printStackTrace();  
6. }  

2。CNWAP，这个我的实践结果根网上的很多介绍不同。看下面这段文字。下面摘自。在J2ME中使用CNWAP接入点联网

都是中国移动搞出来的事情。

所以对于特定的一些机型，普通的直接联网方式会出现连不上网络，这是因为你的手机设备不支持CMNET的联网方式。也许你会发现不经过修改，直接连接的方式也可以在一些cnwap的设备上（只支持cnwap的多为低端机）运行，这个是因为设备上应中国一定的要求，在系统底层进行了转换，如果没有转换的话，就必须你自己手动在代码里面显式的来转换了。

这里我只打算给出一些示意代码，用来辅助说明解决问题的方法

假设你原来要请求的页面是：htpp://www.testwap.com/test/try.jsp

那么你会用这句话连接

HttpConnection httpConnection = (HttpConnection)Connector.open(“http://www.testwap.com/test/try.jsp”);

但是为了转成CNWAP的联网形式 你必须这么写

HttpConnection httpConnection = (HttpConnection)Connector.open(“http://10.0.0.172:80/test/try.jsp”);

接着再写

httpConnection.setRequestProperty("X-Online-Hostwww.testwap.com");
httpConnection.setRequestProperty("Accept","*/*"); 

这样就ok了

不过这个方法在模拟器上没办法测试，因为模拟器移动网关不让你进啊，所以写代码的时候用cmnet的正式发布的时候改成cnwap的。很麻烦
代码是

java 代码

1. http =(HttpConnection)Connector.open("http://10.0.0.172:80/"+url,Connector.READ,true);  
3.      c.setRequestProperty("X-Online-Host",ServerName);  
5.      c.setRequestProperty("Accept", "*/*");  

上面的代码CMNET我试过，因为我那个足球项目需要采用Scoket，确实是只有CMNET能打开Socket。
第二种，我却意外发现，我开发WapExporer进行测试的时候，我没有采用代理，也可以获取连接。
分析有以下几种可能。
1.移动那边可能对于CMNET来说，几乎是对所有的协议进行开放。比如（Socket，Http）跟所有端口。
2.对于CNWAP，我估计只开放http协议以及80端口，其他的都封闭，也就是CNWAP只能访问http协议。
   由于我测试的IP地址进行测试，所以它可以直接找到。对于非IP地址我没测试果。也许CNWAP不能解释域名也说不定，这点我就不清楚了。