Java ChunkedInput类代码示例

import io.netty.handler.stream.ChunkedInput; //导入依赖的package包/类
private static void check(ChunkedInput<?>... inputs) {
    EmbeddedChannel ch = new EmbeddedChannel(new ChunkedWriteHandler());

    for (ChunkedInput<?> input : inputs) {
        ch.writeOutbound(input);
    }

    assertTrue(ch.finish());

    int i = 0;
    int read = 0;
    HttpContent lastHttpContent = null;
    for (;;) {
        HttpContent httpContent = (HttpContent) ch.readOutbound();
        if (httpContent == null) {
            break;
        }
        if (lastHttpContent != null) {
            assertTrue("Chunk must be DefaultHttpContent", lastHttpContent instanceof DefaultHttpContent);
        }

        ByteBuf buffer = httpContent.content();
        while (buffer.isReadable()) {
            assertEquals(BYTES[i++], buffer.readByte());
            read++;
            if (i == BYTES.length) {
                i = 0;
            }
        }
        buffer.release();

        // Save last chunk
        lastHttpContent = httpContent;
    }

    assertEquals(BYTES.length * inputs.length, read);
    assertSame("Last chunk must be DefaultLastHttpContent", LastHttpContent.EMPTY_LAST_CONTENT, lastHttpContent);
}
 

import io.netty.handler.stream.ChunkedInput; //导入依赖的package包/类
private static String objectToString(Object o) {
  if (o instanceof SmtpRequest) {
    SmtpRequest request = (SmtpRequest) o;

    if (request.command().equals(AUTH_COMMAND)) {
      return "<redacted-auth-command>";
    } else {
      return String.format("%s %s", request.command().name(), Joiner.on(" ").join(request.parameters()));
    }
  } else if (o instanceof SmtpContent || o instanceof ByteBuf || o instanceof ChunkedInput) {
    return "[CONTENT]";
  } else {
    return o.toString();
  }
}
 

import io.netty.handler.stream.ChunkedInput; //导入依赖的package包/类
@Override
public ChunkedInput<ByteBuf> chunkFile(FileChannel fileChannel) {
	try {
		//TODO tune the chunk size
		return new ChunkedNioFile(fileChannel, 1024);
	}
	catch (IOException e) {
		throw Exceptions.propagate(e);
	}
}
 

import io.netty.handler.stream.ChunkedInput; //导入依赖的package包/类
default NettyOutbound sendFileChunked(Path file, long position, long count) {
	Objects.requireNonNull(file);
	final FileChunkedStrategy strategy = getFileChunkedStrategy();
	final boolean needChunkedWriteHandler = context().channel().pipeline().get(NettyPipeline.ChunkedWriter) == null;
	if (needChunkedWriteHandler) {
		strategy.preparePipeline(context());
	}

	return then(Mono.using(() -> FileChannel.open(file, StandardOpenOption.READ),
			fc -> {
					try {
						ChunkedInput<?> message = strategy.chunkFile(fc);
						return FutureMono.from(context().channel().writeAndFlush(message));
					}
					catch (Exception e) {
						return Mono.error(e);
					}
			},
			fc -> {
				try {
					fc.close();
				}
				catch (IOException ioe) {/*IGNORE*/}
				finally {
					strategy.cleanupPipeline(context());
				}
			}));
}
 

import io.netty.handler.stream.ChunkedInput; //导入依赖的package包/类
@Override
public ChunkedInput<HttpContent> chunkFile(FileChannel fileChannel) {
	try {
		//TODO tune the chunk size
		return new HttpChunkedInput(new ChunkedNioFile(fileChannel, 1024));
	}
	catch (IOException e) {
		throw Exceptions.propagate(e);
	}
}
 

import io.netty.handler.stream.ChunkedInput; //导入依赖的package包/类
@Override
public ChunkedInput<ByteBuf> chunkFile(FileChannel fileChannel) {
	try {
		return new ChunkedNioFile(fileChannel, 1024);
	}
	catch (IOException e) {
		throw Exceptions.propagate(e);
	}
}
 

import io.netty.handler.stream.ChunkedInput; //导入依赖的package包/类
public void send(ChunkedInput<HttpContent> content) {
	if (this.chan != null)  
		this.chan.write(content);
	
	/* TODO we don't need this?
	.addListener(new GenericFutureListener<Future<? super Void>>() {
			@Override
			public void operationComplete(Future<? super Void> future)
					throws Exception {
				//System.out.println("Sending an end");
				//HttpContext.this.response.writeEnd(HttpContext.this.chan);
			}
		});
		*/
}
 

import io.netty.handler.stream.ChunkedInput; //导入依赖的package包/类
/**
 * Creates a new instance using the specified input.
 * @param input {@link ChunkedInput} containing data to write
 */
public HttpChunkedInput(ChunkedInput<ByteBuf> input) {
    this.input = input;
    lastHttpContent = LastHttpContent.EMPTY_LAST_CONTENT;
}
 

import io.netty.handler.stream.ChunkedInput; //导入依赖的package包/类
static ChunkedInput<HttpContent> create(ChunkSource chunkSource) throws IOException {
    return new ChunkSourceChunkedInput(chunkSource);
}
 

import io.netty.handler.stream.ChunkedInput; //导入依赖的package包/类
static ChunkedInput<HttpContent> createZipFileDownload(ChunkSource chunkSource, String fileName)
        throws IOException {
    return new ZipFileChunkedInput(chunkSource, fileName);
}
 

import io.netty.handler.stream.ChunkedInput; //导入依赖的package包/类
public HttpChunkedBodyEncoder( ChunkedInput<ByteBuf> chunkedBody )
{
    this.chunkedBody = chunkedBody;
}
 

import io.netty.handler.stream.ChunkedInput; //导入依赖的package包/类
public void send(ChunkedInput<HttpContent> content) {
	this.innerctx.send(content);
}
 

import io.netty.handler.stream.ChunkedInput; //导入依赖的package包/类
@Override
public void send(ChunkedInput<HttpContent> content) {
	System.out.println("unexpected send chunk");
}
 

import io.netty.handler.stream.ChunkedInput; //导入依赖的package包/类
@Override
public ChunkedInput<ByteBuf> open() throws IOException {
    return new EmptyChunkedInput<ByteBuf>();
}
 

import io.netty.handler.stream.ChunkedInput; //导入依赖的package包/类
@Override
public ChunkedInput<ByteBuf> open(Long from, Long to) throws IOException {
    return new SliceByteInput(open(), from, to);
}