Go语言快速入门-项目案例-即时通信系统

最新推荐文章于 2023-10-07 00:00:34 发布
最新推荐文章于 2023-10-07 00:00:34 发布
阅读量1.3k 收藏 14
点赞数 2
分类专栏： Go 文章标签： go
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44706647/article/details/117468418
版权

后端人员快速入门go语言，上手项目。是一个通信系统，覆盖了go语言的基本语法以及go程的使用

一、构造基本Serve

构造基本的Serve，就是Socket编程，同时在处理操作时，开启go的协程处理

serve.go

package main

import (
	"fmt"
	"net"
)

type Server struct {
	Ip string
	Port int
}
//创建一个Server的接口
func NewServer(ip string, port int) *Server {
	server := &Server{
		Ip: ip,
		Port: port,
	}
	return server
}

func (s *Server)Handle(coon net.Conn)  {
	fmt.Println("连接成功")
}

func (s *Server) Start() {
	//创建连接
	listen, err := net.Listen("tcp", fmt.Sprintf("%s:%d", s.Ip, s.Port))
	if err != nil {
		fmt.Println("net.Listen is err")
		return
	}

	//关闭连接
	defer listen.Close()

	for {
		coon, err := listen.Accept()
		if err != nil {
			fmt.Println("listen is not accept ")
			continue
		}
		//业务操作
		go s.Handle(coon)

	}

}

main.go

package main

func main() {
   server := NewServer("127.0.0.1", 8888)
   server.Start()
}

二、上线通知

v2版本需要做的事情是当一个用户连接的时候，需要广播这个用户上线的消息

思路是在对每一个连接的用户首先封装一个类，同时这个类绑定一个Channel。同时在服务端需要维护一个OnlineMap对象以及Message的Channel，当用户上线的时候，添加进OnlineMap，同时广播消息。

广播消息在服务端需要做的事情就是将消息写入到Message这个Channel中，同时一直监听Message这个状态，如果发现有消息，就遍历OnlineMap对象，将消息写入到对应的用户的Channel中

user.go

package main

import (
	"net"
)

//创建一个User对象 封装客户端信息
type User struct {
	Name string
	Addr string
	C chan string
	Conn net.Conn
}

//创建一个User对象
func NewUser(conn net.Conn) *User{
	userAddr := conn.RemoteAddr().String()
	user := &User{
		Name: userAddr,
		Addr: userAddr,
		C: make(chan string),
		Conn: conn,
	}
	//当User被创建的时候就要进行监听消息
	go user.listenMessge()
	return user
}
//监听消息
func (u *User)listenMessge() {
	for {
		msg := <- u.C
		u.Conn.Write([]byte(msg + "\n"))
	}
}

server.go

package main

import (
	"fmt"
	"net"
	"sync"
)

type Server struct {
	Ip string
	Port int
	OnlineMap map[string]*User		//在线用户对象是一个map集合userName:user
	mapLock sync.RWMutex			//锁
	Message chan string				//广播channel
}
//创建一个Server的接口
func NewServer(ip string, port int) *Server {
	server := &Server{
		Ip: ip,
		Port: port,
		OnlineMap: make(map[string]*User),
		Message: make(chan string),
	}
	return server
}

func (s *Server)Handle(coon net.Conn)  {
	//fmt.Println("连接成功")
	user := NewUser(coon)
	s.mapLock.Lock()
	s.OnlineMap[user.Name] = user
	s.mapLock.Unlock()
	//广播消息
	s.BroadCast(user, "已上线")
	select {
	}
}

//广播消息
func (s *Server)BroadCast(user *User, msg string) {
	sendMsg := "[" + user.Addr + "]" + user.Name + msg
	s.Message <- sendMsg
}
//监听Message广播channel的goroutine 一旦有消息就发送给全部在线的User
func (s *Server) ListenMessage(){
	for {
		msg := <- s.Message
		s.mapLock.Lock()
		for _, cli := range s.OnlineMap{
			cli.C <- msg
		}
		s.mapLock.Unlock()
	}

}

