程序员经验分享-hwhale

Springboot+Netty搭建TCP服务端

2023-05-16

Netty是业界最流行的nio框架之一，它具有功能强大、性能优异、可定制性和可扩展性的优点

Netty的优点：

1.API使用简单，开发入门门槛低。

2.功能十分强大，预置多种编码解码功能，支持多种主流协议。

3.可定制、可扩展能力强，可以通过其提供的ChannelHandler进行灵活的扩展。

4.性能优异，特别在综合性能上的优异性。

5.成熟，稳定，适用范围广。

6.可用于智能GSM/GPRS模块的通讯服务端开发，使用它进行MQTT协议的开发。

Netty结合Springboot快速开发框架搭建服务端程序：

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.server</groupId>
	<artifactId>boot-example-base-tcp-server-2.0.5</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<name>boot-example-base-tcp-server-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.server;

import boot.example.tcp.server.netty.BootNettyServer;
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;

/**
 * 	蚂蚁舞
 */
@SpringBootApplication
@EnableAsync
public class BootNettyServerApplication implements CommandLineRunner{
    public static void main( String[] args ) {
		SpringApplication app = new SpringApplication(BootNettyServerApplication.class);
		app.run(args);
        System.out.println( "Hello World!" );
    }

    @Async
	@Override
	public void run(String... args) throws Exception {
		/**
		 * 使用异步注解方式启动netty服务端服务
		 */
		new BootNettyServer().bind(6655);
		
	}
}

Netty的server类

package boot.example.tcp.server.netty;


import io.netty.bootstrap.ServerBootstrap;
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.NioServerSocketChannel;

/**
 *  蚂蚁舞
 */
public class BootNettyServer {
	
	public void bind(int port) throws Exception {
		
        /**
         * 	配置服务端的NIO线程组
         * 	NioEventLoopGroup 是用来处理I/O操作的Reactor线程组
         * 	bossGroup：用来接收进来的连接，workerGroup：用来处理已经被接收的连接,进行socketChannel的网络读写，
         * 	bossGroup接收到连接后就会把连接信息注册到workerGroup
         * 	workerGroup的EventLoopGroup默认的线程数是CPU核数的二倍
         */
        EventLoopGroup bossGroup = new NioEventLoopGroup(1);
        EventLoopGroup workerGroup = new NioEventLoopGroup();
        
        try {
        	/**
        	 * ServerBootstrap 是一个启动NIO服务的辅助启动类
        	 */
            ServerBootstrap serverBootstrap = new ServerBootstrap();
            /**
             * 	设置group，将bossGroup， workerGroup线程组传递到ServerBootstrap
             */
            serverBootstrap = serverBootstrap.group(bossGroup, workerGroup);
            /**
             * ServerSocketChannel是以NIO的selector为基础进行实现的，用来接收新的连接，这里告诉Channel通过NioServerSocketChannel获取新的连接
             */
            serverBootstrap = serverBootstrap.channel(NioServerSocketChannel.class);

            //  option是设置 bossGroup，childOption是设置workerGroup

            /**
             * 服务端接受连接的队列长度，如果队列已满，客户端连接将被拒绝(队列被接收后，拒绝的客户端下次连接上来只要队列有空余就能连上)
             */
            serverBootstrap = serverBootstrap.option(ChannelOption.SO_BACKLOG, 128);
            /**
             * 立即发送数据，默认值为Ture（Netty默认为True而操作系统默认为False）。
             * 该值设置Nagle算法的启用，改算法将小的碎片数据连接成更大的报文来最小化所发送的报文的数量，如果需要发送一些较小的报文，则需要禁用该算法。
             * Netty默认禁用该算法，从而最小化报文传输延时。
             */
            serverBootstrap = serverBootstrap.childOption(ChannelOption.TCP_NODELAY, true);
            /**
             * 连接保活，默认值为False。启用该功能时，TCP会主动探测空闲连接的有效性。
             * 可以将此功能视为TCP的心跳机制，默认的心跳间隔是7200s即2小时, Netty默认关闭该功能。
             */
            serverBootstrap = serverBootstrap.childOption(ChannelOption.SO_KEEPALIVE, true);

            /**
             * 设置 I/O处理类,主要用于网络I/O事件，记录日志，编码、解码消息
             */
            serverBootstrap = serverBootstrap.childHandler(new BootNettyChannelInitializer<SocketChannel>());

            /**
             * 绑定端口，同步等待成功
             */
            ChannelFuture f = serverBootstrap.bind(port).sync();
            if(f.isSuccess()){
                System.out.println("netty server start success!");
                /**
                 * 等待服务器监听端口关闭
                 */
                f.channel().closeFuture().sync();
            }
        } catch (InterruptedException e) {
            System.out.println(e.toString());
        } finally {
        	/**
        	 * 退出，释放线程池资源
        	 */
            bossGroup.shutdownGracefully().sync();
            workerGroup.shutdownGracefully().sync();
        }
        
	}
}

