服务端请求第三方服务器

使用场景

类型

• 接收第三方提供的chunked接口
• 接收第三方提供的websocket接
• 接收第三方提供的http接口

解决的问题

• 实时转发给客户端（实时性）
• 服务器协议中转（统一性）

用途

• 作为中转服务
• 服务端获取第三方数据

代码实现（服务端选其一即可）

springboot服务端

• 导入pom包

<!-- 接收chunked使用异步客户端 -->
<dependency>
	<groupId>org.asynchttpclient</groupId>
	<artifactId>async-http-client</artifactId>
	<version>2.12.3</version>
</dependency>
<!-- 创建websocket客户端 -->
<dependency>
	<groupId>org.java-websocket</groupId>
	<artifactId>Java-WebSocket</artifactId>
	<version>1.5.2</version>
</dependency>

• chunked请求

import org.asynchttpclient.*;
import static org.asynchttpclient.Dsl.*;

public class TestChunkedReceiver {
    public static void main(String[] args) {
	    String url = "http://127.0.0.1:7001/chunked/chunked-test";
        AsyncHttpClient httpClient = Dsl.asyncHttpClient();
        String jsonBody = "{\"name\": \"name-test\"}";
        Request request = post(url)
                .setHeader("Content-Type", "application/json")
                .setBody(jsonBody)
                .build();
        httpClient.executeRequest(request, new StreamDataHandler()).get();
    }

    private static class StreamDataHandler extends org.asynchttpclient.AsyncCompletionHandler<Response> {
        @Override
        public State onBodyPartReceived(HttpResponseBodyPart bodyPart)  {
 			// 接收到每一个chunked
            byte[] responseData = bodyPart.getBodyPartBytes();
            String responseStr = new String(responseData);
            System.out.println("每个chunked接收的数据=>" + responseStr);
            // 对每个接收到的响应体部分进行处理
           	...
            return State.CONTINUE;
        }

        @Override
        public Response onCompleted(Response response) {
           	// chunked接收完毕回调
            return response;
        }
    }
}

• websocket请求

import lombok.extern.slf4j.Slf4j;

@Slf4j
public class TestWebsocketReceiver {
    public static void main(String[] args) {
    	URI url = new URI("ws://127.0.0.1:70001/websocket/wesocket-test");
    	WebSocketClient client = new WebSocketClient(url) {
                @Override
                public void onOpen(ServerHandshake serverHandshake) {
                    log.info("[websocket] 连接成功");
                }

                @Override
                public void onMessage(String message) {
                    log.info("[websocket] 收到消息={}", message);
                }

                @Override
                public void onClose(int code, String reason, boolean remote) {
                    log.info("[websocket] 退出连接，{}->{}->{}",code, reason, remote);
                }

                @Override
                public void onError(Exception ex) {
                    log.info("[websocket] 连接错误={}", ex.getMessage());
                }
            };
            // 阻塞进行连接
            client.connectBlocking();
            // websocket客户端已经创建，为了进行进程不关闭，需要等待接收完毕之后再结束进程
            ...
    }
}

EGG服务端

• chunked请求（ajax方法实现，请查看《基于node的http请求工具类》）

const url = 'http://127.0.0.1:7001/chunked/chunked-test';
// 请求数据
ajax(url, 'POST', { usernaem: 'wkj'},{
       'Content-Type': 'application/json',
       'Transfer-Encoding': 'chunked'
   },{
       enableChunked: true,
       chunkReceived(data) {
            const resData = typeof data === 'string' ? data : new TextDecoder().decode(data);
           console.log("chunk接收的数据=>" + resData);
       }
   }
).then(() => {
   console.log("chunked接收数据完毕");
});

• websocket请求

const wsUrl = 'ws://127.0.0.1:7001/websocket/websocket-test';
const websocketClient: any = new WebSocketClient(wsUrl);
// 连接建立完毕，读取数据进行识别
websocketClient.on('open', (event) => {
    console.log('连接上了', event);
});
// 接收消息
websocketClient.on('message', (data, err) => {
	// 得到识别结果后进行处理，仅供参考，具体业务具体对待
    console.log('收到的数据', { data, err });
});
// 资源释放
ws.on('close', () => {
    console.log('连接关闭！！！');
});
// 建连错误
ws.on('error', (err) => {
    console.log('websocket连接错误: ' + err);
});