func (s *Server) Start() {
	//创建连接
	listen, err := net.Listen("tcp", fmt.Sprintf("%s:%d", s.Ip, s.Port))
	if err != nil {
		fmt.Println("net.Listen is err")
		return
	}
	//一直开启监听Message
	go s.ListenMessage()

	//关闭连接
	defer listen.Close()

	for {
		coon, err := listen.Accept()
		if err != nil {
			fmt.Println("listen is not accept ")
			continue
		}
		//业务操作
		go s.Handle(coon)

	}
}

三、用户消息广播

思路：服务端需要接受客户端发送来的消息，收到消息之后，进行广播转发即可

//开启一个go协程 用于处理客户端的消息
	go func() {
		buff := make([]byte, 4096)
		for {
			n, err := coon.Read(buff)
			if n == 0 {
				s.BroadCast(user, "Be offLine")
				return
			}
			if err != nil && err != io.EOF {
				fmt.Println("Conn Read Err: ..", err)
				return
			}
			msg := string(buff)
			s.BroadCast(user, msg)
		}
	}()

四、业务层分离

上面代码在编写的过程中，将用户上线，用户下线以及消息处理都写在了serve.go的代码中，现在将其分离处理，将这些代码写在user.go文件中，只需要在user.go中新增一个server的变量，每次处理消息的时候都调用server端的代码

user.go

package main

import (
	"net"
)

//创建一个User对象 封装客户端信息
type User struct {
	Name string
	Addr string
	C chan string
	Conn net.Conn
	server *Server
}

//创建一个User对象
func NewUser(conn net.Conn, server *Server) *User{
	userAddr := conn.RemoteAddr().String()
	user := &User{
		Name: userAddr,
		Addr: userAddr,
		C: make(chan string),
		Conn: conn,
		server: server,
	}
	//当User被创建的时候就要进行监听消息
	go user.listenMessge()
	return user
}
//监听消息
func (u *User)listenMessge() {
	for {
		msg := <- u.C
		u.Conn.Write([]byte(msg + "\n"))
	}
}
//用户上线消息
func (u *User) Online(){
	u.server.mapLock.Lock()
	u.server.OnlineMap[u.Name] = u
	u.server.mapLock.Unlock()

	u.server.BroadCast(u, "已上线")
}

//用户下线
func (u *User) OffLine(){
	u.server.mapLock.Lock()
	delete(u.server.OnlineMap, u.Name)
	u.server.mapLock.Unlock()

	u.server.BroadCast(u, "已下线")
}

//处理消息
func (u *User) DoMessage(msg string){
	u.server.BroadCast(u, msg)
}

server.go

package main

import (
	"fmt"
	"io"
	"net"
	"sync"
)

type Server struct {
	Ip string
	Port int
	OnlineMap map[string]*User		//在线用户对象是一个map集合userName:user
	mapLock sync.RWMutex			//锁
	Message chan string				//广播channel
}
//创建一个Server的接口
func NewServer(ip string, port int) *Server {
	server := &Server{
		Ip: ip,
		Port: port,
		OnlineMap: make(map[string]*User),
		Message: make(chan string),
	}
	return server
}

//连接操作
func (s *Server)Handle(coon net.Conn)  {
	//fmt.Println("连接成功")
	user := NewUser(coon, s)
	//用户上线
	user.Online()


	//开启一个go协程 用于处理客户端的消息
	go func() {
		buff := make([]byte, 4096)
		for {
			n, err := coon.Read(buff)
			if n == 0 {
				//用户下线
				user.OffLine()
				return
			}
			if err != nil && err != io.EOF {
				fmt.Println("Conn Read Err: ..", err)
				return
			}
			msg := string(buff[:n-1])
			// s.BroadCast(user, msg)
			user.DoMessage(msg)
		}
	}()
}

//广播消息
func (s *Server)BroadCast(user *User, msg string) {
	sendMsg := "[" + user.Addr + "]" + user.Name + msg
	s.Message <- sendMsg
}

//监听Message广播channel的goroutine 一旦有消息就发送给全部在线的User
func (s *Server) ListenMessage(){
	for {
		msg := <- s.Message
		s.mapLock.Lock()
		for _, cli := range s.OnlineMap{
			cli.C <- msg
		}
		s.mapLock.Unlock()
	}

}

