Springboot+Netty搭建TCP客户端-多客户端

置顶 已于 2023-01-31 21:33:07 修改
阅读量1.6w 收藏 92
点赞数 9
分类专栏： SpringBoot+Netty 文章标签： Netty Springboot+Netty Springboot集成Netty Netty TCP Netty TCP客户端
于 2019-07-04 19:16:51 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/myyhtw/article/details/94579126
版权

之前搭建了一个Springboot+Netty服务端的应用，既然有服务端，自然也有客户端的应用，现在搭建一个Springboot+Netty客户端的应用Demo程序，多客户端方式，使用服务端和客户端进行联调测试，也可以用tcp的小工具来测试(中文可能乱码)

SpringBoot+Netty实现TCP服务端客户端的源码Demo

新建Springboot的maven项目，pom.xml文件导入依赖包

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

	<parent>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-parent</artifactId>
		<version>2.0.5.RELEASE</version>
		<relativePath />
	</parent>

	<groupId>boot.base.tcp.client</groupId>
	<artifactId>boot-example-base-tcp-client-2.0.5</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<name>boot-example-base-tcp-client-2.0.5</name>
	<url>http://maven.apache.org</url>
	<properties>
		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
		<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
		<java.version>1.8</java.version>
	</properties>

	<dependencies>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-web</artifactId>
		</dependency>
		<dependency>
			<groupId>io.netty</groupId>
			<artifactId>netty-all</artifactId>
		</dependency>
		<dependency>
			<groupId>io.springfox</groupId>
			<artifactId>springfox-swagger2</artifactId>
			<version>2.9.2</version>
		</dependency>
		<dependency>
			<groupId>com.github.xiaoymin</groupId>
			<artifactId>swagger-bootstrap-ui</artifactId>
			<version>1.9.2</version>
		</dependency>
	</dependencies>
	<build>
		<plugins>
			<!-- 打包成一个可执行jar -->
			<plugin>
				<groupId>org.springframework.boot</groupId>
				<artifactId>spring-boot-maven-plugin</artifactId>
				<executions>
					<execution>
						<goals>
							<goal>repackage</goal>
						</goals>
					</execution>
				</executions>
			</plugin>
		</plugins>
	</build>
</project>

Springboot启动类，启动一个Netty的客户端

package boot.example.tcp.client;

import boot.example.tcp.client.netty.BootNettyClientThread;
import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.scheduling.annotation.Async;
import org.springframework.scheduling.annotation.EnableAsync;
import org.springframework.scheduling.annotation.EnableScheduling;

/**
 * 蚂蚁舞
 */
@SpringBootApplication
@EnableAsync
@EnableScheduling
public class BootNettyClientApplication implements CommandLineRunner{
    public static void main( String[] args ) {
		SpringApplication app = new SpringApplication(BootNettyClientApplication.class);
		app.run(args);

        System.out.println( "Hello World!" );
    }

    @Async
	@Override
	public void run(String... args) throws Exception {
		/**
		 * 使用异步注解方式启动netty客户端服务
		 */
		int port = 6655;
		String address = "127.0.0.1";
		int count = 10; // 模拟多个客户端
		for(int i = 0; i < count; i++) {
			BootNettyClientThread thread = new BootNettyClientThread(port, address);
			thread.start();
		}

	}
}

Netty的client类

package boot.example.tcp.client.netty;


import io.netty.bootstrap.Bootstrap;
import io.netty.channel.Channel;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelOption;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioSocketChannel;

/**
 * 
 * netty 客户端
 * 蚂蚁舞
 */
public class BootNettyClient {

