（二） 用QWebSocket 实现服务端和客户端（详细代码直接使用）

目录

前言

一、服务器的代码：

1、服务器的思路

2、具体服务器的代码示例

二、客户端的代码：

1、客户端的思路（和服务器类似）

2、具体客户端的代码示例

前言

        要是想了解QWebSocket的详细知识，还得移步到上一篇文章：


WebSocket 详解，以及用QWebSocket 实现服务端和客户端（含代码例子）-CSDN博客WebSocket 详解，以及用QWebSocket 实现服务端和客户端（含代码例子）-CSDN博客

        本篇文章主要讲解如何利用QWebSocket 实现服务和客户之间的通讯

一、服务器的代码：

1、服务器的思路

（1）首先创建了一个服务器的基类，主要实现了服务类的基本接口：

1、创建服务器：new QWebSocketServer
2、监听：listen
m_pWebSocketServer->listen(QHostAddress::LocalHost, mPort);//端口号
3、有新的连接，收到这个信号：QWebSocketServer::newConnection
4、获得新的客户端：nextPendingConnection 
5、接收到信息时候，收到信号：QWebSocket::binaryMessageReceived 
6、断开连接，收到信号：QWebSocket::disconnected

注意：数据的接收和发送，有两种格式，二进制和文本的，具体按照实际需要的来选择；

（2）在服务器的基类上，封装一个具体使用的类，这个类，主要是添加了QThread，创建一个子线程来进行服务器的开启，监听和接收数据，不会影响主线程的事件。

2、具体服务器的代码示例

        接收和发送的数据，以二进制为例

（1）服务器基类：

服务器基类的头文件：

        1）开启一个端口号为“9000”的服务器

        2）监听的网路是：QHostAddress::Any

QHostAddress::Any表示服务端监听所有可用的网络接口。
它是一个特殊的IP地址，表示服务端可以接受来自任何IP地址的连接请求。
这通常用于在一个计算机上运行多个网络服务时，让服务端能够监听所有可用的网络接口，

以便接受来自不同网络接口的连接请求。

注意：也可以监听具体的IP地址：

例如：QHostAddress(strLocalHostIp)

#ifndef WEBSOCKETSERVERBASE_H
#define WEBSOCKETSERVERBASE_H

#include <QObject>
#include <QtWebSockets>

QT_FORWARD_DECLARE_CLASS(QWebSocketServer)
QT_FORWARD_DECLARE_CLASS(QWebSocket)
QT_FORWARD_DECLARE_CLASS(QString)

class WebsocketServerBase : public QObject
{
    Q_OBJECT
public:
    explicit WebsocketServerBase(QString serverName,  quint16 port, QObject *parent = 0);
    virtual ~WebsocketServerBase();

signals:
    //客户端发来的数据
    void sigProcessServerMessage(const QByteArray &data);

public slots:
    //发送数据给客户端
    void slotSendToAllClients(const QByteArray &data);

    //启动websocket服务器
    void slotStartServer();

private slots:
    //处理新接入的连接
    void slotNewConnection();

    //处理链接断开的事件
    void slotSocketDisconnected();

    //接收数据，并转发
    void slotProcessBinaryMessage(const QByteArray &message);

public:
    //检测是否存在客户端
    bool hadClients();

private:
    QWebSocketServer *m_pWebSocketServer = nullptr;
    QList<QWebSocket *> m_clients;

    unsigned short m_nPort = 9000;
    QString m_strServerName = "server";
};

#endif // WEBSOCKETSERVERBASE_H

服务器基类的源文件：

#include "websocketserverbase.h"

#include<QDebug>

static QString getIdentifier(QWebSocket *peer)
{
    return QStringLiteral("%1:%2").arg(peer->peerAddress().toString(),
                                       peer->origin());
}

WebsocketServerBase::WebsocketServerBase(QString serverName,  quint16 port, QObject *parent)
    : QObject(parent)
    ,m_nPort(port)
    ,m_strServerName(serverName)
{
}

WebsocketServerBase::~WebsocketServerBase()
{   
    if(m_pWebSocketServer)
    {
        m_pWebSocketServer->close();
        //m_pWebSocketServer->abort();
        m_pWebSocketServer->deleteLater();
    }
}

