如何搭建一个简易的App Server

首先实现一个简单的客户端，使用Eclipse创建一个Java Project，使用Okhttp3.10.0库实现客户端类，以下实现POST Form表单的形式实现文件上传功能 `package com.johnson4droid.client;

import java.io.File; import java.io.IOException;

import com.johnson4droid.client.log.LoggingInterceptor; import com.johnson4droid.client.log.LoggingLevel;

import okhttp3.MediaType; import okhttp3.MultipartBody; import okhttp3.OkHttpClient; import okhttp3.Request; import okhttp3.RequestBody; import okhttp3.Response;

/**

@author johnson4droid

*/ public final class FileUploader {

/**

*/ public FileUploader() { }

public static void upload() { //OkHttpClient client = new OkHttpClient(); OkHttpClient client = new OkHttpClient.Builder() .addInterceptor(new LoggingInterceptor(LoggingLevel.ALL)) //增加日志打印 .build();

File file = new File("C:\\Users\\johnson4droid\\Desktop\\device-2017-11-24-143447.png");
MultipartBody multipartBody = new MultipartBody.Builder()
        .addFormDataPart("username", "admin") //Form字符串参数
        .addFormDataPart("password", "test12345") // From字符串参数
        .addFormDataPart("file", file.getName(), RequestBody.create(MediaType.parse("image/png"), file))//Form文件参数
        .build();

Request request = new Request.Builder()
        .url("http://localhost/HttpServerDemo/clientRequest")
        .post(multipartBody)
        .addHeader("Content-Type", "multipart/form-data")
        .addHeader("Cache-Control", "no-cache")
        .build();

try {
    Response response = client.newCall(request).execute();
    byte[] bodyBytes = response.body().bytes();
    System.out.println("result: " + new String(bodyBytes));
} catch (IOException e) {
    e.printStackTrace();
}

}

public static void main(String[] args) { upload(); }

日志 `package com.johnson4droid.client.log;

/**

{@link LoggingInterceptor} 中使用到的log打印等级，包含7个log类型，有 {@link #NONE}, {@link #URL_BODY}, {@link #SINGLE},
{@link #STATE}, {@link #HEADERS}, {@link #BODY}, {@link #ALL}，类型丰富，按类型打印了log，可以设置为你喜欢的等级，直接使用.
@author Ayvytr 's GitHub
@since 1.0.0 */ public enum LoggingLevel { /**
- 不打印log */ NONE, /**
- 打印url和响应体.
- ��：
- ```
{@code
```
- ┣━ http://xx.com 响应体
- } */ URL_BODY, /**
- 打印Http状态，url, 请求时长和响应体.
- ��：
- ```
{@code
```
- ┣━ [GET 200 OK][http/1.1 915ms] http://wthrcdn.etouch.cn/weather_mini?city=%E6%B7%B1%E5%9C%B3 响应体
- } */ SINGLE, /**
- 打印Http状态和url
- ��:
- ```
{@code
```
- ┣━ [GET 200 OK][http/1.1 168ms] http://wthrcdn.etouch.cn/weather_mini?city=%E6%B7%B1%E5%9C%B3
- } */ STATE, /**
- 打印Http状态，url，请求头和响应头
- ��:
- ```
{@code
```
- --> POST /greeting http/1.1
- Host: example.com
- Content-Type: plain/text
- Content-Length: 3
- --> END POST
- <-- 200 OK (22ms)
- Content-Type: plain/text
- Content-Length: 6
- <-- END HTTP
- } */ HEADERS, /**
- 打印Http状态，url, 请求时长和响应体.
- ��：
- ```
{@code
```
- ┏━━ [GET 200 OK][http/1.1 915ms] http://xx.com
- 响应体
- ┗━ END HTTP
- } */ BODY, /**
- 打印http状态，url，请求时长，响应体，请求头和响应头
- ��:
- ```
{@code
```
- ┏━ [GET 200 OK][http/1.1 52ms] http://wthrcdn.etouch.cn/weather_mini?city=%E6%B7%B1%E5%9C%B3
- 响应体
- Date: Thu, 22 Jun 2017 06:07:27 GMT
- Cache-Control: must-revalidate, max-age=300
- Connection: Keep-Alive
- Server: Tengine/2.1.2
- Access-Control-Allow-Origin: *
- Access-Control-Allow-Headers: *
- Access-Control-Allow-Methods: *
- Fw-Cache-Status: hit
- Fw-Via: DISK HIT from 115.231.47.62, DISK HIT from 163.177.175.65
- ┗━ END HTTP
- } */ ALL }`

`package com.johnson4droid.client.log;