	public void connect(int port, String host) throws Exception{
		
		/**
		 * 客户端的NIO线程组
		 * 
		 */
        EventLoopGroup group = new NioEventLoopGroup();
        
        try {
        	/**
        	 * Bootstrap 是一个启动NIO服务的辅助启动类 客户端的
        	 */
        	Bootstrap bootstrap = new Bootstrap();
        	bootstrap = bootstrap.group(group);
        	bootstrap = bootstrap.channel(NioSocketChannel.class).option(ChannelOption.TCP_NODELAY, true);
        	/**
        	 * 设置 I/O处理类,主要用于网络I/O事件，记录日志，编码、解码消息
        	 */
        	bootstrap = bootstrap.handler(new BootNettyChannelInitializer<SocketChannel>());
        	/**
        	 * 连接服务端
        	 */
			ChannelFuture future = bootstrap.connect(host, port).sync();
			if(future.isSuccess()) {
				Channel channel = future.channel();
				String id = future.channel().id().toString();
				BootNettyClientChannel bootNettyClientChannel = new BootNettyClientChannel();
				bootNettyClientChannel.setChannel(channel);
				bootNettyClientChannel.setCode("clientId:"+id);
				BootNettyClientChannelCache.save("clientId:"+id, bootNettyClientChannel);
				System.out.println("netty client start success="+id);
				/**
				 * 等待连接端口关闭
				 */
				future.channel().closeFuture().sync();
			}
		} finally {
			/**
			 * 退出，释放资源
			 */
			group.shutdownGracefully().sync();
		}
        
	}
	

}

通道初始化

package boot.example.tcp.client.netty;


import io.netty.channel.Channel;
import io.netty.channel.ChannelHandler;
import io.netty.channel.ChannelInitializer;
import io.netty.handler.codec.string.StringDecoder;
import io.netty.handler.codec.string.StringEncoder;
import io.netty.util.CharsetUtil;

/**
 * 通道初始化
 * 蚂蚁舞
 */
@ChannelHandler.Sharable
public class BootNettyChannelInitializer<SocketChannel> extends ChannelInitializer<Channel> {

	@Override
	protected void initChannel(Channel ch) throws Exception {

        ch.pipeline().addLast("encoder", new StringEncoder(CharsetUtil.UTF_8));
        ch.pipeline().addLast("decoder", new StringDecoder(CharsetUtil.UTF_8));
        /**
         * 自定义ChannelInboundHandlerAdapter
         */
        ch.pipeline().addLast(new BootNettyChannelInboundHandlerAdapter());
		
	}

}

客户端I/O数据读写处理类

package boot.example.tcp.client.netty;

import java.io.IOException;
import java.net.InetSocketAddress;

import io.netty.channel.ChannelHandler;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;

/**
 * 
 * I/O数据读写处理类
 * 蚂蚁舞
 */
@ChannelHandler.Sharable
public class BootNettyChannelInboundHandlerAdapter extends ChannelInboundHandlerAdapter{
	
    /**
     * 从服务端收到新的数据时，这个方法会在收到消息时被调用
     */
    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception, IOException {
        if(msg == null){
            return;
        }
    	System.out.println("channelRead:read msg:"+msg.toString());
        BootNettyClientChannel bootNettyClientChannel = BootNettyClientChannelCache.get("clientId:"+ctx.channel().id().toString());
        if(bootNettyClientChannel != null){
            System.out.println("to do");
            bootNettyClientChannel.setLast_data(msg.toString());
        }

        //回应服务端
        //ctx.write("I got server message thanks server!");
    }

    /**
     * 从服务端收到新的数据、读取完成时调用
     */
    @Override
    public void channelReadComplete(ChannelHandlerContext ctx) throws IOException {
    	System.out.println("channelReadComplete");
    	ctx.flush();
    }

    /**
     * 当出现 Throwable 对象才会被调用，即当 Netty 由于 IO 错误或者处理器在处理事件时抛出的异常时
     */
    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws IOException {
    	System.out.println("exceptionCaught");
        cause.printStackTrace();
        ctx.close();//抛出异常，断开与客户端的连接
    }

    /**
     * 客户端与服务端第一次建立连接时 执行
     */
    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception, IOException {
        super.channelActive(ctx);
        InetSocketAddress inSocket = (InetSocketAddress) ctx.channel().remoteAddress();
        String clientIp = inSocket.getAddress().getHostAddress();
        System.out.println(clientIp);
    }

    /**
     * 客户端与服务端 断连时 执行
     */
    @Override
    public void channelInactive(ChannelHandlerContext ctx) throws Exception, IOException {
        super.channelInactive(ctx);
        InetSocketAddress inSocket = (InetSocketAddress) ctx.channel().remoteAddress();
        String clientIp = inSocket.getAddress().getHostAddress();
        ctx.close(); //断开连接时，必须关闭，否则造成资源浪费
        System.out.println("channelInactive:"+clientIp);
    }
    

    
}

