Java HttpResponseBodyPart类代码示例

import org.asynchttpclient.HttpResponseBodyPart; //导入依赖的package包/类
public void onBinaryFragment(HttpResponseBodyPart part) {

        for (WebSocketListener listener : listeners) {
            if (listener instanceof WebSocketByteFragmentListener)
                WebSocketByteFragmentListener.class.cast(listener).onFragment(part);
        }

        if (interestedInByteMessages) {
            byte[] fragment = part.getBodyPartBytes();

            if (part.isLast()) {
                if (bufferSize == 0) {
                    notifyByteListeners(fragment);

                } else {
                    bufferFragment(fragment);
                    notifyByteListeners(fragmentsBytes());
                }

                reset();

            } else
                bufferFragment(fragment);
        }
    }
 

import org.asynchttpclient.HttpResponseBodyPart; //导入依赖的package包/类
public void onTextFragment(HttpResponseBodyPart part) {
    for (WebSocketListener listener : listeners) {
        if (listener instanceof WebSocketTextFragmentListener)
            WebSocketTextFragmentListener.class.cast(listener).onFragment(part);
    }

    if (interestedInTextMessages) {
        byte[] fragment = part.getBodyPartBytes();

        if (part.isLast()) {
            if (bufferSize == 0) {
                notifyTextListeners(fragment);

            } else {
                bufferFragment(fragment);
                notifyTextListeners(fragmentsBytes());
            }

            reset();

        } else
            bufferFragment(fragment);
    }
}
 

import org.asynchttpclient.HttpResponseBodyPart; //导入依赖的package包/类
private void handleFrame(Channel channel, WebSocketFrame frame, WebSocketUpgradeHandler handler, NettyWebSocket webSocket) throws Exception {
    if (frame instanceof CloseWebSocketFrame) {
        Channels.setDiscard(channel);
        CloseWebSocketFrame closeFrame = (CloseWebSocketFrame) frame;
        webSocket.onClose(closeFrame.statusCode(), closeFrame.reasonText());
    } else {
        ByteBuf buf = frame.content();
        if (buf != null && buf.readableBytes() > 0) {
            HttpResponseBodyPart part = config.getResponseBodyPartFactory().newResponseBodyPart(buf, frame.isFinalFragment());
            handler.onBodyPartReceived(part);

            if (frame instanceof BinaryWebSocketFrame) {
                webSocket.onBinaryFragment(part);
            } else if (frame instanceof TextWebSocketFrame) {
                webSocket.onTextFragment(part);
            } else if (frame instanceof PingWebSocketFrame) {
                webSocket.onPing(part);
            } else if (frame instanceof PongWebSocketFrame) {
                webSocket.onPong(part);
            }
        }
    }
}
 

import org.asynchttpclient.HttpResponseBodyPart; //导入依赖的package包/类
private void handleChunk(HttpContent chunk,//
        final Channel channel,//
        final NettyResponseFuture<?> future,//
        AsyncHandler<?> handler) throws IOException, Exception {

    boolean interrupt = false;
    boolean last = chunk instanceof LastHttpContent;

    // Netty 4: the last chunk is not empty
    if (last) {
        LastHttpContent lastChunk = (LastHttpContent) chunk;
        HttpHeaders trailingHeaders = lastChunk.trailingHeaders();
        if (!trailingHeaders.isEmpty()) {
            interrupt = handler.onHeadersReceived(new HttpResponseHeaders(trailingHeaders, true)) != State.CONTINUE;
        }
    }

    ByteBuf buf = chunk.content();
    if (!interrupt && !(handler instanceof StreamedAsyncHandler) && (buf.readableBytes() > 0 || last)) {
        HttpResponseBodyPart part = config.getResponseBodyPartFactory().newResponseBodyPart(buf, last);
        interrupt = updateBodyAndInterrupt(future, handler, part);
    }

    if (interrupt || last)
        finishUpdate(future, channel, !last);
}
 

import org.asynchttpclient.HttpResponseBodyPart; //导入依赖的package包/类
/**
 * {@inheritDoc}
 */
