精华内容
下载资源
问答
  • netty服务器son解析

    2021-08-23 15:33:05
    netty服务器son解析
  • Netty服务器与客户端

    2017-02-17 15:25:11
    Netty服务器与客户端
  • netty服务器解析16进制数据
  • netty服务器通讯说明: 服务器条件NETTY框架编程: 服务器IP:192.168.2.106 端口8810 数据传输的方式:从串口接收到一条完整的协议数据,计算出数据字节长度,打包成HtAlingProtocol类,并发送给服务器; package ...
  • 净度量 在Netty服务器上使用度量
  • 前言使用idea快速搭建基于maven的netty服务器项目1.新建空白maven项目file-new-project选择maven空白项目,输入groupid和artifactid,一路点next 2.引入netty maven 依赖pom.xml 文件加入netty-all 依赖io....

    前言

    使用idea快速搭建基于maven的netty服务器项目

    1.新建空白maven项目

    file-new-project

    选择maven空白项目,输入groupid和artifactid,一路点next

    6c8ff6117e969da5c52f0226ee91cf3a.png

    2.引入netty maven 依赖

    pom.xml 文件加入netty-all 依赖

    io.netty

    netty-all

    4.1.42.Final

    3.服务器代码

    tcp套接字server

    创建ServerBootstrap,io模式为nio。同时自定义handler消息处理。

    server代码:

    public static void main(String[] args) throws InterruptedException {

    //config the server

    EventLoopGroup bossGroup = new NioEventLoopGroup();

    EventLoopGroup workerGroup = new NioEventLoopGroup();

    try{

    ServerBootstrap b = new ServerBootstrap();

    b.channel(NioServerSocketChannel.class)

    .group(bossGroup,workerGroup)

    .handler(new LoggingHandler(LogLevel.INFO))

    .childHandler(new ChannelInitializer() {

    protected void initChannel(SocketChannel ch) throws Exception {

    ChannelPipeline pipeline = ch.pipeline();

    pipeline.addLast(new LoggingHandler(LogLevel.INFO))

    .addLast(new EchoServerHandler());

    }

    });

    //start the server

    ChannelFuture future = b.bind(8090).sync();

    //wait until server is closed

    future.channel().closeFuture().sync();

    }finally {

    //shut down the event loop to terminate all threads

    bossGroup.shutdownGracefully();

    workerGroup.shutdownGracefully();

    }

    }

    handler代码:

    public class EchoServerHandler extends ChannelInboundHandlerAdapter {

    @Override

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

    ctx.write(msg);

    }

    @Override

    public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {

    ctx.flush();

    }

    @Override

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

    cause.printStackTrace();

    ctx.close();

    }

    }

    http server

    server 代码

    public class HttpHelloWorldServer {

    public static void main(String[] args) throws InterruptedException {

    //config the server

    NioEventLoopGroup bossGroup = new NioEventLoopGroup(1);

    NioEventLoopGroup group = new NioEventLoopGroup();

    try{

    ServerBootstrap b = new ServerBootstrap();

    b.group(bossGroup,group)

    .channel(NioServerSocketChannel.class)

    .handler(new LoggingHandler(LogLevel.INFO))

    .childHandler(new ChannelInitializer(){

    protected void initChannel(Channel ch) throws Exception {

    ChannelPipeline p = ch.pipeline();

    p.addLast(new HttpServerCodec())

    .addLast(new HttpServerExpectContinueHandler())

    .addLast(new HttpHelloWorldServerHandler());

    }

    });

    //start the server

    ChannelFuture future = b.bind(8090).sync();

    System.out.println("open you browser and navigate to 127.0.0.1:8090");

    //wait until server is closed

    future.channel().closeFuture().sync();

    }finally {

    bossGroup.shutdownGracefully();

    group.shutdownGracefully();

    }

    }

    }

    handler代码

    public class HttpHelloWorldServerHandler extends SimpleChannelInboundHandler {

    private static final byte[] CONTENT = "helloworld".getBytes();

    protected void channelRead0(ChannelHandlerContext ctx, HttpObject msg) throws Exception {

    if (msg instanceof HttpRequest){

    HttpRequest request = (HttpRequest) msg;

    FullHttpResponse response = new DefaultFullHttpResponse(request.protocolVersion(), OK,Unpooled.wrappedBuffer(CONTENT));

    response.headers()

    .set(CONTENT_TYPE, TEXT_PLAIN)

    .setInt(CONTENT_LENGTH, response.content().readableBytes());

    ChannelFuture f = ctx.write(response);

    }

    }

    @Override

    public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {

    ctx.flush();

    }

    @Override

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

    cause.printStackTrace();

    ctx.close();

    }

    }

    测试

    首先测试tcp server。我们同时新建一个客户端与server进行交互:

    client代码

    public class EchoClient {

    public static void main(String[] args) throws InterruptedException {

    //config the client

    EventLoopGroup group = new NioEventLoopGroup();

    try{

    Bootstrap bootstrap = new Bootstrap();

    bootstrap.group(group)

    .channel(NioSocketChannel.class)

    .option(ChannelOption.TCP_NODELAY,true)

    .handler(new ChannelInitializer() {

    protected void initChannel(SocketChannel ch) throws Exception {

    ChannelPipeline pipeline = ch.pipeline();

    pipeline.addLast(new LoggingHandler(LogLevel.INFO))

    .addLast(new EchoClientHandler());

    }

    });

    //start the client

    ChannelFuture future = bootstrap.connect("127.0.0.1", 8090).sync();

    //wait until the connection is closed

    future.channel().closeFuture().sync();

    }finally {

    //shut down the event loop to terminate all threads

    group.shutdownGracefully();

    }

    }

    }

    clienhandler

    public class EchoClientHandler extends ChannelInboundHandlerAdapter {

    private final ByteBuf firstMsg;

    public EchoClientHandler() {

    this.firstMsg = Unpooled.wrappedBuffer("i am echo message".getBytes());

    }

    @Override

    public void channelActive(ChannelHandlerContext ctx) throws Exception {

    ctx.writeAndFlush(firstMsg);

    }

    @Override

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

    ctx.write(msg);

    }

    @Override

    public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {

    TimeUnit.SECONDS.sleep(3);

    ctx.flush();

    }

    @Override

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

    cause.printStackTrace();

    ctx.close();

    }

    }

    先启动server,绑定端口8090。再启动client。连接server。

    server日志:

    43f46a7c5852b568eaab34df92294575.png

    client 日志

    2e4c8bebc6c8dd4cac15f2d69cc4e85b.png

    可以看到客户端向服务器发送了一条消息,服务器收到消息原封不动回复客户端,客户端收到消息又原封不同回复服务器。像互相踢皮球一样。

    然后再看下http server:

    启动HttpHelloworldServer,然后打开浏览器访问http://127.0.0.1:8090。页面会出现helloworld的文字。

    863473ddc9184ea453a50c920b911c9b.png

    server日志

    396bd05070df9998ab181abf9d6d31f3.png

    最后

    示例代码: my-netty-example

    展开全文
  • Netty服务器+消息队列

    千次阅读 2020-09-17 16:05:34
    文章目录Netty服务器+消息队列一、系统架构图二、搭建netty服务器三、将netty接收到的信息发布到消息队列四、创建消息队列消费者五、将拿到的数据存储到数据库中 Netty服务器+消息队列 一、系统架构图 实现:创建...

    Netty服务器+消息队列

    一、系统架构图

    在这里插入图片描述

    实现:创建netty服务器,服务器发送消息,发送到消息队列上
    客户端依次从队列中获取信息
    目标1:搭建netty服务端
    目标2:搭建mq消息服务器
    mq一端发送信息之后,接收端能够接收到
    netty收到设备的信息之后,不进行转发,而是将收到的信息发送到消息队列上
    消息队列这边的一直在监听,拿到消息后,做消息处理

    二、搭建netty服务器

       <dependency>
                <groupId>io.netty</groupId>
                <artifactId>netty-all</artifactId>
                <version>4.1.50.Final</version>
        </dependency>
    
    //netty服务
    public class GroupServer {
        private int port;//监听端口
    
        public GroupServer(int port) {
            this.port = port;
        }
    
        //编写run方法处理客户端请求
        public void run() throws Exception{
            //创建两个线程组
            NioEventLoopGroup bossGroup = new NioEventLoopGroup(1);
            NioEventLoopGroup workGGroup = new NioEventLoopGroup();
    
            try{
                ServerBootstrap b = new ServerBootstrap();
                b.group(bossGroup,workGGroup)
                        .channel(NioServerSocketChannel.class)
                        .option(ChannelOption.SO_BACKLOG,128)
                        .childOption(ChannelOption.SO_KEEPALIVE,true)
                        .childHandler(new ChannelInitializer<SocketChannel>() {
                            @Override
                            protected void initChannel(SocketChannel ch) throws Exception {
                                //获取到pipline
                                ChannelPipeline pipeline = ch.pipeline();
                                //向pipeline中加入解码器
                                pipeline.addLast("decoder", new StringDecoder());
                                //向pipeline中加入编码器
                                pipeline.addLast("encoder", new StringEncoder());
                                //加入自己的业务处理handler
                                pipeline.addLast(new GroupServerHandler());
                            }
                        });
    
                System.out.println("netty 服务器启动");
                ChannelFuture channelFuture = b.bind(port).sync();
                //监听关闭
                channelFuture.channel().closeFuture().sync();
            }finally {
                bossGroup.shutdownGracefully();
                workGGroup.shutdownGracefully();
            }
        }
    
    //自定义处理器
    public class GroupServerHandler extends SimpleChannelInboundHandler<String> {
    
        //定义一个channel组,管理所有的channel
        //GlobalEventExecutor是全局的事件执行器,是一个单例
        private static ChannelGroup channelGroup = new DefaultChannelGroup(GlobalEventExecutor.INSTANCE);
        //显示时间
        SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    
        //表示一旦连接,第一个执行的,将channel加入channelGroup中
        @Override
        public void handlerAdded(ChannelHandlerContext ctx) throws Exception {
            Channel channel = ctx.channel();
            //该方法会将channelGroup中所有的channel遍历,并发送消息,自己不需要遍历
            channelGroup.writeAndFlush("[设备]" + channel.remoteAddress() + " 加入服务器" + sdf.format(new Date()) + "\n");
            channelGroup.add(channel);
        }
    
        //读取数据
        @Override
        protected void channelRead0(ChannelHandlerContext ctx, String msg) throws Exception {
            //获取当前的channel
            Channel channel = ctx.channel();
            //显示设备信息以及发送的消息
            System.out.println("[设备]" + channel.remoteAddress() + " 发送了消息: " + msg + "\n");
    
    //        //这时遍历channelGroup,根据不同的情况,回送不同的消息
    //        channelGroup.forEach(ch -> {
    //            if (channel != ch) {//不是当前的channel,转发消息
    //                ch.writeAndFlush("[设备]" + channel.remoteAddress() + " 发送了消息" + msg + "\n");
    //            } else {//回显自己发送的消息给自己
    //                ch.writeAndFlush("[服务器]发送了消息" + msg + "\n");
    //            }
    //        });
        }
    
        //表示处于活跃状态,提示xx上线
        @Override
        public void channelActive(ChannelHandlerContext ctx) throws Exception {
            System.out.println("[设备]"+ctx.channel().remoteAddress() + " 上线了---");
        }
    
        //表示不再活跃状态,提示离线
        @Override
        public void channelInactive(ChannelHandlerContext ctx) throws Exception {
            System.out.println("[设备]"+ctx.channel().remoteAddress() + " 离线了---");
        }
    
    
        //断开连接
        @Override
        public void handlerRemoved(ChannelHandlerContext ctx) throws Exception {
            Channel channel = ctx.channel();
            channelGroup.writeAndFlush("[设备]" + channel.remoteAddress() + " 离开了\n");
            System.out.println(sdf.format(new Date())+" [当前设备数量]: " + channelGroup.size());
        }
    
        //错误处理
        @Override
        public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
           //出现异常关闭通道
            ctx.close();
        }
    }
    

    三、将netty接收到的信息发布到消息队列

    在这里插入图片描述

    队列

    在这里插入图片描述

     消息队列平台端口号:15672
     <dependency>
        <groupId>com.rabbitmq</groupId>
        <artifactId>amqp-client</artifactId>
        <version>4.0.3</version><!--此版本与spring boot 1.5.9版本匹配-->
    </dependency>
    

    GroupServerHandler修改

     //读取数据
        @Override
        protected void channelRead0(ChannelHandlerContext ctx, String msg) throws Exception {
            //获取当前的channel
            Channel channel = ctx.channel();
            //显示设备信息以及发送的消息
            String message="[设备]" + channel.remoteAddress() + " 发送了消息: " + msg + "\n";
            System.out.println(message);
            //将消息上传到MQ服务器
            MQHelper.sendMesssage(message);
    
    public class MQHelper {
        //队列名称
        private static final String QUEUE = "DeviceGroup";
        //消息 参数
        private static String HOST = "localhost";
        private static int PORT=5672;
        private static String USERNAME = "guest";
        private static String PASSWORD = "guest";
        private static String VIRTUALHOST = "/";//虚拟机
        //发送消息
        public static void sendMesssage(String message) throws Exception {
            Connection connection = null;
            Channel channel = null;
            try {
                ConnectionFactory factory = new ConnectionFactory();
                //初始化
                factory.setHost(HOST);
                factory.setPort(PORT);
                factory.setUsername(USERNAME);
                factory.setPassword(PASSWORD);
    
                //rabbitmq默认虚拟机名称为“/”,虚拟机相当于一个独立的mq服务器
                factory.setVirtualHost(VIRTUALHOST);
    
                //创建与RabbitMQ服务的TCP连接
                connection  = factory.newConnection();
                //创建与Exchange的通道,每个连接可以创建多个通道,每个通道代表一个会话任务
                channel = connection.createChannel();
    
                /**
                 * 声明队列,如果Rabbit中没有此队列将自动创建
                 * param1:队列名称
                 * param2:是否持久化
                 * param3:队列是否独占此连接
                 * param4:队列不再使用时是否自动删除此队列
                 * param5:队列参数
                 */
                channel.queueDeclare(QUEUE, true, false, false, null);
    
                /**
                 * 消息发布方法
                 * param1:Exchange的名称,如果没有指定,则使用Default Exchange
                 * param2:routingKey,消息的路由Key,是用于Exchange(交换机)将消息转发到指定的消息队列
                 * param3:消息包含的属性
                 * param4:消息体
                 */
                /**
                 * 这里没有指定交换机,消息将发送给默认交换机,每个队列也会绑定那个默认的交换机,但是不能显示绑定或解除绑定
                 * 默认的交换机,routingKey等于队列名称
                 */
                channel.basicPublish("", QUEUE, null, message.getBytes());
    
            } catch (Exception e) {
                e.printStackTrace();
            }finally {
                if(channel != null)
                {
                    channel.close();
                }
                if(connection != null)
                {
                    connection.close();
                } }}}
    
    
    

    四、创建消息队列消费者

    在这里插入图片描述

    mQ监听程序创建过程

    1. 创建连接

    2. 创建通道

    3. 声明队列

    4. 监听队列

    5. 接收消息

    6. ack回复

    public class Consumer {
        //队列名称
        private static final String QUEUE = "DeviceGroup";
    
        public static void main(String[] args) throws Exception {
            ConnectionFactory factory = new ConnectionFactory();
            //设置mq所在的服务器的ip和端口
            factory.setHost("127.0.0.1");
            factory.setPort(5672);
            Connection connection = factory.newConnection();
            Channel channel = connection.createChannel();
            //声明队列
            channel.queueDeclare(QUEUE, true, false, false, null);
            //定义消费方法
            DefaultConsumer consumer = new DefaultConsumer(channel){
                /**
                 * 消费者接收消息调用此方法
                 * @param consumerTag 消费者的标签,在channel.basicConsume()去指定
                 * @param envelope 消息包的内容,可从中获取消息id,消息routingkey,交换机,消息和重传标志(收到消息失败后是否需要重新发送)
                 * @param properties
                 * @param body
                 * @throws IOException
                 */
                @Override
                public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                   //交换机
                    String exchange = envelope.getExchange();
                    //路由key
                    String routingKey = envelope.getRoutingKey();
                    //消息id
                    long deliveryTag = envelope.getDeliveryTag();
                    //消息内容
                    String msg = new String(body, "utf-8");
                    System.out.println("接收的消息为:" + msg+" 消息id为:"+deliveryTag);
                }
            };
            /**
             * 监听队列String queue, boolean autoAck,Consumer callback
             * 参数明细
             * 1、队列名称
             * 2、是否自动回复,设置为true为表示消息接收到自动向mq回复接收到了,mq接收到回复会删除消息,设置为false则需要手动回复
             * 3、消费消息的方法,消费者接收到消息后调用此方法
             */
            channel.basicConsume(QUEUE, true, consumer);
        }
    }
    

    五、将拿到的数据存储到数据库中

    在这里插入图片描述

    数据库设计:

    在这里插入图片描述

    操作:将拿到的消息与消息id存储到数据库中

      public static void add(String msg) {
            Decivemsg decivemsg = new Decivemsg();
            decivemsg.setMsg(msg);
            //测试代理方式
            SqlSession sqlSession = null;
            try {
                //获取mybatis框架生成的mapper接口
    
                sqlSession=MybatisHelper.getSqlSession();
                DeviceMsgMapper deviceMsgMapper = sqlSession.getMapper(DeviceMsgMapper.class);
                deviceMsgMapper.addOne(decivemsg);
            } catch (Exception e) {
                e.printStackTrace();
                //回滚
                sqlSession.rollback();
            }finally {
                sqlSession.commit();
                sqlSession.close();
            }
        }
    
    展开全文
  • 本篇文章主要介绍了spring+netty服务器搭建的方法,小编觉得挺不错的,现在分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • netty 服务器端主动发消息给客户端 内容精选换一换客户在云容器引擎上搭建服务为手机应用订阅信息。首先客户端会向部署在CCE集群上的服务端(redis)发起请求,成功订阅信息服务。后继服务端侧会定时推送订阅的消息给...

    netty 服务器端主动发消息给客户端 内容精选

    换一换

    c8a5a5028d2cabfeeee0907ef5119e7e.png

    客户在云容器引擎上搭建服务为手机应用订阅信息。首先客户端会向部署在CCE集群上的服务端(redis)发起请求,成功订阅信息服务。后继服务端侧会定时推送订阅的消息给客户端。服务端部署后,第一次订阅信息通信正常,但是10分钟内没有数据通信,客户端就接收不到订阅信息了。客户端第一次向服务端建立通信链接的时候(订阅),会主动开放对服务端的通信权限

    设备接入到物联网平台后,便可与物联网平台进行通信。设备通过自定义Topic或产品模型方式将数据上报到平台,在控制台设置后,通过订阅推送的方式,将设备生命周期变更、设备属性上报、设备消息上报、设备消息状态变更、设备状态变更、批量任务状态变更等消息推送到您指定的服务器。当前华为物联网平台支持HTTP/HTTPS和AMQP两种订阅方式:HTTP

    netty 服务器端主动发消息给客户端 相关内容

    ELB的常见异常返回码有400、403、502、504等。若遇到这些返回码建议您先直接访问后端云服务器,查看是否是后端云服务器的异常。若后端云服务器响应正常,请参考表1排查处理。如果仍无法解决,请联系客服人员继续排查。

    Netty是一个非阻塞I/O客户端-服务器框架,主要用于开发Java网络应用程序,如:协议服务器和客户端。Netty包括了反应器编程模式的实现。Netty最初由JBoss开发,现在由Netty项目社区开发和维护。除了作为异步网络应用程序框架,Netty还包括了对HTTP、HTTP2、DNS及其他协议的支持,涵盖了在Servlet容器内运行

    netty 服务器端主动发消息给客户端 更多内容

    5a6f55482f6b3f19420161bd3dfbba6a.png

    Redis实例的发布订阅功能详细信息参见Pub/Sub,使用Redis发布订阅功能时有如下事项请注意:客户端需要及时消费和处理消息。客户端订阅了channel之后,如果接收消息不及时,可能导致DCS实例消息堆积,当达到消息堆积阈值(默认值为32MB),或者达到某种程度(默认8MB)一段时间(默认为1分钟)后,服务器端会自动断开该客户端连接

    f3b8b8d84706868f201fb0c4780edbab.png

    由于WebSocket是全双工的,因此响应就是从服务器端发送给客户端的消息,但也并不是所有的请求信息都有一条对应的响应。服务器端收到“开始识别”请求时,会给出如下响应消息,以json字符串形式放置在text message中。状态码请参见状态码。错误码请参见错误码。

    55a2638139d68369d49b3058cd5d88e8.png

    HTTP/2是HTTP超文本传输协议的最新版本,于2015年5月份正式发布,HTTP/2之前有HTTP1.0和HTTP1.1两个版本。各主流浏览器,如Chrome、Firefox、Safari及IE11等均已支持HTTP/2协议。目前,http://url只能使用HTTP1.x版本协议,https://url支持HTTP/2版本的使用。H

    9548b768b78243d473da1b2758db3f2b.png

    设备接入到物联网平台后,便可与物联网平台进行通信。设备通过自定义Topic或产品模型方式将数据上报到平台,在控制台设置后,通过订阅推送的方式,将设备生命周期变更、设备属性上报、设备消息上报、设备消息状态变更、设备状态变更、批量任务状态变更等消息推送到您指定的服务器。当前华为物联网平台支持HTTP/HTTPS和AMQP两种订阅方式:HTTP

    c0e51685ecf1c455eed0daf868911dc9.png

    一个响应消息通常由三部分组成:状态行、响应报头、响应正文。响应消息格式如表1所示。HTTP-Version Status-Code Reason-Phrase CRLF其中:HTTP-Version表示服务器HTTP协议的版本号Status-Code表示服务器发回的响应状态代码Reason-Phrase表示状态代码的文本描述。状态代码有三

    f2c4fc7c94b8a6968e9bfbe258188211.png

    本节提供API API和SDK的定义要求。REST中定义工程对外提供的服务。HTTP动词:常用的HTTP动词如下(括号里是对应的SQL命令):GET(SELECT):从服务器取出一项或多项资源。POST(CREATE):在服务器新建一个资源。PUT(UPDATE):客户端提供改变后的完整资源,在服务器更新资源。PATCH(UPDATE):

    e8856eb4a33744e9e363326f14bf7b97.png

    使用SSH方式登录CentOS 6.5操作系统的弹性云服务器时,过一段时间就会自动断开连接。本节操作介绍如何保持SSH会话持续连接不断开该文档适用于CentOS/EulerOS系统。本节操作涉及重启sshd服务,会造成sshd断开。编辑/etc/ssh/sshd_config文件设置心跳,保持连接。编辑/etc/ssh/sshd_conf

    784b2dc537fb8677eac9c3453eafe288.png

    如果客户端或JDBC/ODBC应用程序要使用SSL连接方式,用户必须在客户端或应用程序代码中配置相关的SSL连接参数。GaussDB(DWS) 管理控制台提供了客户端所需的SSL证书,该SSL证书包含了客户端所需的默认证书、私钥、根证书以及私钥密码加密文件。请将该SSL证书下载到客户端所在的主机上,然后在客户端中指定证书所在的路径。使用默

    91fba63c5e17e5f0e99d0f8174c4b31b.png

    修改系统时间后服务器网卡出现感叹号,无法连接网络。该文档适用于CentOS 7、EulerOS,并使用DHCP协议获取IP场景。DHCP租约通常默认为24小时,具体以实际场景为例。DHCP会话过程:DHCP典型会话过程包括:DHCP发现、DHCP提供、DHCP请求、DHCP确认,如图1所示DHCP发现(DISCOVER)客户在物理子网上发

    展开全文
  • 快速搭建 netty服务器

    2020-02-24 12:58:38
    使用idea快速搭建基于maven的netty服务器项目 1.新建空白maven项目 file-new-project 选择maven空白项目,输入groupid和artifactid,一路点next 2.引入netty maven 依赖 pom.xml 文件加入netty-all 依赖 io....

    前言

    使用idea快速搭建基于maven的netty服务器项目

    1.新建空白maven项目

    file-new-project
    在这里插入图片描述
    选择maven空白项目,输入groupid和artifactid,一路点next
    在这里插入图片描述

    2.引入netty maven 依赖

    pom.xml 文件加入netty-all 依赖


    io.netty
    netty-all
    4.1.42.Final

    </dependencies>
    

    3.服务器代码

    tcp套接字server

    创建ServerBootstrap,io模式为nio。同时自定义handler消息处理。

    server代码:

        public static void main(String[] args) throws InterruptedException {
            //config the server
            EventLoopGroup bossGroup = new NioEventLoopGroup();
            EventLoopGroup workerGroup = new NioEventLoopGroup();
    
            try{
                ServerBootstrap b = new ServerBootstrap();
                b.channel(NioServerSocketChannel.class)
                        .group(bossGroup,workerGroup)
                        .handler(new LoggingHandler(LogLevel.INFO))
                        .childHandler(new ChannelInitializer<SocketChannel>() {
                            protected void initChannel(SocketChannel ch) throws Exception {
                                ChannelPipeline pipeline = ch.pipeline();
                                pipeline.addLast(new LoggingHandler(LogLevel.INFO))
                                        .addLast(new EchoServerHandler());
                            }
                        });
    
                //start the server
                ChannelFuture future = b.bind(8090).sync();
    
                //wait until server is closed
                future.channel().closeFuture().sync();
    
    
            }finally {
                //shut down the event loop to terminate all threads
                bossGroup.shutdownGracefully();
                workerGroup.shutdownGracefully();
            }
    
    
        }
    

    handler代码:

    public class EchoServerHandler extends ChannelInboundHandlerAdapter {
        @Override
        public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
            ctx.write(msg);
        }
    
    
        @Override
        public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {
            ctx.flush();
        }
    
        @Override
        public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
            cause.printStackTrace();
            ctx.close();
        }
    
    }
    

    http server

    server 代码

    public class HttpHelloWorldServer {
        public static void main(String[] args) throws InterruptedException {
    
            //config the server
            NioEventLoopGroup bossGroup = new NioEventLoopGroup(1);
            NioEventLoopGroup group = new NioEventLoopGroup();
            try{
                ServerBootstrap b = new ServerBootstrap();
                b.group(bossGroup,group)
                        .channel(NioServerSocketChannel.class)
                        .handler(new LoggingHandler(LogLevel.INFO))
                        .childHandler(new ChannelInitializer(){
    
                            protected void initChannel(Channel ch) throws Exception {
                                ChannelPipeline p = ch.pipeline();
                                p.addLast(new HttpServerCodec())
                                        .addLast(new HttpServerExpectContinueHandler())
                                        .addLast(new HttpHelloWorldServerHandler());
                            }
                        });
    
                //start the server
                ChannelFuture future = b.bind(8090).sync();
    
                System.out.println("open you browser and navigate to 127.0.0.1:8090");
    
                //wait until server is closed
                future.channel().closeFuture().sync();
    
    
            }finally {
                bossGroup.shutdownGracefully();
                group.shutdownGracefully();
            }
    
        }
    }
    

    handler代码

    public class HttpHelloWorldServerHandler extends SimpleChannelInboundHandler<HttpObject> {
    
        private static final byte[] CONTENT = "helloworld".getBytes();
    
        protected void channelRead0(ChannelHandlerContext ctx, HttpObject msg) throws Exception {
            if (msg instanceof HttpRequest){
                HttpRequest request = (HttpRequest) msg;
                FullHttpResponse response = new DefaultFullHttpResponse(request.protocolVersion(), OK,Unpooled.wrappedBuffer(CONTENT));
                response.headers()
                        .set(CONTENT_TYPE, TEXT_PLAIN)
                        .setInt(CONTENT_LENGTH, response.content().readableBytes());
    
                ChannelFuture f = ctx.write(response);
            }
    
        }
    
        @Override
        public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {
            ctx.flush();
        }
    
        @Override
        public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
            cause.printStackTrace();
            ctx.close();
        }
    }
    

    测试

    首先测试tcp server。我们同时新建一个客户端与server进行交互:
    client代码

    public class EchoClient {
    
        public static void main(String[] args) throws InterruptedException {
            //config the client
            EventLoopGroup group = new NioEventLoopGroup();
            try{
    
                Bootstrap bootstrap = new Bootstrap();
                bootstrap.group(group)
                        .channel(NioSocketChannel.class)
                        .option(ChannelOption.TCP_NODELAY,true)
                        .handler(new ChannelInitializer<SocketChannel>() {
                            protected void initChannel(SocketChannel ch) throws Exception {
                                ChannelPipeline pipeline = ch.pipeline();
                                pipeline.addLast(new LoggingHandler(LogLevel.INFO))
                                        .addLast(new EchoClientHandler());
    
                            }
                        });
    
                //start the client
                ChannelFuture future = bootstrap.connect("127.0.0.1", 8090).sync();
                //wait until the connection is closed
                future.channel().closeFuture().sync();
            }finally {
                //shut down the event loop to terminate all threads
                group.shutdownGracefully();
            }
    
    
        }
    }
    

    clienhandler

    public class EchoClientHandler extends ChannelInboundHandlerAdapter {
    
    
        private final ByteBuf firstMsg;
    
    
        public EchoClientHandler() {
            this.firstMsg = Unpooled.wrappedBuffer("i am echo message".getBytes());
        }
    
        @Override
        public void channelActive(ChannelHandlerContext ctx) throws Exception {
            ctx.writeAndFlush(firstMsg);
        }
    
        @Override
        public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
            ctx.write(msg);
        }
    
    
        @Override
        public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {
            TimeUnit.SECONDS.sleep(3);
            ctx.flush();
        }
    
        @Override
        public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
            cause.printStackTrace();
            ctx.close();
        }
    }
    
    

    先启动server,绑定端口8090。再启动client。连接server。
    server日志:
    在这里插入图片描述
    client 日志
    在这里插入图片描述
    可以看到客户端向服务器发送了一条消息,服务器收到消息原封不动回复客户端,客户端收到消息又原封不同回复服务器。像互相踢皮球一样。

    然后再看下http server:
    启动HttpHelloworldServer,然后打开浏览器访问http://127.0.0.1:8090。页面会出现helloworld的文字。
    在这里插入图片描述

    server日志
    在这里插入图片描述

    最后

    示例代码: my-netty-example

    展开全文
  • java netty服务器简单例子

    千次阅读 2017-12-07 14:27:41
    java netty 服务器简单例子 例子实现的功能是客户端连接服务器服务器返回当前时间的例子,使用maven导入netty的包,其pom依赖为: <groupId>io.netty <artifactId>netty-all <version>4.1.17.Final </depe
  • Netty服务器端获取数据并存入数据库

    千次阅读 2019-03-23 16:29:26
    Netty服务器 在学习了一段时间Netty后写的一个小demo 1.—添加Maven依赖 <dependency> <groupId>io.netty</groupId> <artifactId>netty-all</artifactId> <versio...
  • 2、实现客户端发送一个请求,服务器会返回hello netty,即构建hello netty服务器 3、为channel设置初始化器 4、编写自定义助手类 5、netty生命周期 转载于:...
  • Netty服务器和客户端交互案例

    千次阅读 2018-01-19 00:03:30
    Netty服务器和客户端交互案例 简述:使用netty完成通讯简单的例子 服务器端代码: package netty; import java.net.InetSocketAddress; import java.util.concurrent.Executors; import org.jboss.netty....
  • 用于快速启动的基本 Netty 服务器 要求 JDK 7 阿帕奇Maven 3 从 CLI 运行 mvn clean package java -jar target/netty-base-0.0.3-SNAPSHOT.jar 特征 Netty 引导程序配置 支持 HTTP 从 Spring Context 配置的路由...
  • 在RPC框架中,使用Netty作为高性能的网络通信框架时,每一次服务调用,都需要与Netty服务端建立连接的话,很容易导致Netty服务器资源耗尽。所以,想到连接池技术,将与同一个Netty服务器地址建立的连接放入池中维护...
  • WebSocket 与 netty服务器 实战

    万次阅读 2017-04-15 17:40:51
    WebSocket 与 netty服务器 实战后续献上 线上的例子….websocket原理是客户端浏览器首先要向服务器发送一个http请求,这个请求与一般的http请求不同,包含了一些附加头消息,其中 Upgrade:WebSocket 表明这是一个...
  • netty服务器开发

    2015-12-29 13:32:50
    netty nio 长连接 基于NIO非阻塞特性构建高性能、异步和高可靠性的底层通信框架。
  • 一、 Netty 模型代码解析 、 二、 Netty 案例服务器端代码 、 三、 Netty 案例客户端代码 、 四、 Netty 案例运行 、
  • java socket与Netty服务器通信

    千次阅读 2016-08-28 16:05:42
    java socket与Netty服务器通信 C/C++中在进行网络通信的过程中直接面对的是字节流或是字符流。java中网络通信的话面对的是缓冲区buffer。 ByteBuffer是来自于java.nio ByteBuf是来自于io.netty.buffer 两者相互转换...
  • Netty服务器线程模型概览

    千次阅读 2014-05-14 21:52:08
    Netty服务器线程模型概览  发表于8个月前(2013-08-24 15:24) 阅读(96) | 评论(0)  1人收藏此文章,我要收藏 赞0 一切从ServerBootstrap开始 ServerBootstrap 负责初始话netty服务器,并且开始监听...
  • 2. Netty服务器搭建步骤 1)构建一对主从线程池 2)创建服务器启动类 3)为服务器启动类并绑定Channel、主从线程组 4)设置处理从线程池任务的助手类初始化器 5)监听启动和关闭服务器 设置Channel初始化器 每一...
  • netty服务器运行一段时间,出现一定比例的客户端无法链接 cpu和内存占用都很低,客户端链接服务器端口,服务器大概率没有任何反应,但是客户端显示链接成功。 新启动的服务,每个链接服务器都可以正确响应。 ...
  • Netty服务器部署在Android设备上,接收来自PC客户端的Java Socket客户端发送的数据 一个简单的模型,在Android手机上部署一个Netty写的服务器,绑定端口9000,等待客户端连接,连接建立后,读取来自PC客户端的...
  • 具体信息查看我的博客:https://blog.csdn.net/qq_37437983/article/details/86585079
  • netty服务器使用的是LengthFieldBasedFrameDecoder解析类 channelPipeline.addLast("frameDecoder", new LengthFieldBasedFrameDecoder(Integer.MAX_VALUE, 0, 4, 0, 4)); channelPipeline.addLast(...
  • Netty服务器请求分发

    千次阅读 2018-11-07 15:35:40
    才接触U3D和Netty,我的理解是netty是对TCP/IP协议的封装,用来对客户端的请求进行处理,而对客户端请求的处理方法只有一个,那么如果客户端请求类型非常之多,这个方法的代码就肯定非常臃肿了,这个时候想到JAVAWEB...
  • 求各位兄弟们帮帮忙啊,小弟使用telnet发送了一个命令到我的服务端,是这样子的 !... 然后服务端成功接到了这个“abcdefg”字符串,接下来服务端返回个字符串,代码是这样的 !...请问,我应该如何正确的使用windows的...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 56,700
精华内容 22,680
关键字:

netty服务器