import java.io.EOFException; import java.io.IOException; import java.nio.charset.Charset; import java.util.Locale; import java.util.concurrent.TimeUnit;

import okhttp3.Connection; import okhttp3.Headers; import okhttp3.Interceptor; import okhttp3.MediaType; import okhttp3.Protocol; import okhttp3.Request; import okhttp3.RequestBody; import okhttp3.Response; import okhttp3.ResponseBody; import okhttp3.internal.http.HttpHeaders; import okhttp3.internal.platform.Platform; import okio.Buffer; import okio.BufferedSource;

/**

拦截器，提供了打印状态，头，响应体等5种类型的log拦截打印方式.
@author Ayvytr 's GitHub
@since 1.0.0 */ public final class LoggingInterceptor implements Interceptor { //一行字符最大数量 private static final int MAX_LENGTH = 1024;

private final Charset UTF8 = Charset.forName("UTF-8"); private final Logger logger; private volatile LoggingLevel level = LoggingLevel.NONE;

public LoggingInterceptor() { this(LoggingLevel.SINGLE); }

public LoggingInterceptor(LoggingLevel level) { this(level, Logger.DEFAULT); }

public LoggingInterceptor(LoggingLevel level, Logger logger) { this.level = level; if(this.level == null) { this.level = LoggingLevel.SINGLE; } this.logger = logger; }

/**
- 更改log等级，见 {@link LoggingLevel}.
- @param level 新的拦截等级
- @return {@link LoggingInterceptor} */ public LoggingInterceptor setLevel(LoggingLevel level) { this.level = level; if(this.level == null) { this.level = LoggingLevel.BODY; }
  
  return this; }
/**
- 返回拦截等级
- @return {@link #level} */ public LoggingLevel getLevel() { return level; }
@Override public Response intercept(Chain chain) throws IOException { return logIntercept(chain); }

/**
- 拦截日志方法.
- @param chain {@link Chain}
- @return {@link Response}
- @throws IOException */ private Response logIntercept(Chain chain) throws IOException { Request request = chain.request();
  
  long startNs = System.nanoTime(); Response response; try { response = chain.proceed(request); } catch(IOException e) { print(String.format("┣━━━ [HTTP FAILED] url:%s exception:%s", request.url(), e.getMessage())); throw e; } long tookMs = TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - startNs);
  
  String httpHeaderString = getHttpHeaderString(request, response, tookMs, chain);
  
  switch(level) { //do nothing // case NONE: // break; case URL_BODY: printUrlBody(request, response); break; case SINGLE: printSingle(request, response, httpHeaderString); break; case STATE: printState(httpHeaderString); break; case HEADERS: printHeaders(request, response, httpHeaderString); break; case BODY: printBody(request, response, httpHeaderString); break; case ALL: printAll(request, response, httpHeaderString); break; default: break; }
  
  return response; }
/**
- 打印 {@link LoggingLevel#URL_BODY} 类型的log
- @param request {@link Request}
- @param response {@link Response} */ private void printUrlBody(Request request, Response response) throws IOException { String responseBody = getResponseBody(request, response); String format = String.format("%s %s %s", getHeaderSymbol(), request.url(), responseBody); if(format.length() > MAX_LENGTH) { print(String.format("%s %s", getHeaderSymbol(), request.url())); printLong(responseBody); printEnd(); } else { print(format); } }
/**
- 打印内容过长文本，超过一行长度，折行显示
- @param text 要打印的文本 */ private void printLong(String text) { int length = text.length(); if(length <= MAX_LENGTH) { print(text); } else { int lineNum = length / MAX_LENGTH; if(length % MAX_LENGTH != 0) { lineNum++; }
```
for(int i = 1; i <= lineNum; i++)
{
    if(i < lineNum)
    {
        print(text.substring((i - 1) * MAX_LENGTH, i * MAX_LENGTH));
    }
    else
    {
        print(text.substring((i - 1) * MAX_LENGTH, length));
    }
}
```
  } }
/**
- 打印 {@link LoggingLevel#HEADERS} 类型的log
- @param request {@link Request}
- @param response {@link Response}
- @param httpHeaderString http头字符串 */
private void printHeaders(Request request, Response response, String httpHeaderString) throws IOException { print(httpHeaderString); printHttpHeaders(request, response); printEnd(); }

/**
- 通过 {@link #logger} 打印字符串 s
- @param s 要打印的字符串 */ private void print(String s) { logger.log(s); }
/**
- 打印 {@link LoggingLevel#BODY} 类型的log
- @param response {@link Response}
- @param httpHeaderString http头字符串 */ private void printBody(Request request, Response response, String httpHeaderString) throws IOException { print(httpHeaderString); printLong(getResponseBody(request, response)); printEnd(); }
/**
- 打印 {@link LoggingLevel#SINGLE} 类型的log
- @param request {@link Request}
- @param response {@link Response}
- @param httpHeaderString http头字符串 */ private void printSingle(Request request, Response response, String httpHeaderString) throws IOException { String responseBody = getResponseBody(request, response); String format = String.format("%s %s", httpHeaderString, responseBody); if(format.length() > MAX_LENGTH) { print(httpHeaderString); printLong(responseBody); } else { print(format); } }
/**
- 打印 {@link LoggingLevel#STATE} 类型的log
- @param httpHeaderString http头字符串 */ private void printState(String httpHeaderString) { print(httpHeaderString); }
/**
- 打印log尾. */ private void printEnd() { print("┗━ END HTTP"); }
/**
- 返回Http请求状态字符串，见 {@link #getHttpStateString(Request, Response, long, Chain)}
- @param request {@link Request}
- @param response {@link Response}
- @param tookMs 请求花费时长
- @param chain {@link Chain}
- @return 请求状态字符串. */ private String getHttpHeaderString(Request request, Response response, long tookMs, Chain chain) { return String.format("%s %s", getHeaderSymbol(), getHttpStateString(request, response, tookMs, chain)); }
/**
- 返回请求状态字符串，包括 Http method, response code, response message, protocol, 请求花费时长，url.
- @param request {@link Request}
- @param response {@link Response}
- @param tookMs 请求花费时长
- @param chain {@link okhttp3.Interceptor.Chain}
- @return 请求状态字符串. */ private String getHttpStateString(Request request, Response response, long tookMs, Chain chain) { Connection connection = chain.connection(); Protocol protocol = connection != null ? connection.protocol() : Protocol.HTTP_1_1; return String.format(Locale.getDefault(), "[%s %d %s][%s %dms] %s", request.method(), response.code(), response.message(), protocol, tookMs, request.url()); }
/**
- 返回log头符号
- @return log头符号 */ private String getHeaderSymbol() { return (level == LoggingLevel.SINGLE || level == LoggingLevel.URL_BODY || level == LoggingLevel.STATE) ? "┣━" : "┏━"; }
/**
- 打印所有请求状态
- @param request {@link Request}
- @param response {@link Response}
- @param httpHeaderString http头字符串 */ private void printAll(Request request, Response response, String httpHeaderString) throws IOException { print(httpHeaderString); printLong(getResponseBody(request, response)); printHttpHeaders(request, response); printEnd(); }
/**
- 打印请求头和响应头，如果有的话.
- @param request {@link Request}
- @param response {@link Response} */ private void printHttpHeaders(Request request, Response response) throws IOException { RequestBody requestBody = request.body(); boolean hasRequestBody = requestBody != null; if(hasRequestBody) { print("Content-Length: " + requestBody.contentLength()); MediaType mediaType = requestBody.contentType(); // Request body headers are only present when installed as a network interceptor. Force // them to be included (when available) so there values are known. if(mediaType != null) { print("Content-Type: " + mediaType); }
```
Headers headers = request.headers();
for(int i = 0, count = headers.size(); i < count; i++)
{
    String name = headers.name(i);
    // Skip headers from the request body as they are explicitly logged above.
    if(!"Content-Type".equalsIgnoreCase(name) && !"Content-Length".equalsIgnoreCase(name))
    {
        print(name + ": " + headers.value(i));
    }
}
```
  }
  
  Headers headers = response.headers(); if(headers != null) { for(int i = 0, count = headers.size(); i < count; i++) { print(headers.name(i) + ": " + headers.value(i)); } } }
/**
- 返回响应体字符串
- @param request {@link Request}
- @param response {@link Response}
- @return 响应体字符串 */ private String getResponseBody(Request request, Response response) throws IOException { String body = "[No Response Body]"; if(HttpHeaders.hasBody(response)) { ResponseBody responseBody = response.body(); BufferedSource source = responseBody.source(); source.request(Long.MAX_VALUE); // Buffer the entire body. Buffer buffer = source.buffer();
```
if(isEncoded(request.headers()))
{
    body = "[Body: Encoded]";
}
else if(!isPlaintext(buffer))
{
    String url = request.url().toString();
    if(!url.contains("?"))
    {
        body = String.format("[File:%s]", url.substring(url.lastIndexOf("/") + 1));
    }
    else
    {
        body = "[Body: Not readable]";
    }
}
else
{
    Charset charset = UTF8;
    MediaType contentType = responseBody.contentType();
    if(contentType != null)
    {
        charset = contentType.charset(UTF8);
    }

    body = buffer.clone().readString(charset);
}
```
  }
  
  return body; }
/**
- log打印等级，默认提供了 {@link #DEFAULT}，{@link #WARN} 两种等级，差别在Android Logcat中可以体现出来 */ public interface Logger { void log(String message);
  
  /**
  - A {@link Logger} defaults output appropriate for the current platform. */ Logger DEFAULT = new Logger() { @Override public void log(String message) { Platform.get().log(Platform.INFO, message, null); } };
  /**
  - A {@link Logger} warn level output appropriate for the current platform. */ Logger WARN = new Logger() { @Override public void log(String message) { Platform.get().log(Platform.WARN, message, null); } }; }
/**
- Returns true if the body in question probably contains human readable text. Uses a small sample
- of code points to detect unicode control characters commonly used in binary file signatures. */ private boolean isPlaintext(Buffer buffer) { try { Buffer prefix = new Buffer(); long byteCount = buffer.size() < 64 ? buffer.size() : 64; buffer.copyTo(prefix, 0, byteCount); for(int i = 0; i < 16; i++) { if(prefix.exhausted()) { break; } int codePoint = prefix.readUtf8CodePoint(); if(Character.isISOControl(codePoint) && !Character.isWhitespace(codePoint)) { return false; } } return true; } catch(EOFException e) { return false; // Truncated UTF-8 sequence. } }
/**
- 判断 Headers 是不是编码过的
- @param headers {@link Headers}
- @return {@code true } 编码过的 */ private boolean isEncoded(Headers headers) { String contentEncoding = headers.get("Content-Encoding"); return contentEncoding != null && !contentEncoding.equalsIgnoreCase("identity"); } }`

客户端实现完成，下面介绍App Server的实现首先通过Eclipse J2EE新建一个Dynamic Web Project，然后新建一个ClientRequestHandler（继承自HttpServlet）来实现服务端，代码如下: `package com.johnson4droid.server;

import java.io.IOException;

import javax.servlet.ServletException; import javax.servlet.ServletRequest; import javax.servlet.ServletResponse; import javax.servlet.annotation.WebServlet; import javax.servlet.http.HttpServlet; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; import javax.servlet.http.Part;

import com.alibaba.fastjson.JSONObject; import com.johnson4droid.server.utils.DateUtils; import com.johnson4droid.server.utils.IoUtils;

/**

Servlet implementation class ClientRequestHandler */ @WebServlet("/ClientRequestHandler") public class ClientRequestHandler extends HttpServlet { private static final long serialVersionUID = 1L;

/**
- @see HttpServlet#HttpServlet() */ public ClientRequestHandler() { super(); }
/**
- @see HttpServlet#doGet(HttpServletRequest request, HttpServletResponse
- response) */ protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { // response.getWriter().append("Served at: // ").append(request.getContextPath()); }
/**
- @see HttpServlet#doPost(HttpServletRequest request, HttpServletResponse
- response) */ protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { doGet(request, response);
  
  /*
  - ServletInputStream inputStream = request.getInputStream();
  - byte[] body = IoUtils.inputStream2Bytes(inputStream); String
  - requestBody = new String(body);
  - System.out.println("requestBody: "+requestBody); */
  Part part1 = request.getPart("username"); String username = new String(IoUtils.inputStream2Bytes(part1.getInputStream())); System.out.println("username:" + username);
  
  Part part2 = request.getPart("password"); String password = new String(IoUtils.inputStream2Bytes(part2.getInputStream())); System.out.println("password:" + password);
  
  Part part3 = request.getPart("file"); byte[] fileBytes = IoUtils.inputStream2Bytes(part3.getInputStream()); String fileName = part3.getSubmittedFileName(); //中文文件名乱码 System.out.println("fileName:"+fileName); // IoUtils.saveBytes2File(fileBytes, fileName); String p3ContentType = part3.getContentType(); System.out.println("p3ContentType: "+p3ContentType); IoUtils.saveBytes2File(fileBytes, "C:/Users/johnson4droid/Desktop/files/" + DateUtils.format(System.currentTimeMillis()) + ".png"); /String _fileName = DateUtils.format(System.currentTimeMillis()) + ".png"; IoUtils.saveBytes2File(fileBytes, _fileName); System.out.println("_fileName : "+_fileName);/
  
  JSONObject jsonResp = new JSONObject(); jsonResp.put("code", 0); jsonResp.put("msg", "success"); jsonResp.put("sessionId", request.getSession().getId());
  
  // Send data to client. response.getWriter().write(jsonResp.toJSONString());
}

@Override public void service(ServletRequest arg0, ServletResponse arg1) throws ServletException, IOException { super.service(arg0, arg1); }

@Override protected void service(HttpServletRequest arg0, HttpServletResponse arg1) throws ServletException, IOException { super.service(arg0, arg1); }

在doPost方法中，我们接收字符串参数以及文件参数，并将接收到的文件保存到磁盘中。以下是两个工具类的代码 `package com.johnson4droid.server.utils;

import java.text.SimpleDateFormat; import java.util.Calendar;

/**

@author johnson4droid
*/ public final class DateUtils {

public static final String COMMON_FORMAT = "yyyyMMdd_HH_mm_ss"; private static final SimpleDateFormat DATE_FORMAT_COMMON = new SimpleDateFormat(COMMON_FORMAT);

/**
- */ public DateUtils() { }
public static String format(long time) { Calendar ca = Calendar.getInstance(); ca.setTimeInMillis(time); return DATE_FORMAT_COMMON.format(ca.getTime()); }

`package com.johnson4droid.server.utils;

import java.io.ByteArrayOutputStream; import java.io.FileNotFoundException; import java.io.FileOutputStream; import java.io.IOException; import java.io.InputStream;

/**

@author johnson4droid

*/ public final class IoUtils {

/**

*/ public IoUtils() { }

public static byte[] inputStream2Bytes(InputStream is) { byte[] b = new byte[1024]; ByteArrayOutputStream baos = null; int len = 0;

try {
    baos = new ByteArrayOutputStream();
    while ((len = is.read(b)) != -1) {
        baos.write(b, 0, len);
    }
    return baos.toByteArray();
} catch (IOException e) {
    e.printStackTrace();
} finally {
    if (baos != null) {
        try {
            baos.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    /*
     * if (is != null) { try { is.close(); } catch (IOException e) {
     * e.printStackTrace(); } }
     */
}
return null;

}

public static void saveBytes2File(byte[] fileBytes, String fileName) { FileOutputStream fos = null;

try {
    fos = new FileOutputStream(fileName);
    fos.write(fileBytes);
} catch (FileNotFoundException e) {
    e.printStackTrace();
} catch (IOException e) {
    e.printStackTrace();
} finally {
    if (fos != null) {
        try {
            fos.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

}

最后贴一下web.xml中的配置 `

<?xml version="1.0" encoding="UTF-8"?> <web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://xmlns.jcp.org/xml/ns/javaee" xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd" id="WebApp_ID" version="3.1">

HttpServer

<welcome-file-list>
    <welcome-file>index.html</welcome-file>
    <welcome-file>index.htm</welcome-file>
    <welcome-file>index.jsp</welcome-file>
    <welcome-file>default.html</welcome-file>
    <welcome-file>default.htm</welcome-file>
    <welcome-file>default.jsp</welcome-file>
</welcome-file-list>

<servlet>
    <servlet-name>clientRequest</servlet-name>
    <servlet-class>com.johnson4droid.server.ClientRequestHandler</servlet-class>
    <multipart-config>
        <max-file-size>1000000</max-file-size>
    </multipart-config>
</servlet>

<servlet-mapping>
    <servlet-name>clientRequest</servlet-name>
    <url-pattern>/clientRequest</url-pattern>
</servlet-mapping>

最后将我们创建的服务端程序发布到Tomcat中即可完成服务端发布，可使用上面的客户端代码进行测试。

zhdh2008 / JohnsonUtils4Droid

如何搭建一个简易的App Server #92