zookeeper分布式(五)--netty(一)

最新推荐文章于 2024-07-19 21:26:34 发布
最新推荐文章于 2024-07-19 21:26:34 发布
阅读量155 收藏
点赞数
分类专栏： zookeeper netty
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jz1993/article/details/109152209
版权

client

package com.test.netty.netty.example.discard;

import io.netty.buffer.ByteBuf;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelFutureListener;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.SimpleChannelInboundHandler;

public class DiscardClientHandler extends SimpleChannelInboundHandler<Object> {

    private ByteBuf content;
    private ChannelHandlerContext ctx;

    private void generateTraffic(){
        ctx.writeAndFlush(content.retainedDuplicate()).addListener(trafficGenerator);
    }

    private final ChannelFutureListener trafficGenerator = new ChannelFutureListener() {
        @Override
        public void operationComplete(ChannelFuture channelFuture) throws Exception {
            if (channelFuture.isSuccess()){
                generateTraffic();
            } else {
                channelFuture.cause().printStackTrace();
                channelFuture.channel().close();
            }
        }
    };

    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        this.ctx = ctx;
        // initialize the message
        content = ctx.alloc().directBuffer(DiscardClient.SIZE).writeZero(DiscardClient.SIZE);
        // send the initialize messages
        generateTraffic();
    }

    @Override
    public void channelInactive(ChannelHandlerContext ctx) throws Exception {
        content.release();
    }

    @Override
    protected void channelRead0(ChannelHandlerContext channelHandlerContext, Object o) throws Exception {

    }

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

package com.test.netty.netty.example.discard;

import io.netty.buffer.ByteBuf;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelFutureListener;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.SimpleChannelInboundHandler;

public class DiscardClientHandler2 extends SimpleChannelInboundHandler<Object> {

    private ByteBuf content;
    private ChannelHandlerContext ctx;

    private void generateTraffic(){
        ctx.writeAndFlush(content.retainedDuplicate()).addListener(trafficGenerator);
    }

    private final ChannelFutureListener trafficGenerator = new ChannelFutureListener() {
        @Override
        public void operationComplete(ChannelFuture channelFuture) throws Exception {
            if (channelFuture.isSuccess()){
                generateTraffic();
            } else {
                channelFuture.cause().printStackTrace();
                channelFuture.channel().close();
            }
        }
    };

    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        this.ctx = ctx;
        String sendMsg = "hello, server";
        content = ctx.alloc().directBuffer(1024);
        content.writeBytes(sendMsg.getBytes());
        ctx.writeAndFlush(content);
        System.out.println("send msg:" + sendMsg);

//        ChannelFuture channelFuture = ctx.writeAndFlush(content);
//        channelFuture.addListener(ChannelFutureListener.CLOSE);
//        channelFuture.addListener(new ChannelFutureListener() {
//            @Override
//            public void operationComplete(ChannelFuture channelFuture) throws Exception {
//                channelFuture.channel().close();
//            }
//        });
//
//        channelFuture.addListener((ChannelFutureListener) (future)->{future.channel().close();});
    }

    @Override
    protected void channelRead0(ChannelHandlerContext channelHandlerContext, Object o) throws Exception {
        System.out.println("receive msg : " + o);
    }

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

package com.test.netty.netty.example.discard;

import io.netty.bootstrap.Bootstrap;
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.handler.codec.LengthFieldBasedFrameDecoder;
import io.netty.handler.codec.LengthFieldPrepender;
import io.netty.handler.logging.LogLevel;
import io.netty.handler.logging.LoggingHandler;
import io.netty.handler.ssl.SslContext;
import io.netty.handler.ssl.SslContextBuilder;
import io.netty.handler.ssl.util.InsecureTrustManagerFactory;
import org.jboss.netty.channel.socket.nio.NioChannelConfig;

import javax.net.ssl.SSLException;

public final class DiscardClient {

    static final boolean SSL = System.getProperty("ssl") != null;

    static final String HOST = System.getProperty("host", "127.0.0.1");

    static final int PORT = Integer.parseInt(System.getProperty("port", "8080"));

    static final int SIZE = Integer.parseInt(System.getProperty("size", "256"));

    public static void main(String[] args) {
        start2();
    }