通道初始化

package boot.example.tcp.server.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.handler.timeout.IdleStateHandler;
import io.netty.util.CharsetUtil;

import java.util.concurrent.TimeUnit;

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

    public static long READ_TIME_OUT = 60;

    public static long WRITE_TIME_OUT = 60;

    public static long ALL_TIME_OUT = 60;

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

        ch.pipeline().addLast(new IdleStateHandler(READ_TIME_OUT, WRITE_TIME_OUT, ALL_TIME_OUT, TimeUnit.SECONDS));

        // 带编码
        ch.pipeline().addLast("encoder", new StringEncoder(CharsetUtil.UTF_8));
        ch.pipeline().addLast("decoder", new StringDecoder(CharsetUtil.UTF_8));

//		// ChannelOutboundHandler，依照逆序执行
//        ch.pipeline().addLast("encoder", new StringEncoder());
//
//        // 属于ChannelInboundHandler，依照顺序执行
//        ch.pipeline().addLast("decoder", new StringDecoder());

        //自定义ChannelInboundHandlerAdapter
        ch.pipeline().addLast(new BootNettyChannelInboundHandlerAdapter());
		
	}

}

I/O数据读写处理类

package boot.example.tcp.server.netty;

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.charset.StandardCharsets;

import io.netty.buffer.Unpooled;
import io.netty.channel.ChannelHandler;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;
import io.netty.util.CharsetUtil;

/**
 * I/O数据读写处理类
 * 蚂蚁舞
 */
@ChannelHandler.Sharable
public class BootNettyChannelInboundHandlerAdapter extends ChannelInboundHandlerAdapter{

    /**
     *  注册时执行
     */
    @Override
    public void channelRegistered(ChannelHandlerContext ctx) throws Exception {
        super.channelRegistered(ctx);
        System.out.println("--channelRegistered--"+ctx.channel().id().toString());
    }

    /**
     *  离线时执行
     */
    @Override
    public void channelUnregistered(ChannelHandlerContext ctx) throws Exception {
        super.channelUnregistered(ctx);
        System.out.println("--channelUnregistered--"+ctx.channel().id().toString());
    }