建立channel保存多客户端BootNettyClientChannel

package boot.example.tcp.client.netty;

import io.netty.channel.Channel;

/**
 * 	蚂蚁舞
 */
public class BootNettyClientChannel {

	//	连接客户端唯一的code
	private String code;

	//	客户端最新发送的消息内容
	private String last_data;

	private transient volatile Channel channel;

	public String getCode() {
		return code;
	}

	public void setCode(String code) {
		this.code = code;
	}

	public Channel getChannel() {
		return channel;
	}

	public void setChannel(Channel channel) {
		this.channel = channel;
	}

	public String getLast_data() {
		return last_data;
	}

	public void setLast_data(String last_data) {
		this.last_data = last_data;
	}
}

BootNettyClientChannelCache
package boot.example.tcp.client.netty;

import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

/**
 *  蚂蚁舞
 */
public class BootNettyClientChannelCache {

    public static volatile Map<String, BootNettyClientChannel> channelMapCache = new ConcurrentHashMap<String, BootNettyClientChannel>();

    public static void add(String code, BootNettyClientChannel channel){
    	channelMapCache.put(code,channel);
    }

    public static BootNettyClientChannel get(String code){
        return channelMapCache.get(code);
    }

    public static void remove(String code){
    	channelMapCache.remove(code);
    }

    public static void save(String code, BootNettyClientChannel channel) {
        if(channelMapCache.get(code) == null) {
            add(code,channel);
        }
    }


}

netty的启动BootNettyClientThread

package boot.example.tcp.client.netty;


/**
 * 
 * netty 客户端
 * 蚂蚁舞
 */
public class BootNettyClientThread extends Thread {

	private final int port;

	private final String address;
	public BootNettyClientThread(int port, String address){
		this.port = port;
		this.address = address;
	}

	public void run() {
		try {
			new BootNettyClient().connect(port, address);
		} catch (Exception e) {
			throw new RuntimeException(e);
		}
	}
}

心跳使用定时器BootNettyHeartTimer

package boot.example.tcp.client.netty;


import io.netty.buffer.Unpooled;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Service;

import java.util.Map;

/**
 *  蚂蚁舞
 */
@Service
public class BootNettyHeartTimer {

    //  使用定时器发送心跳
    @Scheduled(cron = "0/30 * * * * ?")
    public void heart_timer() {
        String back = "heart";
        if(BootNettyClientChannelCache.channelMapCache.size() > 0){
            for (Map.Entry<String, BootNettyClientChannel> entry : BootNettyClientChannelCache.channelMapCache.entrySet()) {
                BootNettyClientChannel bootNettyChannel = entry.getValue();
                if(bootNettyChannel != null && bootNettyChannel.getChannel().isOpen()){
                    bootNettyChannel.getChannel().writeAndFlush(Unpooled.buffer().writeBytes(back.getBytes()));
                }
            }
        }

    }

}

测试接口BootNettyClientController

package boot.example.tcp.client.controller;

import boot.example.tcp.client.netty.BootNettyClientChannel;
import boot.example.tcp.client.netty.BootNettyClientChannelCache;
import io.netty.buffer.Unpooled;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * 	蚂蚁舞
 */
@RestController
public class BootNettyClientController {

	@GetMapping("/list")
	public List<Map<String,String>> list() {
		List<Map<String,String>> list = new ArrayList<>();
		for (Map.Entry<String, BootNettyClientChannel> entry : BootNettyClientChannelCache.channelMapCache.entrySet()) {
			Map<String, String> map = new HashMap<String, String>();
			map.put("code", entry.getKey());
			//map.put("code", entry.getValue().getCode());
			map.put("last_data", entry.getValue().getLast_data());
			list.add(map);
		}
		return list;
	}

	@PostMapping("/reportAllClientDataToServer")
	public String reportAllClientDataToServer(@RequestParam(name="content", required = true) String content) {
		for (Map.Entry<String, BootNettyClientChannel> entry : BootNettyClientChannelCache.channelMapCache.entrySet()) {
			BootNettyClientChannel bootNettyChannel = entry.getValue();
			if(bootNettyChannel != null && bootNettyChannel.getChannel().isOpen()){
				bootNettyChannel.getChannel().writeAndFlush(Unpooled.buffer().writeBytes(content.getBytes()));
			}
		}
		return "ok";
	}