    public static void start2(){
        EventLoopGroup group = new NioEventLoopGroup(1);
        Bootstrap bootstrap = new Bootstrap();
        bootstrap.group(group)
                .channel(NioSocketChannel.class)
                .option(ChannelOption.SO_KEEPALIVE, true)
                .handler(new ChannelInitializer<SocketChannel>() {
                    @Override
                    protected void initChannel(SocketChannel socketChannel) throws Exception {
                        ChannelPipeline channelPipeline = socketChannel.pipeline();
                        channelPipeline.addLast("frameworkEncode", new LengthFieldPrepender(4));
                        channelPipeline.addLast("frameworkDecode", new LengthFieldBasedFrameDecoder(Integer.MAX_VALUE, 0, 4, 0, 4));
                        channelPipeline.addLast(new DiscardClientHandler2());
                    }
                });
        try {
            ChannelFuture channelFuture = bootstrap.connect("127.0.0.1", 8090).sync();
            channelFuture.channel().close().sync();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            group.shutdownGracefully();
        }
    }

    public void start() throws SSLException {
        final SslContext sslCtx;
        if (SSL){
            sslCtx = SslContextBuilder.forClient().trustManager(InsecureTrustManagerFactory.INSTANCE).build();
        } else {
            sslCtx = null;
        }

        EventLoopGroup group = new NioEventLoopGroup();
        try {
            Bootstrap bootstrap = new Bootstrap();
            bootstrap.group(group).channel(NioSocketChannel.class).handler(new ChannelInitializer<SocketChannel>(){
                @Override
                protected void initChannel(SocketChannel socketChannel) throws Exception {
                    ChannelPipeline p = socketChannel.pipeline();
                    p.addLast(new LoggingHandler(LogLevel.DEBUG));
                    if (sslCtx != null){
                        p.addLast(sslCtx.newHandler(socketChannel.alloc(), HOST, PORT));
                    }
                    p.addLast(new DiscardClientHandler());
                }
            });

            // make the connection attempt
            ChannelFuture f = bootstrap.connect(HOST, PORT).sync();

            // wait unit the connection is closed
            f.channel().closeFuture().sync();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            group.shutdownGracefully();
        }
    }
}

server

package com.test.netty.netty.example.discard;


import io.netty.buffer.ByteBuf;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;
import io.netty.util.ReferenceCountUtil;

public class DiscardServerHandler extends ChannelInboundHandlerAdapter {

    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
//        ByteBuf in = (ByteBuf) msg;
//        try {
//            while (in.isReadable()){
//                System.out.println((char)in.readByte());
//                System.out.flush();
//            }
//        } finally {
//            ReferenceCountUtil.release(msg);
//        }
        String response = "hello, client!";
        ByteBuf byteBuf = ctx.alloc().directBuffer(1024);
        byteBuf.writeBytes(response.getBytes());
        ctx.writeAndFlush(byteBuf);
//        System.out.println("receive:" + msg);
//        ctx.write(msg);
//        ctx.flush();
        System.out.println("return msg:" + response);
    }

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

package com.test.netty.netty.example.discard;

import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.*;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioServerSocketChannel;
import io.netty.handler.codec.LengthFieldBasedFrameDecoder;
import io.netty.handler.codec.LengthFieldPrepender;
import io.netty.handler.logging.LogLevel;
import io.netty.handler.logging.LoggingHandler;
import io.netty.handler.ssl.SslContext;
import io.netty.handler.ssl.SslContextBuilder;
import io.netty.handler.ssl.util.SelfSignedCertificate;

import javax.net.ssl.SSLException;
import java.security.cert.CertificateException;

public class DiscardServer {
    static final boolean SSL = System.getProperty("ssl") != null;

    private int port;

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

    public void run2(){
        EventLoopGroup boss = new NioEventLoopGroup(1);
        EventLoopGroup worker = new NioEventLoopGroup(3);
        ServerBootstrap serverBootstrap = new ServerBootstrap();
        serverBootstrap.group( boss, worker)
                .channel(NioServerSocketChannel.class)
                .option(ChannelOption.SO_BACKLOG, 128)
                .childOption(ChannelOption.SO_KEEPALIVE, true)
                .handler(new LoggingHandler(LogLevel.DEBUG))
                .childHandler(new ChannelInitializer<SocketChannel>(){
                    @Override
                    protected void initChannel(SocketChannel socketChannel) throws Exception {
                        ChannelPipeline pipeline = socketChannel.pipeline();
                        pipeline.addLast("frameworkDecoder", new LengthFieldBasedFrameDecoder(Integer.MAX_VALUE, 0, 4, 0, 4));
                        pipeline.addLast("frameworkEncoder", new LengthFieldPrepender(4));
                        pipeline.addLast(new DiscardServerHandler());
                    }
                });
        try {
            ChannelFuture channelFuture = serverBootstrap.bind(port).sync();
            System.out.println("server init success,bind on the port:" + port);
            channelFuture.channel().closeFuture().sync();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            boss.shutdownGracefully();
            worker.shutdownGracefully();
        }
    }

