intellij netty客户端和服务端

作者: 木子李_af14 | 来源:发表于2017-08-05 12:01 被阅读379次

Netty是一款异步的事件驱动的网络应用程序框架，支持快速地开发可维护的高性能的面向协议的服务器和客户端。 ----摘自《Netty in action》

如果对于Java网络编程不是很熟悉的同学，在第一遍看书的时候，心里肯定是一个大写的懵 - -，所以老老实实的照着教程写了第一个netty的客户端和服务端，并思考了netty的核心组件。

netty的核心组件：

Channel （渠道，出入站数据的载体）
回调
Future
事件和ChannelHandler

新建项目

通过file -> new -> project -> maven
新建一个maven项目，不用选择原型，填写GroupId和ArtifactId，版本号默认。

新建nettyJoin项目

通过file -> new -> Module 新建客户端模块
GroupId和version是默认的，artifactId可以自定义。

客户端模块
同样的方式建立服务端模块

服务端模块

项目结构如下

项目结构

添加依赖与maven插件

主pom.xml文件（最外部的）
这里加了两个插件，一个是maven-compiler-plugin，主要是用在项目编译、打包的时候。一个是exe-maven-plugin，主要是用来执行main函数。

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.netty</groupId>
    <artifactId>nettyJoin</artifactId>
    <packaging>pom</packaging>
    <version>1.0-SNAPSHOT</version>
    <modules>
        <module>nettyClient</module>
        <module>nettyServer</module>
    </modules>
    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>io.netty</groupId>
                <artifactId>netty-all</artifactId>
                <version>4.1.13.Final</version>
            </dependency>
        </dependencies>
    </dependencyManagement>

    <build>
        <pluginManagement>
            <plugins>
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-compiler-plugin</artifactId>
                    <version>3.5.1</version>
                    <configuration>
                        <!-- put your configurations here -->
                        <source>1.7</source>
                        <target>1.7</target>
                    </configuration>
                </plugin>
                <plugin>
                    <groupId>org.codehaus.mojo</groupId>
                    <artifactId>exec-maven-plugin</artifactId>
                    <version>1.2.1</version>
                    <executions>
                        <execution>
                            <goals>
                                <goal>java</goal>
                            </goals>
                        </execution>
                    </executions>
                </plugin>
            </plugins>
        </pluginManagement>
    </build>
</project>

nettyClient的pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <artifactId>nettyJoin</artifactId>
        <groupId>com.netty</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.netty</groupId>
    <artifactId>nettyClient</artifactId>
    <packaging>jar</packaging>

    <dependencies>
        <dependency>
            <groupId>io.netty</groupId>
            <artifactId>netty-all</artifactId>
        </dependency>
    </dependencies>
</project>

nettyServer的pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <artifactId>nettyJoin</artifactId>
        <groupId>com.netty</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.netty</groupId>
    <artifactId>nettyServer</artifactId>
    <packaging>jar</packaging>

    <dependencies>
        <dependency>
            <groupId>io.netty</groupId>
            <artifactId>netty-all</artifactId>
        </dependency>
    </dependencies>
</project>

注：jdk、maven什么的环境变量这里就不累赘了

编写客户端代码

注：代码都是参考《netty in action》中的例子

处理器EchoClientHandler

@ChannelHandler.Sharable
public class EchoClientHandler extends SimpleChannelInboundHandler<ByteBuf> {

    @Override
    protected void channelRead0(ChannelHandlerContext channelHandlerContext,
                                          ByteBuf byteBuf) throws Exception {
        //记录已接收消息的转储
        System.out.println("Client received: " + byteBuf.toString(CharsetUtil.UTF_8));
    }

    /**
     * 作为一个回调函数
     *
     * @param ctx
     * @throws Exception
     */
    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        //当被通知Channel是活跃的时候，发送一条消息
        ctx.writeAndFlush(Unpooled.copiedBuffer("Netty rocks!", CharsetUtil.UTF_8));
    }

    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause)
            throws Exception {
        cause.printStackTrace();
        ctx.close();
    }
}

main函数

public class EchoClient {

    private int port;

    private String host;

    public EchoClient(int port, String host) {
        this.port = port;
        this.host = host;
    }