	@PostMapping("/reportClientDataToServer")
	public String downDataToClient(@RequestParam(name="code", required = true) String code, @RequestParam(name="content", required = true) String content) {
		BootNettyClientChannel bootNettyChannel = BootNettyClientChannelCache.get(code);
		if(bootNettyChannel != null && bootNettyChannel.getChannel().isOpen()){
			bootNettyChannel.getChannel().writeAndFlush(Unpooled.buffer().writeBytes(content.getBytes()));
			return "success";
		}
		return "fail";
	}



}

SwaggerConfig测试方便

package boot.example.tcp.client;

import com.google.common.base.Predicates;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import springfox.documentation.builders.ApiInfoBuilder;
import springfox.documentation.builders.PathSelectors;
import springfox.documentation.builders.RequestHandlerSelectors;
import springfox.documentation.service.ApiInfo;
import springfox.documentation.spi.DocumentationType;
import springfox.documentation.spring.web.plugins.Docket;
import springfox.documentation.swagger2.annotations.EnableSwagger2;

/**
 *  蚂蚁舞
 */
@Configuration
@EnableSwagger2
public class SwaggerConfig {

    @Bean
    public Docket createRestApi(){
        return new Docket(DocumentationType.SWAGGER_2).apiInfo(apiInfo()).select()
                .apis(RequestHandlerSelectors.any()).paths(PathSelectors.any())
                .paths(Predicates.not(PathSelectors.regex("/error.*")))
                .paths(PathSelectors.regex("/.*"))
                .build().apiInfo(apiInfo());
    }

    private ApiInfo apiInfo(){
        return new ApiInfoBuilder()
                .title("netty tcp 客户端demo")
                .description("netty tcp 客户端接口测试demo")
                .version("0.01")
                .build();
    }

    /**
     * http://localhost:8094/doc.html  地址和端口根据实际项目查看
     */


}

客户端demo代码的目录结构

├─boot-example-base-tcp-client-2.0.5
│  │  pom.xml
│  │  
│  ├─src
│  │  ├─main
│  │  │  ├─java
│  │  │  │  └─boot
│  │  │  │      └─example
│  │  │  │          └─tcp
│  │  │  │              └─client
│  │  │  │                  │  BootNettyClientApplication.java
│  │  │  │                  │  SwaggerConfig.java
│  │  │  │                  │  
│  │  │  │                  ├─controller
│  │  │  │                  │      BootNettyClientController.java
│  │  │  │                  │      
│  │  │  │                  └─netty
│  │  │  │                          BootNettyChannelInboundHandlerAdapter.java
│  │  │  │                          BootNettyChannelInitializer.java
│  │  │  │                          BootNettyClient.java
│  │  │  │                          BootNettyClientChannel.java
│  │  │  │                          BootNettyClientChannelCache.java
│  │  │  │                          BootNettyClientThread.java
│  │  │  │                          BootNettyHeartTimer.java
│  │  │  │                          
│  │  │  └─resources
│  │  │          application.properties
│  │  │          
│  │  └─test
│  │      └─java
│  │          └─boot
│  │              └─example
│  │                  └─tcp
│  │                      └─client
│  │                              BootNettyClientApplicationTest.java
│  │

基本demo客户端代码就完成了，要进行测试了。

我这里不使用tcp服务端工具测试，之前使用之前使用netty搭建的服务端进行交互测试

地址Springboot+Netty搭建TCP服务端_蚂蚁舞的博客-CSDN博客

测试步骤

先启动springBoot+Netty的服务端代码

2023-01-20 10:25:55.677  INFO 2664 --- [           main] s.d.s.w.s.ApiListingReferenceScanner     : Scanning for api listing references
2023-01-20 10:25:55.904  INFO 2664 --- [           main] o.s.b.w.embedded.tomcat.TomcatWebServer  : Tomcat started on port(s): 6654 (http) with context path ''
2023-01-20 10:25:55.909  INFO 2664 --- [           main] b.e.t.server.BootNettyServerApplication  : Started BootNettyServerApplication in 6.752 seconds (JVM running for 7.598)
2023-01-20 10:25:55.915  INFO 2664 --- [           main] .s.a.AnnotationAsyncExecutionInterceptor : No task executor bean found for async processing: no bean of type TaskExecutor and no bean named 'taskExecutor' either
Hello World!
netty server start success!

