Java netty发送接收（TCP、UDP）

最新推荐文章于 2024-06-08 22:45:27 发布
最新推荐文章于 2024-06-08 22:45:27 发布
阅读量2.4k 收藏 11
点赞数
分类专栏： java 文章标签： java 开发语言
原文链接：https://blog.csdn.net/weixin_50272584/article/details/130638515
版权

依赖

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

yml配置

gps:
  netty:
    tcp:
      port: 8888
      read-timeout: 15 #读超时 15分钟
    udp:
      port: 7777
    threads:
      boss: 1
      worker: 4
      business:
        num: 1 #业务线程数量
        max-pending: 100000

配置类

@Configuration
public class EventLoopGroupConfig {
 
    @Value("${gps.netty.threads.boss}")
    private int bossNum;
 
    @Value("${gps.netty.threads.worker}")
    private int workerNum;
 
    @Value("${gps.netty.threads.business.num}")
    private int businessNum;
 
	@Value("${gps.netty.threads.business.max-pending}")
    private int maxPending;
 
 
    /**
     * TCP连接处理
     * @return
     */
    @Bean(name = "bossGroup")
    public NioEventLoopGroup bossGroup() {
        return new NioEventLoopGroup(bossNum);
    }
 
    /**
     * Socket数据读写
     * @return
     */
    @Bean(name = "workerGroup")
    public NioEventLoopGroup workerGroup() {
        return new NioEventLoopGroup(workerNum);
    }
 
    /**
     * Handler业务处理
     * @return
     */
    @Bean(name = "businessGroup")
    public EventExecutorGroup businessGroup() {
        return new DefaultEventExecutorGroup(businessNum,new BusinessThreadFactory(),maxPending, RejectedExecutionHandlers.reject());
    }
    
    static class BusinessThreadFactory implements ThreadFactory {
        private final ThreadGroup group;
        private final AtomicInteger threadNumber = new AtomicInteger(1);
        private final String namePrefix;
 
        BusinessThreadFactory() {
            SecurityManager s = System.getSecurityManager();
            group = (s != null) ? s.getThreadGroup() :
                                  Thread.currentThread().getThreadGroup();
            namePrefix = "business-thread-";
        }
 
        @Override
        public Thread newThread(Runnable r) {
            Thread t = new Thread(group, r,
                                  namePrefix + threadNumber.getAndIncrement(),
                                  0);
            if (t.isDaemon()){
                t.setDaemon(false);
            }
 
            if (t.getPriority() != Thread.NORM_PRIORITY){
                t.setPriority(Thread.NORM_PRIORITY);
            }
            return t;
        }
    }
 
}

TcpServer

@Slf4j
@Component
public class NettyTcpServer implements ApplicationListener<ApplicationStartedEvent> {
 
    @Value("${gps.netty.tcp.port}")
    private int port;
    
    @Value("${gps.netty.tcp.read-timeout}")
    private int readTimeOut;
 
    @Autowired
    @Qualifier("bossGroup")
    private NioEventLoopGroup bossGroup;
 
    @Autowired
    @Qualifier("workerGroup")
    private NioEventLoopGroup workerGroup;
    
    @Autowired
    @Qualifier("businessGroup")
    private EventExecutorGroup businessGroup;
 
    @Autowired
    private TcpServerHandler tcpServerHandler;
 