//接收到外部发来的信息，转发给客户端
void WebsocketServerBase::slotSendToAllClients(const QByteArray &data)
{
    qDebug() << __FUNCTION__;

    for (QWebSocket *pClient : qAsConst(m_clients)) {
        qDebug() << "data: " << data;
         pClient->sendBinaryMessage(data);
    }
}

bool WebsocketServerBase::hadClients()
{
    return m_clients.size()>0;
}

void WebsocketServerBase::slotStartServer()
{
    if(m_pWebSocketServer)
        return;

    m_pWebSocketServer = new QWebSocketServer(m_strServerName, QWebSocketServer::NonSecureMode, this);

    if (m_pWebSocketServer->listen(QHostAddress::Any, m_nPort))
    {
        connect(m_pWebSocketServer, &QWebSocketServer::newConnection, this, &WebsocketServerBase::slotNewConnection);
        qDebug() << "WebSocket is start, port:" << m_nPort;
    }
}

void WebsocketServerBase::slotNewConnection()
{
    auto pSocket = m_pWebSocketServer->nextPendingConnection();
    QTextStream(stdout) << getIdentifier(pSocket) << " connected!\n";

    qDebug() << "client connected!";

    pSocket->setParent(this);

	//二进制数据的接收
    connect(pSocket, &QWebSocket::binaryMessageReceived, this, &WebsocketServerBase::slotProcessBinaryMessage);
    connect(pSocket, &QWebSocket::disconnected, this, &WebsocketServerBase::slotSocketDisconnected);

    m_clients << pSocket;
}

void WebsocketServerBase::slotSocketDisconnected()
{
	QWebSocket *pClient = qobject_cast<QWebSocket *>(sender());
	QTextStream(stdout) << getIdentifier(pClient) << " disconnected!\n";
	if (pClient)
	{
		m_clients.removeAll(pClient);
		pClient->deleteLater();
	}
}

//接收客户端发来的数据，并转发出去
void WebsocketServerBase::slotProcessBinaryMessage(const QByteArray &data)
{
    qDebug() << __FUNCTION__ << " data:" << data;
    emit sigProcessServerMessage(data);

    //test
    //slotSendToAllClients(data);
}

（2）将服务器基类封装，改造下：（外面可以直接使用这个类进行通讯）

改造后服务器的头文件：

        此处本例是使用回调函数将结果抛给上一层调用者，在qt里，完全可以用信号槽代替的。

#ifndef READERWEBSOCKETSERVER_H
#define READERWEBSOCKETSERVER_H

#include <QObject>
#include "Singleton.h"


// 回调函数，将websocket的结果抛给上层
typedef void(*recvMsgToSerial)(const QByteArray &byteArray);

class WebsocketServerBase;
class ReaderWebsocketServer : public QObject, public Singleton<ReaderWebsocketServer>
{
    Q_OBJECT
    friend class Singleton<ReaderWebsocketServer>;

public:
    explicit ReaderWebsocketServer(QObject *parent = 0);
    virtual ~ReaderWebsocketServer();

public:
    // 设置回调函数
    void setCallBack(recvMsgToSerial pFunc, void* pUser = NULL);

    // 接收串口发来数据，转发给客户端
    bool sendData(const QByteArray &byteArray);

signals:
	//转发数据给客户端
    void sigSendToAllClients(const QByteArray &data);

private slots:
    //处理客户端发来的数据，转发给需要的地方
    void slotProcessServerMessage(const QByteArray &data);

private:
    WebsocketServerBase* m_pWsServer = nullptr;
    QThread* m_thdWsServer = nullptr;

    void* m_pUser;							// 返回回调的对象
    recvMsgToSerial m_pRecvMsgToSerial;		// 回调
};

#endif // READERWEBSOCKETSERVER_H

改造后服务器的源文件：

#include "readerwebsocketserver.h"

#include <QThread>
#include <cstring>
#include "websocketserverbase.h"