    public void run() throws CertificateException, SSLException, InterruptedException {
        final SslContext sslCtx;
        if (SSL){
            SelfSignedCertificate ssc = new SelfSignedCertificate();
            sslCtx = SslContextBuilder.forServer(ssc.certificate(), ssc.privateKey()).build();
        } else {
            sslCtx = null;
        }
        EventLoopGroup bossGroup = new NioEventLoopGroup(1);
        EventLoopGroup workerGroup = new NioEventLoopGroup();

        ServerBootstrap b = new ServerBootstrap();
        b.group(bossGroup, workerGroup)
                .channel(NioServerSocketChannel.class) //NioServerSocketChannel 用于接收客户端连接
                .handler(new LoggingHandler(LogLevel.INFO))
                .childHandler(new ChannelInitializer<SocketChannel>() {

                    @Override
                    protected void initChannel(SocketChannel socketChannel) throws Exception {
                        ChannelPipeline p = socketChannel.pipeline();
                        if (sslCtx != null) {
                            p.addLast(sslCtx.newHandler(socketChannel.alloc()));
                        }
                        p.addLast(new DiscardServerHandler());
                    }
                }).option(ChannelOption.SO_BACKLOG, 128)
                .childOption(ChannelOption.SO_KEEPALIVE, true);

        try {
            // Bind and start to accept incoming connections.
            ChannelFuture f = b.bind(port).sync();

            // Wait until the server socket is closed.
            // In this example, this does not happen, but you can do that to gracefully
            // shut down your server.
            f.channel().closeFuture().sync();
        } finally {
            workerGroup.shutdownGracefully();
            bossGroup.shutdownGracefully();
        }


    }
}

 