    /**
     * 从客户端收到新的数据时，这个方法会在收到消息时被调用
     */
    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) {
        try {
            if(msg == null){return;}
            String data = (String) msg;
            data = data.replaceAll("\r|\n", "");
            String channelId = ctx.channel().id().toString();
            System.out.println("channelId="+channelId + "data="+data);

            // 这里我将通道id作为code来使用，实际是需要msg里来摘取的客户端数据里的唯一值的
            // 如果没有则创建 如果有，更新data值
            BootNettyChannel b = BootNettyChannelCache.get("server:"+channelId);
            if(b == null){
                BootNettyChannel bootNettyChannel = new BootNettyChannel();
                bootNettyChannel.setChannel(ctx.channel());
                bootNettyChannel.setCode("server:"+channelId);
                bootNettyChannel.setReport_last_data(data);
                BootNettyChannelCache.save("server:"+channelId, bootNettyChannel);
            } else {
                b.setReport_last_data(data);
            }
            ctx.writeAndFlush(Unpooled.buffer().writeBytes(("server:"+channelId).getBytes()));
            // netty的编码已经指定，因此可以不需要再次确认编码
            // ctx.writeAndFlush(Unpooled.buffer().writeBytes(channelId.getBytes(CharsetUtil.UTF_8)));
        } catch (Exception e) {
            System.out.println("channelRead--"+e.toString());
        }
    }

    /**
     * 从客户端收到新的数据、读取完成时调用
     */
    @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();
        BootNettyChannel bootNettyChannel = BootNettyChannelCache.get("server:"+ctx.channel().id().toString());
        if(bootNettyChannel != null){
            BootNettyChannelCache.remove("server:"+ctx.channel().id().toString());
        }
        ctx.close();//抛出异常，断开与客户端的连接
    }

    /**
     * 客户端与服务端第一次建立连接时 执行
     */
    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception, IOException {
        super.channelActive(ctx);
        ctx.channel().read();
        InetSocketAddress inSocket = (InetSocketAddress) ctx.channel().remoteAddress();
        String clientIp = inSocket.getAddress().getHostAddress();
        //此处不能使用ctx.close()，否则客户端始终无法与服务端建立连接
        System.out.println("channelActive:"+clientIp+ctx.name());
    }

    /**
     * 客户端与服务端 断连时 执行
     */
    @Override
    public void channelInactive(ChannelHandlerContext ctx) throws Exception, IOException {
        super.channelInactive(ctx);
        InetSocketAddress inSocket = (InetSocketAddress) ctx.channel().remoteAddress();
        String clientIp = inSocket.getAddress().getHostAddress();
        System.out.println("channelInactive:"+clientIp);
        BootNettyChannel bootNettyChannel = BootNettyChannelCache.get("server:"+ctx.channel().id().toString());
        if(bootNettyChannel != null){
            BootNettyChannelCache.remove("server:"+ctx.channel().id().toString());
        }
        ctx.close(); //断开连接时，必须关闭，否则造成资源浪费，并发量很大情况下可能造成宕机
    }

    /**
     * 服务端当read超时, 会调用这个方法
     */
    @Override
    public void userEventTriggered(ChannelHandlerContext ctx, Object evt) throws Exception, IOException {
        super.userEventTriggered(ctx, evt);
        InetSocketAddress inSocket = (InetSocketAddress) ctx.channel().remoteAddress();
        String clientIp = inSocket.getAddress().getHostAddress();

        ctx.close();//超时时断开连接
    	System.out.println("userEventTriggered:"+clientIp);
    }
    

}


BootNettyChannel  
package boot.example.tcp.server.netty;

import io.netty.channel.Channel;

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

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

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

	private transient volatile Channel channel;

	public String getCode() {
		return code;
	}

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

	public String getReport_last_data() {
		return report_last_data;
	}

	public void setReport_last_data(String report_last_data) {
		this.report_last_data = report_last_data;
	}

	public Channel getChannel() {
		return channel;
	}

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


}


BootNettyChannelCache  
package boot.example.tcp.server.netty;

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

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

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

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

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

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

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


}


BootNettyController  
package boot.example.tcp.server.controller;

import boot.example.tcp.server.netty.BootNettyChannel;
import boot.example.tcp.server.netty.BootNettyChannelCache;
import io.netty.buffer.Unpooled;
import io.netty.util.CharsetUtil;
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 BootNettyController {

	@GetMapping(value = {"", "/"})
	public String index() {
		return "netty springBoot tcp demo";
	}

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

	@PostMapping("/downDataToAllClient")
	public String downDataToAllClient(@RequestParam(name="content", required = true) String content) {
		for (Map.Entry<String, BootNettyChannel> entry : BootNettyChannelCache.channelMapCache.entrySet()) {
			BootNettyChannel bootNettyChannel = entry.getValue();
			if(bootNettyChannel != null && bootNettyChannel.getChannel().isOpen()){
				bootNettyChannel.getChannel().writeAndFlush(Unpooled.buffer().writeBytes(content.getBytes()));
				// netty的编码已经指定，因此可以不需要再次确认编码
				// bootNettyChannel.getChannel().writeAndFlush(Unpooled.buffer().writeBytes(content.getBytes(CharsetUtil.UTF_8)));
			}
		}
		return "ok";
	}

	@PostMapping("/downDataToClient")
	public String downDataToClient(@RequestParam(name="code", required = true) String code, @RequestParam(name="content", required = true) String content) {
		BootNettyChannel bootNettyChannel = BootNettyChannelCache.get(code);
		if(bootNettyChannel != null && bootNettyChannel.getChannel().isOpen()){
			bootNettyChannel.getChannel().writeAndFlush(Unpooled.buffer().writeBytes(content.getBytes()));
			// netty的编码已经指定，因此可以不需要再次确认编码
			// bootNettyChannel.getChannel().writeAndFlush(Unpooled.buffer().writeBytes(content.getBytes(CharsetUtil.UTF_8)));
			return "success";
		}
		return "fail";
	}


}