    /**
     * 启动Server
     *
     */
    @Override
	public void onApplicationEvent(ApplicationStartedEvent event) {
    	try {
	        ServerBootstrap serverBootstrap = new ServerBootstrap();
	        serverBootstrap.group(bossGroup, workerGroup)
	                .channel(NioServerSocketChannel.class)
	                .childHandler(new ChannelInitializer<SocketChannel>() { //
						@Override
						public void initChannel(SocketChannel ch) throws Exception {
							ch.pipeline().addLast(new IdleStateHandler(readTimeOut, 0, 0, TimeUnit.MINUTES));
							// 1024表示单条消息的最大长度，解码器在查找分隔符的时候，达到该长度还没找到的话会抛异常
							ch.pipeline().addLast(
									new DelimiterBasedFrameDecoder(1024, Unpooled.copiedBuffer(new byte[] { MsgUtil.DELIMITER }),
											Unpooled.copiedBuffer(new byte[] { MsgUtil.DELIMITER, MsgUtil.DELIMITER })));
							ch.pipeline().addLast(businessGroup,tcpServerHandler);
						}
					})
	                .option(ChannelOption.SO_BACKLOG, 1024) //服务端可连接队列数,对应TCP/IP协议listen函数中backlog参数
	                .childOption(ChannelOption.TCP_NODELAY, true)//立即写出
	                .childOption(ChannelOption.SO_KEEPALIVE, true);//长连接
	        ChannelFuture channelFuture = serverBootstrap.bind(port).sync();
	        if (channelFuture.isSuccess()) {
				log.info("TCP服务启动完毕,port={}", port);
	        }
    	}catch(Exception e) {
			log.info("TCP服务启动失败", e);
    	}
    }
 
    /**
     * 销毁资源
     */
    @PreDestroy
    public void destroy() {
        bossGroup.shutdownGracefully().syncUninterruptibly();
        workerGroup.shutdownGracefully().syncUninterruptibly();
        log.info("TCP服务关闭成功");
    }
}

UdpServer

@Slf4j
@Configuration
public class NettyUdpServer implements ApplicationListener<ApplicationStartedEvent> {
 
    @Value("${gps.netty.udp.port}")
    private int port;
 
    @Resource
    private UdpServerHandler udpServerHandler;
 
    private EventLoopGroup group = null;
 
    @Override
    public void onApplicationEvent(@NonNull ApplicationStartedEvent event) {
 
        try {
            Bootstrap b = new Bootstrap();
            String osName= SystemPropertyUtil.get("os.name").toLowerCase();
            if("linux".equals(osName)) {
                group = new EpollEventLoopGroup();
                b.group(group)
                        .channel(EpollDatagramChannel.class);
            }else {
                group = new NioEventLoopGroup();
                b.group(group)
                        .channel(NioDatagramChannel.class);
            }
            //广播
            b.option(ChannelOption.SO_BROADCAST, true)
                    //接收缓存区  10M
                    .option(ChannelOption.SO_RCVBUF, 1024 * 1024 * 10 )
                    //发送缓存区  10M
                    .option(ChannelOption.SO_SNDBUF, 1024 * 1024 * 10 )
                    .handler(udpServerHandler);
 
            ChannelFuture channelFuture = b.bind(port).sync();
            if (channelFuture.isSuccess()) {
                log.info("UDP服务启动完毕,port={}", port);
            }
 
        } catch (InterruptedException e) {
            log.info("UDP服务启动失败", e);
        }
 
    }
 
    /**
     * 销毁资源
     */
    @PreDestroy
    public void destroy() {
        if(group!=null) {
            group.shutdownGracefully();
        }
        log.info("UDP服务关闭成功");
    }
}

TcpHandler

@Slf4j
@ChannelHandler.Sharable
@Component
public class TcpServerHandler extends SimpleChannelInboundHandler<ByteBuf> {
 
	@Autowired
	private KafkaSender kafkaSender;
 
	@Autowired
	@Qualifier("businessGroup")
	private EventExecutorGroup businessGroup;
 
    /**
     * 使用
     * @param ctx
     * @param byteBuf
     * @throws Exception
     */
    @Override
    protected void channelRead0(ChannelHandlerContext ctx, ByteBuf byteBuf) {
		String content = byteBuf.toString(StandardCharsets.UTF_8);
 
		log.info("TCP服务端接收到消息：{}",  content);
 
 
		ByteBuf buf = Unpooled.copiedBuffer("TCP已经接收到消息：".getBytes(StandardCharsets.UTF_8));
 
		businessGroup.execute(()->{
			try {
				kafkaSender.sendMessage("hello", content);
				send2client(ctx,buf.array());
			}catch(Throwable e) {
				log.error("TCP数据接收处理出错",e);
				ByteBuf err = Unpooled.copiedBuffer("系统错误：".getBytes(StandardCharsets.UTF_8));
				send2client(ctx,err.array());
			}
		});
 
    }
    @Override
    public void channelReadComplete(ChannelHandlerContext ctx) {
        ctx.flush();
    }
 
    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {
    	log.error("TCP数据接收处理出错：",cause);
    }
 