func (s *Server) Start() {
	//创建连接
	listen, err := net.Listen("tcp", fmt.Sprintf("%s:%d", s.Ip, s.Port))
	if err != nil {
		fmt.Println("net.Listen is err")
		return
	}
	//一直开启监听Message
	go s.ListenMessage()

	//关闭连接
	defer listen.Close()

	for {
		coon, err := listen.Accept()
		if err != nil {
			fmt.Println("listen is not accept ")
			continue
		}
		//业务操作
		go s.Handle(coon)

	}

}

五、在线用户查询

指定消息格式 who 当客户端发送who指令时，向该客户端发送当前在线的用户，只需要将OnlineMap查询出来即可

//处理消息
func (u *User) DoMessage(msg string){
	if msg == "who" {
		//查询当前在线用户
		u.server.mapLock.Lock()
		for _, user := range u.server.OnlineMap {
			onlineMsg := "[" + user.Addr + "]" + user.Name + ":" + "在线..\n"
			u.sendMsg(onlineMsg)
		}
		u.server.mapLock.Unlock()
	} else {
		u.server.BroadCast(u, msg)
	}
	
}

六、修改用户名

用户消息格式 “rename|用户名”，有了前面的基础就很好写出代码

//处理消息
func (u *User) DoMessage(msg string){
	if msg == "who" {
		//查询当前在线用户
		u.server.mapLock.Lock()
		for _, user := range u.server.OnlineMap {
			onlineMsg := "[" + user.Addr + "]" + user.Name + ":" + "在线..\n"
			u.sendMsg(onlineMsg)
		}
		u.server.mapLock.Unlock()
	}else if len(msg) > 7 && msg[:7] == "rename|" {
		newName := strings.Split(msg, "|")[1]
		_, ok := u.server.OnlineMap[newName]
		if ok {
			u.sendMsg("该用户名已被占用")
		}else {
			u.server.mapLock.Lock()
			delete(u.server.OnlineMap, u.Name)
			u.Name = newName
			u.server.OnlineMap[newName] = u
			u.server.mapLock.Unlock()
			u.sendMsg("已经成功修改" + u.Name + "\n")
		}

	}else {
		u.server.BroadCast(u, msg)
	}
	
}

image-20210601151455402

七、私聊模式

同样是在DoMessage方法中处理

func (u *User) DoMessage(msg string){
	if msg == "who" {
		//查询当前在线用户
		u.server.mapLock.Lock()
		for _, user := range u.server.OnlineMap {
			onlineMsg := "[" + user.Addr + "]" + user.Name + ":" + "在线..\n"
			u.sendMsg(onlineMsg)
		}
		u.server.mapLock.Unlock()
	}else if len(msg) > 7 && msg[:7] == "rename|" {
		newName := strings.Split(msg, "|")[1]
		_, ok := u.server.OnlineMap[newName]
		if ok {
			u.sendMsg("该用户名已被占用")
		}else {
			u.server.mapLock.Lock()
			delete(u.server.OnlineMap, u.Name)
			u.Name = newName
			u.server.OnlineMap[newName] = u
			u.server.mapLock.Unlock()
			u.sendMsg("已经成功修改" + u.Name + "\n")
		}
	//处理发送私聊消息
	} else if len(msg) > 4 && msg[:3] == "to|"{
		remoteName := strings.Split(msg, "|")[1]
		if remoteName == "" {
			u.sendMsg("消息格式不正确")
			return
		}
		remoteUser, ok := u.server.OnlineMap[remoteName]
		if !ok {
			u.sendMsg("当前用户名不存在")
			return
		}
		content := strings.Split(msg, "|")[2]
		if content == "" {
			u.sendMsg("内容不能为空")
			return
		}
		remoteUser.sendMsg(u.Name + "对你说：" + content)
	} else {
		u.server.BroadCast(u, msg)
	}
	
}

image-20210601155951716

八、超时强踢功能

//连接操作
func (s *Server)Handle(coon net.Conn)  {
	//fmt.Println("连接成功")
	user := NewUser(coon, s)
	//用户上线
	user.Online()
	
	isLive := make(chan bool)

	//开启一个go协程 用于处理客户端的消息
	go func() {
		buff := make([]byte, 4096)
		for {
			n, err := coon.Read(buff)
			if n == 0 {
				//用户下线
				user.OffLine()
				return
			}
			if err != nil && err != io.EOF {
				fmt.Println("Conn Read Err: ..", err)
				return
			}
			msg := string(buff[:n-1])
			// s.BroadCast(user, msg)
			user.DoMessage(msg)
			//一旦发送消息 表示该用户活跃
			isLive <- true
		}
	}()

	select {
	case <- isLive:
		//代表当前用户是活跃的 不进行操作 进入下一行代码
	//开启一个定时器 为10秒钟
	case <-time.After(time.Second * 10):
		//已经超时
		user.sendMsg("你被踢了")
		close(user.C)
		coon.Close()
		return 
	}
}

