1

2

3

4

5

6

<!-- https://mvnrepository.com/artifact/io.netty/netty-all -->

<dependency>

<groupId>io.netty</groupId>

<artifactId>netty-all</artifactId>

<version>4.1.16.Final</version>

</dependency>

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

import io.netty.buffer.ByteBuf;

import io.netty.buffer.Unpooled;

import io.netty.channel.ChannelFutureListener;

import io.netty.channel.ChannelHandler.Sharable;

import io.netty.channel.ChannelHandlerContext;

import io.netty.channel.ChannelInboundHandlerAdapter;

import io.netty.util.CharsetUtil;

@Sharable

public class EchoServerHandler extends ChannelInboundHandlerAdapter{

@Override

public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {

//将客户端传入的消息转换为Netty的ByteBuf类型

ByteBuf in = (ByteBuf) msg;

// 在控制台打印传入的消息

System.out.println(

"Server received: " + in.toString(CharsetUtil.UTF_8)

);

//将接收到的消息写给发送者，而不冲刷出站消息

ctx.write(in);

}

@Override

public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {

// 将未处决消息冲刷到远程节点， 并且关闭该Channel

ctx.writeAndFlush(Unpooled.EMPTY_BUFFER)

.addListener(ChannelFutureListener.CLOSE);

}

/**

* 异常处理

* @param ctx

* @param cause

* @throws Exception

*/

@Override

public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {

//打印异常栈跟踪

cause.printStackTrace();

// 关闭该Channel

ctx.close();

}

}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

import io.netty.bootstrap.ServerBootstrap;

import io.netty.channel.ChannelFuture;

import io.netty.channel.ChannelInitializer;

import io.netty.channel.EventLoopGroup;

import io.netty.channel.nio.NioEventLoopGroup;

import io.netty.channel.socket.SocketChannel;

import io.netty.channel.socket.nio.NioServerSocketChannel;

import java.net.InetSocketAddress;

public class EchoServer {

private final static int port = 8080;

public static void main(String[] args) {

start();

}

private static void start() {

final EchoServerHandler serverHandler = new EchoServerHandler();

// 创建EventLoopGroup

EventLoopGroup bossGroup = new NioEventLoopGroup();

EventLoopGroup workerGroup = new NioEventLoopGroup();

// 创建EventLoopGroup

ServerBootstrap b = new ServerBootstrap();

b.group(bossGroup, workerGroup)

//指定所使用的NIO传输Channel

.channel(NioServerSocketChannel.class)

//使用指定的端口设置套接字地址

.localAddress(new InetSocketAddress(port))

// 添加一个EchoServerHandler到Channle的ChannelPipeline

.childHandler(new ChannelInitializer<SocketChannel>() {

@Override

protected void initChannel(SocketChannel socketChannel) throws Exception {

//EchoServerHandler被标注为@shareable,所以我们可以总是使用同样的案例

socketChannel.pipeline().addLast(serverHandler);

}

});

try {

// 异步地绑定服务器;调用sync方法阻塞等待直到绑定完成

ChannelFuture f = b.bind().sync();

// 获取Channel的CloseFuture，并且阻塞当前线程直到它完成

f.channel().closeFuture().sync();

} catch (InterruptedException e) {

e.printStackTrace();

} finally {

// 优雅的关闭EventLoopGroup，释放所有的资源

bossGroup.shutdownGracefully();

workerGroup.shutdownGracefully();

}

}

}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

import io.netty.buffer.ByteBuf;

import io.netty.buffer.Unpooled;

import io.netty.channel.ChannelHandler.Sharable;

import io.netty.channel.ChannelHandlerContext;

import io.netty.channel.SimpleChannelInboundHandler;

import io.netty.util.CharsetUtil;

@Sharable

public class EchoClientHandler extends SimpleChannelInboundHandler<ByteBuf> {

@Override

public void channelActive(ChannelHandlerContext ctx) throws Exception {

//当被通知Channel是活跃的时候，发送一条消息

ctx.writeAndFlush(Unpooled.copiedBuffer("Netty rocks!", CharsetUtil.UTF_8));

}

@Override

protected void channelRead0(ChannelHandlerContext channelHandlerContext, ByteBuf byteBuf) throws Exception {

System.out.println(

"Client received: " + byteBuf.toString(CharsetUtil.UTF_8)

);

}

@Override

public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {

cause.printStackTrace();

ctx.close();

}

}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

import io.netty.bootstrap.Bootstrap;

import io.netty.channel.ChannelFuture;

import io.netty.channel.ChannelInitializer;

import io.netty.channel.EventLoopGroup;

import io.netty.channel.nio.NioEventLoopGroup;

import io.netty.channel.socket.SocketChannel;

import io.netty.channel.socket.nio.NioSocketChannel;

import java.net.InetSocketAddress;

public class EchoClient {

private final static String HOST = "localhost";

private final static int PORT = 8080;

public static void start() {

EventLoopGroup group = new NioEventLoopGroup();

Bootstrap bootstrap = new Bootstrap();

bootstrap.group(group)

.channel(NioSocketChannel.class)

.remoteAddress(new InetSocketAddress(HOST, PORT))

.handler(new ChannelInitializer<SocketChannel>() {

@Override

protected void initChannel(SocketChannel socketChannel) throws Exception {

socketChannel.pipeline().addLast(new EchoClientHandler());

}

});

try {

ChannelFuture f = bootstrap.connect().sync();

f.channel().closeFuture().sync();

} catch (InterruptedException e) {

e.printStackTrace();

}finally {

group.shutdownGracefully();

}

}

public static void main(String[] args) {

start();

}

}