    /**
     * 返回消息给客户端
     * @param ctx
     * @param msg
     */
    void send2client(ChannelHandlerContext ctx, byte[] msg) {
    	ByteBuf buf= Unpooled.buffer(msg.length+1);
    	buf.writeBytes(msg);
    	buf.writeByte(MsgUtil.DELIMITER);
    	ctx.writeAndFlush(buf).addListener(future->{
    		if(!future.isSuccess()) {
				log.error("TCP发送给客户端消息失败");
    		}
    	});
    }
}

UdpHandler

@ChannelHandler.Sharable
@Component
@Slf4j
public class UdpServerHandler extends SimpleChannelInboundHandler<DatagramPacket> {
 
    @Autowired
    @Qualifier("businessGroup")
    private EventExecutorGroup businessGroup;
 
   @Autowired
   private KafkaSender kafkaSender;
 
    @Override
    protected void channelRead0(ChannelHandlerContext ctx, DatagramPacket packet) throws Exception {
        String content = packet.content().toString(StandardCharsets.UTF_8);
 
        log.info("UDP服务端接收到消息：{}",  content);
 
 
        ByteBuf buf = Unpooled.copiedBuffer("UDP已经接收到消息：".getBytes(StandardCharsets.UTF_8));
 
 
        businessGroup.execute(()->{
            try {
                kafkaSender.sendMessage("hello", content);
                ctx.writeAndFlush(new DatagramPacket(buf, packet.sender()));
            }catch(Throwable e) {
                log.info("UDP数据接收处理出错{}",  e);
            }
        });
    }

Tcp消息发送

@Slf4j
@RestController
public class TcpClientController {
 
    @Value("${gps.netty.tcp.port}")
    private int port;
 
    @PostMapping("sendTcp")
    public String send(String msg){
        EventLoopGroup group = new NioEventLoopGroup();
        Bootstrap b = new Bootstrap();
        Channel ch =null;
        TcpServerHandler handler=new TcpServerHandler();
 
        try {
            b.group(group)
                    .channel(NioSocketChannel.class)
                    .handler(new ChannelInitializer<NioSocketChannel>() {
                        @Override
                        protected void initChannel(NioSocketChannel ch) throws Exception {
                            ch.pipeline().addLast(
                                    new DelimiterBasedFrameDecoder(1024, Unpooled.copiedBuffer(new byte[] { 0x7e }),
                                            Unpooled.copiedBuffer(new byte[] { 0x7e, 0x7e })));
                            ch.pipeline().addLast(handler);
                        }});
            ch =b.connect("localhost", port).sync().channel();
 
        } catch (Exception e) {
            e.printStackTrace();
        }
 
        ByteBuf tcpMsg = Unpooled.copiedBuffer(msg.getBytes(StandardCharsets.UTF_8));
 
        ByteBuf buf= Unpooled.buffer(msg.length() + 1);
        try{
            log.info("TCP客户端发送消息：{}", msg);
            buf.writeBytes(tcpMsg);//消息体
            buf.writeByte(MsgUtil.DELIMITER);//消息分割符
            ch.writeAndFlush(buf).sync();
        }catch (Exception e){
            log.info("TCP客户端发送消息失败：{}", e);
        }
 
        //关闭链接
        group.shutdownGracefully();
        return "success";
    }

Udp消息发送

@Slf4j
@RestController
public class UdpClientController {
 
    @Value("${gps.netty.udp.port}")
    private int port;
 