image-20210601161029953

九、客户端

v1 ：简单版的客户端连接功能

package main

import (
	"fmt"
	"net"
)

type Client struct {
	ServerIp string
	ServerPort int
	Name string
	conn net.Conn
}
//创建连接函数
func NewClient(ServerIp string, serverPort int) *Client{
	client := &Client{
		ServerIp: ServerIp,
		ServerPort: serverPort,
	}
	conn, err := net.Dial("tcp",fmt.Sprintf("%s:%d", ServerIp, serverPort))
	if(err != nil){
		fmt.Println("net.Dial is Err")
	}
	client.conn = conn
	return client
}



func main() {
	client := NewClient("127.0.0.1", 8890)
	if client == nil {
		fmt.Println(">>>>>>>>>>>> 连接服务器失败")
		return
	}
	fmt.Println(">>>>>>>>>>>> 连接服务器成功")
	select {
	}

}

image-20210602092649762

v2版本：使用命令行

var ServerIp string
var ServerPort int

//main函数之前执行init函数
func init()  {
	flag.StringVar(&ServerIp, "ip", "127.0.0.1","设置服务器的ip地址 默认为127.0.0.1")
	flag.IntVar(&ServerPort, "port", 8890, "设置服务器的端口，默认端口为8890")
}



func main() {
	//命令行解析
	flag.Parse()
	
	client := NewClient(ServerIp, ServerPort)
	if client == nil {
		fmt.Println(">>>>>>>>>>>> 连接服务器失败")
		return
	}
	fmt.Println(">>>>>>>>>>>> 连接服务器成功")
	select {
	}

}

image-20210602093246823

v3版本：菜单显示

//菜单
func (client *Client) Menu() bool {
	var flag int
	fmt.Println("1.公聊模式")
	fmt.Println("2.私聊模式")
	fmt.Println("3.更改用户名")
	fmt.Println("0.退出")
	
	fmt.Scanln(&flag)
	
	if flag >= 0 && flag <= 3 {
		client.flag = flag
		return true
	}else {
		fmt.Println("输入合法的指令")
		return false
	}
}

func (client *Client) Run() {
	for client.flag != 0 {
		for client.Menu() != true{}
		switch client.flag {
		case 1:
			fmt.Println("公聊模式")
			break
		case 2:
			fmt.Println("私聊模式")
			break
		case 3:
			fmt.Println("更改用户名")
			break
			
		}
	}
}

v4版本：修改用户名

需要使用一个修改名字的方法，然后开启一个go程用于接收消息

//修改用户名
func (client *Client) updateName() bool {
	fmt.Println(">>>> 请输入用户名")
	var name string
	fmt.Scanln(&name)
	sendMsg := "rename|" + name + "\n"
	_, err := client.conn.Write([]byte(sendMsg))
	if err != nil {
		fmt.Println("conn 写入失败")
		return false
	}
	return true
	
}

//接收serve端的消息的go程
func (client *Client) DealMessage() {
	io.Copy(os.Stdin, client.conn)
}

image-20210602100019702

v5版本：公聊模式

//公聊模式
func (client *Client) PublicChat() bool {
	
	fmt.Println("请输入聊天内容，exit退出")
	var chatMsg string
	fmt.Scanln(&chatMsg)
	for chatMsg != "exit" {
		if len(chatMsg) != 0 {
			sendMsg := chatMsg + "\n"
			_, err := client.conn.Write([]byte(sendMsg))
			if err != nil {
				fmt.Println("发送失败")
				return false
			}
			sendMsg = ""
			fmt.Println("请输入聊天内容，exit退出")
			fmt.Scanln(&chatMsg)
		}
	}
	return true
}

v6：私聊模式