@Override
public AsyncHandler.State onBodyPartReceived(HttpResponseBodyPart bodyPart) throws Exception {

    if (accumulateBody) {
        responseBuilder.accumulate(bodyPart);
    }

    State state = State.CONTINUE;
    try {
        resumableListener.onBytesReceived(bodyPart.getBodyByteBuffer());
    } catch (IOException ex) {
        return AsyncHandler.State.ABORT;
    }

    if (decoratedAsyncHandler != null) {
        state = decoratedAsyncHandler.onBodyPartReceived(bodyPart);
    }

    byteTransferred.addAndGet(bodyPart.getBodyPartBytes().length);
    resumableProcessor.put(url, byteTransferred.get());

    return state;
}
 

import org.asynchttpclient.HttpResponseBodyPart; //导入依赖的package包/类
@Test
public void testOnBodyPartReceivedWithDecoratedAsyncHandler() throws Exception {
    HttpResponseBodyPart bodyPart = PowerMockito.mock(HttpResponseBodyPart.class);
    when(bodyPart.getBodyPartBytes()).thenReturn(new byte[0]);
    ByteBuffer buffer = ByteBuffer.allocate(0);
    when(bodyPart.getBodyByteBuffer()).thenReturn(buffer);

    @SuppressWarnings("unchecked")
    AsyncHandler<Response> decoratedAsyncHandler = mock(AsyncHandler.class);
    State mockState = mock(State.class);
    when(decoratedAsyncHandler.onBodyPartReceived(bodyPart)).thenReturn(mockState);

    // following is needed to set the url variable
    HttpResponseStatus mockResponseStatus = mock(HttpResponseStatus.class);
    when(mockResponseStatus.getStatusCode()).thenReturn(200);
    Uri mockUri = mock(Uri.class);
    when(mockUri.toUrl()).thenReturn("http://non.null");
    when(mockResponseStatus.getUri()).thenReturn(mockUri);

    ResumableAsyncHandler handler = new ResumableAsyncHandler(decoratedAsyncHandler);
    handler.onStatusReceived(mockResponseStatus);

    State state = handler.onBodyPartReceived(bodyPart);
    assertEquals(state, mockState, "State should be equal to the state returned from decoratedAsyncHandler");

}
 

import org.asynchttpclient.HttpResponseBodyPart; //导入依赖的package包/类
public void onPing(HttpResponseBodyPart part) {
    for (WebSocketListener listener : listeners) {
        if (listener instanceof WebSocketPingListener)
            // bytes are cached in the part
            WebSocketPingListener.class.cast(listener).onPing(part.getBodyPartBytes());
    }
}
 

import org.asynchttpclient.HttpResponseBodyPart; //导入依赖的package包/类
public void onPong(HttpResponseBodyPart part) {
    for (WebSocketListener listener : listeners) {
        if (listener instanceof WebSocketPongListener)
            // bytes are cached in the part
            WebSocketPongListener.class.cast(listener).onPong(part.getBodyPartBytes());
    }
}
 

import org.asynchttpclient.HttpResponseBodyPart; //导入依赖的package包/类
public NettyResponse(HttpResponseStatus status,//
        HttpResponseHeaders headers,//
        List<HttpResponseBodyPart> bodyParts) {
    this.bodyParts = bodyParts;
    this.headers = headers;
    this.status = status;
}
 

import org.asynchttpclient.HttpResponseBodyPart; //导入依赖的package包/类
public State onBodyPartReceived(HttpResponseBodyPart bodyPart) throws Exception {
    // body arrived, flush headers
    if (!responseSet) {
        response = responseBuilder.build();
        responseSet = true;
        headersArrived.countDown();
    }

    output.write(bodyPart.getBodyPartBytes());
    return State.CONTINUE;
}
 

import org.asynchttpclient.HttpResponseBodyPart; //导入依赖的package包/类
@Override
public State onBodyPartReceived(final HttpResponseBodyPart content) throws Exception {
    State s = State.CONTINUE;
    if (accumulateResponseBytes) {
        s = super.onBodyPartReceived(content);
    }
    fireOnBytesReceived(content.getBodyPartBytes());
    return s;
}
 

