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();
}
}