    public void start() throws InterruptedException {
        //进行事件处理分配，包括创建新的连接以及处理入站和出站数据
        EventLoopGroup group = new NioEventLoopGroup();

        try {
            //创建Bootstrap 初始化客户端
            Bootstrap b = new Bootstrap();
            b.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());
                        }
                    });

            //连接到远程节点，阻塞等待直到连接完成
            ChannelFuture f = b.connect().sync();
            //阻塞，直到channel关闭
            f.channel().closeFuture().sync();
        } finally {
            //关闭线程池并且释放所有的资源
            group.shutdownGracefully().sync();
        }
    }

    public static void main(String[] args) throws InterruptedException {
        if (args.length != 2) {
            System.err.println("Usages: " + EchoClient.class.getSimpleName() + "<host><port>");
            return;
        }

        String host = args[0];
        int port = Integer.parseInt(args[1]);
        new EchoClient(port, host).start();
    }
}

编写服务端代码

处理器EchoServerHandler

@ChannelHandler.Sharable
public class EchoServerHandler extends ChannelInboundHandlerAdapter {

    private Logger logger = Logger.getLogger("com.EchoServerHandler");

    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        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);
    }

    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause)
            throws Exception {
        cause.printStackTrace();
        ctx.close();
    }
}

main函数

public class EchoServer {

    private int port;

    public EchoServer(int port) {
        this.port = port;
    }

    public static void main(String[] args) throws InterruptedException {
        if (args.length != 1) {
            System.err.println("Usages: " + EchoServer.class.getSimpleName() + "<port>");
        }

        int port = Integer.parseInt(args[0]);
        new EchoServer(port).start();
    }

    /**
     * 启动方法
     *
     * @throws InterruptedException
     */
    public void start() throws InterruptedException {
        final EchoServerHandler serverHandler = new EchoServerHandler();

        //1创建EventLoopGroup 用来接收和处理新的连接
        EventLoopGroup group = new NioEventLoopGroup();

        try {
            //2 创建ServerBootstrap
            ServerBootstrap b = new ServerBootstrap();
            b.group(group)
                    //3 制定所使用的NIO传输channel
                    .channel(NioServerSocketChannel.class)
                    //4 使用制定的端口设置套接字地址
                    .localAddress(new InetSocketAddress((port)))
                    //5 添加一个EchoServerHandler到子channel的ChannelPipeLine
                    .childHandler(new ChannelInitializer<SocketChannel>() {

                        @Override
                        protected void initChannel(SocketChannel socketChannel)
                                throws Exception {
                            //EchoServerHandler被标注为@Shareable，所以我们可以总是使用同样的实例
                            socketChannel.pipeline().addLast(serverHandler);
                        }
                    });

            //6 异地绑定服务器；调用sync方法阻塞等待直到绑定完成
            ChannelFuture f = b.bind().sync();
            //7 获取channel的closeFuture，并且阻塞当前线程直到它完成
            f.channel().closeFuture().sync();
        } finally {
            //8 关闭EventLoopGroup释放所有的资源
            group.shutdownGracefully().sync();
        }
    }
}

目录结构

运行项目

现在本地将客户端和服务端的代码打包，进入两个模块的根目录，运行mvn clean package即可。

项目打包

客户端打包

打包成功

运行服务端代码
进入服务端模块的根目录，运行下面的命令，后面跟的是main函数和入参

mvn exec:java -Dexec.mainClass="com.EchoServer" -Dexec.args="9999"

运行结果

服务器启动完毕，并等待连接。

启动客户端
进入客户端模块的根目录，运行下面的命令，后面跟的是main函数和入参

mvn exec:java -Dexec.mainClass="com.EchoClient" -Dexec.args="127.0.0.1 9999"

客户端启动成功

图中右边的是客户端命令行，可以看到已经打印出“Client received: Netty rocks!”，服务端也正常接收到消息，并打印出了“Server received: Netty rocks!”。

小结

可能在代码编写过程中，或是编译打包的过程中，都会碰到各种错误，因为大家的运行环境都各不相同，碰到问题的同学可以在下面留言，也可以自行百度。
这也是我第一次接触netty，才看了书的前两章，接下来也会把自己的总结、感悟写在netty上。

intellij netty客户端和服务端

netty的核心组件：

新建项目

添加依赖与maven插件

编写客户端代码

编写服务端代码

目录结构

运行项目

小结

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读

Java学习笔记