可以浏览器web访问

http://localhost:6654/doc.html

再启动springBoot+Netty的客户端代码(多客户端啊，这里启动10个)

    	int port = 6655;
		String address = "127.0.0.1";
		int count = 10; // 模拟多个客户端
		for(int i = 0; i < count; i++) {
			BootNettyClientThread thread = new BootNettyClientThread(port, address);
			thread.start();
		}
2023-01-20 10:29:01.955  INFO 13120 --- [           main] o.s.j.e.a.AnnotationMBeanExporter        : Registering beans for JMX exposure on startup
2023-01-20 10:29:01.966  INFO 13120 --- [           main] o.s.c.support.DefaultLifecycleProcessor  : Starting beans in phase 2147483647
2023-01-20 10:29:01.967  INFO 13120 --- [           main] d.s.w.p.DocumentationPluginsBootstrapper : Context refreshed
2023-01-20 10:29:02.007  INFO 13120 --- [           main] d.s.w.p.DocumentationPluginsBootstrapper : Found 1 custom documentation plugin(s)
2023-01-20 10:29:02.053  INFO 13120 --- [           main] s.d.s.w.s.ApiListingReferenceScanner     : Scanning for api listing references
2023-01-20 10:29:02.205  INFO 13120 --- [           main] s.a.ScheduledAnnotationBeanPostProcessor : No TaskScheduler/ScheduledExecutorService bean found for scheduled processing
2023-01-20 10:29:02.257  INFO 13120 --- [           main] o.s.b.w.embedded.tomcat.TomcatWebServer  : Tomcat started on port(s): 8094 (http) with context path ''
2023-01-20 10:29:02.264  INFO 13120 --- [           main] b.e.t.client.BootNettyClientApplication  : Started BootNettyClientApplication in 6.258 seconds (JVM running for 7.18)
2023-01-20 10:29:02.270  INFO 13120 --- [           main] .s.a.AnnotationAsyncExecutionInterceptor : No task executor bean found for async processing: no bean of type TaskExecutor and no bean named 'taskExecutor' either
Hello World!
127.0.0.1
127.0.0.1
127.0.0.1
127.0.0.1
127.0.0.1
127.0.0.1
127.0.0.1
127.0.0.1
127.0.0.1
127.0.0.1
netty client start success=8f7ca2ce
netty client start success=987e23c5
netty client start success=dc272839
netty client start success=c74a53a9
netty client start success=cbf85db3
netty client start success=e6ff0519
netty client start success=bc0fc00f
netty client start success=29db84c8
netty client start success=6e20d3e6
netty client start success=30378f02

可以浏览客户端的web访问

 可以看到客户端启动了是个客户端，服务端也给客户端返回了服务端创建成功的code(实际是netty的通道id,唯一的拿来使用的)

可以看到服务端收到了来自客户端的心跳

 我选取一个客户端来测试客户端给服务端发送消息(含中文)


  {
    "code": "clientId:bc0fc00f",
    "last_data": "server:bd255b2d"
  }

 可以看到给服务端发送的数据是

蚂蚁舞mywhtw147258#$%^

服务端接收到的最新数据


  {
    "code": "server:bd255b2d",
    "report_last_data": "蚂蚁舞mywhtw147258#$%^"
  }

服务端控制台的打印日志

channelId=bd255b2ddata=蚂蚁舞mywhtw147258#$%^
channelReadComplete
channelId=bd255b2ddata=蚂蚁舞mywhtw147258#$%^
channelReadComplete

服务端给客户端发送消息的方式是一样的，以及服务端批量给客户端发送消息，还有多个客户端给服务端发送同样的消息，都是可以达到的。

基于springboot+netty的客户端和服务端就调通了，支持中文不乱码。