ReaderWebsocketServer::ReaderWebsocketServer(QObject *parent)
    : QObject(parent)
{
    m_thdWsServer = new QThread();
    m_pWsServer = new WebsocketServerBase("reader", 9000);
    m_pWsServer->moveToThread(m_thdWsServer);

    connect(m_pWsServer, &WebsocketServerBase::sigProcessServerMessage, this, &ReaderWebsocketServer::slotProcessServerMessage);
    connect(this, &ReaderWebsocketServer::sigSendToAllClients, m_pWsServer, &WebsocketServerBase::slotSendToAllClients);

    connect(m_thdWsServer, &QThread::started, m_pWsServer, &WebsocketServerBase::slotStartServer);
    connect(m_thdWsServer, &QThread::finished, m_pWsServer, &WebsocketServerBase::deleteLater);
    connect(m_thdWsServer, &QThread::finished, m_thdWsServer, &WebsocketServerBase::deleteLater);
    m_thdWsServer->start();
}

ReaderWebsocketServer::~ReaderWebsocketServer()
{
    if(m_thdWsServer)
    {
        m_thdWsServer->quit();
        m_thdWsServer->wait();
    }

    if(m_pWsServer)
    {
        m_pWsServer->deleteLater();
    }
}

void ReaderWebsocketServer::setCallBack(recvMsgToSerial pFunc, void *pUser)
{
    if (nullptr != pFunc)
        m_pRecvMsgToSerial = pFunc;

    if (nullptr != pUser)
        m_pUser = pUser;
}

//接收串口发来数据，转发给客户端
bool ReaderWebsocketServer::sendData(const QByteArray &byteArray)
{
    bool hadBnode = m_pWsServer->hadClients();
    if (hadBnode)
    {
        emit sigSendToAllClients(byteArray);
    }
}

//处理客户端发来的数据，转发给需要的地方
void ReaderWebsocketServer::slotProcessServerMessage(const QByteArray &byteArray)
{
    qDebug() << __FUNCTION__ ;
    m_pRecvMsgToSerial(byteArray);
}

二、客户端的代码：

1、客户端的思路（和服务器类似）

（1）首先创建了一个客户端的基类，主要实现了客户端的基本接口：

（2）在客户端基类上，封装一个具体使用的类：（外面可以直接使用这个类进行通讯）

        这个类，主要是添加了QThread 和QTimer，QThread 创建一个子线程来进行服务器的开启，监听和接收数据，不会影响主线程的事件；QTimer主要是发心跳包，实现断开重连机制；

2、具体客户端的代码示例

        接收和发送的数据，以二进制为例

（1）客户端基类：

客户端基类的头文件：

/*
 * @Description: websocket客户端，用于与中间件通信
 */

#pragma once
#include <QObject>
#include <QByteArray>

class QTimer;
class QWebSocket;
class WebSocketBase : public QObject
{
    Q_OBJECT
public:
    WebSocketBase(QObject *parent = nullptr);
    ~WebSocketBase();

    void setWebSocketUrl(QString strUrl="");
    bool getConnectStatus();
    int RecvFrom(QByteArray& byteArray);

signals:
    void sigClientBinaryMessageReceived(const QByteArray &byteArray); //借用websocket的信号函数

public slots:
    void slotCreateDataRecWS();//创建websocket连接
    void slotSendBinaryMessageMessage(const QByteArray &byteArray);
    void slotReconnect();           /*-<周期重连函数 */
    void slotActiveReconnect();

private slots:
    void slotOnConnected();                 /*-<socket建立成功后，触发该函数 */
    void slotOnBinaryMessageReceived(const QByteArray &byteArray);   /*-<收到Sev端的数据时，触发该函数 */
    void slotOnDisConnected();              /*-<socket连接断开后，触发该函数 */

private:
    QWebSocket *m_pDataRecvWS;     /*-<websocket类 */
    QTimer *m_pTimer;            /*-<周期重连Timer */
    QString m_strURL;              /*连接URL*/
    bool m_bConnectStatus;         /*-<websocket连接状态，连接成功：true；断开：false */
    QByteArray m_byteArray;
};

客户端基类的源文件：

#include "WebSocketBase.h"
#include <QWebSocket>
#include <QTimer>
#include <QByteArray>
#include <cstring>