SwaggerConfig  
package boot.example.tcp.server;

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:6654/doc.html  地址和端口根据实际项目查看
     */


}

目录结构

├─boot-example-base-tcp-server-2.0.5
│  │  pom.xml
│  │  
│  ├─src
│  │  ├─main
│  │  │  ├─java
│  │  │  │  └─boot
│  │  │  │      └─example
│  │  │  │          └─tcp
│  │  │  │              └─server
│  │  │  │                  │  BootNettyServerApplication.java
│  │  │  │                  │  SwaggerConfig.java
│  │  │  │                  │  
│  │  │  │                  ├─controller
│  │  │  │                  │      BootNettyController.java
│  │  │  │                  │      
│  │  │  │                  └─netty
│  │  │  │                          BootNettyChannel.java
│  │  │  │                          BootNettyChannelCache.java
│  │  │  │                          BootNettyChannelInboundHandlerAdapter.java
│  │  │  │                          BootNettyChannelInitializer.java
│  │  │  │                          BootNettyServer.java
│  │  │  │                          
│  │  │  └─resources
│  │  │          application.properties
│  │  │          
│  │  └─test
│  │      └─java
│  │          └─boot
│  │              └─example
│  │                  └─tcp
│  │                      └─server
│  │                              BootNettyServerApplicationTest.java
│  │

很简单的几个类加swagger，启动Springboot应用的同时也就启动了Netty

Netty Server端口：6655

SpringBoot Web端口: 6654

访问 

http://localhost:6654/doc.html

使用常见的tcp客户端工具发送字母或数字(客户端工具发送中文可能出现乱码的，虽然程序已经处理了中文乱码，但依旧容易出现，处理办法是用netty写一个客户端来测试)

可以看到客户端发送消息，服务端能收到消息，并且在服务端做了保活，服务端也可以根据客户端的信息向客户端发送消息

Springboot整合Netty的服务端demo开发测试完成。

注意：如果乱码的话需要统一编码，最简单的方式

        // 带编码
        ch.pipeline().addLast("encoder", new StringEncoder(CharsetUtil.UTF_8));
        ch.pipeline().addLast("decoder", new StringDecoder(CharsetUtil.UTF_8));

本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容，请联系:hwhale#tublm.com(使用前将#替换为@)

springboot

Netty

TCP

Springboot+Netty搭建TCP服务端 的相关文章