    @PostMapping("sendUdp")
    public String send(String msg){
        EventLoopGroup group = new NioEventLoopGroup();
        Bootstrap b = new Bootstrap();
        Channel ch =null;
        UdpServerHandler handler=new UdpServerHandler();
 
        try {
            b.group(group)
                    .channel(NioDatagramChannel.class)
                    .option(ChannelOption.SO_BROADCAST, true)
                    .handler(new ChannelInitializer<NioDatagramChannel>() {
 
                        @Override
                        protected void initChannel(NioDatagramChannel ch) throws Exception {
                            ch.pipeline().addLast(handler.getClass().getSimpleName(),handler);
                        }});
            ch =b.bind(0).sync().channel();
        } catch (Exception e) {
            e.printStackTrace();
        }
 
        ByteBuf buf = Unpooled.copiedBuffer(msg.getBytes(StandardCharsets.UTF_8));
 
        try{
            log.info("UDP客户端发送消息：{}", msg);
            ch.writeAndFlush(new DatagramPacket(
                    Unpooled.copiedBuffer(buf.array()),
                    SocketUtils.socketAddress("localhost", port))).sync();
        }catch (Exception e){
            log.info("UDP客户端发送消息失败：{}", e);
        }
 
        //关闭链接
        group.shutdownGracefully();
        return "success";
    }
}

项目地址：

Netty + KafKa: 使用netty发送、接收tcp和udp数据，多线程处理接收的数据。 kafka批处理 (gitee.com)

擦肩而过
关注
  • 0
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java netty实现tcp协议_Netty实现网络通信
weixin_33521678的博客
02-24 1589
Netty是一个 Java NIO 客户端服务器框架，使用它可以快速简单地开发网络应用程序，比如服务器和客户端的协议。Netty 大大简化了网络程序的开发过程比如 TCP 和 UDP 的 socket 服务的开发。更多关于 Netty 的知识，可以参阅《Netty 4.x 用户指南》( https://github.com/waylau/netty-4-user-guide)下面，就基于 N...
netty发送接收16进制代码_netty tcp以16进制字节码的形式与硬件通信
weixin_30750349的博客
02-08 5031
netty 以16进制字节码和硬件通信技术交流QQ群 10934764531 核心代码 需要把16进制的字节码数组写入 byteBuf里面再发送给硬件才可以/*** 发送数据*/private static void send2client(ChannelHandlerContext channel, final String receiveStr) {try {// netty需要用ByteB...
Netty-SocketIO：最好用的Java版即时消息推送
热门推荐
沉默王二
09-13 6万+
Netty-SocketIO是一个开源的、基于Netty的、Java版的即时消息推送项目。通过Netty-SocketIO，我们可以轻松的实现服务端主动向客户端推送消息的场景，比如说股票价格变化、K线图、消息提醒等。它和websocket有相同的作用，只不过Netty-SocketIO可支持所有的浏览器。
netty搭建TCP、UDP服务
09-23
Java异步NIO框架Netty实现高性能高并发,通过netty搭建TCP、UDP服务，支持物联网设备上行，下行
Netty向设备发送消息并等待设备响应
最新发布
StruggleRookie的博客
06-08 336
在使用netty开发和硬件对接时，经常会遇到服务端给硬件设备发送命令后需要等待设备反馈响应命令后执行逻辑。
java实现基于netty 的udp字节数据接收服务
08-14
java实现基于netty 的utp字节数据接收服务，服务具体实现代码。样例java实现基于netty 的utp字节数据接收服务，服务具体实现代码。样例
【Java】Netty创建网络服务端客户端（TCP/UDP）
DevFrank的博客
11-09 4521
Netty创建网络服务端客户端示例
netty tcp udp监听同一端口
牛雪的小商店
07-07 2246
文章目录前言一、tcp和udp区别二、netty创建服务1.tcp服务2.udp服务总结 前言 经常写tcp，最近需求突然要搞udp和tcp监听同一端口号。 一、tcp和udp区别 TCP 是面向连接的，UDP 是面向无连接的 UDP程序结构较简单 TCP 是面向字节流的，UDP 是基于数据报的 TCP 保证数据正确性，UDP 可能丢包 TCP 保证数据顺序，UDP 不保证 二、netty创建服务 1.tcp服务 代码如下（示例）： public class TcpServer { pub
使用Netty构建TCP和UDP服务器和客户端
lonely_baby的博客
03-09 1911
上述示例代码中，分别定义了一个TCP服务器、TCP客户端、UDP服务器和UDP客户端，并使用了Netty提供的NIO事件循环组（EventLoopGroup）、服务器/客户端启动器（ServerBootstrap/Bootstrap）和通道初始化器（ChannelInitializer）等组件，以实现服务器和客户端的建立、连接、数据读写等功能。总之，使用Netty构建TCP和UDP服务器和客户端，可以帮助开发人员快速构建高性能、可扩展的网络应用程序，并通过其丰富的功能和插件实现更加细粒度的控制和调试。
笔记 Netty 处理Tcp Http Udp
FOREVERHOPE_WBZ的专栏
01-07 430
/心跳包 socketChannel.pipeline().addLast(new IdleStateHandler(300,0,0, TimeUnit.SECONDS));//处理tcp请求 }else{ log.info("请求端口出错："+socketChannel.localAddress().getPort());
基于java netty的udp客户端声呐数据对接
06-07
Java Netty是一个高性能、异步事件驱动的网络应用程序框架，常用于开发高效的网络服务，包括TCP、UDP等网络协议的应用。在"基于Java Netty的UDP客户端声呐数据对接"项目中，我们主要关注如何利用Netty处理UDP通信，...
java用netty写udp与tcp.pdf
11-24
Java 用 Netty 写 UDP 与 TCP Netty 是由 JBOSS 提供的一个 Java 开源框架，提供异步的、事件驱动的网络应用程序框架和工具，用以快速开发高性能、高可靠性的网络服务器和客户端程序。Netty 是一个基于 NIO 的客户...
java网络编程使用tcp、udp实现多用户对话
01-10
在Java中，通过Socket API可以方便地实现基于TCP和UDP的网络通信。 TCP是一种面向连接的、可靠的协议，它确保数据包按照发送顺序到达目的地，且不丢失任何数据。在Java中，我们可以通过`java.net.Socket`和`java...
java的netty实现的可靠udp网络库.rar
08-25
在Java世界中，Netty因其强大的功能和灵活性而被广泛应用于各种网络应用，包括TCP、UDP以及HTTP等多种协议。在这个“java的netty实现的可靠udp网络库”中，我们可以探讨Netty如何通过UDP协议实现可靠的网络通信。 ...
java网络编程，UDP，发送16进制报文。
03-06
在Java中，我们使用`java.net.DatagramSocket`类来创建一个UDP套接字，用于发送和接收数据报。`DatagramPacket`类用于封装我们要发送的数据和目标地址。以下是一个简单的UDP客户端示例： ```java import java.io....
Netty的UDP广播发送与接收
明光的博客
08-09 1万+
想要的逻辑是这样的： A向局域网内发送广播消息messageA； B收到了messageA并直接使用既有的session或channel把需要回复的消息write回来就行了。 自己尝试了一下，记载一下使用中较为便利的写法。 客户端一般是这样写： EventLoopGroup eventLoopGroup = new NioEventLoopGroup(); try { ...
《Netty实战篇》快速搭建UDP服务端
一个不断前行的程序者
03-15 2256
Netty是一个基于NIO的客户、服务端开发框架，使用Netty能够使你快速和简单的开发出一个网络应用，例如实现某种协议的客户、服务端应用。Netty相当于简化和流程化了网络应用的编程过程，例如基于UDP和TCP的socket开发。“快速而简单”并不意味着生成的应用程序将面临可维护性或性能问题。Netty是经过精心设计的，其经验来自FTP、SMTP、HTTP以及各种二进制和基于文本的传统协议的实现。因此，Netty成功地找到了一种不妥协地实现易于开发、性能、稳定性和灵活性的方法。
java netty框架
02-16
2. **Channel**：代表一个到另一端的连接，可以是TCP、UDP、文件或管道等。Channel提供了一种统一的方式来处理不同类型的I/O操作。 3. **EventLoop**：事件循环，负责处理事件并调度任务。每个EventLoop都有一个...
java netty发送邮件
07-24
Netty是一个网络编程框架，它主要用于构建高性能、高可靠性的网络应用程序。然而，Netty本身并不提供发送邮件的功能，它更适用于实现基于TCP或UDP的网络通信。 如果你想在Java中使用Netty发送邮件，你可以借助JavaMail API来实现。JavaMail API是Java平台的标准API，它提供了发送和接收电子邮件的功能。 以下是一个使用Netty和JavaMail API发送简单邮件的示例代码： ```java import io.netty.util.concurrent.Future; import io.netty.util.concurrent.FutureListener; import io.netty.util.concurrent.Promise; import javax.mail.*; import javax.mail.internet.InternetAddress; import javax.mail.internet.MimeMessage; import javax.mail.internet.MimeMultipart; import javax.mail.internet.MimeBodyPart; import javax.activation.DataHandler; import javax.activation.FileDataSource; import java.util.Properties; public class EmailSender { public static void main(String[] args) { // 配置SMTP服务器和认证信息 Properties props = new Properties(); props.put("mail.smtp.host", "smtp.example.com"); props.put("mail.smtp.port", "587"); props.put("mail.smtp.auth", "true"); // 创建会话 Session session = Session.getInstance(props, new Authenticator() { protected PasswordAuthentication getPasswordAuthentication() { return new PasswordAuthentication("your_username", "your_password"); } }); // 创建邮件消息 MimeMessage message = new MimeMessage(session); try { // 设置发件人 message.setFrom(new InternetAddress("sender@example.com")); // 设置收件人 message.addRecipient(Message.RecipientType.TO, new InternetAddress("recipient@example.com")); // 设置主题 message.setSubject("Test Email"); // 创建正文部分 MimeBodyPart textPart = new MimeBodyPart(); textPart.setText("This is the email content."); // 创建附件部分 MimeBodyPart attachmentPart = new MimeBodyPart(); FileDataSource fileDataSource = new FileDataSource("path_to_attachment_file"); attachmentPart.setDataHandler(new DataHandler(fileDataSource)); attachmentPart.setFileName(fileDataSource.getName()); // 创建多部分消息 MimeMultipart multipart = new MimeMultipart(); multipart.addBodyPart(textPart); multipart.addBodyPart(attachmentPart); // 设置消息内容 message.setContent(multipart); // 使用Netty发送邮件 Promise<Void> promise = new DefaultPromise<>(session.channel().eventLoop()); Transport transport = session.getTransport("smtp"); transport.connect(); transport.sendMessage(message, message.getAllRecipients(), new SendListener(promise)); transport.close(); // 等待邮件发送完成 Future<Void> future = promise; future.addListener(new FutureListener<Void>() { @Override public void operationComplete(Future<Void> future) throws Exception { if (future.isSuccess()) { System.out.println("Email sent successfully."); } else { System.out.println("Failed to send email: " + future.cause().getMessage()); } } }); } catch (Exception ex) { ex.printStackTrace(); } } private static class SendListener extends SendMailTransportListener { private final Promise<Void> promise; public SendListener(Promise<Void> promise) { this.promise = promise; } @Override public void messageDelivered(TransportEvent e) { promise.setSuccess(null); } @Override public void messageNotDelivered(TransportEvent e) { promise.setFailure(e.getException()); } @Override public void messagePartiallyDelivered(TransportEvent e) { promise.setFailure(e.getException()); } } } ``` 请注意，上述代码中的SMTP服务器和认证信息需要根据你的实际情况进行配置。另外，需要将"sender@example.com"和"recipient@example.com"替换为实际的发件人和收件人邮箱地址。最后，将"path_to_attachment_file"替换为要附加的文件的路径。 这只是一个简单的示例，你可以根据自己的需求进行扩展和定制。希望对你有帮助！
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值