今天终于把老大交代的任务搞完了，感觉收获挺多的，所以就写一篇来记录一下吧，首先还是来看一下，老大们的需求
需求：
希望移动端的用户标识(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在这个服务中，我们开始的时候就进行注册，上报一些信息： imei:手机移动的标识
hs_ip:手机的HttpServer的地址和端口号
route_mac:手机连接的路由器的mac地址
route_ssid:手机连接的路由器的ssid
timetag:注册的时间戳
同时我们还注册了一个监听网络变化的广播，这个是为了防止，开始的时候用户没有开启网络，一旦用户开启网路的时候，我们就开启监听并且进行注册。
这里我们使用的监听端口是3个，因为我们知道，端口最大的是655535，0-1024是系统使用的，所以我们就使用了三个备用的端口，在使用这个端口之前要检测一下该端口有没有被占用，这里我们就使用Socket探针技术。
再来看一下最核心的HttpServer的实现：
首先我们需要下载Apache提供的jar包：
代码：
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 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 getParam(String uri){ Map params = new HashMap (); try{ if(isNotEmpty(uri)){ String subStr = uri.substring(uri.indexOf("?")+1); String[] ary = subStr.split("&"); for(int i=0;i en = NetworkInterface.getNetworkInterfaces(); // 遍历所用的网络接口 while (en.hasMoreElements()){ NetworkInterface nif = en.nextElement();// 得到每一个网络接口绑定的所有ip Enumeration 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 param) { HttpPost httpPost = new HttpPost(url); // 设置HTTP POST请求参数必须用NameValuePair对象 List params = new ArrayList (); if (param != null) { Set > set = param.entrySet(); Iterator > iterator = set.iterator(); while (iterator.hasNext()) { Entry 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页面
Click这里就是为了简单的模拟，所以直接随便写了一个cookie值
我们将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 * * * NanoHTTPD * Copyright (c) 2012-2013 by Paul S. Hawke, 2001,2005-2013 by Jarno Elonen, 2010 by Konstantinos Togias * * * Features + limitations: *
- * *
- Only one Java file *
- Java 5 compatible *
- Released as open source, Modified BSD licence *
- No fixed config files, logging, authorization etc. (Implement yourself if you need them.) *
- Supports parameter parsing of GET and POST methods (+ rudimentary PUT support in 1.25) *
- Supports both dynamic content and file serving *
- Supports file upload (since version 1.2, 2010) *
- Supports partial content (streaming) *
- Supports ETags *
- Never caches anything *
- Doesn't limit bandwidth, request time or simultaneous connections *
- Default code serves files and shows all HTTP parameters and headers *
- File server supports directory listing, index.html and index.htm *
- File server supports partial content (streaming) *
- File server supports ETags *
- File server does the 301 redirection trick for directories without '/' *
- File server supports simple skipping for files (continue download) *
- File server serves also very long files without memory overhead *
- Contains a built-in list of most common mime types *
- All header names are converted lowercase so they don't vary between browsers/clients * *
- * *
- Subclass and implement serve() and embed to your own program * *
String values. * * @param str the percent encoded String * @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 NanoHttpd parameters values, as passed to the serve() method. * @return a map of String (parameter name) to List (a list of the values supplied). */ protected Map String (parameter name) to List (a list of the values supplied). */ protected Map String 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. * * 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.
*/ public interface TempFileManager { TempFile createTempFile() throws Exception; void clear(); } /** * A temp file. * *Temp files are responsible for managing the actual temporary storage and cleaning * themselves up when no longer needed.
*/ public interface TempFile { OutputStream open() throws Exception; void delete() throws Exception; String getName(); } /** * Default threading strategy for NanoHttpd. * *By default, the server spawns a new Thread for every incoming request. These are set * to daemon status, and named according to the request number. The name is * useful when profiling the application.
*/ 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. * * This class stores its files in the standard location (that is, * whereverjava.io.tmpdir points to). Files are added * to an internal list, and deleted when no longer needed (that is, * when clear() is invoked at the end of processing a * request). */ public static class DefaultTempFileManager implements TempFileManager { private final String tmpdir; private final List File.createTempFile() in * the directory specified. */ public static class DefaultTempFile implements TempFile { private File file; private OutputStream fstream; public DefaultTempFile(String tempdir) throws IOException { file = File.createTempFile("NanoHTTPD-", "", new File(tempdir)); fstream = new FileOutputStream(file); } @Override public OutputStream open() throws Exception { return fstream; } @Override public void delete() throws Exception { safeClose(fstream); file.delete(); } @Override public String getName() { return file.getAbsolutePath(); } } /** * HTTP response. Return one of these from serve(). */ public static class Response { /** * HTTP status code after processing, e.g. "200 OK", HTTP_OK */ private Status status; /** * MIME type of content, e.g. "text/html" */ private String mimeType; /** * Data of the response, may be null. */ private InputStream data; /** * Headers for the HTTP response. Use addHeader() to add lines. */ private Map
package com.sohu.nanohttpd;import android.app.Activity;import android.os.Bundle;import android.util.Log;public class MainActivity extends Activity { @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); NanoHTTPD nanoHttpd = new MyNanoHTTPD("127.0.0.1",23456); try{ nanoHttpd.start(); }catch(Exception e){ e.printStackTrace(); } Log.e("DEMO",nanoHttpd.isAlive()+""); }}class MyNanoHTTPD extends NanoHTTPD{ public MyNanoHTTPD(int port) { super(port); } public MyNanoHTTPD(String hostName,int port){ super(hostName,port); } public Response serve(IHTTPSession session) { Method method = session.getMethod(); Log.e("DEMO","Method:"+method.toString()); if(NanoHTTPD.Method.GET.equals(method)){ //get方式 String queryParams = session.getQueryParameterString(); Log.e("DEMO","params:"+queryParams); }else if(NanoHTTPD.Method.POST.equals(method)){ //post方式 } return super.serve(session); } }这里只是做了一下拓展知识，两种方式搭建都可以的，但是明显Apache的功能强大一点。。 测试项目的下载地址：
Android测试项目HttpServer下载地址
PC端的Server测试项目HttpServer下载地址
Android测试项目NanoHTTPD下载地址
总结：上面就是将PC端的Cookie和移动端的imei进行绑定的操作，这种操作的价值是很大的，未来如果用户在家里面进行上网的话，我们就可以将PC端和移动端进行紧密耦合在一起，相当于一个整体。。这样我们对用户的行为就更加了解了。。