蚂蚁舞
关注
专栏目录
用Netty快速落地一个客户端程序
Hi，我是sharkchili，CSDN Java领域博客专家，开源项目JavaGuide维护人员，我想写一些有意思的东西，希望对你有帮助。
07-29 1091
于是我们给出下面这样一段基于引导类配置客户端程序的代码段，可以看到因为客户端无需处理接入连接，所以就没有配置主从reactor，对应的引导类我们就采用。因为近期收到很多读者的私信，所以也专门创建了一个交流群，感兴趣的读者可以通过上方的公众号获取笔者的联系方式完成好友添加，点击备注。因为近期收到很多读者的私信，所以也专门创建了一个交流群，感兴趣的读者可以通过上方的公众号获取笔者的联系方式完成好友添加，点击备注。或者超时在进行发送，所以在没收到ACK且没超时期间，客户端又攒了18bytes的数据，服务端发送。
springboot+netty+websocket+redis
03-08
springboot+netty+websocket+redis 分布式聊天，实现简单的聊天功能
Tcp客户端与服务端的搭建
最新发布
laterstage的博客
08-12 327
【代码】Tcp客户端与服务端的搭建。
spring boot 整合的netty 实现的socket的服务端和客户端
05-08
spring boot 整合的netty 实现的socket的demo（包括服务端和客户端是分开的两个项目，导入idea，启动即可）。
netty学习（3）:SpringBoot整合netty实现多个客户端与服务器通信
weixin_42774617的博客
07-03 5870
整体工程目录：一个server服务（netty服务器），两个client服务（netty客户端）pom文件引入netty依赖，springboot依赖。创建一个SpringBoot工程，然后创建三个子模块。然后按照相同的方法创建client2。
springboot+netty实现TCP客户端
jiaerkai
09-21 475
【代码】springboot+netty实现TCP客户端。
Springboot+Netty搭建基于TCP协议的客户端（二）
zwj1030711290的CSDN
07-27 547
之前搭建了一个Springboot+Netty服务端的应用，既然有服务端，自然也有客户端的应用，现在搭建一个Springboot+Netty客户端的应用Demo程序，也是使用TCP工具来进行测试，最终将客户端和服务端作为一个具体的应用来测试。1、新建Springboot的maven项目，pom.xml文件导入依赖包。
springboot整合netty，分客户端和服务端两个项目
07-20
springboot整合netty，分客户端和服务端两个项目，springboot整合netty，分客户端和服务端两个项目，springboot整合netty，分客户端和服务端两个项目，springboot整合netty，分客户端和服务端两个项目
基于netty+mqtt3.1.1+springboot+jdk8 实现的 mqtt 服务端跟客户端
04-29
#### 已实现： * 发布订阅功能 * 遗言通知 * 会话session数据 * 发布保留消息 * 主题过滤（/test 会接受到 /test/yy 的主题消息） * 实现标准的 qos0 qos1 qos2消息确认机制 * ssl加密 * 支持ws协议 ...
Java整合springboot2.3+modbusTcp协议+netty高性能物联网服务源码
03-31
Java整合springboot2.3+modbusTcp协议+netty高性能物联网服务源码 ...5、完全支持Modbus TCP 4种部署模式: TCP服务器master,TCP客户端slave,TCP服务器slave,TCP客户端master。 本人QQ412961810，有问题可以帮忙解答
springboot+netty+mybatis+sqlserver
01-25
标题 "springboot+netty+mybatis+sqlserver" 涉及到的是一个使用Spring Boot、Netty、MyBatis以及SQL Server构建的项目。这个项目可能是一个高性能、轻量级的网络通信应用，利用Spring Boot的便利性和Netty的高效...
java springboot tcp通讯 demo
03-21
java springboot tcp通讯 demo ;
springbootnettyclient:netty长连接客户端
05-18
概述 在实际的生产项目中，尤其是soa架构的系统。会用到网络传输的接口。首先会想到的springboot+netty的方式。springboot不用多说，火的不行，netty在很多实际项目中都有运用，非常好的一个框架，开发非常方便。 本文主要内容是： springboot与netty的整合 netty简单的长连接 pom文件 <parent> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-parent</artifactId> <version>1.5.1.RELEASE</version> <relativePath> </parent> <dependencies> <!--
spring-boot-tcp-client.zip
06-28
SpringBoot TCP Client 已测试
springboot下 创建TCP客户端，并发送消息
_Mr丶s
07-11 501
【代码】springboot下 创建TCO客户端，并发送消息。
SpringBoot快速搭建TCP服务端和客户端
IRpickstars的博客
11-23 2809
由于工作需要,研究了SpringBoot搭建TCP通信的过程,对于工程需要的小伙伴,只是想快速搭建一个可用的服务.其他的教程看了许多,感觉讲得太复杂,很容易弄乱,这里我只讲效率,展示快速搭建过程。
SpringBoot+Netty实现TCP客户端实现接收数据按照16进制解析并存储到Mysql以及Netty断线重连检测与自动重连
BADAO_LIUMANG_QIZHI的博客
03-30 9241
在SpringBoot项目中需要对接三方系统，对接协议是TCP，需实现一个TCP客户端接收服务端发送的数据并按照16进制进行解析数据，然后对数据进行过滤，将指定类型的数据通过mybatis存储进mysql数据库中。并且当tcp服务端断连时，tcp客户端能定时检测并发起重连。
SpringBoot整合Netty实现TCP通信
weixin_51717204的博客
09-17 7962
SpringBoot整合Netty，实现TCP通信 组成部分为：SpringBoot + Mybatis + netty； 开发环境为Java8 ，IDEA，Maven； 开始教程 使用 idea 创建 SpringBoot 项目； 创建完成后在 pom.xml 文件 dependencies 写入以下代码： <!--netty--> <dependency> <groupId>io.netty</gro
springboot+netty+mqtt客户端实现
zwjzone的博客
06-21 2021
springboot+netty+mqtt客户端实现
基于springboot+netty封装websocket客户端生成代码发给我
05-26
很抱歉，作为一名AI语言模型，我无法生成代码。不过我可以给你提供一些参考资料，希望能对你有所帮助。 首先，你需要在Spring Boot项目中引入Netty和WebSocket的依赖，例如： ```xml <dependency> <groupId>io.netty</groupId> <artifactId>netty-all</artifactId> <version>4.1.22.Final</version> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-websocket</artifactId> </dependency> ``` 然后，你可以编写一个WebSocket客户端类，例如： ```java @Component public class WebSocketClient { private final WebSocketClientHandshaker handshaker; private WebSocketChannel channel; public WebSocketClient(@Value("${websocket.url}") String url) throws Exception { URI uri = new URI(url); handshaker = WebSocketClientHandshakerFactory.newHandshaker(uri, WebSocketVersion.V13, null, true, new DefaultHttpHeaders()); } public void connect() throws Exception { Bootstrap bootstrap = new Bootstrap(); EventLoopGroup group = new NioEventLoopGroup(); try { bootstrap.group(group) .channel(NioSocketChannel.class) .handler(new WebSocketClientInitializer(handshaker)); ChannelFuture future = bootstrap.connect(handshaker.uri().getHost(), handshaker.uri().getPort()).sync(); channel = ((WebSocketClientHandler) future.channel().pipeline().last()).getChannel(); handshaker.handshake(channel).sync(); } catch (InterruptedException e) { e.printStackTrace(); } finally { group.shutdownGracefully(); } } public void send(String message) { WebSocketFrame frame = new TextWebSocketFrame(message); channel.writeAndFlush(frame); } public void close() { channel.close(); } } ``` 其中，WebSocketClientInitializer是用于初始化Netty的WebSocket客户端的，例如： ```java public class WebSocketClientInitializer extends ChannelInitializer<SocketChannel> { private final WebSocketClientHandshaker handshaker; public WebSocketClientInitializer(WebSocketClientHandshaker handshaker) { this.handshaker = handshaker; } @Override protected void initChannel(SocketChannel channel) throws Exception { channel.pipeline() .addLast(new HttpClientCodec()) .addLast(new HttpObjectAggregator(8192)) .addLast(new WebSocketClientHandler(handshaker)); } } ``` 最后，你可以在Spring Boot的控制器中使用WebSocketClient来与WebSocket服务器进行通信，例如： ```java @RestController public class WebSocketController { @Autowired private WebSocketClient webSocketClient; @PostMapping("/send") public void send(@RequestBody String message) { webSocketClient.send(message); } } ``` 这样你就可以使用Spring Boot和Netty来实现WebSocket客户端了。希望对你有所帮助。
评论 8
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值