import org.asynchttpclient.HttpResponseBodyPart; //导入依赖的package包/类
@Test(groups = "standalone")
public void zeroCopyFileTest() throws IOException, ExecutionException, TimeoutException, InterruptedException, URISyntaxException {
    File tmp = new File(System.getProperty("java.io.tmpdir") + File.separator + "zeroCopy.txt");
    tmp.deleteOnExit();
    try (AsyncHttpClient client = asyncHttpClient()) {
        try (FileOutputStream stream = new FileOutputStream(tmp)) {
            Response resp = client.preparePost("http://localhost:" + port1 + "/").setBody(SIMPLE_TEXT_FILE).execute(new AsyncHandler<Response>() {
                public void onThrowable(Throwable t) {
                }

                public State onBodyPartReceived(HttpResponseBodyPart bodyPart) throws Exception {
                    stream.write(bodyPart.getBodyPartBytes());
                    return State.CONTINUE;
                }

                public State onStatusReceived(HttpResponseStatus responseStatus) throws Exception {
                    return State.CONTINUE;
                }

                public State onHeadersReceived(HttpResponseHeaders headers) throws Exception {
                    return State.CONTINUE;
                }

                public Response onCompleted() throws Exception {
                    return null;
                }
            }).get();
            assertNull(resp);
            assertEquals(SIMPLE_TEXT_FILE.length(), tmp.length());
        }
    }
}
 

import org.asynchttpclient.HttpResponseBodyPart; //导入依赖的package包/类
@Test(groups = "standalone")
public void zeroCopyFileWithBodyManipulationTest() throws IOException, ExecutionException, TimeoutException, InterruptedException, URISyntaxException {
    File tmp = new File(System.getProperty("java.io.tmpdir") + File.separator + "zeroCopy.txt");
    tmp.deleteOnExit();
    try (AsyncHttpClient client = asyncHttpClient()) {
        try (FileOutputStream stream = new FileOutputStream(tmp)) {
            Response resp = client.preparePost("http://localhost:" + port1 + "/").setBody(SIMPLE_TEXT_FILE).execute(new AsyncHandler<Response>() {
                public void onThrowable(Throwable t) {
                }

                public State onBodyPartReceived(HttpResponseBodyPart bodyPart) throws Exception {
                    stream.write(bodyPart.getBodyPartBytes());

                    if (bodyPart.getBodyPartBytes().length == 0) {
                        return State.ABORT;
                    }

                    return State.CONTINUE;
                }

                public State onStatusReceived(HttpResponseStatus responseStatus) throws Exception {
                    return State.CONTINUE;
                }

                public State onHeadersReceived(HttpResponseHeaders headers) throws Exception {
                    return State.CONTINUE;
                }

                public Response onCompleted() throws Exception {
                    return null;
                }
            }).get();
            assertNull(resp);
            assertEquals(SIMPLE_TEXT_FILE.length(), tmp.length());
        }
    }
}
 

import org.asynchttpclient.HttpResponseBodyPart; //导入依赖的package包/类
@Override
public void onNext(HttpResponseBodyPart t) {
    streamStarted.countDown();
    try {
        streamOnHold.await();
    } catch (InterruptedException e) {
        LOGGER.error("`streamOnHold` latch was interrupted", e);
    }
    super.onNext(t);
}
 

import org.asynchttpclient.HttpResponseBodyPart; //导入依赖的package包/类
@Test
public void testOnBodyPartReceived() throws Exception {
    ResumableAsyncHandler handler = new ResumableAsyncHandler();
    HttpResponseBodyPart bodyPart = PowerMockito.mock(HttpResponseBodyPart.class);
    when(bodyPart.getBodyPartBytes()).thenReturn(new byte[0]);
    ByteBuffer buffer = ByteBuffer.allocate(0);
    when(bodyPart.getBodyByteBuffer()).thenReturn(buffer);
    State state = handler.onBodyPartReceived(bodyPart);
    assertEquals(state, AsyncHandler.State.CONTINUE, "State should be CONTINUE for a successful onBodyPartReceived");
}