Android 手机微服务架构的简单实现

功能：

使得手机app具有服务端功能，例如：wifi传书，可以通过手机app产生一个url地址，然后使用同一网段的电脑，打开浏览器，输入ip地址打开网页，上传文件，这样手机app就可以接受到这个文件，完成整个数据上传的过程。

知识储备：

通信协议：

TCP/IP 面向连接--需要连接之后才能传输数据（三次握手，四次挥手）数据可靠性--数据校验保证完整性，传输ack防丢包

UDP 不面向连接 不提供数据可靠性验证 速度快

容错性高，速度快，可以接受丢包使用UDP。

Socket:

网络上的两个程序通过一个双向的通信连接实现数据的交换，这个连接的一端称为一个socket。

ServerSocket 对socket进行简单封装

1、对指定端口监听--bind

2、等待连接--accept--对应三次握手的结束--接受到连接之后返回远程的socket

3、inputstream\outputstream 远程端口的输入输出流

4、关闭连接--close

http 请求格式：

http 相应格式：

路由规则：

客户端访问服务端以后，交给谁来处理。

代码：

网络配置类

WebConfiguration

public class WebConfiguration {    // 端口号    private int port;    // 最大并发数    private int maxParallels;    public int getPort() {        return port;    }    public void setPort(int port) {        this.port = port;    }    public int getMaxParallels() {        return maxParallels;    }    public void setMaxParallels(int maxParallels) {        this.maxParallels = maxParallels;    }}

服务类--启动和停止服务，不断监听，针对不同的请求进行不同的处理。

SimpleHttpServer

public class SimpleHttpServer {    private final WebConfiguration webConfig;    private final ExecutorService threadPool;    private boolean isEnable;    private ServerSocket socket;    private Set<IResourceHandler> resourceHandlers;    SimpleHttpServer(WebConfiguration webConfig) {        this.webConfig = webConfig;        threadPool = Executors.newCachedThreadPool();        resourceHandlers = new HashSet<IResourceHandler>();    }    /**     * 启动Server(异步)     */    public void startAsync() {        isEnable = true;        new Thread(new Runnable() {            @Override            public void run() {                doProcSync();            }        }).start();    }    /**     * 停止Server(异步)     */    public void stopAsync() throws IOException {        if (!isEnable || socket == null) {            return;        }        isEnable = false;        socket.close();        socket = null;    }    private void doProcSync() {        try {            // 创建端口地址            InetSocketAddress socketAddress = new InetSocketAddress(webConfig.getPort());            socket = new ServerSocket();            // 监听端口            socket.bind(socketAddress);            while (isEnable) {                // 当远程有设备连接当前端口时，返回远程端口                final Socket remotePeer = socket.accept();                threadPool.submit(new Runnable() {                    @Override                    public void run() {                        Log.d("spy", "a remote peer accepted..." + remotePeer.getRemoteSocketAddress().toString());                        onAcceptedRemotePeer(remotePeer);                    }                });            }        } catch (IOException e) {            Log.e("spy", e.toString());        }    }    public void registerResourceHandler(IResourceHandler handler) {        resourceHandlers.add(handler);    }    private void onAcceptedRemotePeer(Socket remotePeer) {        try {            HttpContext context = new HttpContext();            context.setUnderlySocket(remotePeer);//            remotePeer.getOutputStream().write("congratulations, connect successful".getBytes());            InputStream nis = remotePeer.getInputStream();            String headLine = null;            String resourceUri = headLine = StreamTookit.readLine(nis).split(" ")[1];            Log.d("spy", resourceUri);            while ((headLine = StreamTookit.readLine(nis)) != null) {                if (headLine.equals("\r\n")) {                    break;                }                String[] pair = headLine.split(": ");                if (pair.length > 1) {                    context.addRequestHeaders(pair[0], pair[1].replace("\r\n", ""));                }                Log.d("spy", "header line = " + headLine);            }            for (IResourceHandler handler : resourceHandlers) {                if (!handler.accept(resourceUri)) {                    continue;                }                handler.handle(resourceUri, context);            }        } catch (IOException e) {            Log.e("spy", e.toString());        } finally {            try {                remotePeer.close();            } catch (IOException e) {                e.printStackTrace();            }        }    }}

启动服务之后，就会调用doProcSync函数,这个函数可以循环监听是否有远程连接到服务端。

首先根据网络配置监听指定的端口，然后监听，一旦有远程连接就返回远程socket，把他交给一个线程池中的某个线程进行处理，避免延迟和频繁的线程创建和销毁，影响其他连接的监听。

onAcceptedRemotePeer是真正的处理函数。可以从远程socket的inputstream获取网络请求头的具体内容，还可以根据url的内容把他交给相匹配的handler进行处理。

网络请求头的内容是有‘/r/n’来分行的，而我们需要的url具体请求地址在第一行，第二个字段中。

IResourceHandler

public interface IResourceHandler {    boolean accept(String uri);    void handle(String uri, HttpContext httpContext) throws IOException;}

处理访问静态html的handler

如果路径是ip/static/xxx，就使用这个handler

public class ResourceInAssetsHandler implements IResourceHandler {    private final Context context;    private String acceptPrefix = "/static/";    ResourceInAssetsHandler(Context context) {        this.context = context;    }    @Override    public boolean accept(String uri) {        return uri.startsWith(acceptPrefix);    }    @Override    public void handle(String uri, HttpContext httpContext) throws IOException {        int startIndex = acceptPrefix.length();        String assetsPath = uri.substring(startIndex);        InputStream fis = context.getAssets().open(assetsPath);        byte[] raw = StreamTookit.readRawFromStrem(fis);        fis.close();        OutputStream nos = httpContext.getUnderlySocket().getOutputStream();        PrintStream print = new PrintStream(nos);        print.println("HTTP/1.1 200 OK");        print.println("Content-Length:" + raw.length);        if (assetsPath.endsWith(".html")) {            print.println("Content-Type:text/html");        } else if (assetsPath.endsWith(".js")) {            print.println("Content-Type:text/js");        } else if (assetsPath.endsWith(".css")) {            print.println("Content-Type:text/css");        } else if (assetsPath.endsWith(".jpg")) {            print.println("Content-Type:text/jpg");        } else if (assetsPath.endsWith(".png")) {            print.println("Content-Type:text/png");        }        print.println();        print.write(raw);        print.close();    }}
处理上传图片的handler

如果路径是ip/upload_image/xxx，就使用该handler.

public class UploadImageHandler implements IResourceHandler {    private String acceptPrefix = "/upload_image/";    @Override    public boolean accept(String uri) {        return uri.startsWith(acceptPrefix);    }    @Override    public void handle(String uri, HttpContext httpContext) throws IOException {        String tmpPath = Environment.getExternalStorageDirectory().getPath() + "/test_upload.jpg";        long totalLength = Long.parseLong(httpContext.getRequestHeaderValue("Content-Length"));        FileOutputStream fos = new FileOutputStream(tmpPath);        InputStream nis = httpContext.getUnderlySocket().getInputStream();        byte[] buffer = new byte[10240];        int nReaded = 0;        long nLeftLength = totalLength;        while ((nLeftLength > 0) && (nReaded = nis.read(buffer)) > 0) {            fos.write(buffer, 0, nReaded);            nLeftLength -= nReaded;        }        fos.close();        OutputStream nos = httpContext.getUnderlySocket().getOutputStream();        PrintStream writer = new PrintStream(nos);        writer.println("HTTP/1.1 200 OK");        writer.println();        onImageLoaded(tmpPath);    }    protected void onImageLoaded(String path) {    }}

MainActivity

public class MainActivity extends Activity {    private SimpleHttpServer shs;    @Override    protected void onCreate(Bundle savedInstanceState) {        super.onCreate(savedInstanceState);        setContentView(R.layout.activity_main);        WebConfiguration configuration = new WebConfiguration();        configuration.setPort(8088);        configuration.setMaxParallels(50);        shs = new SimpleHttpServer(configuration);        shs.registerResourceHandler(new ResourceInAssetsHandler(this));        shs.registerResourceHandler(new UploadImageHandler() {            @Override            protected void onImageLoaded(String path) {                showImage(path);            }        });        shs.startAsync();    }    private void showImage(final String path) {        runOnUiThread(new Runnable() {            @Override            public void run() {                ImageView img = (ImageView) findViewById(R.id.img);                Bitmap bitmap = BitmapFactory.decodeFile(path);                img.setImageBitmap(bitmap);                Toast.makeText(MainActivity.this, "image received and show", Toast.LENGTH_SHORT).show();            }        });    }    @Override    protected void onDestroy() {        try {            shs.stopAsync();        } catch (IOException e) {            Log.e("spy", e.toString());        }        super.onDestroy();    }}

layout_main

<?xml version="1.0" encoding="utf-8"?><LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"    android:layout_width="match_parent"    android:layout_height="match_parent"    android:orientation="vertical">    <ImageView        android:id="@+id/img"        android:layout_width="match_parent"        android:layout_height="match_parent" /></LinearLayout>
HttpContext
public class HttpContext {    private final HashMap<String, String> requestHeaders;    private Socket underlySocket;    HttpContext() {        requestHeaders = new HashMap<String, String>();    }    public void setUnderlySocket(Socket socket) {        this.underlySocket = socket;    }    public Socket getUnderlySocket() {        return underlySocket;    }    public void addRequestHeaders(String headerName, String headerValue) {        requestHeaders.put(headerName, headerValue);    }    public String getRequestHeaderValue(String headerName) {        return requestHeaders.get(headerName);    }}

工具类

读取请求的每一行并返回。
public class StreamTookit {    public static final String readLine(InputStream nis) throws IOException {        StringBuffer sb = new StringBuffer();        int c1 = 0;        int c2 = 0;        while (c2 != -1 && !(c1 == '\r' && c2 == '\n')) {            c1 = c2;            c2 = nis.read();            sb.append((char) c2);        }        if (sb.length() == 0) {            return null;        }        return sb.toString();    }    public static byte[] readRawFromStrem(InputStream fis) throws IOException {        ByteArrayOutputStream bos = new ByteArrayOutputStream();        byte[] buffer = new byte[10240];        int nReaded;        while ((nReaded = fis.read(buffer)) > 0) {            bos.write(buffer, 0, nReaded);        }        return bos.toByteArray();    }}