手机终端开发相关技巧收集

最新推荐文章于 2025-11-20 19:00:40 发布

原创最新推荐文章于 2025-11-20 19:00:40 发布 · 2.3k 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#手机 #终端 #string #socket #header #opera

手机开发专栏收录该内容

10 篇文章

订阅专栏

手机终端开发相关技巧

GPRS: Opera + Proxomitron

1. ProxN45J.zip 解压后创建一个 Proxomitron.exe 桌面快捷方式。

2. Opera(9.20) http、https 代理服务器 127.0.0.1 端口 80，并选上为代理启用 http 1.1

3. 在 Opera 地址栏输入 opera:config，查找 http accept charset，删除其内容，保存。

运行 Proxomitron、Opera 浏览网页基本都可以了、比较快。xml 解析错误、乱码、淘宝...

不同地区 Proxomitron 设置可能有所不同。

较好的方法是 TCP tunnel for HTTP proxies，ccproxy、httport、desproxy 都可以，有的地区因 tcp socket 大小的限制（内建的 socks 4 是有缺陷的），少数页面不能完整打开，不可下载用。例如可用此方法先登陆论坛，正确 cookie 后再使用第一种方法登陆，此外 windows messenger、tm...

物尽其凑合用吧...

nokia 的模拟器
nS60_jme_sdk_3rd_e_FP1.zip
j2me_wireless_toolkit-2_2-ml-windows.exe

装上飞信等

如果java 可以，可以自己写个代理
这样想改什么头就可以改什么头了
个Proxomitron.exe
cmwap的头有什么特征，我只在书上看到过
网上查得到的，联通和移动的都不一样

1.JDK

当前版本

http://java.sun.com/javase/downloads/index.jsp

原来版本

http://java.sun.com/javase/downloads/previous.jsp

2.WTK

当前版本

http://java.sun.com/javame/downloads/index.jsp

原来版本

http://java.sun.com/javame/downloads/previous.jsp

3.索爱WTK

SE WTK 2.2.4

http://ftpapp.kpimdp.com/StreamD ... %0AwNpNmS3Ldg%3D%3D

4.摩托罗拉SDK

Motorola J2ME SDK v6.4 for Motorola OS Products

https://developer.motorola.com/docstools/sdks/motorola64/motorola_64_SDK.zip/

5.三星

http://developer.samsungmobile.com/Developer/resources/board_list.jsp

6.诺基亚

开发者套件

http://forum.nokia.com/info/sw.n ... e-aa5cd26be54e.html

原型SDK

http://www.im.cyu.edu.tw/tech/hcchiu/J2ME/doc/nptsdk_jme_v4_0.zip

Carbide.j 1.5

http://forum.nokia.com/info/sw.n ... e-aa5cd26be54e.html

S40

http://forum.nokia.com/info/sw.nokia.com/id/cc48f9a1-f5cf-447b-bdba-c4d41b3d05ce/Series_40_Platform_SDKs.html

S60 SDK（如果是第二版，看清小版本号，不要下错了！）

http://forum.nokia.com/info/sw.n ... an_OS_for_Java.html

第一版

用户名：shuijingtiantang

密码：jGTvNIDXSW5oQcnQWFqGb+GVx7g=

第三版

用户名：shuijingtiantang

密码：WS8VDABut6BgEW1S1XnTAVLyL5w=

S60 3rd Edition FP1

http://sw.nokia.com/id/02055bc6-76c6-4bf3-adc6-216b9de0514e/nS60_jme_sdk_3rd_e_FP1.zip

7210 SDK

http://sw.nokia.com/id/74104661- ... 10_jme_sdk_v1_0.zip

用户名：shuijingtiantang

密码：qJt2AJgHGtAdbN3HEmjAa5RwD88=

7.Netbeans

http://www.netbeans.info/downloads/start.php

8.Eclipse & EcliseMe

Eclipse

http://www.eclipse.org/downloads/

EclipseMe

http://sourceforge.net/project/showfiles.php?group_id=86829

java 实现Http代理

我们将会使用最原始的想法来介绍整个流程，我们觉得下一步程序该做什么，我们才会写什么样的代码，而不是一开始就把所有的问题都想到，然后画出流程图，那样的方式对于我们去一个从来没写过的程序来说比较难，我们用最简单的方式来思考问题。
前面，我们已经拿到了HttpRequest对象，这个是我们自己封装出来的对象，那么接下来的事情应该是我们根据这个请求对象，把请求发给真正的主机，然后呢，我们从真正的主机那里拿到响应，再把响应发给原始的客户机，这样我们中转的功能就完成了，流程比较简单。
接下来我们写一个Dispatcher得类用于完成转发：
package com.icss.http.server.proxy;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.InetAddress;
import java.net.MalformedURLException;
import java.net.Socket;
import java.net.URL;
import com.icss.http.HttpRequest;
import com.icss.http.HttpResponse;
import com.icss.http.HttpResponseFactory;

/**
*
* Title: Dispatcher
* Description: 
* Copyright: Copyright (c) 2006
* Company: 中软国际
* @author chenyankui
* @version 1.0
*/
public class Dispatcher
{
 public String host = null;
 public int port = 80;

 private HttpProxyServer httpProxyServer = null;

 public Dispatcher(){}

 /**
 *
 * @param host
 * @param port
 */
 public Dispatcher(HttpProxyServer hps, String _host, int _port)
 {
 this.host = _host;
 this.port = _port;
 this.httpProxyServer = hps;
 }