//查询用户上线情况
func (client *Client) SelectUsers() {
	sendMsg := "who"
	_, err := client.conn.Write([]byte(sendMsg))
	if err != nil {
		fmt.Println("coon write err")
		return
	}
	return
}
//发送私聊消息
func (client *Client) PrivateChat() bool {
	var remoteName string
	var chatMsg string
	go client.SelectUsers()
	fmt.Println(">>>请输入聊天对象[用户名]，exit退出")
	fmt.Scanln(&remoteName)
	for remoteName != "exit" {
		fmt.Println("请输入聊天消息，exit退出")
		fmt.Scanln(&chatMsg)
		for chatMsg != "exit" {
			if len(chatMsg) != 0 {
				sendMsg := "to|" + remoteName + "|" + chatMsg + "\n"
				_, err := client.conn.Write([]byte(sendMsg))
				if err != nil {
					fmt.Println("coon write err")
					return false
				}
			}
			chatMsg = ""
			fmt.Println("请输入聊天消息，exit退出")
			fmt.Scanln(&chatMsg)
		}
		remoteName = ""
		fmt.Println(">>>请输入聊天对象[用户名]，exit退出")
		fmt.Scanln(&remoteName)
	}
	return true
	
}

项目地址：https://github.com/GuoPuWen/GoLangIMSystem