WebSocketBase::WebSocketBase(QObject *parent) : QObject(parent)
  ,m_pDataRecvWS(nullptr)
  ,m_pTimer(nullptr)
  ,m_strURL("")
  ,m_bConnectStatus(false)
  ,m_byteArray("")
{

}

WebSocketBase::~WebSocketBase()
{
    m_pTimer->stop();
    m_pTimer->deleteLater();
    m_pDataRecvWS->abort();
    m_pDataRecvWS->deleteLater();
}

void WebSocketBase::setWebSocketUrl(QString strUrl)
{
    m_strURL = strUrl;
    if(m_strURL.isEmpty())
    {
        m_strURL = "127.0.0.1";
    }
}

bool WebSocketBase::getConnectStatus()
{
    return m_bConnectStatus;
}

int WebSocketBase::RecvFrom(QByteArray &byteArray)
{
    byteArray = m_byteArray;
    m_byteArray.clear();
    return byteArray.size();
}

void WebSocketBase::slotCreateDataRecWS()
{
    if(nullptr == m_pTimer)
    {
        m_pTimer = new QTimer();
    }

    qDebug() << "Server Address" << m_strURL;

    if(m_pDataRecvWS == nullptr)
    {
        m_pDataRecvWS = new QWebSocket();
        connect(m_pDataRecvWS, &QWebSocket::disconnected, this, &WebSocketBase::slotOnDisConnected);
        connect(m_pDataRecvWS, &QWebSocket::binaryMessageReceived, this, &WebSocketBase::slotOnBinaryMessageReceived);
        connect(m_pDataRecvWS, &QWebSocket::connected, this, &WebSocketBase::slotOnConnected);
        connect(m_pTimer, &QTimer::timeout, this, &WebSocketBase::slotReconnect);
        m_pDataRecvWS->open(QUrl(m_strURL));
    }
}

void WebSocketBase::slotSendBinaryMessageMessage(const QByteArray &message)
{
    if (m_pDataRecvWS)
        m_pDataRecvWS->sendBinaryMessage(message);
}

void WebSocketBase::slotActiveReconnect()
{
    qDebug("try to Active Reconnect!!!");
    if(m_pDataRecvWS != nullptr)
    {
        m_bConnectStatus = false;
        m_pDataRecvWS->abort();
        qDebug("Exec Active Reconnect!");
        m_pDataRecvWS->open(QUrl(m_strURL));
    }

    return;
}

void WebSocketBase::slotReconnect()
{
    qDebug() << "try to reconnect:" << m_strURL;

    m_pDataRecvWS->abort();
    m_pDataRecvWS->open(QUrl(m_strURL));
}

void WebSocketBase::slotOnConnected()
{
    qDebug("WebSocketBase websocket is already connect!");

    m_bConnectStatus = true;
    m_pTimer->stop();
    qDebug() << "Address:" << m_strURL;
}

void WebSocketBase::slotOnDisConnected()
{
    qDebug() << "Address is disconnected:" << m_strURL;

    m_bConnectStatus = false;
    m_pTimer->start(3000);/*-<当连接失败时，触发重连计时器，设置计数周期为3秒 */
}

void WebSocketBase::slotOnBinaryMessageReceived(const QByteArray& byteArray)
{
    m_byteArray = byteArray;
}

（2）将客户端基类封装，改造下：（外面可以直接使用这个类进行通讯）

改造后客户端头文件：

/*
 * @Description: websocket客户端，用于与中间件通信
 */
#pragma once

#include <QObject>
#include <QCoreApplication>

#include "Singleton.h"

class WebSocketBase;
class QTimer;

class WsReaderClient : public QObject, public Singleton<WsReaderClient>
{
    Q_OBJECT
    friend class Singleton<WsReaderClient>;

public:
    WsReaderClient(QObject *parent = nullptr);
    ~WsReaderClient();

public:
    void SendTo(const QByteArray &byteArray);
    int RecvFrom(QByteArray& byteArray);

    bool getConnectStatus();

signals:
    //转发数据给server
    void sigSendToServer(const QByteArray &byteArray);

public slots:
    //接收服务器数据
    void slotRecvServerData(const QByteArray &byteArray);

