Android中如何搭建一个WebServer
今天终于把老大交代的任务搞完了，感觉收获挺多的，所以就写一篇来记录一下吧，首先还是来看一下，老大们的需求
需求：
希望移动端的用户标识(IMEI)和HTML页面的用户标识(Cookie)连接起来，其中HTML页面可能是用户使用PC访问指定的html页面也有可能是移动端使用浏览器访问html页面
技术解决：
运用移动设备的系统特型，用Apps的Service监听本地的网络端口，当局域网内或本机的Html页面通过请求调用本地IP:Port时触发监听。Apps在将当前Html的Cookie和移动设备标识物发回服务端时，即实现了本次PC/Mobile Html页面的Cookie和移动设备的互相绑定。
具体实现方案之多端通信技术方案
各模块细节
1.Native App(移动端的app)：
1).跟随主服务常驻内存，在收到当前网络环境为Wifi事件后，启动HttpServer。
(当前网络切换成3G/2G等网络时关闭HttpServer)。
以上这步我们叫做注册:启动移动端的HttpServer的时候，我们会将移动设备的ip地址(内网地址)发送到指定的后台Server上
2).收到从Web来的http请求后，往Server发送绑定请求，这时候就将移动端的IMEI和HTML中的Cookie一起上传到指定的Server上
例如：
http://serverhost/?cookie=123213&imei=31233213123
以上这步我们叫做一次绑定的完成操作
以为我们是在移动端开始一个HttpServer的，所以要考虑一些额外的因素，比如耗电量
风险控制：使用灰度测试规则，并使用开关限制功能。
功耗风险：经过三台设备测试，电量消耗忽略不计（具体CPU使用时间在统计）。
2.Web JS：
1).加载页面加载后先从CDN加载一个静态的JS到此页面。
2).静态JS再请求Server 获取一段动态JS用以做本地Ping。
(如果此IP已有N次获取，则考虑>N的节点是一个大型公共网络，则把此公共IP加入黑名单，不再返回动态JS)
3).获得动态JS后直接Ping本地的HttpServer。
(Ping的IP/Port会随着动态JS一起下发)
这里我们是在Html页面中使用JS脚本来处理传递Cookie给移动端的功能。
3.Bridge Server：
1).Sever选型：Node.js
同时考虑到开发效率，性能，和client的JS的契合度。
Node.js单台16核服务器，4节点，QPS经测试能到6k-8k。
较适合短频非阻塞的请求。
2).数据存储：Redis
考虑到NativeApp的外网IP时效性，以及对于短频请求的快速应答。
以外网IP为Key，各个IP为Value。每天清理一次外网IP。
存储格式：{外网IP：{NativeApp IP/Port, .........}}
3).移动端所需要的接口
接口一：Native App 对于本外网IP的注册的请求。
接口二：Navtive App的绑定请求。
具体原理图：
上面讲解了一下技术的实现方案，下面我们就来看一下，具体的实现技术
首先来看移动端的，我们需要建立一个HttpServer
我们可能知道在PC端建立一个Server很简单，直接使用Tomcat服务器就可以了，但是我们移动端不可能去搭建一个服务器的，那么我们该怎么办呢？我们可以在网上搜索一下关于如何在手机中搭建一个WebServce，我们可以看到Apache已经帮我们做好了这件事了，他提供了一个jar，有相应的api，同时还有一种技术就是老外有个人写好了一个类：NanoHttpd，我们只需要看懂这个类，然后自己在编写一个类，继承这个类即可，因为这个类是抽象的。这两种搭建的Server原理都是很简单的，就是建立一个Socket连接，这个和Tomcat是一样的，只是他们将这种操作进行优化处理了，那么我们首先来看一下Apache给我们提供的这个HttpServer：
按照上面的技术方案，我们希望这个HttpServer常驻在一个服务中进行监听的，所以我们需要建立一个Service
package com.sohu.tests;import java.io.IOException;import org.apache.http.client.ClientProtocolException;import android.app.Service;import android.content.BroadcastReceiver;import android.content.Context;import android.content.Intent;import android.content.IntentFilter;import android.net.ConnectivityManager;import android.os.IBinder;import android.util.Log;public class SocketService extends Service { private int port = Consts.defaultPort; //网络开关状态改变的监听 private BroadcastReceiver receiver = new BroadcastReceiver() { @Override public void onReceive(Context context, Intent intent) { if(intent.getAction().equals(ConnectivityManager.CONNECTIVITY_ACTION)){ AppListYPLog.e("DEMO","网络状态切换..."); //注册接口 new Thread(){ @Override public void run(){ //开始注册 register(); } }.start(); } } }; @Override public IBinder onBind(Intent arg0) { return null; } @Override public void onCreate() { super.onCreate(); Log.v("23233", "Complete"); Utils.init(this); //开启监听端口 HttpServer hs = new HttpServer(); try{ AppListYPLog.i("监听开启..."); for(int i=0;i<Consts.portAry.length;i++){ if(Utils.checkPort(Consts.portAry[i])){ port = Consts.portAry[i]; break; } } hs.execute(port); register(); }catch(Exception e){ AppListYPLog.e("异常:"+e.getMessage()); } //注册广播 IntentFilter filter = new IntentFilter(); filter.addAction(ConnectivityManager.CONNECTIVITY_ACTION); registerReceiver(receiver, filter); } /** * 注册ip地址 * @return */ public boolean register(){ //拼接参数 StringBuilder param = new StringBuilder(); param.append("imei="); param.append(Utils.getImeiInfo()); param.append("&hs_ip="); param.append(Utils.getLocalHostIp()+":"+port); param.append("&route_mac="); param.append(Utils.getRouteMac()); param.append("&route_ssid="); param.append(Utils.getRouteSSID()); param.append("&timetag="); param.append(System.currentTimeMillis()+""); boolean flag = false; //上报数据 if(Utils.checkNetWorkState()){ try { flag = NetUtils.uploadRequest(Consts.registerUrl, param.toString()); if(flag){ AppListYPLog.i("注册操作成功"); //Toast.makeText(getApplicationContext(), "注册成功", Toast.LENGTH_LONG).show(); }else{ AppListYPLog.e("注册操作失败"); //Toast.makeText(getApplicationContext(), "注册失败", Toast.LENGTH_LONG).show(); } } catch (ClientProtocolException e) { AppListYPLog.e("异常:"+e.getMessage()+",注册失败"); } catch (IOException e) { AppListYPLog.e("异常:"+e.getMessage()+",注册失败"); } catch(Exception e){ AppListYPLog.e("异常:"+e.getMessage()+",注册失败"); } } return flag; } }imei:手机移动的标识
hs_ip:手机的HttpServer的地址和端口号
route_mac:手机连接的路由器的mac地址
route_ssid:手机连接的路由器的ssid
timetag:注册的时间戳
同时我们还注册了一个监听网络变化的广播，这个是为了防止，开始的时候用户没有开启网络，一旦用户开启网路的时候，我们就开启监听并且进行注册。
这里我们使用的监听端口是3个，因为我们知道，端口最大的是655535，0-1024是系统使用的，所以我们就使用了三个备用的端口，在使用这个端口之前要检测一下该端口有没有被占用，这里我们就使用Socket探针技术。
首先我们需要下载Apache提供的jar包：
http://download.****.net/detail/jiangwei0910410003/7431829
代码：
package com.sohu.tests;import java.io.IOException; import java.io.InterruptedIOException; import java.net.ServerSocket; import java.net.Socket; import java.util.Locale; import java.util.Map;import org.apache.http.ConnectionClosedException; import org.apache.http.HttpException; import org.apache.http.HttpRequest; import org.apache.http.HttpResponse; import org.apache.http.HttpResponseInterceptor; import org.apache.http.HttpServerConnection; import org.apache.http.HttpStatus; import org.apache.http.MethodNotSupportedException; import org.apache.http.entity.StringEntity; import org.apache.http.impl.DefaultConnectionReuseStrategy; import org.apache.http.impl.DefaultHttpResponseFactory; import org.apache.http.impl.DefaultHttpServerConnection; import org.apache.http.params.BasicHttpParams; import org.apache.http.params.CoreConnectionPNames; import org.apache.http.params.CoreProtocolPNames; import org.apache.http.params.HttpParams; import org.apache.http.protocol.BasicHttpContext; import org.apache.http.protocol.HttpContext; import org.apache.http.protocol.HttpProcessor; import org.apache.http.protocol.HttpRequestHandler; import org.apache.http.protocol.HttpRequestHandlerRegistry; import org.apache.http.protocol.HttpService; import org.apache.http.protocol.ImmutableHttpProcessor; import org.apache.http.protocol.ResponseConnControl; import org.apache.http.protocol.ResponseContent; import org.apache.http.protocol.ResponseDate; import org.apache.http.protocol.ResponseServer; public class HttpServer { //获取来访者的ip地址 private static String ipAddress = ""; //开启监听 public void execute(int port) throws Exception{ Thread t = new RequestListenerThread(port); t.setDaemon(false); t.start(); } //自定义HttpRequest的处理类，我们需要继承HttpRequestHandler接口 static class WebServiceHandler implements HttpRequestHandler { public WebServiceHandler() { super(); } //在这个方法中我们就可以处理请求的业务逻辑 public void handle(final HttpRequest request, final HttpResponse response, final HttpContext context) throws HttpException, IOException { //获取请求方法 String method = request.getRequestLine().getMethod().toUpperCase(Locale.ENGLISH); //获取请求的uri String target = request.getRequestLine().getUri(); Map<String,String> params = Utils.getParam(target); //拼接参数 StringBuilder param = new StringBuilder(); param.append("cookie="); if(params.get("cookie") != null){ param.append(params.get("cookie")); } param.append("&imei="); param.append(Utils.getImeiInfo()); param.append("&visitor_ip="); param.append(ipAddress); param.append("&local_ip="); param.append(Utils.getLocalHostIp()); param.append("&route_mac="); param.append(Utils.getRouteMac()); param.append("&route_ssid="); param.append(Utils.getRouteSSID()); param.append("&timetag="); param.append(System.currentTimeMillis()+""); //上报数据 try{ if(Utils.checkNetWorkState()){ boolean flag = NetUtils.uploadRequest(Consts.cookieUrl, param.toString()); if(flag){ AppListYPLog.e("完成操作成功"); }else{ AppListYPLog.e("完成操作失败"); } } }catch(Exception e){ AppListYPLog.e("异常:"+e.getMessage()+"完成操作失败"); } //get请求方式(我们这里只处理get方式) if (method.equals("GET") ) { response.setStatusCode(HttpStatus.SC_OK); StringEntity entity = new StringEntity("Request Success!!"); response.setEntity(entity); } else if (method.equals("POST") ) { response.setStatusCode(HttpStatus.SC_OK); StringEntity entity = new StringEntity("Request Success!!"); response.setEntity(entity); } else { throw new MethodNotSupportedException(method + " method not supported"); } } } /** * 自定一个监听的线程 * @author weijiang204321 * */ static class RequestListenerThread extends Thread { private final ServerSocket serversocket; private final HttpParams params; private final HttpService httpService; public RequestListenerThread(int port) throws IOException { /**********************下面就是模板代码了***********************/ this.serversocket = new ServerSocket(port); HttpProcessor httpproc = new ImmutableHttpProcessor( new HttpResponseInterceptor[] { new ResponseDate(), new ResponseServer(), new ResponseContent(), new ResponseConnControl() }); this.params = new BasicHttpParams(); this.params .setIntParameter(CoreConnectionPNames.SO_TIMEOUT, 5000) .setIntParameter(CoreConnectionPNames.SOCKET_BUFFER_SIZE,8 * 1024) .setBooleanParameter(CoreConnectionPNames.STALE_CONNECTION_CHECK, false) .setBooleanParameter(CoreConnectionPNames.TCP_NODELAY, true) .setParameter(CoreProtocolPNames.ORIGIN_SERVER,"HttpComponents/1.1"); //这只请求头信息 HttpRequestHandlerRegistry reqistry = new HttpRequestHandlerRegistry(); //WebServiceHandler用来处理webservice请求,这里我们可以注册多个处理器Handler的 reqistry.register("*", new WebServiceHandler()); this.httpService = new HttpService(httpproc, new DefaultConnectionReuseStrategy(), new DefaultHttpResponseFactory()); httpService.setParams(this.params); //为http服务设置注册好的请求处理器。 httpService.setHandlerResolver(reqistry); } @Override public void run() { AppListYPLog.i("Listening on port " + this.serversocket.getLocalPort()); AppListYPLog.i("Thread.interrupted = " + Thread.interrupted()); while (!Thread.interrupted()) { try { // 建立Http连接 Socket socket = this.serversocket.accept(); DefaultHttpServerConnection conn = new DefaultHttpServerConnection(); ipAddress = socket.getInetAddress().getHostAddress(); AppListYPLog.i("Incoming connection from " + socket.getInetAddress()); conn.bind(socket, this.params); //开启工作线程 Thread t = new WorkerThread(this.httpService, conn); t.setDaemon(true); t.start(); } catch (InterruptedIOException ex) { AppListYPLog.e("异常:InterruptedIOException"); break; } catch (IOException e) { AppListYPLog.e("I/O error initialising connection thread: " + e.getMessage()); break; } } } } /** * 后台工作线程 * @author weijiang204321 * */ static class WorkerThread extends Thread { private final HttpService httpservice; private final HttpServerConnection conn; public WorkerThread(final HttpService httpservice,final HttpServerConnection conn) { super(); this.httpservice = httpservice; this.conn = conn; } @Override public void run() { System.out.println("New connection thread"); HttpContext context = new BasicHttpContext(null); try { while (!Thread.interrupted() && this.conn.isOpen()) { this.httpservice.handleRequest(this.conn, context); } } catch (ConnectionClosedException ex) { System.err.println("Client closed connection"); } catch (IOException ex) { System.err.println("I/O error: " + ex.getMessage()); } catch (HttpException ex) { System.err.println("Unrecoverable HTTP protocol violation: "+ ex.getMessage()); } finally { try { this.conn.shutdown(); } catch (IOException ignore) { } } } } } 我们首先需要定义一个RequestHander用来处理请求的逻辑结果，同时我们需要建立一个HttpConnection,这里我们需要获取来访者的ip地址，所以我们定义了一个全局的变量ipAddress,然后在WebServiceHandler类中的handle方法中进行上报完成的动作，需要上报的参数为：
cookie:来访者携带的cookie值(也就是Html页面中的cookie)
imei:手机的移动标识
visitor_ip:来访者的ip地址
local_ip:本机的ip地址
route_mac:手机连接的路由器的地址
route_ssid:手机连接的路由器的ssid
timetag:上报的时间戳
下面再来看一下辅助类
Utils:
package com.sohu.tests;import java.io.IOException;import java.net.InetAddress;import java.net.NetworkInterface;import java.net.Socket;import java.net.SocketException;import java.net.UnknownHostException;import java.util.Enumeration;import java.util.HashMap;import java.util.Map;import org.apache.http.conn.util.InetAddressUtils;import android.content.Context;import android.net.ConnectivityManager;import android.net.NetworkInfo;import android.net.wifi.WifiInfo;import android.net.wifi.WifiManager;import android.telephony.TelephonyManager;import android.text.TextUtils;/** * 工具类 * * @author weijiang204321 * */public class Utils { public static Context mContext; public static void init(Context context) { mContext = context; } /** * * @param str * @return 字符串是否为空 */ public static boolean isNotEmpty(String str) { if (str != null && !"".equals(str)) { return true; } return false; } /** * 获取手机的Mac地址 * * @return */ public static String getMacAddress() { String result = ""; try { WifiManager wifiManager = (WifiManager) mContext.getSystemService(Context.WIFI_SERVICE); WifiInfo wifiInfo = wifiManager.getConnectionInfo(); result = wifiInfo.getMacAddress(); } catch (Exception e) { result = ""; } return result; } /** * 获取手机的imei * * @return */ public static String getImeiInfo() { try { TelephonyManager mTm = (TelephonyManager) mContext.getSystemService(Context.TELEPHONY_SERVICE); return mTm.getDeviceId(); } catch (Exception e) { e.printStackTrace(); return ""; } } /** * 获取手机的imsi * * @return */ public static String getImsiInfo() { try { String imsi = ""; TelephonyManager telephonyManager = (TelephonyManager) mContext.getSystemService(Context.TELEPHONY_SERVICE); if (telephonyManager != null) { imsi = telephonyManager.getSubscriberId(); } if (TextUtils.isEmpty(imsi)) { imsi = "UNKNOWN"; } return imsi; } catch (Exception e) { return ""; } } /** * 获取手机型号 * * @return */ public static String getTypeInfo() { return android.os.Build.MODEL; // 手机型号 } /** * 获取手机系统版本 * * @return */ public static String getOsVersion() { return android.os.Build.VERSION.RELEASE; } /** * 获取路由器的SSID * * @return */ public static String getRouteSSID() { try { WifiManager wm = (WifiManager) mContext.getSystemService(Context.WIFI_SERVICE); WifiInfo info = wm.getConnectionInfo(); if(info.getSSID().contains("<")){ return ""; }else{ return info.getSSID().replace("\"","") + ""; } } catch (Exception e) { AppListYPLog.e("异常:" + e.getMessage() + ",获取SSID失败!"); return ""; } } /** * 获取路由器的Mac地址 * * @return */ public static String getRouteMac() { try { WifiManager wm = (WifiManager) mContext.getSystemService(Context.WIFI_SERVICE); WifiInfo info = wm.getConnectionInfo(); if(info.getBSSID() == null){ return ""; }else{ return info.getBSSID() + ""; } } catch (Exception e) { AppListYPLog.e("异常:" + e.getMessage() + ",获取Mac地址失败!"); return ""; } } /** * 解析uri参数 * @param uri * @return */ public static Map<String,String> getParam(String uri){ Map<String,String> params = new HashMap<String,String>(); try{ if(isNotEmpty(uri)){ String subStr = uri.substring(uri.indexOf("?")+1); String[] ary = subStr.split("&"); for(int i=0;i<ary.length;i++){ String[] temp = ary[i].split("="); if(temp.length<2){ params.put(temp[0], ""); }else{ params.put(temp[0], temp[1]); } } return params; }else{ return null; } }catch(Exception e){ return null; } } /** * 判断网络 * @param ctx * @return */ public static boolean checkNetWorkState() { boolean isnetwork = false; ConnectivityManager connManager = (ConnectivityManager) mContext.getSystemService(Context.CONNECTIVITY_SERVICE); NetworkInfo info = connManager.getActiveNetworkInfo(); if (info != null && (info.isAvailable() || info.isConnected())) { isnetwork = true; } return isnetwork; } /** * 获取本机的ip * @return */ public static String getLocalHostIp(){ String ipaddress = ""; try{ Enumeration<NetworkInterface> en = NetworkInterface.getNetworkInterfaces(); // 遍历所用的网络接口 while (en.hasMoreElements()){ NetworkInterface nif = en.nextElement();// 得到每一个网络接口绑定的所有ip Enumeration<InetAddress> inet = nif.getInetAddresses(); // 遍历每一个接口绑定的所有ip while (inet.hasMoreElements()){ InetAddress ip = inet.nextElement(); if (!ip.isLoopbackAddress()&& InetAddressUtils.isIPv4Address(ip.getHostAddress())){ return ip.getHostAddress(); } } } }catch (SocketException e){ AppListYPLog.e("feige", "获取本地ip地址失败"); } return ipaddress; } /** * 检查端口port是否被占用了 * @param port * @return */ public static boolean checkPort(int port){ try{ InetAddress theAddress=InetAddress.getByName("127.0.0.1"); try { Socket theSocket = new Socket(theAddress,port); theSocket.close(); theSocket = null; theAddress = null; return false; }catch (IOException e) { AppListYPLog.e("异常:"+e.getMessage()+"检查端口号是否被占用"); }catch(Exception e){ AppListYPLog.e("异常:"+e.getMessage()+"检查端口号是否被占用"); } }catch(UnknownHostException e) { AppListYPLog.e("异常:"+e.getMessage()+"检查端口号是否被占用"); } return true; } }网络工具类NetUtils
package com.sohu.tests;import java.io.IOException;import java.util.ArrayList;import java.util.HashMap;import java.util.Iterator;import java.util.List;import java.util.Map.Entry;import java.util.Set;import org.apache.http.HttpResponse;import org.apache.http.NameValuePair;import org.apache.http.client.ClientProtocolException;import org.apache.http.client.HttpClient;import org.apache.http.client.entity.UrlEncodedFormEntity;import org.apache.http.client.methods.HttpGet;import org.apache.http.client.methods.HttpPost;import org.apache.http.impl.client.DefaultHttpClient;import org.apache.http.message.BasicNameValuePair;import org.apache.http.params.CoreConnectionPNames;import org.apache.http.params.HttpConnectionParams;import org.apache.http.params.HttpParams;import org.apache.http.protocol.HTTP;import org.apache.http.util.EntityUtils;public final class NetUtils { /** * 上传数据 * * @param url * @param param * @return */ public static String postData(String url, HashMap<String, String> param) { HttpPost httpPost = new HttpPost(url); // 设置HTTP POST请求参数必须用NameValuePair对象 List<NameValuePair> params = new ArrayList<NameValuePair>(); if (param != null) { Set<Entry<String, String>> set = param.entrySet(); Iterator<Entry<String, String>> iterator = set.iterator(); while (iterator.hasNext()) { Entry<String, String> tempEntry = iterator.next(); params.add(new BasicNameValuePair(tempEntry.getKey(), tempEntry.getValue())); } } else { AppListYPLog.e("DEMO:", "上传参数错误"); return null; } HttpResponse httpResponse = null; try { // 设置httpPost请求参数 httpPost.setEntity(new UrlEncodedFormEntity(params, HTTP.UTF_8)); HttpClient httpClient = new DefaultHttpClient(); // 请求超时 httpClient.getParams().setParameter(CoreConnectionPNames.CONNECTION_TIMEOUT, 20000); // 读取超时 httpClient.getParams().setParameter(CoreConnectionPNames.SO_TIMEOUT, 20000); httpResponse = httpClient.execute(httpPost); if (httpResponse.getStatusLine().getStatusCode() == 200) { // 第三步，使用getEntity方法活得返回结果 String result = EntityUtils.toString(httpResponse.getEntity()); return result; } } catch (ClientProtocolException e) { AppListYPLog.e("异常:" + e.getMessage()); return null; } catch (IOException e) { AppListYPLog.e("异常:" + e.getMessage()); return null; } return null; } /** * @return 通过Request方式曝光 */ public static boolean uploadRequest(String baseUrl, String param) throws ClientProtocolException, IOException { HttpGet httpGet = null; if (param != null && !"".equals(param)) { httpGet = new HttpGet(baseUrl + "?" + param); } else { httpGet = new HttpGet(baseUrl); } AppListYPLog.e("URL:"+httpGet.getURI()+""); HttpParams params = httpGet.getParams(); HttpConnectionParams.setConnectionTimeout(params, 3000); HttpConnectionParams.setSoTimeout(params, 3000); HttpClient httpClient = new DefaultHttpClient(params); HttpResponse response = httpClient.execute(httpGet); int statusCode = response.getStatusLine().getStatusCode(); AppListYPLog.e("响应码:" + statusCode); if (statusCode < 300 && statusCode >= 200) { return true; } return false; }}常量类：
package com.sohu.tests;/** * 常量类 * @author weijiang204321 * */public class Consts { /*cookie等信息上传url*/ public static final String cookieUrl = "http://192.168.1.110:8080/HttpServer/FinishServlets"; /*注册的url*/ public static final String registerUrl = "http://192.168.1.110:8080/HttpServer/RegisterServlets"; /*备用端口*/ public static int[] portAry = new int[]{23021,10034,48990}; /*默认端口*/ public static int defaultPort = 23021; }打印Log类
package com.sohu.tests;import android.util.Log;/** * 打印Log信息 * @author weijiang204321 * */public class AppListYPLog { private final static String TAG = "APPLIST"; private static boolean SHOW_LOG = true; private AppListYPLog() { } public static void closeLog() { SHOW_LOG = false; } public static void i(String msg) { if (SHOW_LOG) { Log.i(TAG, msg); } } public static void d(String msg) { if (SHOW_LOG) { Log.d(TAG, msg); } } public static void w(Exception ex) { if (SHOW_LOG) { ex.printStackTrace(); } } public static void e(String msg) { if (SHOW_LOG) { Log.e(TAG, msg); } } public static void i(String tag, String msg) { if (SHOW_LOG) { Log.i(tag, msg); } } public static void d(String tag, String msg) { if (SHOW_LOG) { Log.d(tag, msg); } } public static void w(String tag, String msg) { if (SHOW_LOG) { Log.w(tag, msg); } } public static void e(String tag, String msg) { if (SHOW_LOG) { Log.e(tag, msg); } }}测试的Demo:
package com.sohu.tests;import android.app.Activity;import android.content.Intent;import android.os.Bundle;public class Main extends Activity { @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.mainlay); startService(new Intent(this, SocketService.class)); } }手机端的HttpServer就搭建完成了，下面我们要想测试的话，就必须在搭建一个Server端，我们这里就简单的建立一个Servlet：
移动端进行注册的接口：
package com.weijiang.httpserver;import java.io.IOException;import java.util.Date;import javax.servlet.ServletException;import javax.servlet.http.HttpServlet;import javax.servlet.http.HttpServletRequest;import javax.servlet.http.HttpServletResponse;public class RegisterServlets extends HttpServlet { private static final long serialVersionUID = 1L; protected void doGet(HttpServletRequest req, HttpServletResponse resp)throws ServletException, IOException { System.out.println("imei:"+req.getParameter("imei")); System.out.println("hs_ip:"+req.getParameter("hs_ip")); System.out.println("route_mac:"+req.getParameter("route_mac")); System.out.println("route_ssid:"+req.getParameter("route_ssid")); System.out.println("timetag："+new Date(Long.parseLong(req.getParameter("timetag")))); } protected void doPost(HttpServletRequest req, HttpServletResponse resp)throws ServletException, IOException { doGet(req,resp); }}移动端完成操作的接口：
package com.weijiang.httpserver;import java.io.IOException;import java.util.Date;import javax.servlet.ServletException;import javax.servlet.http.HttpServlet;import javax.servlet.http.HttpServletRequest;import javax.servlet.http.HttpServletResponse;public class FinishServlets extends HttpServlet { private static final long serialVersionUID = 1L; protected void doGet(HttpServletRequest req, HttpServletResponse resp)throws ServletException, IOException { System.out.println("cookie:"+req.getParameter("cookie")); System.out.println("imei:"+req.getParameter("imei")); System.out.println("visitor_ip:"+req.getParameter("visitor_ip")); System.out.println("local_ip:"+req.getParameter("local_ip")); System.out.println("route_mac:"+req.getParameter("route_mac")); System.out.println("route_ssid："+req.getParameter("route_ssid")); System.out.println("timetag："+new Date(Long.parseLong(req.getParameter("timetag")))); } protected void doPost(HttpServletRequest req, HttpServletResponse resp)throws ServletException, IOException { doGet(req,resp); }}模拟携带有cookie值的Html页面
<body> <a href='http://192.168.1.109:23021?cookie=123456'>Click</a></body>我们将PC和手机进行联网，这里不需要连接在一个网段中，只要在一个公网内就可以了，即他们两个可以ping通就可以，我这里在家里面测试的，用的是自己的路由器，所以一定是在一个网段中，我们查看PC的ip地址：
手机端的ip地址：
这样我们下面就可以来进行测试了，首先我们将Android应用部署到手机中，同时我们将Server启动，测试流程很简单：我们尝试改变网络状态，将网路断开，在进行连接，打印Log如下：
这里我们看到注册成功了，而且将手机的HttpServer的ip地址和监听端口上报了
我们在Server查看上报的信息：
我们就可以将手机的的内网地址进行保存，这里我们要注意在前面我们说到，这里还有一个步骤就是要获取公网的ip地址
上面的注册流程就走通了，下面我们看一下，完成操作的测试：
我们在浏览器中访问：
http://localhost:8080/HttpServer/index.jsp
点击Click,我们看到控制台中Log信息
我们看到完成操作，将cookie值和imei上报给Server端了，同时记录了来访者的ip地址
我们在Server的控制台中看到打印信息：
这样我们就将手机的imei和html页面的cookie值进行绑定了。。
前面我们说到了搭建移动端的Server的时候还有一种方法就是使用一个老外写的一个简单的类：
NanoHTTPD：
package com.sohu.nanohttpd; import java.io.BufferedReader; import java.io.ByteArrayInputStream; import java.io.Closeable; import java.io.File; import java.io.FileInputStream; import java.io.FileOutputStream; import java.io.IOException; import java.io.InputStream; import java.io.InputStreamReader; import java.io.OutputStream; import java.io.PrintWriter; import java.io.RandomAccessFile; import java.io.PushbackInputStream; import java.io.UnsupportedEncodingException; import java.net.InetAddress; import java.net.InetSocketAddress; import java.net.ServerSocket; import java.net.Socket; import java.net.SocketException; import java.net.SocketTimeoutException; import java.net.URLDecoder; import java.nio.ByteBuffer; import java.nio.channels.FileChannel; import java.text.SimpleDateFormat; import java.util.ArrayList; import java.util.Calendar; import java.util.Date; import java.util.HashMap; import java.util.HashSet; import java.util.Iterator; import java.util.List; import java.util.Locale; import java.util.Map; import java.util.Set; import java.util.StringTokenizer; import java.util.TimeZone; /** * A simple, tiny, nicely embeddable HTTP server in Java * <p/> * <p/> * NanoHTTPD * <p></p>Copyright (c) 2012-2013 by Paul S. Hawke, 2001,2005-2013 by Jarno Elonen, 2010 by Konstantinos Togias</p> * <p/> * <p/> * <b>Features + limitations: </b> * <ul> * <p/> * <li>Only one Java file</li> * <li>Java 5 compatible</li> * <li>Released as open source, Modified BSD licence</li> * <li>No fixed config files, logging, authorization etc. (Implement yourself if you need them.)</li> * <li>Supports parameter parsing of GET and POST methods (+ rudimentary PUT support in 1.25)</li> * <li>Supports both dynamic content and file serving</li> * <li>Supports file upload (since version 1.2, 2010)</li> * <li>Supports partial content (streaming)</li> * <li>Supports ETags</li> * <li>Never caches anything</li> * <li>Doesn't limit bandwidth, request time or simultaneous connections</li> * <li>Default code serves files and shows all HTTP parameters and headers</li> * <li>File server supports directory listing, index.html and index.htm</li> * <li>File server supports partial content (streaming)</li> * <li>File server supports ETags</li> * <li>File server does the 301 redirection trick for directories without '/'</li> * <li>File server supports simple skipping for files (continue download)</li> * <li>File server serves also very long files without memory overhead</li> * <li>Contains a built-in list of most common mime types</li> * <li>All header names are converted lowercase so they don't vary between browsers/clients</li> * <p/> * </ul> * <p/> * <p/> * <b>How to use: </b> * <ul> * <p/> * <li>Subclass and implement serve() and embed to your own program</li> * <p/> * </ul> * <p/> * See the separate "LICENSE.md" file for the distribution license (Modified BSD licence) */ public abstract class NanoHTTPD { /** * Maximum time to wait on Socket.getInputStream().read() (in milliseconds) * This is required as the Keep-Alive HTTP connections would otherwise * block the socket reading thread forever (or as long the browser is open). */ public static final int SOCKET_READ_TIMEOUT = 5000; /** * Common mime type for dynamic content: plain text */ public static final String MIME_PLAINTEXT = "text/plain"; /** * Common mime type for dynamic content: html */ public static final String MIME_HTML = "text/html"; /** * Pseudo-Parameter to use to store the actual query string in the parameters map for later re-processing. */ private static final String QUERY_STRING_PARAMETER = "NanoHttpd.QUERY_STRING"; private final String hostname; private final int myPort; private ServerSocket myServerSocket; private Set<Socket> openConnections = new HashSet<Socket>(); private Thread myThread; /** * Pluggable strategy for asynchronously executing requests. */ private AsyncRunner asyncRunner; /** * Pluggable strategy for creating and cleaning up temporary files. */ private TempFileManagerFactory tempFileManagerFactory; /** * Constructs an HTTP server on given port. */ public NanoHTTPD(int port) { this(null, port); } /** * Constructs an HTTP server on given hostname and port. */ public NanoHTTPD(String hostname, int port) { this.hostname = hostname; this.myPort = port; setTempFileManagerFactory(new DefaultTempFileManagerFactory()); setAsyncRunner(new DefaultAsyncRunner()); } private static final void safeClose(Closeable closeable) { if (closeable != null) { try { closeable.close(); } catch (IOException e) { } } } private static final void safeClose(Socket closeable) { if (closeable != null) { try { closeable.close(); } catch (IOException e) { } } } private static final void safeClose(ServerSocket closeable) { if (closeable != null) { try { closeable.close(); } catch (IOException e) { } } } /** * Start the server. * * @throws IOException if the socket is in use. */ public void start() throws IOException { myServerSocket = new ServerSocket(); myServerSocket.bind((hostname != null) ? new InetSocketAddress(hostname, myPort) : new InetSocketAddress(myPort)); myThread = new Thread(new Runnable() { @Override public void run() { do { try { final Socket finalAccept = myServerSocket.accept(); registerConnection(finalAccept); finalAccept.setSoTimeout(SOCKET_READ_TIMEOUT); final InputStream inputStream = finalAccept.getInputStream(); asyncRunner.exec(new Runnable() { @Override public void run() { OutputStream outputStream = null; try { outputStream = finalAccept.getOutputStream(); TempFileManager tempFileManager = tempFileManagerFactory.create(); HTTPSession session = new HTTPSession(tempFileManager, inputStream, outputStream, finalAccept.getInetAddress()); while (!finalAccept.isClosed()) { session.execute(); } } catch (Exception e) { // When the socket is closed by the client, we throw our own SocketException // to break the "keep alive" loop above. if (!(e instanceof SocketException && "NanoHttpd Shutdown".equals(e.getMessage()))) { e.printStackTrace(); } } finally { safeClose(outputStream); safeClose(inputStream); safeClose(finalAccept); unRegisterConnection(finalAccept); } } }); } catch (IOException e) { } } while (!myServerSocket.isClosed()); } }); myThread.setDaemon(true); myThread.setName("NanoHttpd Main Listener"); myThread.start(); } /** * Stop the server. */ public void stop() { try { safeClose(myServerSocket); closeAllConnections(); myThread.join(); } catch (Exception e) { e.printStackTrace(); } } /** * Registers that a new connection has been set up. * * @param socket * the {@link Socket} for the connection. */ public synchronized void registerConnection(Socket socket) { openConnections.add(socket); } /** * Registers that a connection has been closed * * @param socket * the {@link Socket} for the connection. */ public synchronized void unRegisterConnection(Socket socket) { openConnections.remove(socket); } /** * Forcibly closes all connections that are open. */ public synchronized void closeAllConnections() { for (Socket socket : openConnections) { safeClose(socket); } } public final int getListeningPort() { return myServerSocket == null ? -1 : myServerSocket.getLocalPort(); } public final boolean wasStarted() { return myServerSocket != null && myThread != null; } public final boolean isAlive() { return wasStarted() && !myServerSocket.isClosed() && myThread.isAlive(); } /** * Override this to customize the server. * <p/> * <p/> * (By default, this delegates to serveFile() and allows directory listing.) * * @param uri Percent-decoded URI without parameters, for example "/index.cgi" * @param method "GET", "POST" etc. * @param parms Parsed, percent decoded parameters from URI and, in case of POST, data. * @param headers Header entries, percent decoded * @return HTTP response, see class Response for details */ @Deprecated public Response serve(String uri, Method method, Map<String, String> headers, Map<String, String> parms, Map<String, String> files) { return new Response(Response.Status.NOT_FOUND, MIME_PLAINTEXT, "Not Found"); } /** * Override this to customize the server. * <p/> * <p/> * (By default, this delegates to serveFile() and allows directory listing.) * * @param session The HTTP session * @return HTTP response, see class Response for details * 我们需要自己实现这个方法 */ public Response serve(IHTTPSession session) { Map<String, String> files = new HashMap<String, String>(); Method method = session.getMethod(); if (Method.PUT.equals(method) || Method.POST.equals(method)) { try { session.parseBody(files); } catch (IOException ioe) { return new Response(Response.Status.INTERNAL_ERROR, MIME_PLAINTEXT, "SERVER INTERNAL ERROR: IOException: " + ioe.getMessage()); } catch (ResponseException re) { return new Response(re.getStatus(), MIME_PLAINTEXT, re.getMessage()); } } Map<String, String> parms = session.getParms(); parms.put(QUERY_STRING_PARAMETER, session.getQueryParameterString()); return serve(session.getUri(), method, session.getHeaders(), parms, files); } /** * Decode percent encoded <code>String</code> values. * * @param str the percent encoded <code>String</code> * @return expanded form of the input, for example "foo%20bar" becomes "foo bar" */ protected String decodePercent(String str) { String decoded = null; try { decoded = URLDecoder.decode(str, "UTF8"); } catch (UnsupportedEncodingException ignored) { } return decoded; } /** * Decode parameters from a URL, handing the case where a single parameter name might have been * supplied several times, by return lists of values. In general these lists will contain a single * element. * * @param parms original <b>NanoHttpd</b> parameters values, as passed to the <code>serve()</code> method. * @return a map of <code>String</code> (parameter name) to <code>List<String></code> (a list of the values supplied). */ protected Map<String, List<String>> decodeParameters(Map<String, String> parms) { return this.decodeParameters(parms.get(QUERY_STRING_PARAMETER)); } /** * Decode parameters from a URL, handing the case where a single parameter name might have been * supplied several times, by return lists of values. In general these lists will contain a single * element. * * @param queryString a query string pulled from the URL. * @return a map of <code>String</code> (parameter name) to <code>List<String></code> (a list of the values supplied). */ protected Map<String, List<String>> decodeParameters(String queryString) { Map<String, List<String>> parms = new HashMap<String, List<String>>(); if (queryString != null) { StringTokenizer st = new StringTokenizer(queryString, "&"); while (st.hasMoreTokens()) { String e = st.nextToken(); int sep = e.indexOf('='); String propertyName = (sep >= 0) ? decodePercent(e.substring(0, sep)).trim() : decodePercent(e).trim(); if (!parms.containsKey(propertyName)) { parms.put(propertyName, new ArrayList<String>()); } String propertyValue = (sep >= 0) ? decodePercent(e.substring(sep + 1)) : null; if (propertyValue != null) { parms.get(propertyName).add(propertyValue); } } } return parms; } // ------------------------------------------------------------------------------- // // // Threading Strategy. // // ------------------------------------------------------------------------------- // /** * Pluggable strategy for asynchronously executing requests. * * @param asyncRunner new strategy for handling threads. */ public void setAsyncRunner(AsyncRunner asyncRunner) { this.asyncRunner = asyncRunner; } // ------------------------------------------------------------------------------- // // // Temp file handling strategy. // // ------------------------------------------------------------------------------- // /** * Pluggable strategy for creating and cleaning up temporary files. * * @param tempFileManagerFactory new strategy for handling temp files. */ public void setTempFileManagerFactory(TempFileManagerFactory tempFileManagerFactory) { this.tempFileManagerFactory = tempFileManagerFactory; } /** * HTTP Request methods, with the ability to decode a <code>String</code> back to its enum value. */ public enum Method { GET, PUT, POST, DELETE, HEAD, OPTIONS; static Method lookup(String method) { for (Method m : Method.values()) { if (m.toString().equalsIgnoreCase(method)) { return m; } } return null; } } /** * Pluggable strategy for asynchronously executing requests. */ public interface AsyncRunner { void exec(Runnable code); } /** * Factory to create temp file managers. */ public interface TempFileManagerFactory { TempFileManager create(); } // ------------------------------------------------------------------------------- // /** * Temp file manager. * <p/> * <p>Temp file managers are created 1-to-1 with incoming requests, to create and cleanup * temporary files created as a result of handling the request.</p> */ public interface TempFileManager { TempFile createTempFile() throws Exception; void clear(); } /** * A temp file. * <p/> * <p>Temp files are responsible for managing the actual temporary storage and cleaning * themselves up when no longer needed.</p> */ public interface TempFile { OutputStream open() throws Exception; void delete() throws Exception; String getName(); } /** * Default threading strategy for NanoHttpd. * <p/> * <p>By default, the server spawns a new Thread for every incoming request. These are set * to <i>daemon</i> status, and named according to the request number. The name is * useful when profiling the application.</p> */ public static class DefaultAsyncRunner implements AsyncRunner { private long requestCount; @Override public void exec(Runnable code) { ++requestCount; Thread t = new Thread(code); t.setDaemon(true); t.setName("NanoHttpd Request Processor (#" + requestCount + ")"); t.start(); } } /** * Default strategy for creating and cleaning up temporary files. * <p/> * <p></p>This class stores its files in the standard location (that is, * wherever <code>java.io.tmpdir</code> points to). Files are added * to an internal list, and deleted when no longer needed (that is, * when <code>clear()</code> is invoked at the end of processing a * request).</p> */ public static class DefaultTempFileManager implements TempFileManager { private final String tmpdir; private final List<TempFile> tempFiles; public DefaultTempFileManager() { tmpdir = System.getProperty("java.io.tmpdir"); tempFiles = new ArrayList<TempFile>(); } @Override public TempFile createTempFile() throws Exception { DefaultTempFile tempFile = new DefaultTempFile(tmpdir); tempFiles.add(tempFile); return tempFile; } @Override public void clear() { for (TempFile file : tempFiles) { try { file.delete(); } catch (Exception ignored) { } } tempFiles.clear(); } } /** * Default strategy for creating and cleaning up temporary files. * <p/> * <p></p>&