四五又十
关注
  • 2
    点赞
  • 踩
  • 14
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
GO语言基础与小项目实战——ycgg学GO
m0_61807884的博客
01-16 821
狗语言基础语法以及三个小项目，猜谜游戏，命令行英文翻译字典，socks5代理
Go语言之 快速入门篇（二）：Go 项目工程管理示例（基于 Go Modules）
weixin_59284282的博客
06-13 466
在上一篇教程中，学院君带着大家搭建起了本地开发环境，并且编写了第一个 Go 程序 —— 向世界问好。不过在实际开发过程中，直接调用编译器进行编译和链接（调用 或 命令）的场景很少，因为在项目工程中不会简单到只有一个源文件，往往有很多源文件并且源文件之间会有相互依赖的关系，如果这样一个文件一个文件逐步编译，那简直无法想象。Go 语言的设计者作为行业老将，自然不会忽略这一点。说到这里，我们来看看 Go 语言的主要设计者都是何方神圣：个顶个的都是大神级人物。早期 Go 语言使用 作为临时方案，到了 Go 1
Golang网络编程：即时通讯系统Instance Messaging System
YiGeiGiaoGiao的博客
10-07 530
由于之前开启了一个协程，定期的检查server的channel有没有东西，有东西就发给map表中每个在线的用户，当然，由于。另外，读取到的字节数n与缓冲区的长度不一定相等，这是因为网络中的数据可能会分块传输，需要多次读取才能获取完整的数据。时（通过指定缓冲区大小来初始化通道），当通道中已有缓冲的数据时，即使没有接收操作，发送操作也可以继续进行。函数签名中，net.Conn表示net.Conn类型的对象，b是用于存储读取数据的缓冲区（一个字节数组），函数的返回值为读取到的字节数和可能出现的错误。
[go学习笔记.第十六章.TCP编程] 2.项目-海量用户即时通讯系统
zhoupenghui168的博客
11-21 896
[go学习笔记.第十六章.TCP编程] 2.项目-海量用户即时通讯系统
【Go语言】项目实战：客户信息管理系统（需求分析、项目设计、功能实现）
Zhou_LC的博客
07-04 1395
客户信息管理系统实现 主菜单界面添加客户界面修改客户界面 …删除客户界面客户列表界面在 model 层 customer.go 中 在 service 层 customerService.go 中 在 view 层 customerView.go 中 初步测试运行 在 service 层 customerService.go 中 在 view 层 customerView.go 中 在 service 层 customerService.go 中 在 view 层 customerView.go 中 在
golang快速入门[2.2]-go语言开发环境配置-macOS
01-20
golang快速入门[2.2]-go语言开发环境配置-macOS macos安装Go语言开发包 配置go语言的开发环境的第一步是要在go官网下载页面下载开发包 macOS需要下载pkg后缀文件 macOS和iOS操作系统Apple软件包使用.pkg扩展名,在...
golang快速入门[2.3]-go语言开发环境配置-linux
01-08
golang快速入门[2.3]-go语言开发环境配置-linux linux安装Go语言开发包 默认读者会使用linux的基本操作 配置go语言的开发环境的第一步是要在go官网下载页面下载开发包 linux需要下载tar.gz压缩文件   这里我们...
golang快速入门[2.1]-go语言开发环境配置-windows
01-07
golang快速入门[2.1]-go语言开发环境配置-windows 接下来，我们将讲解在windows、linux、macos三大平台上配置go语言的开发环境。 windows安装Go语言开发包 配置go语言的开发环境的第一步是要在go官网下载页面下载...
gostudy:golang基础教程-go语言快速入门
05-07
golang基础教程-快速入门go语言 教程内容 golang语言介绍，安装部署，运行第一个程序及基础介绍，工具介绍，go module，基础语法，常用数据结构，函数介绍，指针，结构体，接口，错误处理，协程，通道，通道选择器及...
golang基础教程-go语言快速入门.zip
最新发布
04-01
golang基础教程-go语言快速入门
2019年GO语言（20小时快速入门） +项目实战
08-07
20小时入门GO语言 beego框架深入浅出 GO语言游戏开发 金融企业级区块链核心基础 区块链从入门到精通
GO语言项目结构示例
03-12
GO语言项目结构示例。。。。。。。。。。。。。。。。。。。。。
【Go语言入门指南】零基础入门 go 语言 | Golang 入门指南
面向生活编程
09-25 9865
这篇文章是我自己亲身经历这样去学go的，本人是从20年的10月份开始入坑go语言的，当时的资料真的少，现在关于go语言的资料已经很多了。我就在把我自己的学习路线稍微梳理一遍，我个人觉得，学完之后，像深信服，b站，得物什么的应该是没什么问题，但如果是字节，腾讯，阿里这种就除了一些硬性条件之外，自己再刷多点题，背多点八股了。
Go后台项目实战
热门推荐
cj_286的博客
05-28 2万+
本项目完全使用原生开发，没有使用任何WEB框架(如：gin，beego，Martini等)，和ORM(如：gorm,xorm,beego)三层架构三层架构(3-tier architecture) 通常意义上的三层架构就是将整个业务应用划分为：界面层（User Interface layer）、业务逻辑层（Business Logic Layer）、数据访问层（Data access layer）...
10大Go语言开源项目推荐
思月行云
09-14 1万+
http://studygolang.com/articles/2004 引用 2014年11月，Golang官方博客发布文章 ，以纪念Go语言发布5周年。文章称，Go语言在云计算时代找到了位置，预言“2015年将是Go语言急剧发展之年”。 2014年11月，Golang官方博客发布Go语言核心开发组成员Andrew Gerrand文章 《Half a decade with Go》，以
Go语言 零基础入门到精通项目实战
weixin_43611537的博客
04-29 948
|____开发工天具包 |____VSCodeSetup-1.12.2.exe |____Notepad++.7.5.6.Installer.x64.exe |____go1.8.windows-amd64.msi |____Git-2.13.0-64-bit.exe |____第02套-Go语言视频零基础入门到精通...
GO语言项目（一）——猜字游戏
刘桂林的博客
11-27 1538
用GO语言来写一个逻辑稍微复杂一些的猜字游戏，我们可以先来看下代码 package main import &quot;fmt&quot; import &quot;math/rand&quot; import &quot;time&quot; /* 猜字游戏 1.产生4位随机数 2.终端输入 3.提示 */ //控制输出 var DEBUG bool = false func main() { //随机产生的
golang 入门项目（网络爬虫）
在梦中享一刻静谧，等待梦中的你
11-07 897
写了一个基于golang的网络爬虫，功能比较简单，第一次用golang，mark一下，做个纪念 github地址
go语言实现 P-OTDR系统的光纤振动信号快速模式识别算法
02-06
P-OTDR（分布式光时间域反射仪）是一种用于测量光纤传输信号的仪器。P-OTDR系统可以通过测量光纤的振动信号来识别不同的传输模式。 在go语言中，可以使用统计分析方法来实现光纤振动信号的快速模式识别算法。可以使用窗函数对光纤振动信号进行分析，并使用相关系数、均值和标准差等指标来区分不同的传输模式。还可以使用机器学习算法，如决策树、支持向量机、神经网络等，来实现对光纤振动信号的快速模式识别。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值