    //发送服务器心跳包
    void slotHeartBeatToServer();

private:
    void readConfig();

private:
    WebSocketBase* m_wsReaderClient;
    QThread* m_thdReaderClient;
    QTimer *m_pTimerReader;
    int m_nHeartBeatTimeOutReader;
    QString m_URL = "";
};

改造后客户端源文件：

#include "WsReaderClient.h"

#include <QWebSocket>
#include <QTimer>
#include <QThread>
#include <QByteArray>
#include <cstring>
#include <QSettings>

#include "WebSocketBase.h"

WsReaderClient::WsReaderClient(QObject *parent)
    : QObject(parent)
{
    readConfig();

    m_thdReaderClient = new QThread();
    m_wsReaderClient = new WebSocketBase();
    m_wsReaderClient->setWebSocketUrl(m_URL);

    m_wsReaderClient->moveToThread(m_thdReaderClient);
    connect(m_thdReaderClient, &QThread::started, m_wsReaderClient, &WebSocketBase::slotCreateDataRecWS);
    connect(this, &WsReaderClient::sigSendToServer, m_wsReaderClient, &WebSocketBase::slotSendBinaryMessageMessage);
    //connect(this, &WsReaderClient::sigReconnectServer, m_wsReaderClient, &WebSocketBase::slotActiveReconnect);

    connect(m_thdReaderClient, &QThread::finished, m_wsReaderClient, &WebSocketBase::deleteLater);
    connect(m_thdReaderClient, &QThread::finished, m_thdReaderClient, &QThread::deleteLater);
    m_thdReaderClient->start();

    m_pTimerReader = new QTimer(this);
    connect(m_pTimerReader, &QTimer::timeout, this, &WsReaderClient::slotHeartBeatToServer);
    //m_nHeartBeatTimeOutKeyBoard = 0;
    m_pTimerReader->start(10*1000);
}

WsReaderClient::~WsReaderClient()
{
    m_pTimerReader->stop();
    m_pTimerReader->deleteLater();

    if(m_wsReaderClient)
    {
       delete m_wsReaderClient;
        m_wsReaderClient = nullptr;
    }

    if(m_pTimerReader)
    {
        delete m_pTimerReader;
        m_pTimerReader = nullptr;
    }
}

void WsReaderClient::slotHeartBeatToServer()
{
    //todo
}

void WsReaderClient::readConfig()
{
    // "/mnt/hgfs/SharedFiles/shanxi/Reader/linux_readerTest/bin/libReaderApi.so";
    QString appPath = QCoreApplication::applicationDirPath();
    qDebug() << "appPath=" << appPath;

    QString path = appPath + "/ReaderConfig.ini";
    QSettings settings(path, QSettings::IniFormat);
    m_URL = settings.value("Communication/ipAddr").toString();
    qDebug() << "m_URL=" << m_URL;
}

void WsReaderClient::SendTo(const QByteArray &data)
{
    emit sigSendToServer(data);
}

int WsReaderClient::RecvFrom(QByteArray &byteArray)
{
    return m_wsReaderClient->RecvFrom(byteArray);
}