随机推荐

  • 腾讯云轻量服务器的Ubuntu如何使用root（根）用户登陆ssh/Shell/terminal/终端/WindTerm/FinalShell

    Ubuntu 系统的默认用户名是 ubuntu xff0c 并在安装过程中默认不设置 root 帐户和密码 您如有需要 xff0c 可在设置中开启允许 root 用户登录 具体操作步骤如下 xff1a 使用 ubuntu 帐户登录轻量应用服

  • Ubuntu安装sshd服务

    ubuntu安装ssh服务 一 安装shhd SSH分客户端openssh client和openssh server 如果你只是想登陆别的机器的SSH只需要安装openssh client xff08 ubuntu有默认安装 xff0c

  • Linux环境(六)－－资源与限制

    资源与限制 运行在Linux系统上的程序是有资源限制的 这些也许是硬件引起的限制 例如内存 xff0c 也许由系统策略引起的限制 例如 xff0c 允许 的CPU时间 xff0c 或者是实现的限制 例如 xff0c 整数的尺寸或是文件名允许

  • 遇到了C/C++控制台程序无法输入中文的情况

    其实C C 43 43 控制台程序无法cin中文的情况并不是你使用了string xff0c string是能输入并保存中文的 xff1b 经过一番探究 xff0c 我发现主要的问题是文件的编码和控制台所处的代码页 xff08 控制台的编码

  • Jpg2Dcm中文乱码问题

    Jpg2Dcm中文乱码问题 最近老板提出了一个新的功能要求 xff0c 希望可以把图片转成dcm 在实现功能的问题中遇见了很多问题和掉过许多坑 于是在此记录下来 问题 xff1a 第一次在进行Jpg2Dcm时 xff0c 可以进行图片转dc

  • 神经网络的数学表达式,神经网络的数学理论

    什么是神经网络 神经网络可以指向两种 xff0c 一个是生物神经网络 xff0c 一个是人工神经网络 生物神经网络 xff1a 一般指生物的大脑神经元 xff0c 细胞 xff0c 触点等组成的网络 xff0c 用于产生生物的意识 xff0

  • python装饰器详解（四）---把参数传递给装饰器

    因为装饰器必须接收一个函数当做参数 所以 不可以直接把被装饰函数的参数传递给装饰器 装饰器就是一个普通的函数 xff0c 回顾 def my decorator func print 34 I am an ordinary function

  • Motion Deblurring图像运动去模糊代码

    http www di ens fr whyte Efficient Deblurring for Shaken and Partially Saturated Images http www di ens fr willow resear

  • maven执行install时报错 The packaging for this project did not assign a file to the build artifact

    问题描述 maven中执行plugins下面的install install时会报如下错误 span class token class name Failed span span class token keyword to span s

  • realsense相机两种获取相机内外参的方式

    https www it610 com article 1296417297711308800 htm 命令 xff1a rs sensor control 这个命令是一个exe文件 xff0c 可以去 C Program Files x8

  • wget设置代理

    1 在bash shell中设定代理 basrhc export http proxy 61 34 166 111 53A 167 3128 34 export ftp proxy 61 34 166 111 53A 167 3128 34

  • chown,chgrp,chmod,u+s,g+s,o+t

    chown user file directory change owner 将后面的目标文件或者目录的所有者替换成 user chgrp group file directory change group 将目标文件或者目录的所有组替换成

  • Segment Routing笔记（一）

    SR 理论 一 MPLS TE缺点 RSVP TE大部分都是为了FRR的目的不支持ECMP所有流量都需要在隧道里诞生了 战术型 TE xff0c 只在需要的时候使用 术语 TI LFA 与拓扑无关的无环路备份 xff0c 能保证备份路径的最

  • Springboot+Netty搭建UDP服务端

    UDP是一个无连接协议 xff0c 应用范围很大 xff0c 对于一些低功耗的设备可以使用UDP方式向云端推送消息信息 xff0c 也可以在推送消息时收到从云端原路返回的消息 xff0c 使用Netty 43 SpringBoot方式可以快

  • Springboot+Netty搭建UDP客户端

    使用Netty 43 SpringBoot方式可以快速地开发一套基于UDP协议的服务端程序 xff0c 同样的也可以开发客户端 xff0c 一般使用UDP都是使用原生的方式 xff0c 发送消息后就不管不问 xff0c 也就是不需要确定消息

  • Springboot+Netty搭建MQTT协议的服务端(基础Demo)

    Netty是业界最流行的nio框架之一 xff0c 结合springboot可以满足快速开发 MQTT xff08 Message Queuing Telemetry Transport xff0c 消息队列遥测传输协议 xff09 xff

  • SpringBoot+Shiro+Jwt+Vue+elementUI实现前后端分离单体系统Demo

    记录一下使用SpringBoot集成Shiro框架和Jwt框架实现前后端分离Web项目的过程 xff0c 后端使用SpringBoot整合Shiro 43 Jwt auth0 xff0c 前端使用vue 43 elementUI框架 xff

  • Centos系统安装RabbitMQ消息中间件

    记录一下在centos7 x下面安装RabbitMQ消息中间件 RabbitMQ是一个开源而且遵循 AMQP协议实现的基于 Erlang语言编写 xff0c 因此安装RabbitMQ之前是需要部署安装Erlang环境的 先安装Erlang

  • SpringBoot+RXTXcomm实现Java串口通信 读取串口数据以及发送数据

    记录一下使用SpringBoot 43 RXTXcomm实现Java串口通信 xff0c 使用Java语言开发串口 xff0c 对串口进行读写操作 RXTXcomm jar这个包支持的系统较多 xff0c 但是更新太慢 xff0c 在win

  • Springboot+Netty搭建TCP服务端

    Netty是业界最流行的nio框架之一 xff0c 它具有功能强大 性能优异 可定制性和可扩展性的优点 Netty的优点 xff1a 1 API使用简单 xff0c 开发入门门槛低 2 功能十分强大 xff0c 预置多种编码解码功能 xff

热门标签