 /**
 *
 * @param request - void
 * @author: chenyankui
 */
 public void dispatch(HttpRequest request)
 {
 Socket socket = null;

 try
 {
 socket = this.createSocket(host, port);

 InputStream socketInputStream = socket.getInputStream();
 OutputStream socketOutputStream = socket.getOutputStream();

 this.request(request, socketOutputStream);

 HttpResponse httpResponse = HttpResponseFactory.read(socketInputStream, socketOutputStream);

 this.resonse(httpResponse, request.getOutputStream());
 }
 catch(IOException e)
 {
 System.out.println("Warning: " + e.getMessage());
 }
 finally
 {
 if(socket != null)
 {
 try
 {
 socket.close();
 }
 catch(IOException e){}
 }
 }
 }

 /**
 *
 * @param request
 * @throws IOException
 * @author: chenyankui
 */
 private void request(HttpRequest request, OutputStream outputStream) throws IOException
 {
 /* 对请求头进行修改 */
 this.updateHttpRequest(request);

 String headers = request.toString();

 System.out.print("------------------ 修改后的请求头 ------------------/r/n" + headers);

 /* 写请求头 */
 outputStream.write(headers.getBytes());

 /* 将输入数据传输到服务器 */
 ContentPump.pumpContentStream(request.getInputStream(), outputStream, request.getContentLength());
 }

 /**
 *
 * @param response
 * @throws IOException - void
 * @author: chenyankui
 */
 private void resonse(HttpResponse response, OutputStream outputStream) throws IOException
 {
 /* 修改响应头 */
 this.updateHttpResponse(response);

 String headers = response.toString();

 System.out.print("------------------ 修改后的响应头 ------------------/r/n" + headers);

 outputStream = new com.icss.io.PoolOutputStream(new OutputStream[]{outputStream, System.out});

 /* 写响应头 */
 outputStream.write(headers.getBytes());

 /* 是否使用Chunk */
 if(response.getHeader("Transfer-Encoding") != null)
 {
 InputStream inputStream = response.getInputStream();

 ChunkedPump.pumpChunkedStream(inputStream, outputStream);
 }
 else
 {
 InputStream inputStream = response.getInputStream();

 ContentPump.pumpContentStream(inputStream, outputStream, response.getContentLength());
 }

 outputStream.flush();
 }

 /**
 *
 * @param host
 * @param port
 * @return
 * @throws IOException - Socket
 * @author: chenyankui
 */
 private Socket createSocket(String host, int port) throws IOException
 {
 InetAddress inetAddress = InetAddress.getByName(host);

 return new Socket(inetAddress, port);
 }

 /**
 *
 * @param _host
 * @param _port
 * @return - String
 * @author: chenyankui
 */
 private String getHostPort(String _host, int _port)
 {
 if(_port > 0 && _port < 65536 && _port != 80)
 {
 _host += ":" + _port;
 }

 return _host;
 }

 /**
 *
 * @param request - void
 * @author: chenyankui
 */
 private void updateHttpRequest(HttpRequest request)
 {
 String header = request.getHeader("Host");

 if(header != null)
 {
 request.setHeader("Host", getHostPort(this.host, this.port));
 }

 header = request.getHeader("Referer");

 if(header != null)
 {
 header = this.replaceHostPort(header, this.host, this.port);

 request.setHeader("Referer", header);
 }
 }

 /**
 *
 * @param response - void
 * @author: chenyankui
 */
 private void updateHttpResponse(HttpResponse response)
 {
 String header = response.getHeader("Location");

 if(header != null)
 {
 header = this.replaceHostPort(header, httpProxyServer.getHost(), httpProxyServer.getPort());

 response.setHeader("Location", header);
 }
 }

 /**
 *
 * @param srcUrl
 * @param _host
 * @param _port
 * @return - String
 * @author: chenyankui
 */
 private String replaceHostPort(String srcUrl, String _host, int _port)
 {
 try
 {
 URL url = new URL(srcUrl);

 String path = url.getPath();
 String query = url.getQuery();

 if(query != null && query.length() > 0)
 {
 path += "?" + query;
 }

 if(_port > 0 && _port < 65536 && _port != 80)
 {
 _host += ":" + _port;
 }

 return "http://" + _host + path;
 }
 catch(MalformedURLException e)
 {
 e.printStackTrace();
 }

 return srcUrl;
 }

    protected String getHost()
    {
        return this.host;
    }

    protected void setHost(String host)
    {
        this.host = host;
    }

    protected int getPort()
    {
        return this.port;
    }

    protected void setPort(int port)
    {
        this.port = port;
    }

    protected HttpProxyServer getHttpProxyServer()
    {
        return this.httpProxyServer;
    }

    protected void setHttpProxyServer(HttpProxyServer httpProxyServer)
    {
        this.httpProxyServer = httpProxyServer;
    }

    public static void main(String[] args)
    {
        Dispatcher d = new Dispatcher();

        String x = null;

        x = d.replaceHostPort("http://127.0.0.1:8080", "192.168.1.6", 7272);

        System.out.println(x);

        x = d.replaceHostPort("http://127.0.0.1:8080/", "192.168.1.6", 7272);

        System.out.println(x);

        x = d.replaceHostPort("http://127.0.0.1:8080/test.jsp", "192.168.1.6", 7272);

        System.out.println(x);
    }
}