Java网络编程学习笔记(未完待续)
写给自己的,也写给大家一起学习,有错误的地方欢迎交流。Over
参考:1.马士兵老师的公开课
IO(Input/Output)模型
BIO -> NIO -> AIO
- BIO:Blocking IO,阻塞IO
- NIO:Non-Blocking IO,非阻塞IO
- Single thread,单线程模型
- Reactor模式
- AIO:AsyncAsynchronous IO,异步IO(不再需要轮询)
- 设计模式:观察者(Observer)模式
Netty
Netty实际上是对NIO进行了封装,提供了更好用的API,写法有些类似于AIO。
Netty提供了io.netty.channel.nio.NioEventLoopGroup;类,类似于AIO中的ExcutorService+AsynchronousChannelGroup的作用。另外它提供了io.netty.buffer.ByteBuf;类用来代替java.nio.ByteBuffer;显然Netty提供的ByteBuf更加好用
- 方便理解直接上Netty的Server端示例代码。这里throws了Exception用来精简代码,实际开发中不推荐使用。
import io.netty.bootstrap.ServerBootstrap;
import io.netty.buffer.ByteBuf;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.nio.NioServerSocketChannel;
import io.netty.channel.socket.nio.NioSocketChannel;
import io.netty.util.CharsetUtil;
public class HelloNetty{
public static void main(String[] args) {
new NettyServer(8888).serverStart();
}
}
class NettyServer {
int port = 8888;
public NettyServer(int port){
this.port = port;
}
public void serverStart(){
/**
*bossGroup负责建立连接,类似selector
*workerGroup负责进行真正的进行读写等操作,连接建立后boosGroup会把工作交给worker
*这两个可以理解成两个线程池,可以加int型参数
*/
NioEventLoopGroup bossGroup = new NioEventLoopGroup();
NioEventLoopGroup workerGroup = new NioEventLoopGroup();
/**
*对server启动进行一些配置,类似于启动器
*/
ServerBootstrap serverBootstrap = new ServerBootstrap();
/**
*group方法的第一个参数负责连接,第二个参数负责连接之后的IO处理
*channel指定了连接的通道类型
*childHandler意思是当有客户端连接上之后指定一个监听器去处理,这个监听器处理的过程是在这个通道上加一个处理器(又是一个监听器)去处理。在这里我认为这是两个钩子函数,当有客户端连接时调用,当有IO操作时调用
**/
serverBootstrap
.group(bossGroup,workerGroup)
.channel(NioServerSocketChannel.class)
.childHandler(new ChannelInitializer<NioSocketChannel>() {
@Override
protected void initChannel(NioSocketChannel nioSocketChannel) throws Exception {
nioSocketChannel.pipeline().addLast(new Handler());
}
});
try{
ChannelFuture channelFuture = serverBootstrap.bind(port).sync();
channelFuture.channel().closeFuture().sync();
}catch (Exception e){
e.printStackTrace();
}
finally {
workerGroup.shutdownGracefully();
bossGroup.shutdownGracefully();
}
}
}
/**
*自定义的处理器,通过addLast方法加入到处理逻辑中,这里的逻辑是当通道可以读的时候就进行读取,并把结果写回给客户端
*/
class Handler extends ChannelInboundHandlerAdapter{
/**
*当通道可读时进行读取,并写回给客户端,然后关闭通道
*/
@Override
public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
System.out.println("server : channel read");
ByteBuf byteBuf = (ByteBuf)msg;
System.out.println(byteBuf.toString(CharsetUtil.UTF_8));
ctx.writeAndFlush(msg);
ctx.close();
}
/**
*处理异常的函数,一般来说需要关闭通道
*/
@Override
public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
cause.printStackTrace();
ctx.close();
}
}
- Netty的Client端
import io.netty.bootstrap.Bootstrap;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.channel.*;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioSocketChannel;
import io.netty.util.CharsetUtil;
import io.netty.util.ReferenceCountUtil;
public class Client {
public static void main(String[] args) {
new Client().clientStart();
}
public void clientStart(){
/**
*Client端只需要workers
*/
EventLoopGroup workers = new NioEventLoopGroup();
Bootstrap bootstrap = new Bootstrap();
/**
*这里的handler中的参数是在通道初始化时将自己的Handler调用
*/
bootstrap
.group(workers)
.channel(NioSocketChannel.class)
.handler(new ChannelInitializer<SocketChannel>() {
protected void initChannel(SocketChannel socketChannel) throws Exception {
System.out.println("chanenel initialized!");
socketChannel.pipeline().addLast(new ClientHandler());
}
});
try {
System.out.println("Start to connect!");
ChannelFuture channelFuture = bootstrap.connect("127.0.0.1",8888);
channelFuture.channel().closeFuture().sync();
}
catch (Exception e){
e.printStackTrace();
}
finally {
workers.shutdownGracefully();
}
}
}
/**
*自己的Handler逻辑
*这里的思路是当通道激活时向服务器写入"Hellow Netty"
*当通道可读时读取通道上的内容并打印
*/
class ClientHandler extends ChannelInboundHandlerAdapter {
@Override
public void channelActive(ChannelHandlerContext ctx) throws Exception {
System.out.println("Channel is activated!");
final ChannelFuture channelFuture = ctx.writeAndFlush(Unpooled.copiedBuffer("HelloNetty".getBytes()));
channelFuture.addListener(new ChannelFutureListener() {
public void operationComplete(ChannelFuture channelFuture) throws Exception {
System.out.println("msg send!");
}
});
}
@Override
public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
try {
ByteBuf byteBuf = (ByteBuf)msg;
System.out.println(byteBuf.toString(CharsetUtil.UTF_8));
}
finally {
ReferenceCountUtil.release(msg);
}
}
}