scaling_heights
关注
专栏目录
ZooKeeper应用---分布式配置更新
weixin_44489428的博客
03-21 3262
zookeeper API的使用，基于回调和监听的响应式编程
spring boot +maven+ netty4+protostuff+zookeeper实现一个轻量级RPC框架
05-10
Spring：它是最强大的依赖注入框架，也是业界的权威标准。 Netty：它使 NIO 编程更加容易，屏蔽了 Java 底层的 NIO 细节。 Protostuff：它基于 Protobuf 序列化框架，面向 POJO，无需编写 .proto 文件。 ZooKeeper：提供服务注册与发现功能，开发分布式系统的必备选择，同时它也具备天生的集群能力。
自己动手写基于动态代理，使用ZooKeeper作为注册中心，以Netty进行网络通信的RPC框架
01-13
自己动手写基于动态代理，使用ZooKeeper作为注册中心，以Netty进行网络通信的RPC框架。更多详情请查看相关博客：https://blog.csdn.net/qq_31142553/article/details/86316654
zookeeper注册服务与netty的简单结合应用
探索中前进的Rock
02-15 606
简单介绍一下zookeeper和nettyNetty:流行的NIO Socket通信框架，很多开源软件如hadoop tachyon spark都使用Netty作为底层通信框架Zookeeper:分布式的，开放源码的分布式应用程序协调服务,hadoop hbase等开源分布式系统的重要组件   应用场景描述:利用Zookeeper的服务注册与发现功能，实现Netty通信集群的简单高可用。 ...
netty如何结合Zookeeper如何高并发的代码实现步骤 —— 慧哥充电桩开源平台
最新发布
李文慧 国内知名开源工作者 全栈工程师 华为云最具价值专家
07-19 1422
总结起来，将Netty与Zookeeper结合应用于高并发系统，不仅需要理解各自的工作原理和技术特点，还需要结合实际需求设计和实现多种高可用、高可靠的架构方案。Netty是一个高性能、异步事件驱动的NIO（非阻塞IO）网络通信框架，而Zookeeper是一个分布式、开放源码的分布式应用程序协调服务，常用于维护配置信息、命名空间和提供分布式同步。分别运行NettyServer和ZookeeperClient类的main方法，启动Netty服务器和Zookeeper客户端。-慧哥充电桩开源平台
基于Zookeeper与Netty实现的分布式RPC服务
外星喵的博客
08-01 1373
文章目录前言架构前置知识服务接口API用户服务接口用户对象RPC请求对象RPC响应对象服务提供者RPC服务端RPC业务处理暴露接口服务注册服务消费者RPC客户端RPC客户端处理类RPC客户端代理类服务发现web接口 前言 大部分的互联网公司在应用的迭代演进过程中，随着系统访问量提高，业务复杂度提高，代码复杂度提高，应用逐渐从单体式架构向面向服务的分布式架构转变，但具体实现微服务架构的方式有所不同，主流上分为两种，一种是基于Http协议的远程调用，另外一种是基于RPC方式的调用。两种方式都有自己的代表框架，前
ZooKeeper - 负载均衡(Netty)
TrustNature
08-27 283
https://segmentfault.com/a/1190000012185401 架构图 图中左侧为ZooKeeper集群，右侧上方为工作服务器，下面为客户端。每台工作服务器在启动时都会去zookeeper的servers节点下注册临时节点，每台客户端在启动时都会去servers节点下取得所有可用的工作服务器列表，并通过一定的负载均衡算法计算得出一台工作服务器，并与之建立网络连接。网络连...
使用Netty + Zookeeper 简单搭建RPC
k7c9。
02-25 751
目录项目介绍common-通用server-服务端client-客户端 项目介绍 前段时间看了《netty实战》这本书，简单的入了一个netty的门，然后想着dubbo RPC也是用netty，于是打算敲一个netty + zookeeper的简单的RPC框架。项目目前比较简单，使用kryo做序列化，netty通信，zookeeper做注册中心。后期可能会优化，比如加几种负载均衡策略，使用nacos做注册中心（这个还没入门，所以是后期啦！） 下面看一下我这个项目的结构，比较简单，就三个模块，client-客
netty-redis-zookeeper高并发实战学习-netty-redis-zookeeper.zip
11-06
在学习"Netty-Redis-Zookeeper高并发实战"的过程中，你可能会涉及到以下知识点： 1. Netty的基本概念和原理，包括其事件循环模型、ByteBuf的使用以及自定义编解码器的实现。 2. Redis的数据结构及其应用场景，如...
Dubbo-Zookeeper-Netty-SpringMVC, 使用dubbo注册服务，netty做服务器，springmvc提供restful接口.zip
09-18
在本项目"Dubbo-Zookeeper-Netty-SpringMVC"中，我们主要关注四个关键技术和框架的集成与应用。这四个技术分别是Dubbo、Zookeeper、Netty和SpringMVC，它们在分布式系统开发中各自扮演着重要的角色。让我们详细探讨...
《Netty、Redis、ZooKeeper高并发实战》-netty-redis-zookeeper.zip
01-29
Netty是Java领域内的一款高性能网络通信框架，Redis是一款广泛使用的开源内存数据结构存储系统，而ZooKeeper则是一个分布式协调服务。这三者在处理大规模并发请求时都发挥着关键作用。 Netty概述： Netty是一个基于...
netty,redis,zookeeper高-netty_redis_zookeeper_source_code.zip
01-29
总的来说，这个压缩包提供了一个绝佳的学习资源，对于想深入了解网络编程、数据存储和分布式协调的开发者来说，Netty、Redis和Zookeeper的源代码是宝贵的参考资料。通过研究这些源码，你可以提升自己的技能，更好地...
netty入门（zookeeper-java发布和发现）
qq5132834的专栏
12-26 338
注册【发布】 /** * */ package com.cn.server.zuk.registry; import java.io.IOException; import java.util.ArrayList; import java.util.List; import java.util.concurrent.CountDownLatch; import org.apache....
ZooKeeper源码分析之NettyServerCnxnFactory
long99920的博客
11-14 1451
文章目录2021SC@SDUSC 2021SC@SDUSC
基于ZooKeeper为注册中心的Netty_Rpc
qq_30761967的博客
07-08 573
kkkkk
基于 Netty + Zoookeeper 实现零配置分布式RPC框架
BurukeYou
07-18 2575
案例代码地址 BoomRpc 1前言 刚学完Netty后总觉得不写点什么东西好像过意不去,于是就想去实现一个简易的RPC框架,但是见识到Dubbo的繁琐配置后,我知道无论再简陋我都希望它是零配置的, 就像Spring Cloud的Eureka/Nacos + Feign 那样. 2.简介 2.1 特征 零配置 容错处理 负载均衡 超时发送 服务器节点动态上下线 多种序列化方式 自定义协议栈 2.1 使用技术 Spring 项目必备框架,非常强大的对象管理能力 Netty 基于NIO的高性能
基于Zookeeper+Netty+Protostuff实现的简单RPC框架
w
07-04 928
RPC介绍 RPC，即 Remote Procedure Call（远程过程调用），说得通俗一点就是：两台服务器A、B，一个应用部署在A服务器上，想要调用B服务器上应用提供的函数或方法，由于不在一个内存空间，不能直接调用，需要通过网络来表达调用的语义和传达调用的数据。 技术选型 Netty：为了支持高并发，需要异步的IO，netty屏蔽了Java底层的NIO细节，因此用较少的代码即可构...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值