bool WsReaderClient::getConnectStatus()
{
    return m_wsReaderClient->getConnectStatus();
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mfbz.cn/a/139678.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

linux线程

linux线程

文章目录 前言一、线程1、线程概念2、线程使用2.1 pthread_create2.2 线程共享数据和私有数据2.3 为什么线程切换的成本更低&#xff1f; 3、线程性质3.1 线程的优点3.2 线程的缺点3.3 线程异常3.4 线程用途 4、vfork接口 二、线程控制1、线程创建2、线程等待3、线程退出4、线程…
阅读更多...
行业追踪，2023-11-13

行业追踪，2023-11-13

自动复盘 2023-11-13 凡所有相&#xff0c;皆是虚妄。若见诸相非相&#xff0c;即见如来。 k 线图是最好的老师&#xff0c;每天持续发布板块的rps排名&#xff0c;追踪板块&#xff0c;板块来开仓&#xff0c;板块去清仓&#xff0c;丢弃自以为是的想法&#xff0c;板块去留让…
阅读更多...
集成Line、Facebook、Twitter、Google、微信、QQ、微博、支付宝的三方登录sdk

集成Line、Facebook、Twitter、Google、微信、QQ、微博、支付宝的三方登录sdk

下载地址&#xff1a; https://githubfast.com/anerg2046/sns_auth 安装方式建议使用composer进行安装 如果linux执行composer不方便的话&#xff0c;可以在本地新建个文件夹&#xff0c;然后执行上面的composer命令&#xff0c;把代码sdk和composer文件一起上传到项目适当位…
阅读更多...
【STM32】定时器+基本定时器

【STM32】定时器+基本定时器

一、定时器的基本概述 1.软件定时器原理 原来我们使用51单片机的时候&#xff0c;是通过一个__nop()__来进行延时 我们通过软件的方式来进行延时功能是不准确的&#xff0c;受到很多不确定因素。 2.定时器原理&#xff1a;计数之间的比值 因为使用软件延时受到影响&#xff0c…
阅读更多...
Scala---介绍及安装使用

Scala---介绍及安装使用

一、Scala介绍 1. 为什么学习Scala语言 Scala是基于JVM的语言&#xff0c;与java语言类似&#xff0c;Java语言是基于JVM的面向对象的语言。Scala也是基于JVM&#xff0c;同时支持面向对象和面向函数的编程语言。这里学习Scala语言的原因是后期我们会学习一个优秀的计算框架S…
阅读更多...
企业如何管理员工电脑和规范电脑的使用

企业如何管理员工电脑和规范电脑的使用

企业如何管理员工电脑和规范电脑的使用 在现代信息时代&#xff0c;数据安全问题已经成为各个领域都面临的挑战。随着大数据的快速发展和互联网的普及&#xff0c;数据泄露的风险也逐渐增加。而作为企业或个人用户&#xff0c;如何保护自己的数据&#xff0c;避免泄露给不法分…
阅读更多...
ios 对话框UIAlertController放 tableview

ios 对话框UIAlertController放 tableview

//强弱引用 #define kWeakSelf(type)__weak typeof(type)weak##type type; -(void) showUIAlertTable {kWeakSelf(self)UIAlertController *alert [UIAlertController alertControllerWithTitle:NSLocalizedString("select_stu", nil) message:nil prefer…
阅读更多...
构建Docker基础镜像（ubuntu20.04+python3.9.10+pytorch-gpu-cuda11.8）

构建Docker基础镜像（ubuntu20.04+python3.9.10+pytorch-gpu-cuda11.8）

文章目录 一、前置条件1.创建 ubuntu 镜像源文件【sources.list】2.下载 python 安装包【Python-3.9.10.tgz】 二、构建方法1.构建目录2.创建DockerFile3.打包镜像 一、前置条件 配置一下 ubuntu 的镜像源下载 python 安装包 1.创建 ubuntu 镜像源文件【sources.list】 内容…
阅读更多...
麒麟信安登录央视，深度展现为中国信息安全铸“魂”之路

麒麟信安登录央视，深度展现为中国信息安全铸“魂”之路

麒麟信安登录央视&#xff0c;深度展现为中国信息安全铸“魂”之路 近日&#xff0c;麒麟信安登录央视频道&#xff0c;《麒麟信安——为中国信息安全铸“魂”》在CCTV-4中文国际频道、CCTV-7国防军事频道、CCTV-10 科教频道、CCTV-12社会与法频道、CCTV-17农业农村频道&#x…
阅读更多...
动态调整学习率Lr

动态调整学习率Lr

动态调整学习率Lr 0 引入1 代码例程1.1 工作方式解释 2 动态调整学习率的几种方法2.1 lr_scheduler.LambdaLR2.2 lr_scheduler.StepLR2.3 lr_scheduler.MultiStepLR2.4 lr_scheduler.ExponentialLR2.2.5 lr_scheduler.CosineAnnealingLR2.6 lr_scheduler.ReduceLROnPlateau2.7 …
阅读更多...
后门程序2

后门程序2

System\CurrentControlSet\Services\Disk\Enum Windows 操作系统注册表中的一个路径。这个路径通常包含有关磁盘设备的信息。在这个特定的路径下&#xff0c;可能存储了有关磁盘枚举的配置和参数 Enum&#xff08;枚举&#xff09;子键通常包含了系统对磁盘的枚举信息&#xf…
阅读更多...
网络安全/黑客技术（0基础入门到进阶提升）

网络安全/黑客技术（0基础入门到进阶提升）

前言 前几天发布了一篇 网络安全&#xff08;黑客&#xff09;自学 没想到收到了许多人的私信想要学习网安黑客技术&#xff01;却不知道从哪里开始学起&#xff01;怎么学 今天给大家分享一下&#xff0c;很多人上来就说想学习黑客&#xff0c;但是连方向都没搞清楚就开始学习…
阅读更多...
高通SDX12：ASoC 音频框架浅析

高通SDX12：ASoC 音频框架浅析

一、简介 ASoC–ALSA System on Chip ，是建立在标准ALSA驱动层上，为了更好地支持嵌入式处理器和移动设备中的音频Codec的一套软件体系。 本文基于高通SDX12平台，对ASoC框架做一个分析。 二、整体框架 1. 硬件层面 嵌入式Linux设备的Audio subsystem可以划分为Machine（板…
阅读更多...
关于企业海外Social平台营销布局，你需要了解这三件事

关于企业海外Social平台营销布局，你需要了解这三件事

01 企业Social营销布局模式 Social营销走到现在&#xff0c;早已进入了标准配置期。任何企业和组织&#xff0c;进行营销宣传的时候都会在社媒社交平台上创建账号和运营。目前&#xff0c;海外Social平台营销模式基本分为四类&#xff1a; 官方社媒账号运营&#xff1a;以Hoot…
阅读更多...
HTML5学习系列之主结构

HTML5学习系列之主结构

HTML5学习系列之主结构 前言HTML5主结构定义页眉定义导航定义主要区域定义文章块定义区块定义附栏定义页脚 具体使用总结 前言 学习记录 HTML5主结构 定义页眉 head表示页眉&#xff0c;用来表示标题栏&#xff0c;引导和导航作用的结构元素。 <header role"banner…
阅读更多...
使用Python和requests库的简单爬虫程序

使用Python和requests库的简单爬虫程序

这是一个使用Python和requests库的简单爬虫程序。我们将使用代理来爬取网页内容。以下是代码和解释&#xff1a; import requests from fake_useragent import UserAgent # 每行代理信息 proxy_host "jshk.com.cn" # 创建一个代理器 proxy {http: http:// proxy_…
阅读更多...
SQLServer添加Oracle链接服务器

SQLServer添加Oracle链接服务器

又一次在项目中用到了在SQLServer添加Oracle链接服务器&#xff0c;发现之前文章写的也不太好使&#xff0c;那就再总结一次吧。 1、安装OracleClient 安装64位&#xff0c;多数SQLServer是64位&#xff0c;所以OracleClient也安装64位的&#xff1b; 再一个一般安装的Oracl…
阅读更多...
Python二级 每周练习题26

Python二级 每周练习题26

如果你感觉有收获&#xff0c;欢迎给我打赏 ———— 以激励我输出更多优质内容 练习一: 从键盘输入任意字符串&#xff0c;按照下面要求分离字符串中的字符&#xff1a; 1、分别取出该字符串的第偶数位的元素&#xff08;提醒注意&#xff1a;是按照从左往右数的 方式确定字…
阅读更多...
新增配置字

新增配置字

新增的配置字 “使用的集成功放通道数量”&#xff0c;我的理解 channelnum 和 有没有AVAS有关&#xff0c;油车的话没有AVAS&#xff1b; a2b :有外置功放肯定有a2b; amp1:内置功放&#xff1b; amp2:Avas 用的内置功放&#xff1b;
阅读更多...
如何防止听力下降？

如何防止听力下降？

听力受损是不可逆的&#xff0c;一旦听力下降了是无法恢复的&#xff0c;所以当我们出现听力障碍的时候&#xff0c;我们更应该注意我们的耳朵&#xff0c;想想如何能保护我们的残余听力&#xff01; 今天来告诉大家&#xff0c;哪些事是有易于听力的&#xff0c;一起来看看吧…
阅读更多...
最新文章

Copyright @ 2022~2023

友情链接： 我的编程经验分享 一条长河网 尧图网站开发 尧图建网站